SAGE 2.0: Documentation for types


SgTypeUnknown

Unkown type.

For base class see SgType

Variant name: T_UNKNOWN.

class SgTypeUnknown : public SgType {

SgName get_mangled(Unparse_Info&) { return SgName("Unknown"); }

/* Generated accessors */

};

SgTypeUnknown -- Constructors

/* This is generated in the header file  */
  SgTypeUnknown();

 /* This is the generated constructor */
SgTypeUnknown::SgTypeUnknown() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeUnknown


SgTypeChar

Character type

For base class see SgType

Variant name: T_CHAR.

class SgTypeChar : public SgType {

static SgTypeChar builtin_type;
static SgTypeChar* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("c"); }

/* Generated accessors */

};

SgTypeChar -- Constructors

/* This is generated in the header file  */
  SgTypeChar();

 /* This is the generated constructor */
SgTypeChar::SgTypeChar() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeChar


SgTypeSignedChar

Signed character type.

For base class see SgType

Variant name: T_SIGNED_CHAR.

class SgTypeSignedChar : public SgType {

static SgTypeSignedChar builtin_type;
static SgTypeSignedChar* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("si"); }

/* Generated accessors */

};

SgTypeSignedChar -- Constructors

/* This is generated in the header file  */
  SgTypeSignedChar();

 /* This is the generated constructor */
SgTypeSignedChar::SgTypeSignedChar() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeSignedChar


SgTypeUnsignedChar

Unsigned char type.

For base class see SgType

Variant name: T_UNSIGNED_CHAR.

class SgTypeUnsignedChar : public SgType {

static SgTypeUnsignedChar builtin_type;
static SgTypeUnsignedChar* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Uc"); }

/* Generated accessors */

};

SgTypeUnsignedChar -- Constructors

/* This is generated in the header file  */
  SgTypeUnsignedChar();

 /* This is the generated constructor */
SgTypeUnsignedChar::SgTypeUnsignedChar() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeUnsignedChar


SgTypeShort

Type short.

For base class see SgType

Variant name: T_SHORT.

class SgTypeShort : public SgType {

static SgTypeShort builtin_type;
static SgTypeShort* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("s"); }

/* Generated accessors */

};

SgTypeShort -- Constructors

/* This is generated in the header file  */
  SgTypeShort();

 /* This is the generated constructor */
SgTypeShort::SgTypeShort() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeShort


SgTypeSignedShort

Signed short type.

For base class see SgType

Variant name: T_SIGNED_SHORT.

class SgTypeSignedShort : public SgType {

static SgTypeSignedShort builtin_type;
static SgTypeSignedShort* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Ss"); }

/* Generated accessors */

};

SgTypeSignedShort -- Constructors

/* This is generated in the header file  */
  SgTypeSignedShort();

 /* This is the generated constructor */
SgTypeSignedShort::SgTypeSignedShort() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeSignedShort


SgTypeUnsignedShort

Unsigned short type.

For base class see SgType

Variant name: T_UNSIGNED_SHORT.

class SgTypeUnsignedShort : public SgType {

static SgTypeUnsignedShort builtin_type;
static SgTypeUnsignedShort* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Us"); }

/* Generated accessors */

};

SgTypeUnsignedShort -- Constructors

/* This is generated in the header file  */
  SgTypeUnsignedShort();

 /* This is the generated constructor */
SgTypeUnsignedShort::SgTypeUnsignedShort() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeUnsignedShort


SgTypeInt

Integer type

For base class see SgType

Variant name: T_INT.

class SgTypeInt : public SgType {

static SgTypeInt builtin_type[32];
static SgTypeInt* createType(int sz=0);
void post_construction_initialization() 
{ set_field_size(this-SgTypeInt::builtin_type); }
SgName get_mangled(Unparse_Info&) { return SgName("i"); }

/* Generated accessors */
int get_field_size() const;
void set_field_size(int);

/* Protected data members */ protected: int p_field_size; };

SgTypeInt -- Constructors

/* This is generated in the header file  */
  SgTypeInt(int field_size = 0);

 /* This is the generated constructor */
SgTypeInt::SgTypeInt(int field_size) 
:SgType()
{
p_field_size = field_size;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgTypeInt -- Members

Description


SgTypeSignedInt

Signed integer type

For base class see SgType

Variant name: T_SIGNED_INT.

class SgTypeSignedInt : public SgType {

static SgTypeSignedInt builtin_type;
static SgTypeSignedInt* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Si"); }

/* Generated accessors */

};

SgTypeSignedInt -- Constructors

/* This is generated in the header file  */
  SgTypeSignedInt();

 /* This is the generated constructor */
SgTypeSignedInt::SgTypeSignedInt() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeSignedInt


SgTypeUnsignedInt

Unsigned integer type

For base class see SgType

Variant name: T_UNSIGNED_INT.

class SgTypeUnsignedInt : public SgType {

static SgTypeUnsignedInt builtin_type;
static SgTypeUnsignedInt* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Ui"); }

/* Generated accessors */

};

SgTypeUnsignedInt -- Constructors

/* This is generated in the header file  */
  SgTypeUnsignedInt();

 /* This is the generated constructor */
SgTypeUnsignedInt::SgTypeUnsignedInt() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeUnsignedInt


SgTypeLong

Long type.

For base class see SgType

Variant name: T_LONG.

class SgTypeLong : public SgType {

static SgTypeLong builtin_type;
static SgTypeLong* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("l"); }

/* Generated accessors */

};

SgTypeLong -- Constructors

/* This is generated in the header file  */
  SgTypeLong();

 /* This is the generated constructor */
SgTypeLong::SgTypeLong() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeLong


SgTypeSignedLong

Signed long type

For base class see SgType

Variant name: T_SIGNED_LONG.

class SgTypeSignedLong : public SgType {

static SgTypeSignedLong builtin_type;
static SgTypeSignedLong* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Sl"); }

/* Generated accessors */

};

SgTypeSignedLong -- Constructors

/* This is generated in the header file  */
  SgTypeSignedLong();

 /* This is the generated constructor */
SgTypeSignedLong::SgTypeSignedLong() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeSignedLong


SgTypeUnsignedLong

Unsigned long type.

For base class see SgType

Variant name: T_UNSIGNED_LONG.

class SgTypeUnsignedLong : public SgType {

static SgTypeUnsignedLong builtin_type;
static SgTypeUnsignedLong* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Ul"); }

/* Generated accessors */

};

SgTypeUnsignedLong -- Constructors

/* This is generated in the header file  */
  SgTypeUnsignedLong();

 /* This is the generated constructor */
SgTypeUnsignedLong::SgTypeUnsignedLong() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeUnsignedLong


SgTypeVoid

Void type.

For base class see SgType

Variant name: T_VOID.

class SgTypeVoid : public SgType {

static SgTypeVoid builtin_type;
static SgTypeVoid* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("v"); }

/* Generated accessors */

};

SgTypeVoid -- Constructors

/* This is generated in the header file  */
  SgTypeVoid();

 /* This is the generated constructor */
SgTypeVoid::SgTypeVoid() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeVoid


SgTypeGlobalVoid

Global void type.

For base class see SgType

Variant name: T_GLOBAL_VOID.

class SgTypeGlobalVoid : public SgType {

static SgTypeGlobalVoid builtin_type;
static SgTypeGlobalVoid* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("gv"); }

/* Generated accessors */

};

SgTypeGlobalVoid -- Constructors

/* This is generated in the header file  */
  SgTypeGlobalVoid();

 /* This is the generated constructor */
SgTypeGlobalVoid::SgTypeGlobalVoid() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeGlobalVoid


SgTypeWchar

Wchar type.

For base class see SgType

Variant name: T_WCHAR.

class SgTypeWchar : public SgType {

static SgTypeWchar builtin_type;
static SgTypeWchar* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("wc"); }

/* Generated accessors */

};

SgTypeWchar -- Constructors

/* This is generated in the header file  */
  SgTypeWchar();

 /* This is the generated constructor */
SgTypeWchar::SgTypeWchar() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeWchar


SgTypeFloat

Type float.

For base class see SgType

Variant name: T_FLOAT.

class SgTypeFloat : public SgType {

static SgTypeFloat builtin_type;
static SgTypeFloat* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("f"); }

/* Generated accessors */

};

SgTypeFloat -- Constructors

/* This is generated in the header file  */
  SgTypeFloat();

 /* This is the generated constructor */
SgTypeFloat::SgTypeFloat() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeFloat


SgTypeDouble

Type double.

For base class see SgType

Variant name: T_DOUBLE.

class SgTypeDouble : public SgType {

static SgTypeDouble builtin_type;
static SgTypeDouble* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("d"); }

/* Generated accessors */

};

SgTypeDouble -- Constructors

/* This is generated in the header file  */
  SgTypeDouble();

 /* This is the generated constructor */
SgTypeDouble::SgTypeDouble() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeDouble


SgTypeLongLong

Type long long.

For base class see SgType

Variant name: T_LONG_LONG.

class SgTypeLongLong : public SgType {

static SgTypeLongLong builtin_type;
static SgTypeLongLong* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("ll"); }

/* Generated accessors */

};

SgTypeLongLong -- Constructors

/* This is generated in the header file  */
  SgTypeLongLong();

 /* This is the generated constructor */
SgTypeLongLong::SgTypeLongLong() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeLongLong


SgTypeUnsignedLongLong

Unsigned long long type.

For base class see SgType

Variant name: T_UNSIGNED_LONG_LONG.

class SgTypeUnsignedLongLong : public SgType {

static SgTypeUnsignedLongLong builtin_type;
static SgTypeUnsignedLongLong* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("Ull"); }

/* Generated accessors */

};

SgTypeUnsignedLongLong -- Constructors

/* This is generated in the header file  */
  SgTypeUnsignedLongLong();

 /* This is the generated constructor */
SgTypeUnsignedLongLong::SgTypeUnsignedLongLong() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeUnsignedLongLong


SgTypeLongDouble

Long double type.

For base class see SgType

Variant name: T_LONG_DOUBLE.

class SgTypeLongDouble : public SgType {

static SgTypeLongDouble builtin_type;
static SgTypeLongDouble* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("ld"); }

/* Generated accessors */

};

SgTypeLongDouble -- Constructors

/* This is generated in the header file  */
  SgTypeLongDouble();

 /* This is the generated constructor */
SgTypeLongDouble::SgTypeLongDouble() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeLongDouble


SgTypeString

String type (char *). --ever parsed as such?

For base class see SgType

Variant name: T_STRING.

class SgTypeString : public SgType {

static SgTypeString builtin_type;
static SgTypeString* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("str"); }

/* Generated accessors */

};

SgTypeString -- Constructors

/* This is generated in the header file  */
  SgTypeString();

 /* This is the generated constructor */
SgTypeString::SgTypeString() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeString


SgTypeBool

Bool type.

For base class see SgType

Variant name: T_BOOL.

class SgTypeBool : public SgType {

static SgTypeBool builtin_type;
static SgTypeBool* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("b"); }

/* Generated accessors */

};

SgTypeBool -- Constructors

/* This is generated in the header file  */
  SgTypeBool();

 /* This is the generated constructor */
SgTypeBool::SgTypeBool() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeBool


SgTypeComplex

Complex type. (for Fortran).

For base class see SgType

Variant name: T_COMPLEX.

class SgTypeComplex : public SgType {

SgName get_mangled(Unparse_Info&) { return SgName("Complex"); } 

/* Generated accessors */

};

SgTypeComplex -- Constructors

/* This is generated in the header file  */
  SgTypeComplex();

 /* This is the generated constructor */
SgTypeComplex::SgTypeComplex() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeComplex


SgTypeDefault

Default type.

For base class see SgType

Variant name: T_DEFAULT.

class SgTypeDefault : public SgType {

static SgTypeDefault builtin_type;
static SgTypeDefault* createType(void);
SgName get_mangled(Unparse_Info&) { return SgName("u"); }

/* Generated accessors */

};

SgTypeDefault -- Constructors

/* This is generated in the header file  */
  SgTypeDefault();

 /* This is the generated constructor */
SgTypeDefault::SgTypeDefault() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeDefault


SgPointerType

Pointer type.

For base class see SgType

Variant name: T_POINTER.

class SgPointerType : public SgType {

static SgPointerType* createType(SgType*);
SgName get_mangled(Unparse_Info& info);


/* Generated accessors */
SgType* get_base_type() const;
void set_base_type(SgType*);

/* Protected data members */ protected: SgType* p_base_type; };

SgPointerType -- Constructors

/* This is generated in the header file  */
  SgPointerType(SgType* base_type);

 /* This is the generated constructor */
SgPointerType::SgPointerType(SgType* base_type) 
:SgType()
{
p_base_type = base_type;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgPointerType -- Members

Description


SgPointerMemberType

Pointer member type.(pointer to member data or function data) // plain type : int (P::*) // type with name: int P::* pmi = &X::a; // use: obj.*pmi=7;

For base class see SgPointerType

Variant name: T_MEMBER_POINTER.

class SgPointerMemberType : public SgPointerType {

static SgPointerMemberType* createType(SgType*, SgClassDefinition*);
SgName get_mangled(Unparse_Info&);

/* Generated accessors */
SgClassDefinition* get_class_of() const;
void set_class_of(SgClassDefinition*);

/* Protected data members */ protected: SgClassDefinition* p_class_of; };

SgPointerMemberType -- Constructors

/* This is generated in the header file  */
  SgPointerMemberType(SgType* base_type, SgClassDefinition* class_of);

 /* This is the generated constructor */
SgPointerMemberType::SgPointerMemberType(SgType* base_type, SgClassDefinition* class_of) 
:SgPointerType(base_type)
{
p_class_of = class_of;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgPointerMemberType -- Members

Description


SgReferenceType

Reference type.

For base class see SgType

Variant name: T_REFERENCE.

class SgReferenceType : public SgType {

static SgReferenceType* createType(SgType*);
SgName get_mangled(Unparse_Info& info);


/* Generated accessors */
SgType* get_base_type() const;
void set_base_type(SgType*);

/* Protected data members */ protected: SgType* p_base_type; };

SgReferenceType -- Constructors

/* This is generated in the header file  */
  SgReferenceType(SgType* base_type);

 /* This is the generated constructor */
SgReferenceType::SgReferenceType(SgType* base_type) 
:SgType()
{
p_base_type = base_type;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgReferenceType -- Members

Description


SgNamedType

Type name. Abstract base class for class typedef, enum types.

For base class see SgType

Variant name: ABSTRACT. Abstract class, can not be instantiated.

class SgNamedType : public SgType {

virtual SgName get_name() const =0;
SgName get_qualified_name() const;

/* Generated accessors */
SgDeclarationStatement* get_declaration() const;
void set_declaration(SgDeclarationStatement*);

/* Protected data members */ protected: SgDeclarationStatement* p_declaration; };

SgNamedType -- Constructors

/* This is generated in the header file  */
  SgNamedType(SgDeclarationStatement* declaration);

 /* This is the generated constructor */
SgNamedType::SgNamedType(SgDeclarationStatement* declaration) 
:SgType()
{
p_declaration = declaration;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgNamedType -- Members

Description


SgClassType

Class type.

For base class see SgNamedType

Variant name: T_CLASS.

class SgClassType : public SgNamedType {

static SgClassType* createType(SgClassDeclaration * cd);
SgName get_name() const;
SgName get_mangled(Unparse_Info&);


/* Generated accessors */

};

SgClassType -- Constructors

/* This is generated in the header file  */
  SgClassType(SgDeclarationStatement* declaration);

 /* This is the generated constructor */
SgClassType::SgClassType(SgDeclarationStatement* declaration) 
:SgNamedType(declaration)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgClassType


SgEnumType

Enumeration type.

For base class see SgNamedType

Variant name: T_ENUM.

class SgEnumType : public SgNamedType {

static SgEnumType* createType(SgEnumDeclaration* cd);
SgName get_name() const;
SgName get_mangled(Unparse_Info&) { return get_name(); }

/* Generated accessors */

};

SgEnumType -- Constructors

/* This is generated in the header file  */
  SgEnumType(SgDeclarationStatement* declaration);

 /* This is the generated constructor */
SgEnumType::SgEnumType(SgDeclarationStatement* declaration) 
:SgNamedType(declaration)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgEnumType


SgTypedefType

Typedef type.

For base class see SgNamedType

Variant name: T_TYPEDEF.

class SgTypedefType : public SgNamedType {

static SgTypedefType* createType(SgTypedefDeclaration *decl);
SgName get_name() const;

SgName get_mangled(Unparse_Info& ui);
SgType * get_base_type() const;

/* Generated accessors */
SgSymbol* get_parent_scope() const;
void set_parent_scope(SgSymbol*);

/* Protected data members */ protected: SgSymbol* p_parent_scope; };

SgTypedefType -- Constructors

/* This is generated in the header file  */
  SgTypedefType(SgDeclarationStatement* declaration, SgSymbol* parent_scope = 0);

 /* This is the generated constructor */
SgTypedefType::SgTypedefType(SgDeclarationStatement* declaration, SgSymbol* parent_scope) 
:SgNamedType(declaration)
{
p_parent_scope = parent_scope;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgTypedefType -- Members

Description


SgModifierType

Modifier type.

For base class see SgType

Variant name: T_MODIFIER.

class SgModifierType : public SgType {

enum modifiers {
   m_volatile = 0x1,
   m_global   = 0x2,
   m_sync     = 0x4,
   m_const    = 0x8
};
/* mask some bit on or off */
void set_modifier(int flag);
void unset_modifier(int flag);
bool isConst() const { return p_bitfield & m_const; }
bool isSync() const { return p_bitfield & m_sync; }
bool isGlobal() const { return p_bitfield & m_global; }
bool isVolatile() const { return p_bitfield & m_volatile; }
void unsetSync() { p_bitfield &= ~m_sync; }
void setSync() { p_bitfield != m_sync; }
void unsetGlobal() { p_bitfield &= ~m_global; }
void setGlobal() { p_bitfield != m_global; } 
unsigned int bitfield(void) { return p_bitfield; }

static SgModifierType* createType(SgType*, unsigned int);
SgName get_mangled(Unparse_Info& info);


/* Generated accessors */
SgType* get_base_type() const;
void set_base_type(SgType*);
int get_bitfield() const;
void set_bitfield(int);

/* Protected data members */ protected: SgType* p_base_type; int p_bitfield; };

SgModifierType -- Constructors

/* This is generated in the header file  */
  SgModifierType(SgType* base_type, int bitfield);

 /* This is the generated constructor */
SgModifierType::SgModifierType(SgType* base_type, int bitfield) 
:SgType()
{
p_base_type = base_type; p_bitfield = bitfield;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgModifierType -- Members

Description


SgFunctionType

Function type.

For base class see SgType

Variant name: T_FUNCTION.

class SgFunctionType : public SgType {

void post_construction_initialization() { p_orig_return_type = 0;}

SgFunctionType(SgPartialFunctionType *);
static SgFunctionType* createType(SgPartialFunctionType *);

const SgTypePtrList & get_arguments() const;
SgTypePtrList & get_arguments();

void append_argument(const SgTypePtr & what);
void insert_argument(SgTypePtrList::iterator where, 
	                const SgTypePtr & what);

SgName get_mangled(Unparse_Info &);
virtual SgName get_mangled_name(Unparse_Info&); 
virtual SgName get_mangled_type();

SgType *get_orig_return_type() { return p_orig_return_type; }  
void set_orig_return_type(SgType *t) { p_orig_return_type=t; }
SgFunctionType* mkAnotherType(SgType *);

/* Generated accessors */
SgType* get_return_type() const;
void set_return_type(SgType*);
bool get_has_ellipses() const;
void set_has_ellipses(bool);

/* Protected data members */ protected: SgType* p_return_type; SgTypePtrList p_arguments; bool p_has_ellipses; SgType* p_orig_return_type; };

SgFunctionType -- Constructors

/* This is generated in the header file  */
  SgFunctionType(SgType* return_type, bool has_ellipses = 0);

 /* This is the generated constructor */
SgFunctionType::SgFunctionType(SgType* return_type, bool has_ellipses) 
:SgType()
{
p_return_type = return_type; p_has_ellipses = has_ellipses;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgFunctionType -- Members

Description


SgMemberFunctionType

Member function type.

For base class see SgFunctionType

Variant name: T_MEMBERFUNCTION.

class SgMemberFunctionType : public SgFunctionType {

SgMemberFunctionType(SgPartialFunctionType *);

/* const/volatile -- this is here so PartialFunction can set it */
enum func_specifier_enum {
e_const     =     0x00000001,
e_volatile  =     0x00000002
};

void post_construction_initialization()
    { p_struct_name=0; p_mfunc_specifier = 0; }

static SgMemberFunctionType* createType(SgPartialFunctionType *);

int isConstFunc() { return (p_mfunc_specifier & e_const); }
void setConstFunc() { p_mfunc_specifier |= e_const; }
void unsetConstFunc() { p_mfunc_specifier &= ~e_const; }

int isVolatileFunc() { return (p_mfunc_specifier & e_volatile); }
void setVolatileFunc() { p_mfunc_specifier |= e_volatile; }
void unsetVolatileFunc() { p_mfunc_specifier &= ~e_volatile; }

// this routine can do 2 things,
// mangle a type with class name - without funcname 
// mangle a complete function declaration with name and class name
SgName get_mangled(Unparse_Info &);
SgName get_mangled_name(Unparse_Info&); 
SgName get_mangled_type() { return get_mangled(NO_UNPARSE_INFO); }

SgMemberFunctionType * mkAnotherType(SgType *);

/* Generated accessors */
SgClassDefinition* get_struct_name() const;
void set_struct_name(SgClassDefinition*);
unsigned int get_mfunc_specifier() const;
void set_mfunc_specifier(unsigned int);

/* Protected data members */ protected: SgClassDefinition* p_struct_name; unsigned int p_mfunc_specifier; };

SgMemberFunctionType -- Constructors

/* This is generated in the header file  */
  SgMemberFunctionType(SgType* return_type, bool has_ellipses = 0, SgClassDefinition* struct_name = 0, unsigned int mfunc_specifier = 0);

 /* This is the generated constructor */
SgMemberFunctionType::SgMemberFunctionType(SgType* return_type, bool has_ellipses, SgClassDefinition* struct_name, unsigned int mfunc_specifier) 
:SgFunctionType(return_type, has_ellipses)
{
p_struct_name = struct_name; p_mfunc_specifier = mfunc_specifier;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgMemberFunctionType -- Members

Description


SgPartialFunctionType

Partial function type. Needs to inherit all because it needs to be able to take every manglable info.

For base class see SgMemberFunctionType

Variant name: T_PARTIAL_FUNCTION.

class SgPartialFunctionType : public SgMemberFunctionType {

void post_construction_initialization() {}

static SgPartialFunctionType* createType(SgType*);

/* Generated accessors */

};

SgPartialFunctionType -- Constructors

/* This is generated in the header file  */
  SgPartialFunctionType(SgType* return_type, bool has_ellipses = 0, SgClassDefinition* struct_name = 0, unsigned int mfunc_specifier = 0);

 /* This is the generated constructor */
SgPartialFunctionType::SgPartialFunctionType(SgType* return_type, bool has_ellipses, SgClassDefinition* struct_name, unsigned int mfunc_specifier) 
:SgMemberFunctionType(return_type, has_ellipses, struct_name, mfunc_specifier)
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgPartialFunctionType


SgArrayType

Array type.

For base class see SgType

Variant name: T_ARRAY.

class SgArrayType : public SgType {

static SgArrayType* createType(SgType*, SgExpression*);

SgName get_mangled(Unparse_Info & info);

/* Generated accessors */
SgType* get_base_type() const;
void set_base_type(SgType*);
SgExpression* get_index() const;
void set_index(SgExpression*);

/* Protected data members */ protected: SgType* p_base_type; SgExpression* p_index; };

SgArrayType -- Constructors

/* This is generated in the header file  */
  SgArrayType(SgType* base_type, SgExpression* index = 0);

 /* This is the generated constructor */
SgArrayType::SgArrayType(SgType* base_type, SgExpression* index) 
:SgType()
{
p_base_type = base_type; p_index = index;

/* now call the user defined intialization function */ post_construction_initialization();
}

SgArrayType -- Members

Description


SgTypeEllipse

Ellipse type.

For base class see SgType

Variant name: T_ELLIPSE.

class SgTypeEllipse : public SgType {

static SgTypeEllipse builtin_type;
static SgTypeEllipse* createType(void);
SgName get_mangled(Unparse_Info &) { return SgName("e"); } 

/* Generated accessors */

};

SgTypeEllipse -- Constructors

/* This is generated in the header file  */
  SgTypeEllipse();

 /* This is the generated constructor */
SgTypeEllipse::SgTypeEllipse() 
:SgType()
{

/* now call the user defined intialization function */ post_construction_initialization();
}

No members associated with SgTypeEllipse


Goto:
[Extreme] Extreme! Computing Home Page


horea adrian abrudan
Last modified: Wed June 18 13:20:54 EST