SAGE 2.0: Documentation for statements


SgScopeStatement

A statement that contains a symbol table.

For base class see SgStatement

Variant name: SCOPE_STMT.

class SgScopeStatement : public SgStatement {

public:
  void insert_symbol(const SgName& n,SgSymbol*s)
  { p_symbol_table.insert(n,s); }

  // see if this is in symbol table already
  int lookup_symbol(const SgName& n, SgSymbol *s)
  { return p_symbol_table.find(n,s); }

  // first symbol with n
  SgSymbol *lookup_symbol(const SgName& n)
  { return p_symbol_table.findany(n); }

  SgTypedefSymbol *lookup_typedef_symbol(const SgName& n)
  { return p_symbol_table.findtypedef(n); }

  SgEnumSymbol *lookup_enum_symbol(const SgName& n)
  { return p_symbol_table.findenum(n); } 

  SgEnumFieldSymbol *lookup_enumfield_symbol(const SgName& n)
  { return p_symbol_table.findenumfield(n); } 

  SgVariableSymbol *lookup_var_symbol(const SgName& n)
  { return p_symbol_table.findvar(n); }

  SgClassSymbol *lookup_class_symbol(const SgName& n)
  { return p_symbol_table.findclass(n); }

  SgLabelSymbol *lookup_label_symbol(const SgName& n) const
  { return p_symbol_table.findlabel(n); }

  SgFunctionSymbol *lookup_function_symbol(const SgName& n, const SgType* t)
  { return p_symbol_table.findfunc(n,t); }

  SgFunctionSymbol *lookup_function_symbol(const SgName& n)
  { return p_symbol_table.findfunc(n); }

  SgSymbol *first_any_symbol()
  { return p_symbol_table.findfirstany(); }

  SgVariableSymbol *first_variable_symbol()
  { return p_symbol_table.findfirstvar(); }

  SgClassSymbol *first_class_symbol()
  { return p_symbol_table.findfirstclass(); }
 
  SgFunctionSymbol *first_function_symbol() 
  { return p_symbol_table.findfirstfunction(); }

  // use after lookup_XXX_symbol(SgName&)
  // or after first_XXX_symbol()
  SgVariableSymbol *next_variable_symbol() 
   { return p_symbol_table.nextvar(); }

  SgClassSymbol *next_class_symbol() 
   { return p_symbol_table.nextclass(); }

  SgFunctionSymbol *next_function_symbol() 
   { return p_symbol_table.nextfunc(); }

  SgSymbol *next_any_symbol() 
   { return p_symbol_table.nextany(); }

  void print_symboltable(char *str, ostream& os=cout) 
  {
    os << endl << "...SymTbl(" << str << ")... " << endl;
    p_symbol_table.print(os);
  }
  /* additional symbol table insertion utitily routines */
  SgVariableSymbol *insert_symbol(SgInitializedNameList::iterator&);
  SgVariableSymbol *insert_symbol(SgVariableDeclaration *);
  SgFunctionSymbol *insert_symbol(SgFunctionDeclaration *);
  SgMemberFunctionSymbol *insert_symbol(SgMemberFunctionDeclaration *);
  SgClassSymbol *insert_symbol(SgClassDeclaration *cdecl);
  SgEnumSymbol *insert_symbol(SgEnumDeclaration *cdecl);
  SgTypedefSymbol *insert_symbol(SgTypedefDeclaration *);
  SgLabelSymbol *insert_symbol(SgLabelStatement *);

  SgEnumFieldSymbol *insert_enum_symbol(SgInitializedNameList::iterator&);

protected:
  SgScopeStatement() {}

/* Generated accessors */

/* Protected data members */ protected: SgSymbolTable p_symbol_table; };

SgScopeStatement -- Constructors

/* This is generated in the header file  */
  SgScopeStatement(Sg_File_Info *info );

 /* This is the generated constructor */
SgScopeStatement::SgScopeStatement(Sg_File_Info* info ) 
:SgStatement(info)
{

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

SgScopeStatement -- Members

Description


SgFunctionTypeTable

A statement that contains a function type table.

For base class see SgStatement

Variant name: FUNC_TBL_STMT.

class SgFunctionTypeTable : public SgStatement {

public:
SgFunctionTypeTable() {}
void insert_function_type(const SgName&, SgType *);
void insert_function_type(const SgFunctionDeclaration *);
SgType* lookup_function_type (const SgName&);

void print_functypetable(ostream& os=cout)
  {
    os << endl << "...FuncTypeTbl..." << endl;
    p_function_type_table.print(os);
  }

/* Generated accessors */

/* Protected data members */ protected: SgSymbolTable p_function_type_table; };

SgFunctionTypeTable -- Constructors

/* This is generated in the header file  */
  SgFunctionTypeTable(Sg_File_Info *info );

 /* This is the generated constructor */
SgFunctionTypeTable::SgFunctionTypeTable(Sg_File_Info* info ) 
:SgStatement(info)
{

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

SgFunctionTypeTable -- Members

Description


SgGlobal

This is always the root of a Sage parse tree. Manages a list of declarations.

For base class see SgScopeStatement

Variant name: GLOBAL_STMT.

class SgGlobal : public SgScopeStatement {

SgGlobal() {}
SgDeclarationStatementPtrList & get_declarations() 
{ return p_declarations; }
const SgDeclarationStatementPtrList & get_declarations() const 
{ return p_declarations; }
void append_declaration(SgDeclarationStatement * what) 
{ insert_declaration(p_declarations.end(),what); }
void prepend_declaration(SgDeclarationStatement * what) 
{ insert_declaration(p_declarations.begin(),what); }
void insert_declaration(SgDeclarationStatementPtrList::iterator where, 
	                SgDeclarationStatement * what);
SgStatement *get_first() const; 
SgStatement *get_end() const; 
void insert_statement(SgStatement *, SgStatement *, int);

/* Generated accessors */

/* Protected data members */ protected: SgDeclarationStatementPtrList p_declarations; };

SgGlobal -- Constructors

/* This is generated in the header file  */
  SgGlobal(Sg_File_Info *info );

 /* This is the generated constructor */
SgGlobal::SgGlobal(Sg_File_Info* info ) 
:SgScopeStatement(info)
{

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

SgGlobal -- Members

Description


SgDeclarationStatement

Represents the base class for all declarations.

For base class see SgStatement

Variant name: DECL_STMT.

class SgDeclarationStatement : public SgStatement {

void post_construction_initialization()
{
   p_attribute = 0;
   p_linkage = (char*)0L;
}
public:
enum decl_specifier_enum {  
/* access specifier - variable, member function, enum, class, struct, union */
e_private    =     0x00000001, 
e_protected  =     0x00000002,
e_public     =     0x00000004,
/* function specifier - function, member function */
e_inline     =     0x00000010,
e_virtual    =     0x00000020,
e_atomic     =     0x00000040,
/* storage/linkage specifier - variable, function, member function */
e_static     =     0x00000100,
e_extern     =     0x00000200,
e_extern_c   =     0x00000400,
e_extern_brace =   0x00000800,
e_auto       =     0x00001000,
e_register   =     0x00002000,
/* other - class, struct, union, function */ 
e_friend     =     0x00004000,
/* global class */
e_global     =     0x01000000,

e_constructor =    0x00008000,
e_destructor  =    0x00010000,
e_conversion  =    0x00020000,

/* for a class or function declared and defined later */
e_forward     =    0x00040000,

e_operator    =    0x00080000,
e_pure        =    0x00100000,
e_name_only   =    0x00200000,
e_skip_elaborate_type = 0x00400000
};

int checkBit(unsigned int bit) const
{ if(p_attribute & bit) return 1; else return 0; }
void setBit(unsigned int bit)
{ p_attribute |= bit; }
void unsetBit(unsigned int bit)
{ p_attribute &= ~bit; }
 
int isPrivate() const { return checkBit(e_private); }
void setPrivate() { setBit(e_private); }
void unsetPrivate() { unsetBit(e_private); }

int isProtected() const { return checkBit(e_protected); }
void setProtected() { setBit(e_protected); }
void unsetProtected() { unsetBit(e_protected); }

int isPublic() const { return checkBit(e_public); }
void setPublic() { setBit(e_public); }
void unsetPublic() { unsetBit(e_public); }

int isInline() const { return checkBit(e_inline); }
void setInline() { setBit(e_inline); }
void unsetInline() { unsetBit(e_inline); }

int isVirtual() const { return checkBit(e_virtual); }
void setVirtual() { setBit(e_virtual); }
void unsetVirtual() { unsetBit(e_virtual); }

int isAtomic() const { return checkBit(e_atomic); }
void setAtomic() { setBit(e_atomic); }
void unsetAtomic() { unsetBit(e_atomic); }

int isStatic() const { return checkBit(e_static); }
void setStatic() { setBit(e_static); }
void unsetStatic() { unsetBit(e_static); }

int isExtern() const { return checkBit(e_extern); }
void setExtern() { setBit(e_extern); }
void unsetExtern() { unsetBit(e_extern); }

int isExternBrace() const { return checkBit(e_extern_brace); }
void setExternBrace() { setBit(e_extern_brace); }
void unsetExternBrace() { unsetBit(e_extern_brace); }

int isAuto() const { return checkBit(e_auto); }
void setAuto() { setBit(e_auto); }
void unsetAuto() { unsetBit(e_auto); }

int isRegister() const { return checkBit(e_register); }
void setRegister() { setBit(e_register); }
void unsetRegister() { unsetBit(e_register); }

int isFriend() const { return checkBit(e_friend); }
void setFriend() { setBit(e_friend); }
void unsetFriend() { unsetBit(e_friend); }

int isGlobalClass() const { return checkBit(e_global); }
void setGlobalClass() { setBit(e_global); }
void unsetGlobalClass() { unsetBit(e_global); }

int isConstructor() const { return checkBit(e_constructor); }
void setConstructor() { setBit(e_constructor); }
void unsetConstructor() { unsetBit(e_constructor); }

int isDestructor() const { return checkBit(e_destructor); }
void setDestructor() { setBit(e_destructor); }
void unsetDestructor() { unsetBit(e_destructor); }

int isConversion() const { return checkBit(e_conversion); }
void setConversion() { setBit(e_conversion); }
void unsetConversion() { unsetBit(e_conversion); }

// this is to distingush a forward declaration 
// static int a;
// int a=10;
int isForward() const { return checkBit(e_forward); }
void setForward() { setBit(e_forward); }
void unsetForward() { unsetBit(e_forward); }

// this is to distinguish cases like this
// class-P pvar;            -- isNameOnly=1
// class-P { int a; } pvar; -- isNameOnly=0
int isNameOnly() const { return checkBit(e_name_only); }
void setNameOnly() { setBit(e_name_only); }
void unsetNameOnly() { unsetBit(e_name_only); }

// this is to distinguish cases like this
// class P var;
// P var;
int SkipElaborateType() const { return checkBit(e_skip_elaborate_type); }
void  setSkipElaborateType() { setBit(e_skip_elaborate_type); }
void unsetSkipElaborateType() { unsetBit(e_skip_elaborate_type); }

int isOperator() const { return checkBit(e_operator); }
void setOperator() { setBit(e_operator); }
void unsetOperator() { unsetBit(e_operator); }

int isPure() const { return checkBit(e_pure); }
void setPure() { setBit(e_pure); }
void unsetPure() { unsetBit(e_pure); }

const char* get_linkage() const { return p_linkage; }
void set_linkage(char* link) { p_linkage = link; }

SgDeclarationStatement() { p_attribute=0; }

void printSpecifier(Unparse_Info&, ostream& os=cout);


/* Generated accessors */

/* Protected data members */ protected: unsigned int p_attribute; char * p_linkage; };

SgDeclarationStatement -- Constructors

/* This is generated in the header file  */
  SgDeclarationStatement(Sg_File_Info *info );

 /* This is the generated constructor */
SgDeclarationStatement::SgDeclarationStatement(Sg_File_Info* info ) 
:SgStatement(info)
{

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

SgDeclarationStatement -- Members

Description


SgBasicBlock

Contains a group of statements.

For base class see SgScopeStatement

Variant name: BASIC_BLOCK_STMT.

class SgBasicBlock : public SgScopeStatement {

SgStatementPtrList & get_statements() { return p_statements; }
const SgStatementPtrList & get_statements() const { return p_statements; }
void append_statement(SgStatement * what) 
{ insert_statement(p_statements.end(),what); }
void prepend_statement(SgStatement *what)
{ insert_statement(p_statements.begin(), what); }
void insert_statement(SgStatementPtrList::iterator where, SgStatement * what)
{ 
  what->set_parent(this);
  p_statements.insert(where,what);
}

SgStatement *get_first() const; 
SgStatement *get_end() const;

// return the last statement in the SgBasicBlock, note
// this only check the top-level.. it is not going to
// go down to any lower level if this is a another big
// statement with body
SgStatement *get_last() const;

int replace_statement(SgStatement *, SgStatement *);
void insert_statement(SgStatement*, SgStatement*, int);

/* Generated accessors */

/* Protected data members */ protected: SgStatementPtrList p_statements; };

SgBasicBlock -- Constructors

/* This is generated in the header file  */
  SgBasicBlock(Sg_File_Info *info );

 /* This is the generated constructor */
SgBasicBlock::SgBasicBlock(Sg_File_Info* info ) 
:SgScopeStatement(info)
{

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

SgBasicBlock -- Members

Description

SgBasicBlock -- Usage

This holds a list of statements.


SgIfStmt

Represents {if.S0.then.S1.else.S2.} statements.

For base class see SgScopeStatement

Variant name: IF_STMT.

class SgIfStmt : public SgScopeStatement {

void post_construction_initialization()
{
  if (get_conditional()) get_conditional()->set_parent(this);
  if (get_true_body()) get_true_body()->set_parent(this);
  if (get_false_body()) get_false_body()->set_parent(this);
}

/* returns the statement number n (0,1,2) of S0, S1 or S2 if present;
   the value of (n-1) is telling which one was returned */
SgStatement *get_next(int& n) const; 

/* given statement o checks which one is from the 
   conditional, true or false statements and replaces it with 
   statement n; returns 1 on success, 0 otherwise */
int replace_statement(SgStatement *o, SgStatement *n);


/* Generated accessors */
SgStatement* get_conditional() const;
void set_conditional(SgStatement*);
SgBasicBlock* get_true_body() const;
void set_true_body(SgBasicBlock*);
SgBasicBlock* get_false_body() const;
void set_false_body(SgBasicBlock*);

/* Protected data members */ protected: SgStatement* p_conditional; SgBasicBlock* p_true_body; SgBasicBlock* p_false_body; };

SgIfStmt -- Constructors

/* This is generated in the header file  */
  SgIfStmt(Sg_File_Info *info , SgStatement* conditional = 0, SgBasicBlock* true_body = 0, SgBasicBlock* false_body = 0);

 /* This is the generated constructor */
SgIfStmt::SgIfStmt(Sg_File_Info* info , SgStatement* conditional, SgBasicBlock* true_body, SgBasicBlock* false_body) 
:SgScopeStatement(info)
{
p_conditional = conditional; p_true_body = true_body; p_false_body = false_body;

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

SgIfStmt -- Members

Description


SgForStatement

For base class see SgScopeStatement

Variant name: FOR_STMT.

class SgForStatement : public SgScopeStatement {

void post_construction_initialization()
{
 p_test_expr_root.initialize_root(p_test_expr_i, this);
 p_increment_expr_root.initialize_root(p_increment_expr_i, this);
 
  /* set up the symbol table */
  if (get_init_stmt()) get_init_stmt()->set_parent(this);
  if (get_loop_body()) get_loop_body()->set_parent(this);
}

void set_test_expr(SgExpression * exp) {
 set_test_expr_i(exp);
 p_test_expr_root.initialize_root(exp, this);
}

SgExpression * get_test_expr() const { return get_test_expr_i(); }

void set_increment_expr(SgExpression * exp) {
 set_increment_expr_i(exp);
 p_increment_expr_root.initialize_root(exp, this);
}
SgExpression * get_increment_expr() const { return get_increment_expr_i(); }

/* returns init_stmt if exists or loop_body
   n-1 will tell which one is being returned; 
   when calling, n represents the member requested: 0 for init_stmt, etc
   returns 0 when n>1*/
SgStatement* get_next(int& n) const;


/* replaces statement o, the init-stmt or loop_body
   by statement n (casted to SgBasicBlock in the latter case) 
   returns 1 on success, 0 otherwise  */
int replace_statement(SgStatement *o, SgStatement *n);


private:
    SgExpressionRoot p_test_expr_root;
    SgExpressionRoot p_increment_expr_root;

/* Generated accessors */
SgStatement* get_init_stmt() const;
void set_init_stmt(SgStatement*);
SgExpression* get_test_expr_i() const;
void set_test_expr_i(SgExpression*);
SgExpression* get_increment_expr_i() const;
void set_increment_expr_i(SgExpression*);
SgBasicBlock* get_loop_body() const;
void set_loop_body(SgBasicBlock*);

/* Protected data members */ protected: SgStatement* p_init_stmt; SgExpression* p_test_expr_i; SgExpression* p_increment_expr_i; SgBasicBlock* p_loop_body; };

SgForStatement -- Constructors

/* This is generated in the header file  */
  SgForStatement(Sg_File_Info *info , SgStatement* init_stmt = 0, SgExpression* test_expr_i = 0, SgExpression* increment_expr_i = 0, SgBasicBlock* loop_body = 0);

 /* This is the generated constructor */
SgForStatement::SgForStatement(Sg_File_Info* info , SgStatement* init_stmt, SgExpression* test_expr_i, SgExpression* increment_expr_i, SgBasicBlock* loop_body) 
:SgScopeStatement(info)
{
p_init_stmt = init_stmt; p_test_expr_i = test_expr_i; p_increment_expr_i = increment_expr_i; p_loop_body = loop_body;

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

SgForStatement -- Members

Description


SgFunctionDeclaration

Contains the function header part, for either function declaration or function definition.

For base class see SgDeclarationStatement

Variant name: FUNC_DECL_STMT.

class SgFunctionDeclaration : public SgDeclarationStatement {

void post_construction_initialization()
{
  if(p_type) p_orig_return_type=p_type->get_orig_return_type();
    else p_orig_return_type=0;
  p_from_template=0;
}

/* InitalizedName is a tuple : (SgName, DeclStmt, type, Initializer) */
/* an iterator to insert argument--SgInitializedName in the argument list*/
SgInitializedNameList::iterator insert_arg(
	SgInitializedNameList::iterator where,
   	const SgInitializedName & what);

SgInitializedNameList::iterator append_arg(
	const SgInitializedName & what);

SgInitializedNameList::iterator prepend_arg(
	const SgInitializedName & what);

SgInitializedNameList & get_args() { return p_arguments; }
const SgInitializedNameList & get_args() const { return p_arguments; }

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

void hasEllipses() { get_type()->set_has_ellipses(1); }
SgName get_mangled_name();

void set_mangled_name();
void unparse_helper(Unparse_Info& info, ostream& os=cout);

SgStatement* get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);

int get_from_template() const { return p_from_template; }
void set_from_template(int i) { p_from_template=i; }

/* Generated accessors */
SgName get_name() const;
void set_name(SgName);
SgFunctionType* get_type() const;
void set_type(SgFunctionType*);
SgFunctionDefinition* get_definition() const;
void set_definition(SgFunctionDefinition*);

/* Protected data members */ protected: SgName p_name; SgFunctionType* p_type; SgFunctionDefinition* p_definition; SgName p_mangled_name; SgInitializedNameList p_arguments; SgType* p_orig_return_type; int p_from_template; };

SgFunctionDeclaration -- Constructors

/* This is generated in the header file  */
  SgFunctionDeclaration(Sg_File_Info *info , SgName name, SgFunctionType* type, SgFunctionDefinition* definition = 0);

 /* This is the generated constructor */
SgFunctionDeclaration::SgFunctionDeclaration(Sg_File_Info* info , SgName name, SgFunctionType* type, SgFunctionDefinition* definition) 
:SgDeclarationStatement(info)
{
p_name = name; p_type = type; p_definition = definition;

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

SgFunctionDeclaration -- Members

Description


SgFunctionDefinition

Only for function definition statements

For base class see SgScopeStatement

Variant name: FUNC_DEFN_STMT.

class SgFunctionDefinition : public SgScopeStatement {

void post_construction_initialization()
{ 
  p_par_cnt=0;
  if(get_body()) get_body()->set_parent(this);
  if(p_declaration) {
    p_declaration->set_definition(this);
    if(!p_declaration->isForward())
      set_parent(p_declaration); //?? MEI not sure
  }
}

public:
int get_par_flag() const { return p_par_cnt; };
void set_par_flag() { p_par_cnt++; };

SgStatement *get_next(int& n) const;
int replace_statement(SgStatement *o, SgStatement *n);

// allow insertion via function definition level
void append_statement(SgStatement * what);
void prepend_statement(SgStatement *what);

SgFunctionDeclaration* get_declaration() const { return p_declaration; }
void set_declaration(SgFunctionDeclaration*);

/* Generated accessors */
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);

/* Protected data members */ protected: SgFunctionDeclaration* p_declaration; SgBasicBlock* p_body; int p_par_cnt; };

SgFunctionDefinition -- Constructors

/* This is generated in the header file  */
  SgFunctionDefinition(Sg_File_Info *info , SgFunctionDeclaration* declaration /*OPT*/, SgBasicBlock* body);

 /* This is the generated constructor */
SgFunctionDefinition::SgFunctionDefinition(Sg_File_Info* info , SgFunctionDeclaration* declaration, SgBasicBlock* body) 
:SgScopeStatement(info)
{
p_declaration = declaration; p_body = body;

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

SgFunctionDefinition -- Members

Description


SgMemberFunctionDeclaration

Member function header part, for either function declaration or function definition -- parent() will always be at class declaration

For base class see SgFunctionDeclaration

Variant name: MFUNC_DECL_STMT.

class SgMemberFunctionDeclaration : public SgFunctionDeclaration {

/* SgInitializedName tuple: (SgName, type, Initializer) */
void append_ctor_initializer(const SgInitializedName& iName)
{
  p_ctor_initializers.insert(p_ctor_initializers.end(), iName);
}
void prepend_ctor_initializer(const SgInitializedName& iName)
{
  p_ctor_initializers.insert(p_ctor_initializers.begin(), iName);
}
SgInitializedNameList & get_ctors() { return p_ctor_initializers; }
const SgInitializedNameList & get_ctors() const { return p_ctor_initializers; }
SgName get_qualified_name(); 
void set_orig_return_type(SgType *t);


/* Generated accessors */
SgClassDefinition* get_scope() const;
void set_scope(SgClassDefinition*);

/* Protected data members */ protected: SgClassDefinition* p_scope; SgInitializedNameList p_ctor_initializers; };

SgMemberFunctionDeclaration -- Constructors

/* This is generated in the header file  */
  SgMemberFunctionDeclaration(Sg_File_Info *info , SgName name, SgFunctionType* type, SgFunctionDefinition* definition /*OPT*/, SgClassDefinition* scope);

 /* This is the generated constructor */
SgMemberFunctionDeclaration::SgMemberFunctionDeclaration(Sg_File_Info* info , SgName name, SgFunctionType* type, SgFunctionDefinition* definition, SgClassDefinition* scope) 
:SgFunctionDeclaration(info, name, type, definition)
{
p_scope = scope;

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

SgMemberFunctionDeclaration -- Members

Description


SgVariableDeclaration

For variable declaration statement.

For base class see SgDeclarationStatement

Variant name: VAR_DECL_STMT.

class SgVariableDeclaration : public SgDeclarationStatement {

/* constructor */
SgVariableDeclaration(Sg_File_Info*, SgName&, SgType*, SgInitializer*);

/* members to set the type of declaration */
void setDeclarationOnly();
void setExtern();
void setStatic();

SgInitializedNameList & get_variables() { return p_variables; }
const SgInitializedNameList & get_variables() const { return p_variables; }

//generic variable list
SgInitializedNameList::iterator append_variable(const 
	SgInitializedName & what, SgInitializer *init);

SgInitializedNameList::iterator prepend_variable(const 
	SgInitializedName & what, SgInitializer *init);

SgInitializedNameList::iterator insert_variable(
	SgInitializedNameList::iterator where,
	const SgInitializedName & what);

SgVariableDefinition *get_definition(SgInitializedName* ditem=0);
SgInitializedName *get_decl_item(SgName&);
SgInitializedName *get_defn_item(SgName&);

// Only when there is one variable declaration
SgUnsignedLongVal *get_fitfield();
void set_bitfield(SgUnsignedLongVal *);

void printVariableName(int);
// always output with type but not the base type
void printVariables(Unparse_Info&, ostream& os=cout);

SgStatement *get_next(int &) const;

/* Generated accessors */

/* Protected data members */ protected: SgInitializedNameList p_variables; };

SgVariableDeclaration -- Constructors

/* This is generated in the header file  */
  SgVariableDeclaration(Sg_File_Info *info );

 /* This is the generated constructor */
SgVariableDeclaration::SgVariableDeclaration(Sg_File_Info* info ) 
:SgDeclarationStatement(info)
{

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

SgVariableDeclaration -- Members

Description


SgVariableDefinition

For a variable definition statement.

For base class see SgDeclarationStatement

Variant name: VAR_DEFN_STMT.

class SgVariableDefinition : public SgDeclarationStatement {

void post_construction_initialization()
{ p_bitfield=0; }
SgVariableDefinition(Sg_File_Info *, SgInitializedName *, SgInitializer *);
SgInitializedName *get_defn_item(); 
SgInitializedName *get_decl_item(); 
SgVariableDeclaration *get_declaration(); 

private:
    SgExpressionRoot p_initializer_expr_root;

/* Generated accessors */
SgUnsignedLongVal* get_bitfield() const;
void set_bitfield(SgUnsignedLongVal*);

/* Protected data members */ protected: SgInitializedName p_vardefn; SgUnsignedLongVal* p_bitfield; };

SgVariableDefinition -- Constructors

/* This is generated in the header file  */
  SgVariableDefinition(Sg_File_Info *info , SgUnsignedLongVal* bitfield = 0);

 /* This is the generated constructor */
SgVariableDefinition::SgVariableDefinition(Sg_File_Info* info , SgUnsignedLongVal* bitfield) 
:SgDeclarationStatement(info)
{
p_bitfield = bitfield;

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

SgVariableDefinition -- Members

Description


SgClassDeclaration

Head for class definition and also forward class declaration note: for class defined within a variable declaration class P { ... } pvar; parent ptr of class P {...} is the the variable declaration

For base class see SgDeclarationStatement

Variant name: CLASS_DECL_STMT.

class SgClassDeclaration : public SgDeclarationStatement {

void post_construction_initialization()
{
  if (get_type()) 
    get_type()->set_declaration(this);
  else	
    set_type(SgClassType::createType(this)); 
  p_from_template=0;
}

enum class_types { e_class, e_struct, e_union };

  /* tries to get the enclosing class definition */
SgName get_qualified_name();
SgName get_mangled_qualified_name(int&);

SgStatement *get_first() const;

int replace_statement(SgStatement *o, SgStatement *n);

int get_from_template() const { return p_from_template; }
void set_from_template(int i) { p_from_template=i; }

/* Generated accessors */
SgName get_name() const;
void set_name(SgName);
int get_class_type() const;
void set_class_type(int);
SgClassType* get_type() const;
void set_type(SgClassType*);
SgClassDefinition* get_definition() const;
void set_definition(SgClassDefinition*);

/* Protected data members */ protected: SgName p_name; int p_class_type; SgClassType* p_type; SgClassDefinition* p_definition; int p_from_template; };

SgClassDeclaration -- Constructors

/* This is generated in the header file  */
  SgClassDeclaration(Sg_File_Info *info , SgName name, int class_type, SgClassType* type = 0, SgClassDefinition* definition = 0);

 /* This is the generated constructor */
SgClassDeclaration::SgClassDeclaration(Sg_File_Info* info , SgName name, int class_type, SgClassType* type, SgClassDefinition* definition) 
:SgDeclarationStatement(info)
{
p_name = name; p_class_type = class_type; p_type = type; p_definition = definition;

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

SgClassDeclaration -- Members

Description


SgClassDefinition

Handles class definition statements.

For base class see SgScopeStatement

Variant name: CLASS_DEFN_STMT.

class SgClassDefinition : public SgScopeStatement {

void post_construction_initialization()
{ 
  if(p_declaration) {
    p_declaration->set_definition(this); 
    if(!p_declaration->isForward())
      set_parent(p_declaration);
  }
}

SgDeclarationStatementPtrList & get_members() { return p_members; }
const SgDeclarationStatementPtrList & get_members() const { return p_members; }
void insert_member(SgDeclarationStatementPtrList::iterator where, 
	           SgDeclarationStatement * what)
{ 
  what->set_parent(this);
  p_members.insert(where,what);
}
void append_member(SgDeclarationStatement * what) 
{ insert_member(p_members.end(),what); }
void prepend_member(SgDeclarationStatement * what) 
{ insert_member(p_members.begin(),what); }

SgBaseClassList & get_inheritances() { return p_inheritances; }
const SgBaseClassList & get_inheritances() const { return p_inheritances; }
void append_inheritance(const SgBaseClass & what)
{ insert_inheritance(p_inheritances.end(),what); }
void prepend_inheritance(const SgBaseClass & what)
{ insert_inheritance(p_inheritances.begin(),what); }
void insert_inheritance(SgBaseClassList::iterator where, 
	const SgBaseClass & what)
{ p_inheritances.insert(where,what); }

SgName get_qualified_name() { return get_declaration()->get_qualified_name(); }
SgName get_mangled_qualified_name(int& i) 
{ return get_declaration()->get_mangled_qualified_name(i); }

/* replaces the class declaration or a member declaration that 
   matches statement o */
int replace_statement(SgStatement *o, SgStatement *n);
void insert_statement(SgStatement*, SgStatement*, int);
SgStatement *get_first() const;
SgStatement *get_end() const;
SgClassDeclaration* get_declaration() const { return p_declaration; }
void set_declaration(SgClassDeclaration*);


/* Generated accessors */

/* Protected data members */ protected: SgClassDeclaration* p_declaration; SgDeclarationStatementPtrList p_members; SgBaseClassList p_inheritances; };

SgClassDefinition -- Constructors

/* This is generated in the header file  */
  SgClassDefinition(Sg_File_Info *info , SgClassDeclaration* declaration = 0);

 /* This is the generated constructor */
SgClassDefinition::SgClassDefinition(Sg_File_Info* info , SgClassDeclaration* declaration) 
:SgScopeStatement(info)
{
p_declaration = declaration;

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

SgClassDefinition -- Members

Description


SgEnumDeclaration

Handles enumeration statements; enum are always definitions;

For base class see SgDeclarationStatement

Variant name: ENUM_DECL_STMT.

class SgEnumDeclaration : public SgDeclarationStatement {

/* enum are always definition, it can not be forward declared
   note: for enum defined within a variable declaration
    enum E { apple, orange } evar;
    the parent ptr of EnumDeclaration is the variable declaration
*/
void post_construction_initialization()
{ set_type(SgEnumType::createType(this)); }

SgInitializedNameList & get_enumerators() { return p_enumerators; }
const SgInitializedNameList & get_enumerators() const { return p_enumerators; }

SgInitializedNameList::iterator append_enumerator(const 
	SgInitializedName & what);

SgInitializedNameList::iterator prepend_enumerator(const 
	SgInitializedName & what);

SgInitializedNameList::iterator insert_enumerator(
	SgInitializedNameList::iterator where, const SgInitializedName what);


/* Generated accessors */
SgName get_name() const;
void set_name(SgName);
SgEnumType* get_type() const;
void set_type(SgEnumType*);

/* Protected data members */ protected: SgName p_name; SgEnumType* p_type; SgInitializedNameList p_enumerators; };

SgEnumDeclaration -- Constructors

/* This is generated in the header file  */
  SgEnumDeclaration(Sg_File_Info *info , SgName name = 0, SgEnumType* type = 0);

 /* This is the generated constructor */
SgEnumDeclaration::SgEnumDeclaration(Sg_File_Info* info , SgName name, SgEnumType* type) 
:SgDeclarationStatement(info)
{
p_name = name; p_type = type;

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

SgEnumDeclaration -- Members

Description


SgExprStatement

Expression Statement; (for assignments or function calls)

For base class see SgStatement

Variant name: EXPR_STMT.

class SgExprStatement : public SgStatement {

void post_construction_initialization() 
{ p_expression_root.initialize_root(get_the_expr(),this); };

void set_the_expr(SgExpression * exp);
SgExpression * get_the_expr() const;

private:
    SgExpressionRoot p_expression_root;

/* Generated accessors */
SgExpression* get_the_expr_i() const;
void set_the_expr_i(SgExpression*);

/* Protected data members */ protected: SgExpression* p_the_expr_i; };

SgExprStatement -- Constructors

/* This is generated in the header file  */
  SgExprStatement(Sg_File_Info *info , SgExpression* the_expr_i = 0);

 /* This is the generated constructor */
SgExprStatement::SgExprStatement(Sg_File_Info* info , SgExpression* the_expr_i) 
:SgStatement(info)
{
p_the_expr_i = the_expr_i;

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

SgExprStatement -- Members

Description


SgLabelStatement

Label declaration.

For base class see SgStatement

Variant name: LABEL_STMT.

class SgLabelStatement : public SgStatement {

    SgName get_name() const { return get_label(); }	

/* Generated accessors */
SgName get_label() const;
void set_label(SgName);

/* Protected data members */ protected: SgName p_label; };

SgLabelStatement -- Constructors

/* This is generated in the header file  */
  SgLabelStatement(Sg_File_Info *info , SgName label);

 /* This is the generated constructor */
SgLabelStatement::SgLabelStatement(Sg_File_Info* info , SgName label) 
:SgStatement(info)
{
p_label = label;

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

SgLabelStatement -- Members

Description


SgWhileStmt

While Statement.

For base class see SgScopeStatement

Variant name: WHILE_STMT.

class SgWhileStmt : public SgScopeStatement {

void post_construction_initialization()
{
  if(get_condition()) get_condition()->set_parent(this);
  if(get_body()) get_body()->set_parent(this);
}

SgStatement* get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);


/* Generated accessors */
SgStatement* get_condition() const;
void set_condition(SgStatement*);
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);

/* Protected data members */ protected: SgStatement* p_condition; SgBasicBlock* p_body; };

SgWhileStmt -- Constructors

/* This is generated in the header file  */
  SgWhileStmt(Sg_File_Info *info , SgStatement* condition, SgBasicBlock* body = 0);

 /* This is the generated constructor */
SgWhileStmt::SgWhileStmt(Sg_File_Info* info , SgStatement* condition, SgBasicBlock* body) 
:SgScopeStatement(info)
{
p_condition = condition; p_body = body;

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

SgWhileStmt -- Members

Description


SgDoWhileStmt

Handles Do-While Statements.

For base class see SgScopeStatement

Variant name: DO_WHILE_STMT.

class SgDoWhileStmt : public SgScopeStatement {

void post_construction_initialization()
{
  if(get_condition()) get_condition()->set_parent(this);
  if(get_body()) get_body()->set_parent(this);
}

SgStatement *get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);


/* Generated accessors */
SgStatement* get_condition() const;
void set_condition(SgStatement*);
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);

/* Protected data members */ protected: SgStatement* p_condition; SgBasicBlock* p_body; };

SgDoWhileStmt -- Constructors

/* This is generated in the header file  */
  SgDoWhileStmt(Sg_File_Info *info , SgStatement* condition = 0, SgBasicBlock* body = 0);

 /* This is the generated constructor */
SgDoWhileStmt::SgDoWhileStmt(Sg_File_Info* info , SgStatement* condition, SgBasicBlock* body) 
:SgScopeStatement(info)
{
p_condition = condition; p_body = body;

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

SgDoWhileStmt -- Members

Description


SgSwitchStatement

Switch Statement; has two parts: a selector and the body.

For base class see SgScopeStatement

Variant name: SWITCH_STMT.

class SgSwitchStatement : public SgScopeStatement {

void post_construction_initialization()
{
  p_expression_root.initialize_root(get_item_selector(),this);
  if(get_body()) get_body()->set_parent(this); 
};

void append_case(SgCaseOptionStmt *&);
void prepend_case(SgCaseOptionStmt *&);
void append_default(SgDefaultOptionStmt *&);
void set_item_selector(SgExpression * exp);
SgExpression * get_item_selector() const;
/* if n!=0 returns 0; otherwise the body of the switch statement */
SgStatement *get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);

private:
    SgExpressionRoot p_expression_root;


/* Generated accessors */
SgExpression* get_item_selector_i() const;
void set_item_selector_i(SgExpression*);
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);

/* Protected data members */ protected: SgExpression* p_item_selector_i; SgBasicBlock* p_body; };

SgSwitchStatement -- Constructors

/* This is generated in the header file  */
  SgSwitchStatement(Sg_File_Info *info , SgExpression* item_selector_i, SgBasicBlock* body = 0);

 /* This is the generated constructor */
SgSwitchStatement::SgSwitchStatement(Sg_File_Info* info , SgExpression* item_selector_i, SgBasicBlock* body) 
:SgScopeStatement(info)
{
p_item_selector_i = item_selector_i; p_body = body;

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

SgSwitchStatement -- Members

Description


SgCaseOptionStmt

Case option statement; has a key and the body formed by the statements that corresponding to that case.

For base class see SgStatement

Variant name: CASE_STMT.

class SgCaseOptionStmt : public SgStatement {

void post_construction_initialization() 
{
  p_expression_root.initialize_root(get_key(),this);
  if(get_body()) get_body()->set_parent(this);
};

void set_key(SgExpression * exp);
SgExpression * get_key() const;
/* if n is 0 returns a pointer to the block of stmts 
      otherwise returns 0 */
SgStatement* get_next(int&) const;
/* replaces the body block of statements if they match o by n */
int replace_statement(SgStatement *o, SgStatement *n);

private:
    SgExpressionRoot p_expression_root;

/* Generated accessors */
SgExpression* get_key_i() const;
void set_key_i(SgExpression*);
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);

/* Protected data members */ protected: SgExpression* p_key_i; SgBasicBlock* p_body; };

SgCaseOptionStmt -- Constructors

/* This is generated in the header file  */
  SgCaseOptionStmt(Sg_File_Info *info , SgExpression* key_i, SgBasicBlock* body = 0);

 /* This is the generated constructor */
SgCaseOptionStmt::SgCaseOptionStmt(Sg_File_Info* info , SgExpression* key_i, SgBasicBlock* body) 
:SgStatement(info)
{
p_key_i = key_i; p_body = body;

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

SgCaseOptionStmt -- Members

Description


SgTryStmt

Try Statement;

For base class see SgStatement

Variant name: TRY_STMT.

class SgTryStmt : public SgStatement {

void post_construction_initialization()
{ if(get_body()) get_body()->set_parent(this); }

SgStatement *get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);


/* Generated accessors */
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);

/* Protected data members */ protected: SgBasicBlock* p_body; };

SgTryStmt -- Constructors

/* This is generated in the header file  */
  SgTryStmt(Sg_File_Info *info , SgBasicBlock* body);

 /* This is the generated constructor */
SgTryStmt::SgTryStmt(Sg_File_Info* info , SgBasicBlock* body) 
:SgStatement(info)
{
p_body = body;

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

SgTryStmt -- Members

Description


SgCatchOptionStmt

Catch Statement; catch(int *a) {...}

For base class see SgScopeStatement

Variant name: CATCH_STMT.

class SgCatchOptionStmt : public SgScopeStatement {

void post_construction_initialization()
{
  if(get_condition()) get_condition()->set_parent(this);
  if(get_body()) get_body()->set_parent(this);
}

SgStatement* get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);


/* Generated accessors */
SgVariableDeclaration* get_condition() const;
void set_condition(SgVariableDeclaration*);
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);
SgTryStmt* get_trystmt() const;
void set_trystmt(SgTryStmt*);

/* Protected data members */ protected: SgVariableDeclaration* p_condition; SgBasicBlock* p_body; SgTryStmt* p_trystmt; };

SgCatchOptionStmt -- Constructors

/* This is generated in the header file  */
  SgCatchOptionStmt(Sg_File_Info *info , SgVariableDeclaration* condition, SgBasicBlock* body, SgTryStmt* trystmt);

 /* This is the generated constructor */
SgCatchOptionStmt::SgCatchOptionStmt(Sg_File_Info* info , SgVariableDeclaration* condition, SgBasicBlock* body, SgTryStmt* trystmt) 
:SgScopeStatement(info)
{
p_condition = condition; p_body = body; p_trystmt = trystmt;

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

SgCatchOptionStmt -- Members

Description


SgDefaultOptionStmt

Default option statement.

For base class see SgStatement

Variant name: DEFAULT_STMT.

class SgDefaultOptionStmt : public SgStatement {

void post_construction_initialization()
{ if (get_body()) get_body()->set_parent(this); }

SgStatement* get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);


/* Generated accessors */
SgBasicBlock* get_body() const;
void set_body(SgBasicBlock*);

/* Protected data members */ protected: SgBasicBlock* p_body; };

SgDefaultOptionStmt -- Constructors

/* This is generated in the header file  */
  SgDefaultOptionStmt(Sg_File_Info *info , SgBasicBlock* body = 0);

 /* This is the generated constructor */
SgDefaultOptionStmt::SgDefaultOptionStmt(Sg_File_Info* info , SgBasicBlock* body) 
:SgStatement(info)
{
p_body = body;

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

SgDefaultOptionStmt -- Members

Description


SgBreakStmt

For base class see SgStatement

Variant name: BREAK_STMT.

class SgBreakStmt : public SgStatement {

/* Generated accessors */

};

SgBreakStmt -- Constructors

/* This is generated in the header file  */
  SgBreakStmt(Sg_File_Info *info );

 /* This is the generated constructor */
SgBreakStmt::SgBreakStmt(Sg_File_Info* info ) 
:SgStatement(info)
{

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

No members associated with SgBreakStmt


SgContinueStmt

For base class see SgStatement

Variant name: CONTINUE_STMT.

class SgContinueStmt : public SgStatement {

/* Generated accessors */

};

SgContinueStmt -- Constructors

/* This is generated in the header file  */
  SgContinueStmt(Sg_File_Info *info );

 /* This is the generated constructor */
SgContinueStmt::SgContinueStmt(Sg_File_Info* info ) 
:SgStatement(info)
{

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

No members associated with SgContinueStmt


SgReturnStmt

For base class see SgStatement

Variant name: RETURN_STMT.

class SgReturnStmt : public SgStatement {

void post_construction_initialization() 
{ p_expression_root.initialize_root(get_return_expr(),this); };

void set_return_expr(SgExpression * exp);

SgExpression * get_return_expr() const { return get_return_expr_i(); }

private:
    SgExpressionRoot p_expression_root;

/* Generated accessors */
SgExpression* get_return_expr_i() const;
void set_return_expr_i(SgExpression*);

/* Protected data members */ protected: SgExpression* p_return_expr_i; };

SgReturnStmt -- Constructors

/* This is generated in the header file  */
  SgReturnStmt(Sg_File_Info *info , SgExpression* return_expr_i = 0);

 /* This is the generated constructor */
SgReturnStmt::SgReturnStmt(Sg_File_Info* info , SgExpression* return_expr_i) 
:SgStatement(info)
{
p_return_expr_i = return_expr_i;

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

SgReturnStmt -- Members

Description


SgGotoStatement

For base class see SgStatement

Variant name: GOTO_STMT.

class SgGotoStatement : public SgStatement {

void post_construction_initialization()
{ if(get_label()) get_label()->set_parent(this); }
int replace_statement(SgStatement *o, SgStatement *n);

/* Generated accessors */
SgLabelStatement* get_label() const;
void set_label(SgLabelStatement*);

/* Protected data members */ protected: SgLabelStatement* p_label; };

SgGotoStatement -- Constructors

/* This is generated in the header file  */
  SgGotoStatement(Sg_File_Info *info , SgLabelStatement* label);

 /* This is the generated constructor */
SgGotoStatement::SgGotoStatement(Sg_File_Info* info , SgLabelStatement* label) 
:SgStatement(info)
{
p_label = label;

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

SgGotoStatement -- Members

Description


SgAsmStmt

For base class see SgStatement

Variant name: ASM_STMT.

class SgAsmStmt : public SgStatement {

/* Generated accessors */

};

SgAsmStmt -- Constructors

/* This is generated in the header file  */
  SgAsmStmt(Sg_File_Info *info );

 /* This is the generated constructor */
SgAsmStmt::SgAsmStmt(Sg_File_Info* info ) 
:SgStatement(info)
{

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

No members associated with SgAsmStmt


SgSpawnStmt

For base class see SgStatement

Variant name: SPAWN_STMT.

class SgSpawnStmt : public SgStatement {

/* Generated accessors */
SgFunctionCallExp* get_func() const;
void set_func(SgFunctionCallExp*);

/* Protected data members */ protected: SgFunctionCallExp* p_func; };

SgSpawnStmt -- Constructors

/* This is generated in the header file  */
  SgSpawnStmt(Sg_File_Info *info , SgFunctionCallExp* func);

 /* This is the generated constructor */
SgSpawnStmt::SgSpawnStmt(Sg_File_Info* info , SgFunctionCallExp* func) 
:SgStatement(info)
{
p_func = func;

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

SgSpawnStmt -- Members

Description


SgParBlockStmt

For base class see SgBasicBlock

Variant name: PAR_STMT.

class SgParBlockStmt : public SgBasicBlock {

/* Generated accessors */

};

SgParBlockStmt -- Constructors

/* This is generated in the header file  */
  SgParBlockStmt(Sg_File_Info *info );

 /* This is the generated constructor */
SgParBlockStmt::SgParBlockStmt(Sg_File_Info* info ) 
:SgBasicBlock(info)
{

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

No members associated with SgParBlockStmt


SgParForStmt

For base class see SgForStatement

Variant name: PARFOR_STMT.

class SgParForStmt : public SgForStatement {

/* Generated accessors */

};

SgParForStmt -- Constructors

/* This is generated in the header file  */
  SgParForStmt(Sg_File_Info *info , SgStatement* init_stmt = 0, SgExpression* test_expr_i = 0, SgExpression* increment_expr_i = 0, SgBasicBlock* loop_body = 0);

 /* This is the generated constructor */
SgParForStmt::SgParForStmt(Sg_File_Info* info , SgStatement* init_stmt, SgExpression* test_expr_i, SgExpression* increment_expr_i, SgBasicBlock* loop_body) 
:SgForStatement(info, init_stmt, test_expr_i, increment_expr_i, loop_body)
{

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

No members associated with SgParForStmt


SgTypedefDeclaration

A typedef declaration. note: for the type defined within a typedef declaration typedef class P {...} typevar; the parent of the P is the same as the variable declaration

For base class see SgDeclarationStatement

Variant name: TYPEDEF_STMT.

class SgTypedefDeclaration : public SgDeclarationStatement {

void post_construction_initialization()
{
  set_type(SgTypedefType::createType(this));
  if(p_declaration) p_declaration->set_parent(this);
}

SgStatement *get_next(int&) const;
int replace_statement(SgStatement *o, SgStatement *n);


/* Generated accessors */
SgName get_name() const;
void set_name(SgName);
SgType* get_base_type() const;
void set_base_type(SgType*);
SgTypedefType* get_type() const;
void set_type(SgTypedefType*);
SgDeclarationStatement* get_declaration() const;
void set_declaration(SgDeclarationStatement*);
SgSymbol* get_parent_scope() const;
void set_parent_scope(SgSymbol*);

/* Protected data members */ protected: SgName p_name; SgType* p_base_type; SgTypedefType* p_type; SgDeclarationStatement* p_declaration; SgSymbol* p_parent_scope; };

SgTypedefDeclaration -- Constructors

/* This is generated in the header file  */
  SgTypedefDeclaration(Sg_File_Info *info , SgName name, SgType* base_type, SgTypedefType* type = 0, SgDeclarationStatement* declaration = 0, SgSymbol* parent_scope = 0);

 /* This is the generated constructor */
SgTypedefDeclaration::SgTypedefDeclaration(Sg_File_Info* info , SgName name, SgType* base_type, SgTypedefType* type, SgDeclarationStatement* declaration, SgSymbol* parent_scope) 
:SgDeclarationStatement(info)
{
p_name = name; p_base_type = base_type; p_type = type; p_declaration = declaration; p_parent_scope = parent_scope;

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

SgTypedefDeclaration -- Members

Description


SgTemplateClassDeclaration

For base class see SgDeclarationStatement

Variant name: TEMPLATE_CLASS_DECL_STMT.

class SgTemplateClassDeclaration : public SgDeclarationStatement {

void post_construction_initialization() { }

/* Generated accessors */
SgName get_string() const;
void set_string(SgName);

/* Protected data members */ protected: SgName p_string; };

SgTemplateClassDeclaration -- Constructors

/* This is generated in the header file  */
  SgTemplateClassDeclaration(Sg_File_Info *info , SgName string);

 /* This is the generated constructor */
SgTemplateClassDeclaration::SgTemplateClassDeclaration(Sg_File_Info* info , SgName string) 
:SgDeclarationStatement(info)
{
p_string = string;

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

SgTemplateClassDeclaration -- Members

Description


Goto:
[Extreme] Extreme! Computing Home Page


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