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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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;
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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;
};
/* 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();
}
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 */
};
/* 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();
}
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 */
};
/* 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();
}
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;
};
/* 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();
}
To keep track of the scope of the typedef.
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;
};
/* 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();
}
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;
};
/* 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();
}
this is a temporary storage spot for the return type to be used for SgFunctionDeclaration, this is for the case where the functiontype's return type might not be literally the same as the return type for the function declaration (such as typedefed)
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;
};
/* 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();
}
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 */
};
/* 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();
}
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;
};
/* 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();
}
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 */
};
/* 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();
}
![[Extreme]](images/extreme.icon.gif){kind=icon}
Extreme! Computing Home Page