Polaris: Symtab.h Source File

Symtab.h Go to the documentation of this file. /// /// file Symtab.h /// #ifndef SYMTAB_H #define SYMTAB_H /// /// \class Symtab /// \brief a Symbol Table class /// \defgroup Polaris /// \ingroup Polaris /// C++ VDL /// \see Symtab.h /// \see Symtab.h /// \see Symtab.cc /// /// \endcode /// \section Description Description /// Symtab is a symbol table. /// /// Note that the Symtab::Symtab(const BinRep &binstr) method is NOT /// enough to completely read in the correct symbol table from the /// binstr. Because it is necessary to have the symbol table before /// other objects, such as the expression table, are created, and /// vice versa, the constructor just mentioned only creates the /// various symbols and gives them their proper type and name. /// After the expression table, etc., are available, the method /// void fill_in(...) does the rest of the conversion. /// /// \endcode /// \section Usage Usage /// Examples: /// /// Symtab symtab; /// ... /// cout << symtab["J"].is_array() << "\n"; /// /// To insert a new Symbol pointer, you can use notation like the following: /// /// Symbol &sym = symtab.ins( /// new SymbolicConstantSymbol("PI", /// <expr-containing-PI-constant>)); /// /// Using the return value of the ins() method is not necessary, but it /// has the advantage of allowing one to easily get a reference to the /// newly-inserted symbol with having to dereference, which may be /// confusing. The following is just as valid, although perhaps more /// awkward: /// /// Symbol &sym = /// * new SymbolicConstantSymbol("PI", /// <expr-containing-PI-constant>)); /// symtab.ins(&sym); /// /// The following is also valid, although perhaps not as good style /// because afterwards you have a pointer to the symbol rather than /// a reference (which may be confusing because you have to think /// to decide whether or not you are in charge of deleteing it-- /// which in this case you are not): /// /// Symbol *sym = /// new SymbolicConstantSymbol("PI", /// <expr-containing-PI-constant>)); /// symtab.ins(sym); /// /// /// The first example is this author's preferred style. /// /// Either way, the newly-inserted symbol will automatically be deleted /// when symtab is destroyed. /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// #include "ClassNames.h" #include "define.h" #include "Dictionary.h" #include "Collection/KeyIterator.h" #include "Symbol/Symbol.h" /// #define _T3D_NUM_PES "N$PES" ///_ Must be the same as the definition in ///_ t3d_convert.h /// class ProgramUnit; class VDL; class Symtab { friend ostream & operator << (ostream & o, const Symtab & symtab); private: Dictionary<Symbol> _dict; public: Symtab(); virtual ~Symtab(); Symtab(const Symtab &s); ///< Copy constructor. Symtab &operator =(const Symtab &s); ///< Assignment operator. virtual Symtab *clone() const; ///< Create a clone of the Symtab. Symtab(const BinRep & binstr); void fill_in(const BinRep & binstr, ExprTable & exprs, const Dictionary<VoidPtrDef>&stmts, const Dictionary<VoidPtrDef>&commons, const Dictionary<VoidPtrDef>&equivalences); Symbol & ins(Symbol * new_symbol); ///< Insert a new symbol into symbol table. This new symbol is ///< automatically deleted when the symbol table is destroyed ///< (which means that new_symbol must have been created dynamically ///< using the keyword "new"). If the name of new_symbol is already ///< in the symbol table, an error indication is given and the ///< program aborts. If name conflicts might be a problem, use ///< rename_and_ins(...) instead. Symbol & rename_and_ins(Symbol * sym); ///< Renames sym (only if needed) in such a way that there are ///< no naming conflicts, then inserts sym into the symbol table Symbol & ins_intrinsic(const char *name); ///< Checks to see if the intrinsic exists, if it does not then ///< it finds it's type from the intrinsic table and creates it. Symbol const *find_ref(const char *symbol_name) const; Symbol *find_ref(const char *symbol_name) ; ///< returns pointer to Symbol if found, 0 if not found const Symbol & operator[] (const char *symbol_name) const; Symbol & operator[] (const char *symbol_name) ; ///< returns reference to a Symbol if found, causes error otherwise void del(const char *sym_name); ///< deletes if found, ignores otherwise Symbol *grab(const char *symbol_name); ///< Unlinks (removes from the symbol table but DOES NOT delete) ///< and returns a pointer to the symbol. The user is then ///< responsible for deleting the symbol. Returns 0 if not found. int entries() const; ///< returns number of entries void absorb(Symtab & other); ///< "Absorbs" the other symbol table into itself. I.e., removes all ///< symbols from other, renames them as necessary to avoid naming ///< conflicts, and inserts them all into this symbol table. DictionaryIter<Symbol> iterator() const; ///< Return an iterator over all symbols of this symbol table void write(ostream & o, int space_for_label = 0, int max_line_len = FORTRAN_MAX_LINE_LEN) const; ///< Write to stream in Fortran declarations format (including type ///< statements such as INTEGER*4 as well as DIMENSION and SAVE ///< statements. ///< space_for_label should be 0 for FORTRAN output, or the length to ///< to allocate for statement labels (such as "S10") if debugging ///< output is desired. virtual int structures_OK() const; ///< Check the structure of the data for errors or inconsistency ///< Return 0 and print error message if problems found, otherwise ///< return 1 without message. virtual void exchange_convert( VDL &vdl ); ///< Convert the Symbol table into the exchange format. void relink_ptrs( ProgramUnit &p); ///< Change the pointers within a Symtab element to ///< point within the given ProgramUnit. ///< silvius: Symbol Table bug fix: ///< when changing the name of the symbol, its key in the symtab does ///< not change. You cannot do the following sequence: ///< rename(i,j); insert(i) ///< The symtab will complain that i still exists even after it ///< was renamed. void rename(const char* tag, const char* newtag) { _dict.rename(tag, newtag); } }; #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:06:15 2005