Auxiliary Classes for Sage++2.0

Class SgName

 Data Members:
private:
  char * p_char;

 Function Members: 
public:
/* constructors */
SgName();
SgName(const char * str);
SgName(const SgName& n);
SgName(const char *str, int n); // get first n chars in the string
~SgName(); //destructor

/* class operators */
int operator!=(const SgName& n1) const;
int operator==(const SgName& n1) const;
int operator<(const SgName& n1) const;
SgName& operator<<(const char* str);//concatenation
static SgName itoname(int val);
SgName& operator<<(int val);
SgName& operator=(const SgName& n1);

SgName& tail(int n); // keep string after n
SgName& head(int n); // keep first n chars

int is_null(void) const;
// replaces a space inside string p_char by char t
void replace_space(char t);

  const char* str() const { return p_char;}
  operator char*() { return p_char; }

};

Class SgInitializedName

 Data Members:
private:
    SgName p_name;
    SgType *p_typeptr;
    union {
      SgInitializer *p_initptr;
      SgInitializedName *p_prev_itemptr;
    };
    short p_is_initializer;
    SgDeclarationStatement *p_declptr;
           // var decl pt to defn item, var defn pt to decl item
    SgInitializedName *p_itemptr; 

    friend class Sg_Copy_Info; /* does cloning of a tree */

 Function Members: 
public:
/* constructors */
  SgInitializedName() : p_typeptr(0), p_initptr(0), p_declptr(0),
    p_itemptr(0), p_prev_itemptr(0), p_is_initializer(1) {}
  SgInitializedName(const SgName& name, SgType *typeptr, SgInitializer* iptr=0,
    SgDeclarationStatement *declptr=0 , SgInitializedName *itemptr=0,
    SgInitializedName *prev_itemptr=0 ) : p_name(name), p_typeptr(typeptr),
    p_initptr(iptr),p_declptr(declptr), p_itemptr(itemptr), p_is_initializer(1)
    { if(prev_itemptr) set_prev_decl_item(prev_itemptr); }
  SgInitializedName(const SgInitializedName& ptr);
/* destructor */
  ~SgInitializedName() { /*delete p_ptr;*/ }

/* operators */
  SgInitializedName& operator= (const SgInitializedName& ptr);
  inline bool operator== (const SgInitializedName& ) const;
  inline bool operator< (const SgInitializedName&) const;

  SgName get_name() const { return p_name; }
  SgType *get_type() const { return p_typeptr; }
  void set_type(SgType *t) { p_typeptr=t; }
 
  SgInitializer *get_initializer() const;
  void set_initializer(SgInitializer* i);

  SgDeclarationStatement *get_declaration() const;
  void set_declaration(SgDeclarationStatement * decl);

  SgInitializedName *get_prev_decl_item() const;
  void set_prev_decl_item(SgInitializedName * item);

  SgInitializedName *get_named_item() const { return p_itemptr; }
  void set_named_item(SgInitializedName * item) { p_itemptr=item; }

};

Class SgBaseClass

 Data Members:
private:
    int p_specifier;
    int p_direct;
    SgClassDeclaration* p_ptr;
    friend class Sg_Copy_Info;
public:
    typedef SgDeclarationStatement::decl_specifier_enum; 

 Function Members: 
public:
 
/* constructors */
  SgBaseClass(int specifier=0,SgClassDeclaration* ptr = 0, int dir = 0) :
    p_specifier(specifier), p_ptr(ptr), p_direct(dir) { }
  SgBaseClass(const SgBaseClass& ptr);
/* destructor */
  ~SgBaseClass() { /*delete p_ptr;*/ }

  int get_base_specifier() const;
  SgClassDeclaration* get_base_class() const;
  SgClassDeclaration* replace_base_class(SgClassDeclaration *);

/* operators */
  SgBaseClass& operator= (const SgBaseClass& ptr);
  inline bool operator== (const SgBaseClass& ) const
  { return false; }
  inline bool operator< (const SgBaseClass&) const
  { return false; }

};

Class SgSymbolTable

 Data Members:
private:
  SgSymbolHashBase::iterator p_iterator;
  SgName p_name;
  bool p_no_name;
  SgSymbolHashMultiMap * p_table;

 Function Members: 
public:
/* constructors */
  SgSymbolTable() : p_no_name(1) { p_table = 0; }
  SgSymbolTable(int sz);

/* destructor */
  inline ~SgSymbolTable();

  void insert(const SgName &, SgSymbol *sp);
  int find(const SgName &, SgSymbol *sp);

  SgVariableSymbol * findfirstvar();
  SgClassSymbol * findfirstclass();
  SgFunctionSymbol * findfirstfunction();

  SgSymbol * findfirstany();
  SgSymbol * findany(const SgName &);
  SgSymbol * nextany();

  SgVariableSymbol * findvar(const SgName &);
  SgVariableSymbol * nextvar();

  SgClassSymbol * findclass(const SgName &);
  SgClassSymbol * nextclass();

  SgTypedefSymbol * findtypedef(const SgName &); 
  SgEnumSymbol * findenum(const SgName &);
  SgEnumFieldSymbol * findenumfield(const SgName &);

// for both global function and member functions
  SgFunctionSymbol * findfunc(const SgName&, const SgType*);
  SgFunctionSymbol * findfunc(const SgName&); 
  SgFunctionSymbol * nextfunc();

  SgFunctionTypeSymbol * findfunctype(const SgName&) const; 
                              // for func type table
  SgLabelSymbol * findlabel(const SgName &) const;
  SgSymbol * operator[](const SgName &);
  int count(const SgName &nm);
  void print(ostream&);
  void print();
// size of the table
  int size() const;

};

Class SgStatementPtr

Data Members 
private:
    SgStatement* p_ptr;

 Function Members: 
public:
/* constructors */
  SgStatementPtr(SgStatement* ptr = 0) : p_ptr(ptr) { }
  SgStatementPtr(const SgStatementPtr& ptr);

/* destructor */
  ~SgStatementPtr() { /*delete p_ptr;*/ }

/* operators */
  SgStatement* operator->()  { return p_ptr; }
  const SgStatement* operator->()  const { return p_ptr; }
  SgStatementPtr& operator= (const SgStatementPtr& ptr);
  SgStatementPtr& operator= (SgStatement *ptr);

  inline bool operator== (const SgStatementPtr& p) const;
  inline bool operator< (const SgStatementPtr&) const;

  SgStatement* irep(void) const { return p_ptr; }
  SgStatement* replace(SgStatement *); 

};

Class SgDeclarationStatementPtr

Data Members 
private:
    SgDeclarationStatement* p_ptr;

 Function Members: 
public:
/* constructors */
  SgDeclarationStatementPtr(SgDeclarationStatement* ptr = 0) : p_ptr(ptr) { }
  SgDeclarationStatementPtr(const SgDeclarationStatementPtr& ptr);
/* destructor */
  ~SgDeclarationStatementPtr() { /*delete p_ptr;*/ }

/* operators */
  SgDeclarationStatement* operator->()  { return p_ptr; }
  const SgDeclarationStatement* operator->()  const { return p_ptr; }
  SgDeclarationStatementPtr& operator= (const 
         SgDeclarationStatementPtr& ptr);
  SgDeclarationStatementPtr& operator= (SgDeclarationStatement* ptr);
  inline bool operator== (const SgDeclarationStatementPtr& p) const;
  inline bool operator< (const SgDeclarationStatementPtr&) const;
  SgDeclarationStatement* irep(void) const { return p_ptr; }
  SgDeclarationStatement* replace(SgDeclarationStatement *); 

};

Class SgTypePtr

Data Members 
private:
    SgType* p_ptr;

 Function Members: 
public:
/* constructors */
  SgTypePtr(SgType* ptr = 0) : p_ptr(ptr) { }
  SgTypePtr(const SgTypePtr& ptr);
/* destructor */
  ~SgTypePtr() { /*delete p_ptr;*/ }
  SgType* operator->()  { return p_ptr; }
  const SgType* operator->() const { return p_ptr; }

  SgType* irep() const { return p_ptr; }
  SgType* replace(SgType *);

  SgTypePtr& operator= (const SgTypePtr& ptr);
  inline bool operator== (const SgTypePtr& p) const;
  inline bool operator< (const SgTypePtr&) const;

};

Class SgExpressionPtr

Data Members 
private:
    SgExpression* p_ptr;

 Function Members: 
public:
/* constructors */
  SgExpressionPtr(SgExpression* ptr = 0) : p_ptr(ptr) { }
  SgExpressionPtr(const SgExpressionPtr& ptr) {
    p_ptr = ptr.p_ptr;
    /* p_ptr = ptr() ? ptr()->clone() : 0 */;
  }

/* destructor */
  ~SgExpressionPtr() { /*delete p_ptr;*/ }

/* operators */
  SgExpression* operator->()  { return p_ptr; }
  const SgExpression* operator->() const { return p_ptr; }
  SgExpressionPtr& operator= (const SgExpressionPtr& ptr);
  SgExpressionPtr& operator= (SgExpression* ptr);

  inline bool operator== (const SgExpressionPtr& p) const
  { return (p_ptr == p.p_ptr); }
  inline bool operator< (const SgExpressionPtr&) const
  { return false; }

  SgExpression* irep() const { return p_ptr; }
  SgExpression* replace(SgExpression *);

};

Class SgAttribute

Data Members 
private:
  char *p_name; // attribute name or pragma name

 Function Members: 
public:
/* constructors */
  SgAttribute();
  SgAttribute(char *str);
/* destructor */
  ~SgAttribute() { if(p_name) delete [] p_name; }
  int isSame(char *str);
  virtual int isPragma() const =0;
  char *get_name() const { return p_name; }

};

Class SgPragma

Data Members 
private:
  short printed;

 Function Members: 
public:
/* constructors */
  SgPragma(char *name) : SgAttribute(name), printed(0) {};

  char *get_pragma() const { return get_name(); }
  int samePragma(char *str) { return (strcmp(get_name(),str)==0); }
  int isPragma() const { return 1; }
  int gotPrinted() const { return printed; }
  void setPrinted(int s=1) { printed=s; }

};

Class SgBitAttribute

Data Members 
private:
  unsigned long int p_bitflag;

 Function Members: 
public:
/* constructors */
  SgBitAttribute(char *str): SgAttribute(str), p_bitflag(0) {}

  int isAttributeSet(unsigned long int bit) const
  { return (p_bitflag & bit); }
  void setAttribute(unsigned long int bit) { p_bitflag |=bit; }
  void unsetAttribute(unsigned long int bit) { p_bitflag &= ~bit; }
  int isPragma() const { return 0; } 
};

Class FuncDecl_attr

/* attribute class */
/* to suppress the printing of atomic keyword */
Data Members 
private:
  enum { e_suppressatomic = 0x00000001 };

 Function Members: 
public:
  FuncDecl_attr() : SgBitAttribute("FuncDecl_attr") {}
  void set_suppress_atomic()
  { setAttribute(e_suppressatomic); }
  int get_suppress_atomic() const
  { return isAttributeSet(e_suppressatomic); }
};

Class ClassDecl_attr

/* local attribute class */
/* to suppress the printing of global keyword */
Data Members 
private:
  enum { e_suppress_global = 0x00000001 };
 Function Members: 
public: 
  ClassDecl_attr() : SgBitAttribute("ClassDecl_attr") {} 
  void set_suppress_global() 
  { setAttribute(e_suppress_global); }
  int get_suppress_global() const
  { return isAttributeSet(e_suppress_global); }
};

Class SgAttributePtr

Data Members 
private:
  SgAttribute* p_ptr;

 Function Members: 
public:
/* constructors */
  SgAttributePtr(SgAttribute *ptr=0): p_ptr(ptr) {}
  SgAttributePtr(const SgAttributePtr& ptr);
/* destructor*/
  ~SgAttributePtr() { /* delete p_ptr; */}
/* operators */
  SgAttributePtr& operator= (const SgAttributePtr& ptr);

  SgAttribute* irep(void) const { return p_ptr; }
  SgAttribute* replace(SgAttribute *);

  int isPragma() const;
  int isSame(char *str) const; 

  inline bool operator== (const SgAttributePtr& p) const
  { return (p_ptr == p.p_ptr); }
  inline bool operator< (const SgAttributePtr&) const
  { return false; }

};

Class SgModifierNodes

Data Members 
private:
   SgModifierType* nodes[4];
   SgModifierNodes* next;

 Function Members: 
public:
/* constructors */
SgModifierNodes(){
      nodes[0] = nodes[1] = nodes[2] = nodes[3] = (SgModifierType*)0L;
      next = (SgModifierNodes*)0L;
   }
/* destructor */
   ~SgModifierNodes(){ delete next; }

   SgModifierType* match(SgType*, unsigned int);

};

Class Unparse_Info

Private Members 

// space for unparse_type_num tag
  unsigned int unparse_attribute; 
// space for access_attr_enum tag
  int access_attribute;

  int nested_expression;
// for those complicated statemenet unparser that has a special
// unparser helper
  SgNode*  unparse_helper;

// for carrying along the variable name when printing out function/array
// type with the symbol's name
  const char * operator_name;
  SgName var_name;

// keep ptr to the declaration statement 
  SgDeclarationStatement *declstatement_ptr;
// keep current scope's type, set in SgClassDefinition's unparser 
  SgNamedType *current_context;
// keep track of previous array type's index string -- this is because
// array is built like this  A[2][3]  Array(Array(A,3),2) 
  SgName array_index_list;

  int checkBit(unsigned int bit) const
  { if(unparse_attribute & bit) return 1; else return 0; }
  void setBit(unsigned int bit) { unparse_attribute |= bit; }
  void unsetBit(unsigned int bit) { unparse_attribute &= ~bit; }


Pulic Members 
enum unparse_type_num { 
// to postponing the printing of name for ptr of function or array etc
  b_isPointerToSomething     = 0x00000001,
  b_isReferenceToSomething   = 0x00000002,
// if it is in Variable Declaration, output either , or ; for SgExprStmt
  b_inVarDecl              = 0x00000004,
// in a function header, output type+ symbol 
  b_inArgList              = 0x00000008,  
// no ';' for declaration statement
  b_SkipSemiColon          = 0x00000010,
// to setup for printing of enum var in a VariableDeclaration
  b_inEnumDecl             = 0x00000020, 
// not really being used 
  b_inTemplateList         = 0x00000040,
// suppress printing of the base type
  b_SkipBaseType           = 0x00000080,
// for skip "=" if in aggregate initializer
  b_inAggregateInitializer = 0x00000100,
// for print both type & sym name
  b_isWithType             = 0x00000200, 
// it is in conditional expr
  b_inConditional          = 0x00000400,
// skip printing definition part of a declaration
  b_SkipDefinition         = 0x00000800,
// need to put in either class/struct/union keyword 
  b_SkipClassSpecifier     = 0x00001000,
// printing something within a variable declaration
  b_inEmbeddedDecl         = 0x00002000,
// suppress the printing of global and atomic
  b_SkipGlobal             = 0x00004000,
  b_SkipAtomic             = 0x00008000,
// used by set/unsetName and set/unsetPrintName to bring down the 
// Name to lower tree structure
  b_PrintName              = 0x00010000,
// to set the need to check if need access specifier
  b_CheckAccess            = 0x00020000,
// to skip function qualifiers
  b_SkipFunctionQualifier  = 0x00040000,
// to show that the type above current one is an array
  b_isArrayType            = 0x00080000,
// to indicate that this is at the right hand side of a
// binary op
  b_inRhsExpr              = 0x00100000
};

enum access_attr_enum {
  a_unset_access     = 1,
  a_private_access   = 2,
  a_protected_access = 3,
  a_public_access    = 4
};

/* constructor */
Unparse_Info()
  {
    unparse_attribute=0;
    access_attribute=a_unset_access;
    nested_expression =0;
    operator_name =0;
    var_name=0;
    unparse_helper=0;
    declstatement_ptr=0;
    current_context=0;
    array_index_list=0;
  }


/* accessor functions */
// access function to Unparse_Info 
  int get_access_attribute() const     { return access_attribute; }
  void set_access_attribute(int a)   { access_attribute=a; } 

  int isUnsetAccess() const     { return access_attribute == a_unset_access; }
  void set_isUnsetAccess()      { access_attribute = a_unset_access; }
  int isPrivateAccess() const   { return access_attribute == a_private_access; }
  void set_isPrivateAccess()    { access_attribute = a_private_access; }
  int isProtectedAccess() const { return access_attribute == a_protected_access; }
  void set_isProtectedAccess()  { access_attribute = a_protected_access; } 
  int isPublicAccess() const    { return access_attribute == a_public_access; }
  void set_isPublicAccess()     { access_attribute = a_public_access; }  

  int isPointerToSomething() const { return checkBit(b_isPointerToSomething); }
  void set_isPointerToSomething()  { setBit(b_isPointerToSomething); }
  void unset_isPointerToSomething() { unsetBit(b_isPointerToSomething); }

  int isReferenceToSomething() const { return checkBit(b_isReferenceToSomething); }
  void set_isReferenceToSomething()  { setBit(b_isReferenceToSomething); }
  void unset_isReferenceToSomething() { unsetBit(b_isReferenceToSomething); }
	 
  int inVarDecl() const { return checkBit(b_inVarDecl); }
  void set_inVarDecl()  { setBit(b_inVarDecl); }
  void unset_inVarDecl() { unsetBit(b_inVarDecl); }
	 
  int inArgList() const { return checkBit(b_inArgList); }
  void set_inArgList()  { setBit(b_inArgList); }
  void unset_inArgList() { unsetBit(b_inArgList); }
	 
  int SkipSemiColon() const { return checkBit(b_SkipSemiColon); }
  void set_SkipSemiColon()  { setBit(b_SkipSemiColon); }
  void unset_SkipSemiColon() { unsetBit(b_SkipSemiColon); }

  int inEnumDecl() const { return checkBit(b_inEnumDecl); }
  void set_inEnumDecl()  { setBit(b_inEnumDecl); }
  void unset_inEnumDecl() { unsetBit(b_inEnumDecl); }

  int inTemplateList() const { return checkBit(b_inTemplateList); }
  void set_inTemplateList()  { setBit(b_inTemplateList); }
  void unset_inTemplateList() { unsetBit(b_inTemplateList); }

  int SkipBaseType() const { return checkBit(b_SkipBaseType); }
  void set_SkipBaseType()  { setBit(b_SkipBaseType); }
  void unset_SkipBaseType() { unsetBit(b_SkipBaseType); }

  int inAggregateInitializer() const { return checkBit(b_inAggregateInitializer); }
  void set_inAggregateInitializer()  { setBit(b_inAggregateInitializer); }
  void unset_inAggregateInitializer() { unsetBit(b_inAggregateInitializer); }

  int isWithType() const { return checkBit(b_isWithType); }
  void set_isWithType()  { setBit(b_isWithType); }
  void unset_isWithType() { unsetBit(b_isWithType); }

  int inConditional() const { return checkBit(b_inConditional); }
  void set_inConditional()  { setBit(b_inConditional); }
  void unset_inConditional() { unsetBit(b_inConditional); }

  int SkipDefinition() const { return checkBit(b_SkipDefinition); }
  void set_SkipDefinition()  { setBit(b_SkipDefinition); }
  void unset_SkipDefinition() { unsetBit(b_SkipDefinition); }

  int SkipClassSpecifier() const { return checkBit(b_SkipClassSpecifier); }
  void set_SkipClassSpecifier()  { setBit(b_SkipClassSpecifier); }
  void unset_SkipClassSpecifier() { unsetBit(b_SkipClassSpecifier); }

  int inEmbeddedDecl() const { return checkBit(b_inEmbeddedDecl); }
  void set_inEmbeddedDecl()  { setBit(b_inEmbeddedDecl); }
  void unset_inEmbeddedDecl() { unsetBit(b_inEmbeddedDecl); }

  int SkipGlobal() const { return checkBit(b_SkipGlobal); }
  void set_SkipGlobal()  { setBit(b_SkipGlobal); }
  void unset_SkipGlobal() { unsetBit(b_SkipGlobal); }

  int SkipAtomic() const { return checkBit(b_SkipAtomic); }
  void set_SkipAtomic()  { setBit(b_SkipAtomic); }
  void unset_SkipAtomic() { unsetBit(b_SkipAtomic); }

  int PrintName() const { return checkBit(b_PrintName); }
  void set_PrintName() { if(!var_name.is_null()) setBit(b_PrintName); }
  void unset_PrintName() { unsetBit(b_PrintName); }

  int CheckAccess() const { return checkBit(b_CheckAccess); }
  void set_CheckAccess()  { setBit(b_CheckAccess); }
  void unset_CheckAccess() { unsetBit(b_CheckAccess); }

  int SkipFunctionQualifier() const { return checkBit(b_SkipFunctionQualifier); }
  void set_SkipFunctionQualifier()  { setBit(b_SkipFunctionQualifier); }
  void unset_SkipFunctionQualifier() { unsetBit(b_SkipFunctionQualifier); }

  int isArrayType() const { return checkBit(b_isArrayType); }
  void set_isArrayType()  { setBit(b_isArrayType); }
  void unset_isArrayType() { unsetBit(b_isArrayType); }

  int inRhsExpr() const { return checkBit(b_inRhsExpr); }
  void set_inRhsExpr()  { setBit(b_inRhsExpr); }
  void unset_inRhsExpr() { unsetBit(b_inRhsExpr); }

  const char * get_operator_name() { return operator_name; }
  void set_operator_name(const char * on) { operator_name = on; }

  SgName& get_name() { return var_name; }
  void set_name(SgName& name ) { var_name = name; set_PrintName(); }
  void unset_name() { unset_PrintName(); var_name=0; }

  SgDeclarationStatement* get_decl_stmt() { return declstatement_ptr; }
  void set_decl_stmt(SgDeclarationStatement* stmt ) { declstatement_ptr = stmt; }
  void unset_decl_stmt() { declstatement_ptr=0; }

  int get_nested_expression() { return nested_expression; }
  void set_nested_expression() { nested_expression++; }
  void unset_nested_expression() { nested_expression--; }

  SgNode* get_unparse_helper() { return unparse_helper; }
  void set_unparse_helper(SgNode* fd) { unparse_helper=fd; }
  void unset_unparse_helper() { unparse_helper=0; }

  SgNamedType *get_current_context() { return current_context; }
  void set_current_context(SgNamedType *t) { current_context=t; }
  void unset_currrent_context() { current_context=0; }

  SgName get_array_index_list() { return array_index_list; }
  void set_array_index_list(SgExpression *e, Unparse_Info finfo ) { 
     array_index_list << "[";
     ostrstream buffer;
     if(e) e->unparse(finfo,buffer);
     buffer << ends;
     array_index_list << buffer.str() << "]";
  }
  void unset_array_index_list() { array_index_list=0; }
}; 

Class Sg_Copy_Info

Private Members 
private:

  class SgNodePair {
  public:
    SgNodePair()
      :p_original(0), p_copy(0){}
    SgNodePair(SgNode* original, SgNode* copy)
      :p_original(original), p_copy(copy){}
    
    const SgNode* p_original;
    SgNode* p_copy;
  };


  SgNodePair p_store[MAX_COPY_STORE];  /* this holds the pointers */
  int      p_num_stored;


 Public Mambers
public:
  Sg_Copy_Info();
  /*
   * to_be_copied(SgNode* node)
   * takes a pointer to a node from the source tree,
   * if the node has already been copied it returns a pointer to the copy
   * if the node does not need to be copied (because it is outside the 
   *   tree to be copied (for example a definition, or builtin type)
   *   it returns a pointer to itself
   * otherwise it creates a copy and returns it.
   */
  SgNode* copy_sage_type(const SgNode* node);
  /*
   * insert pair is used to add an association between an original node
   * and a copy
   */
  void insert_pair(const SgNode* original, SgNode* copy);
  /* 
   * look_for_copy
   * returns cpy of the original node if such has been made, 
   * otherwise returns zero
   */
  SgNode* look_for_copy(const SgNode* original);

  Sg_File_Info* copy_file_info(Sg_File_Info* file_info);
    /* 
   * copy is defined for all the other, non-sage types, and chosen using 
   * overloading
   */

  void copy(SgName& target, const SgName& source);
  void copy(SgInitializedNameList& target,const SgInitializedNameList& source);
  void copy(SgSymbolTable& target, const SgSymbolTable& source);
  void copy(SgDeclarationStatementPtrList& target, const SgDeclarationStatementPtrList& source);
  void copy(SgBaseClassList& target, const SgBaseClassList& source);
  void copy(SgTypePtrList& target, const SgTypePtrList& source);
  void copy(SgExpressionPtrList& target, const SgExpressionPtrList& source);
  void copy(SgInitializedName& target, const SgInitializedName& source);
  void copy(SgInitializedName* target, const SgInitializedName* source);
  void copy(SgUnaryOp::op_mode& target, const SgUnaryOp::op_mode& source);
  void copy(SgCastExp::e_cast_type& target, const SgCastExp::e_cast_type& source);
  void copy(SgStatementPtrList& target, const SgStatementPtrList& source);
  void copy(SgBaseClass& target, const SgBaseClass& source);

  void copy(SgDeclarationStatementPtr& target, const SgDeclarationStatementPtr& source);
  void copy(SgTypePtr& target, const SgTypePtr& source);
  void copy(SgExpressionPtr& target, const SgExpressionPtr& source);
  void copy(SgStatementPtr& target, const SgStatementPtr& source);
  
  /*
   * copys for builtins
   */
  void copy(unsigned int& target, const unsigned int& source)
    {target=source;}
  void copy(char* target, const char* source);
    {
      if (target != source){
	delete target; 
	target=new char[::strlen(source) +1];
	strcpy(target,source);
      }
    }
  void copy(int& target, const int& source)
    {target=source;}
  void copy(unsigned long& target, const unsigned long& source)
    {target=source;}
  void copy(long& target, const long& source)
    {target=source;}
  void copy(long long& target, const long long& source)
    {target=source;}
  void copy(unsigned long long& target, const unsigned long long& source)
    {target=source;}
  void copy(unsigned short& target, const unsigned short& source)
    {target=source;}
  void copy(short& target, const short& source)
    {target=source;}
  void copy(char& target, const char& source)
    {target=source;}
  void copy(wchar_t& target, const wchar_t& source)
    {target=source;}
  void copy(unsigned char& target, const unsigned char& source)
    {target=source;}
  void copy(float& target, const float& source)
    {target=source;}
  void copy(double& target, const double& source)
    {target=source;}
  void copy(long double& target, const long double& source)
    {target=source;}

};

Class Sg_File_Info

Private Members 
private:
  char* p_filename;
  int   p_line;
  int   p_col;
 
  static int cur_line;
  static char* cur_file;

Public Members 
public:
  void register_node(SgLocatedNode* node){} /* register interest */
  void deregister_node(SgLocatedNode* node){} 
  Sg_File_Info();
  Sg_File_Info(const char* filename, int line, int col);
  void set_line(int line) { p_line = line; }
  void set_filename(char* filename) { p_filename = filename; }
  void output(ostream& os);
 
  char* get_filename() { return p_filename; }
  int   get_line() { return p_line; }
  int   get_col() { return p_col; }
};

Class Sg_Print_Info

Private Members 
private:
  const SgNode *p_store[MAX_STORE];  /* this holds the pointers */
  int      p_num_stored;
  int p_max_depth;
  Sg_Print_Info(); /* these will be a singleton, globally visible */
  ostream *p_stream;
  friend Sg_Print_Info& sg_print_info();/* accessor to the single instance*/


Public Members 
public:
  void reset(ostream* os, int max_depth);/* sets everything up for new print*/
  ostream& stream() {return *p_stream;}
  bool already_printed(const SgNode *node, int& new_number);    
  
  /* 
   * output_class returns a bool indicating whether the subfields need to   * be output.
   */
  bool output_class(const SgNode *node, const char* name, int depth);
  bool output_class(const SgGlobal *node, const char* name, int depth);
  bool output_class(const SgBasicBlock *node, const char* name, int depth);
  bool output_class(const SgVariableDeclaration *node, const char* name,
     int depth);

  bool output_class(const SgClassDefinition *node, const char* name, int depth);
  bool output_class(const SgEnumDeclaration *node, const char* name, int depth);

  bool output_class(const SgFunctionType *node, const char* name, int depth);
  bool output_class(const SgMemberFunctionType *node, const char* name, int depth);

  void output_parent(int variant, int depth);
  void output_field(const SgNode *node, const char* name, int depth);
  void output_field(const SgName& id, const char* name, int depth);
  void output_field(const SgName* id, const char* name, int depth);
  void output_field(const SgInitializedName * id, const char* name, int depth);
  void output_field(const SgInitializedName&, const char* name, int depth);
  void output_field(const SgBaseClass * id, const char* name, int depth);
  void output_field(const char* id, const char* name, int depth); 
  void output_field(SgIter&, const char* name, int depth);
  void output_field(const SgStatementPtrList&, const char* name, int depth);
  void output_field(const SgDeclarationStatementPtrList&, const char* name, int depth);
  void output_field(const SgInitializedNameList&, const char* name, int depth);
  void output_field(const SgTypePtrList&, const char* name, int depth);
  void output_field(const SgExpressionPtrList&, const char* name, int depth);
  void output_field(const SgBaseClassList&, const char* name, int depth);
  void output_field(unsigned int val, const char* name, int depth);
  void output_field(unsigned long  val, const char* name, int depth);
  void output_field(int val, const char* name, int depth);
  void output_field(long val, const char* name, int depth);
  void output_field(long long val, const char* name, int depth);
  void output_field(unsigned long long val, const char* name, int depth);
  void output_field(char val, const char* name, int depth);
  void output_field(float val, const char* name, int depth);
  void output_field(double val, const char* name, int depth);
  void output_field(long double val, const char* name, int depth);

  void output_field(Sg_File_Info* file_info, int depth);

  void output_field(const SgSymbolTable& st, const char* name, int depth);

// XXX MEI, This is a dummy stub to make it link
  void output_field(SgType **val, const char* name, int depth);
  int max_depth() const {return p_max_depth;}
  void tabs(int tab);
  
};

Class SgFile

Private Members 
private:
 SgGlobal p_root;

Public Members 
public:
  SgFile() {};
  void unparsestdout();
  void unparse(ostream&);
  SgGlobal & root() { return p_root;}

Class SgProject

Private Members 
private:
 SgFile* p_file;

Public Members 
public:
  SgProject();
  int numberOfFiles() { return 1; }
  SgFile& file(int i)
  {
    assert(i==0);
    return *p_file;
  }

Class Sg_Options

Private Members 
private:
  Sg_Options(); /* to stop anyone but sg_options() instantiating it */
 
  ostream* p_default_output;
  ostream* p_debug_output;
  ostream* p_error_output;
  ostream* p_logging_output;
  int      p_debug_level;
  int      p_logging_level;
friend Sg_Options& sg_options();


Public Members 
public:
  inline ostream& default_output()      { return *p_default_output;}
  inline void set_default_output(ostream& os){ p_default_output = &os;}
 
  inline ostream& debug_output()        { return *p_debug_output;}
  inline void set_debug_output(ostream& os)  { p_debug_output = &os;}
 
  inline ostream& error_output()        { return *p_error_output;}
  inline void set_error_output(ostream& os)  { p_error_output = &os;}
 
  inline ostream& logging_output()      { return *p_logging_output;}
  inline void set_logging_output(ostream& os){ p_logging_output = &os;}
 
  inline int debug_level()         {return p_debug_level;}
  inline void set_debug_level(int l) { p_debug_level = l; }
 
  inline int logging_level() {return p_logging_level;}
  inline void set_logging(ostream& log_file, int level) 
  {p_logging_level = level; p_logging_output = &log_file;}
 
};

Class Sg_Tree_Traverser

Private Members 
private:
  int p_num_visited;
  SgNode* p_already_visited[MAX_TREE_SIZE];

Public Members 
public:
  Sg_Tree_Traverser():p_num_visited(0){}

  virtual void visit(SgNode* node);
  /*
   * user_visit is the function that would be overridden 
   * by the user for a particular traverser
   */
  bool already_visited(SgNode* node);
  virtual void user_visit(SgNode* node) = 0; 
  
  /*
   * these next functions deal with list types etc, where visiting
   * will probably not be overridden
   */
  virtual void visit(SgDeclarationStatementPtrList& item);  
  virtual void visit(SgStatementPtrList& item);  
  virtual void visit(const SgStatementPtr &item);
  virtual void visit(const SgDeclarationStatementPtr &item);

  /* 
   * the base class list is not visited by default 
   */
  virtual void visit(SgBaseClassList& item) {};
  
  /*
   * none of the following have any default action
   */
  virtual void visit(SgInitializedNameList& item) {};
  virtual void visit(SgSymbolTable& symbol_table) {};
  virtual void visit(SgUnaryOp::op_mode& item) {};
  virtual void visit(SgCastExp::e_cast_type& item) {};
  virtual void visit(SgName& item) {};
  virtual void visit(SgTypePtrList& item) {};
  virtual void visit(SgExpressionPtrList& item) {};
  virtual void visit(SgInitializedName* item) {};
  virtual void visit(SgInitializedName& item) {};
  /*
   * the builtin types are basically ignored by default
   */
  virtual void visit(unsigned int& item){}
  virtual void visit(char* item)  {}
  virtual void visit(int& item)    {}
  virtual void visit(unsigned long& item)  {}
  virtual void visit(long& item)  {}
  virtual void visit(long long& item)  {}
  virtual void visit(unsigned long long& item)  {}
  virtual void visit(unsigned short& item)  {}
  virtual void visit(short& item)  {}
  virtual void visit(char& item)  {}
  virtual void visit(wchar_t& item)  {}
  virtual void visit(unsigned char& item)  {}
  virtual void visit(float& item)  {}
  virtual void visit(double& item)  {}
  virtual void visit(long double& item)  {}
 
};

Class SgGenericList

class SgGenericList
 {
protected:
    typedef allocator_void::pointer void_pointer;
    struct list_node;
    class allocator_list_node;
    friend list_node;
    friend allocator_list_node;
    friend inline SgGeneric * allocate(ptrdiff_t, SgGeneric *);
    friend inline void deallocate(SgGeneric *);
    friend inline list_node * allocate(ptrdiff_t, list_node *);
    friend inline void deallocate(list_node *);
    friend inline void swap(list_node *&, list_node *&); 
    struct list_node {
	void_pointer next;
	void_pointer prev;
	SgGeneric data;
    };

   
 class allocator
 {
    public:
	typedef SgGeneric value_type;
	typedef SgGeneric* pointer;
	typedef const SgGeneric* const_pointer;
	typedef SgGeneric& reference;
	typedef const SgGeneric& const_reference;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	pointer allocate(size_type n) { 
	    return ::allocate((difference_type)n, (pointer)0);
	}
	void deallocate(pointer p) { ::deallocate(p); }
	pointer address(reference x) { return (pointer)&x; }
	const_pointer const_address(const_reference x) { 
	    return (const_pointer)&x; 
	}
	size_type init_page_size() { 
	    return max(size_type(1), size_type(4096/sizeof(SgGeneric))); 
	}
	size_type max_size() const { 
	 return max(size_type(1), size_type(UINT_MAX/sizeof(SgGeneric)));
	}
    };
    
class allocator_list_node 
{
    public:
	typedef list_node value_type;
	typedef list_node* pointer;
	typedef const list_node* const_pointer;
	typedef list_node& reference;
	typedef const list_node& const_reference;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	pointer allocate(size_type n) { 
	    return ::allocate((difference_type)n, (pointer)0);
	}
	void deallocate(pointer p) { ::deallocate(p); }
	pointer address(reference x) { return (pointer)&x; }
	const_pointer const_address(const_reference x) { 
	    return (const_pointer)&x; 
	}
	size_type init_page_size() { 
	    return max(size_type(1), size_type(4096/sizeof(list_node))); 
	}
	size_type max_size() const { 
	    return max(size_type(1), size_type(UINT_MAX/sizeof(list_node))); 
	}
    };
    static allocator_list_node list_node_allocator;
    static allocator value_allocator;
public:      
    typedef SgGeneric value_type;
    typedef allocator value_allocator_type;
    typedef allocator::pointer pointer;
    typedef allocator::reference reference;
    typedef allocator::const_reference const_reference;
    typedef allocator_list_node list_node_allocator_type;
    typedef allocator_list_node::pointer link_type;
    typedef allocator_list_node::size_type size_type;
    typedef allocator_list_node::difference_type difference_type;
protected:
    size_type buffer_size() {
	return list_node_allocator.init_page_size();
    }
    struct list_node_buffer;
    friend list_node_buffer;
    friend inline list_node_buffer * allocate(ptrdiff_t, list_node_buffer *);
    friend inline void deallocate(list_node_buffer *);
    class allocator_list_node_buffer;
    friend allocator_list_node_buffer;
    struct list_node_buffer {
	void_pointer next_buffer;
	link_type buffer;
    };
   
 class allocator_list_node_buffer 
 {
    public:
	typedef list_node_buffer value_type;
	typedef list_node_buffer* pointer;
	typedef const list_node_buffer* const_pointer;
	typedef list_node_buffer& reference;
	typedef const list_node_buffer& const_reference;
	typedef size_t size_type;
	typedef ptrdiff_t difference_type;
	pointer allocate(size_type n) { 
	    return ::allocate((difference_type)n, (pointer)0);
	}
	void deallocate(pointer p) { ::deallocate(p); }
	pointer address(reference x) { return (pointer)&x; }
	const_pointer const_address(const_reference x) { 
	    return (const_pointer)&x; 
	}
	size_type init_page_size() { 
	    return max(size_type(1), 
                  size_type(4096/sizeof(list_node_buffer))); 
	}
	size_type max_size() const { 
	    return max(size_type(1), 
                  size_type(UINT_MAX/sizeof(list_node_buffer))); 
	}
    };

public:
    typedef allocator_list_node_buffer buffer_allocator_type;
    typedef allocator_list_node_buffer::pointer buffer_pointer;     
protected:
    static allocator_list_node_buffer buffer_allocator;
    static buffer_pointer buffer_list;
    static link_type free_list;
    static link_type next_avail;
    static link_type last;
    void add_new_buffer();
    static size_type number_of_lists;
    void deallocate_buffers();
    link_type get_node();
    void put_node(link_type p);

protected:
    link_type node;
    size_type length;
public:
    class iterator;
    class const_iterator;
  
  class iterator 
: public bidirectional_iterator_SgGeneric {
    friend class SgGenericList;
    friend class const_iterator;
    protected:
	link_type node;
	iterator(link_type x) : node(x) {}
    public:
	iterator() {}
	BOOL operator==(const iterator& x) const { return node == x.node; }
	BOOL operator!=(const iterator& x) const { return !(node == x.node); }
	reference operator*() const { return (*node).data; }
	iterator& operator++();
	iterator operator++(int);
	iterator& operator--();
	iterator operator--(int);
    };
   
 class const_iterator
 : public bidirectional_iterator_SgGeneric {
    friend class SgGenericList;
    protected:
	link_type node;
	const_iterator(link_type x) : node(x) {}
    public:     
	const_iterator() {}
	const_iterator(const iterator& x) : node(x.node) {}
	BOOL operator==(const const_iterator& x) const { return node == x.node; } 
	BOOL operator!=(const const_iterator& x) const { return ! (node == x.node); } 
	const_reference operator*() const { return (*node).data; }
	const_iterator& operator++();
	const_iterator operator++(int);
	const_iterator& operator--();
	const_iterator operator--(int);
    };
    
class reverse_bidirectional_const_iterator
 
	: public bidirectional_iterator_SgGeneric {
	typedef reverse_bidirectional_const_iterator self;
	friend BOOL operator==(const self& x, const self& y);
    protected:
	SgGenericList::const_iterator current;
    public:
	reverse_bidirectional_const_iterator() {}
	reverse_bidirectional_const_iterator(SgGenericList::
                     const_iterator x) : current(x) {}
	SgGenericList::const_iterator base() { return current; }
	SgGenericList::const_reference operator*() const;
	self& operator++();
	self operator++(int);
	self& operator--();
	self operator--(int);

    };
    class reverse_bidirectional_iterator 
	: public bidirectional_iterator_SgGeneric {
	typedef reverse_bidirectional_iterator self;
	friend BOOL operator==(const self& x, const self& y);
    protected:
	SgGenericList::iterator current;
    public:
	reverse_bidirectional_iterator() {}
	reverse_bidirectional_iterator(SgGenericList::iterator x) : current(x) {}
	SgGenericList::iterator base() { return current; }
	SgGenericList::reference operator*() const;
	self& operator++();
	self operator++(int);
	self& operator--();
	self operator--(int);
    };

    typedef reverse_bidirectional_const_iterator
	const_reverse_iterator;
    typedef reverse_bidirectional_iterator
        reverse_iterator; 
    SgGenericList() : length(0);

    iterator begin() { return (link_type)((*node).next); }
    const_iterator begin() const { return (link_type)((*node).next); }
    iterator end() { return node; }
    const_iterator end() const { return node; }
    reverse_iterator rbegin() { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const { 
        return const_reverse_iterator(end()); 
    }
    reverse_iterator rend() { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const { 
        return const_reverse_iterator(begin());
    } 
    BOOL empty() const { return length == 0; }
    size_type size() const { return length; }
    size_type max_size() const { return list_node_allocator.max_size(); }
    reference front() { return *begin(); }
    const_reference front() const { return *begin(); }
    reference back() { return *(--end()); }
    const_reference back() const { return *(--end()); }
    void swap(SgGenericList& x) {
	::swap(node, x.node);
	::swap(length, x.length);
    }
    const SgGeneric& remove_front();
    void copy(SgGenericList& dest, SgGenericList& source);
    iterator insert(iterator position, const SgGeneric& x);
    void insert(iterator position, const SgGeneric* a_first, 
                 const SgGeneric* last);
    void insert(iterator position, const_iterator a_first,
		const_iterator a_last);
    void insert(iterator position, size_type n, const SgGeneric& x);
    void push_front(const SgGeneric& x) { insert(begin(), x); }
    void push_back(const SgGeneric& x) { insert(end(), x); }
    void erase(iterator position);
    void erase(iterator a_first, iterator a_last);
    void pop_front() { erase(begin()); }
    void pop_back();

/* constructors */
    SgGenericList(size_type n, const SgGeneric& value = SgGeneric())
                 : length(0);
    SgGenericList(const SgGeneric* a_first, const SgGeneric* a_last)
                 : length(0);
    SgGenericList(const SgGenericList& x) : length(0);
/* destructor */
    ~SgGenericList();
/* operators */
    SgGenericList& operator=(const SgGenericList& x);
protected:
    void transfer(iterator position, iterator a_first, iterator a_last);

public:
    friend inline void distance(iterator, iterator, difference_type &);
    void splice(iterator position, SgGenericList& x);
    void splice(iterator position, SgGenericList& x, iterator i);
    void splice(iterator position, SgGenericList& x, 
                iterator a_first, iterator a_last);
    void remove(const SgGeneric& value);
    void unique();
    void merge(SgGenericList& x);
    void reverse();
    void sort();
};

Extreme! Computing Home Page