Polaris: Symbol.h Source File

Symbol.h Go to the documentation of this file. /// #ifndef _SYMBOL_H #define _SYMBOL_H /// /// \class Symbol /// \brief An abstract class to represent Fortran symbols (identifiers) /// \defgroup Polaris /// \ingroup Polaris /// C++ VDL /// \see Symbol.h /// \see Symbol.h /// \see Symbol.cc /// /// \endcode /// \section Description Description /// The abstract class Symbol represents a Fortran symbol in the C++ VDL /// symbol table. Since this class is abstract, all of the real /// work is done by inherited classes. This class sets up all /// possible methods for inherited classes and either defines /// default values for them or defines default errors for /// accessing them (for these, they are valid only if a derived /// classes inherits them, since not all possible fields are /// for all class types. /// /// The reason for the structure of this class and its subclasses /// is that it was intended for Symtab to contain a list of /// pointers to the base class Symbol. Thus the Symtab list may /// contain pointers actually to any derived class of Symbol. All /// possible methods are supported by Symbol, thus no typecasting /// is necessary. However, the sym_class() method needs to be /// checked before accessing these methods, since some of them /// will give error messages for the inherited classes that /// do not support them. /// /// Note: Although the source for all derived classes are in separate /// files, they are related enough that their header files are all /// included from this file and their methods are all contained in /// the single source file Symbol.cc /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// #include "../ClassNames.h" #include "../String.h" #include "../ArrayBounds.h" #include "../ArrayDims.h" #include "../BinRep.h" #include "../RelinkableDef.h" #include "../Dictionary.h" #include "../Collection/List.h" #include "../p-assert.h" #include "../Type.h" #include "../VoidPtrDef.h" /// class CommonBlock; class Equivalence; class Expression; class ExprTable; class Statement; class SharedDims; class VDL; ///< The SYMBOL_CLASS enumeration defines the possible types of Symbol's enum SYMBOL_CLASS { UNDEFINED_CLASS = 0, PROGRAM_CLASS, ///< A program unit starting with the ///< PROGRAM statement FUNCTION_CLASS, SUBROUTINE_CLASS, VARIABLE_CLASS, SYMBOLIC_CONSTANT_CLASS, ///< i.e. defined in a parameter stmt BLOCK_DATA_CLASS, NAMELIST_CLASS ///< Note to programmer: If this enum is changed in any way, make sure ///< to update the corresponding entries in the class_name[] array ///< in Symbol.cc }; enum EXTERNAL_BOOL { IS_EXTERNAL = 1, NOT_EXTERNAL = 0 }; enum INTRINSIC_BOOL { IS_INTRINSIC = 1, NOT_INTRINSIC = 0 }; enum INITIAL_BOOL { IS_INITIALIZED = 1, NOT_INITIALIZED = 0 }; enum FORMAL_BOOL { IS_FORMAL = 1, NOT_FORMAL = 0 }; enum ALLOC_BOOL { IS_ALLOCATABLE = 1, NOT_ALLOCATABLE = 0 }; enum SAVED_BOOL { IS_SAVED = 1, NOT_SAVED = 0 }; enum GLOBAL_BOOL { IS_GLOBAL = 1, NOT_GLOBAL = 0 }; class Symbol : public RelinkableDef { friend ostream & operator << (ostream & o, const Symbol & other); friend class Symtab; friend class PostPass; protected: SYMBOL_CLASS _sym_class; BinRep *_overflow; int _last_renaming_append; ///< _last_renaming_append is an integer which caches the last ///< appended integer which was added to a name of this base ///< to avoid naming conflicts in the symbol table. I.e. ///< If this symbol name were "I", and three other "I"'s needed ///< to be inserted with naming conflicts avoided, then this ///< value would cached for "I" the values 0, 1, and 2 as the ///< other "I" symbols were renamed to "I0", "I1", and "I2". ///< It is not absolutely necessary, but it should save time ///< reducing multiple renaming attempts. void _ref_error(const char *func_name) const; int _get_size(const BinRep & insp, const BinRep & binstr_context) const; virtual void _dims(ArrayDims *); public: inline Symbol(const char *name, SYMBOL_CLASS cl); ///< Constructor -- requires Symbol name and a SYMBOL_CLASS ///< Note: class Symbol is abstract, so you cannot create ///< an object of type Symbol. Create one of the derived ///< classes instead, or, if you are trying to copy a current ///< symbol, consider the clone() method. virtual Symbol *clone() const = 0; ///< Clone constructor -- returns base pointer to a new clone ///< of the correct derived class of this Symbol virtual Symbol *clone_all() const = 0; ///< Clone constructor -- returns base pointer to a new clone ///< of the correct derived class of this Symbol Definition *definition_clone() const; ///< Clone constructor which returns a Definition* rather than ///< a Symbol* by calling clone() virtual ~Symbol(); ///< Destructor. virtual void print(ostream & o) const = 0; ///< Print onto stream 'o' inline SYMBOL_CLASS sym_class() const; ///< Return the type of this Symbol inline const char *name_ref() const; ///< Return the Symbol name inline void name(const char *new_name); ///< Change the Symbol name (such a change would be reflected in ///< everything else in the Program which points to this Symbol) inline BinRep *overflow_ref() const; virtual void fill_in(const BinRep & binstr, ExprTable & exprs, const Dictionary<VoidPtrDef>&stmts, const Dictionary<VoidPtrDef>&commons, const Dictionary<VoidPtrDef>&equivalences) = 0; ///< Fill in all relevant info from a binstr object ///< None of the following methods are valid (they give error messages) ///< in a derived class unless they are specifically overridden in that ///< class. There is ONE exception to this rule: The type() method ///< returns a VOID type if there is no type associated with the ///< Symbol subclass (e.g. ProgramSymbol::type() always returns a ///< void Type, so that ProgramSymbol::type().is_void() always returns 1) virtual INITIAL_BOOL initial_value() const; virtual void initial_value(INITIAL_BOOL ourbool); virtual EXTERNAL_BOOL external() const; virtual void external(EXTERNAL_BOOL ourbool); virtual INTRINSIC_BOOL intrinsic() const; virtual void intrinsic(INTRINSIC_BOOL ourbool); virtual const Statement *entry_ref() const; virtual Statement *entry_ref() ; virtual void entry(Statement * s); virtual const Type & type() const; ///< Returns the type of the symbol, or else returns type VOID_TYPE ///< if the symbol does not use a type (such as a SubroutineSymbol) virtual void type(const Type & type); virtual Equivalence *equivalence_ref() const; virtual void equivalence(Equivalence & e, int byte_base); virtual void clear_equivalence(); virtual void shared_expr(Expression *shared); ///< 'shared' must be an expression whose 'symbol' is this itself. ///< and it must DISTRIBUTE_OP or ID_OP virtual void set_to_private(); ///< this symbol turns back to be a private by resetting _shared_expr to 0 virtual Expression *shared_expr() const; ///<_ If thie is VariableSymbol and shared data object, it returns to the ///<_ pointer to its correspoding distribution expression. ///<_ The returned expression must be either ID_OP or DISTRIBUTE_OP. ///<_ If this is private, it returns 0. (only applicable to Cray T3D) virtual const ArrayDims & dim() const; virtual ArrayDims & dim() ; virtual const SharedDims & shared_dim() const; virtual SharedDims & shared_dim() ; virtual FORMAL_BOOL formal() const; virtual void formal(FORMAL_BOOL ourbool); virtual ALLOC_BOOL allocatable() const; virtual void allocatable(ALLOC_BOOL ourbool); virtual GLOBAL_BOOL global() const; virtual void global(GLOBAL_BOOL ourbool); virtual SAVED_BOOL saved() const; virtual void saved(SAVED_BOOL ourbool); virtual const CommonBlock *common_ref() const; virtual CommonBlock *common_ref() ; virtual void common(CommonBlock & cb, int index); ///< Insert this variable into common block cb at position ///< index (0 = first element) virtual void clear_common(); ///< Remove this variable from a common block if it is in one virtual const Expression *expr_ref() const; virtual Expression *expr_ref() ; virtual void expr(Expression * e); virtual int is_entry(); virtual int is_scalar() const; virtual int is_array() const; virtual int is_shared() const; virtual int is_pointer() const; virtual const Symbol & assoc_variable() const; virtual Symbol & assoc_variable() ; virtual int size() const; ///< Return the size in bytes of the memory refered to by the symbol. 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 into the exchange format. void renaming_suggestion(String & new_name); ///< Given that some other symbol with the same name as this ///< symbol needs to be inserted into the same symbol table, ///< give a new name suggestion for the other symbol. ///< For example, if this symbol is named "I", the first time ///< this function is called, it will suggest "I0" for the ///< other symbol. The next time it will suggest "I1", etc. ///< ///< This name suggestion is returned in the String ///< parameter 'new_name'. ///< ///< (\note It should be rare that this function will be ///< be used directly, since there could still be naming ///< conflicts in a symbol table after using this function. ///< The preferred method is to create a new symbol with ///< the name being the base name that is desired, and then ///< to use the Symtab::rename_and_ins() function, which ///< references this function as many times as is needed.) }; Symbol *make_symbol(const char *name, const BinRep & binstr); char *upcase_ch( const char *string ); inline Symbol::Symbol(const char *name, SYMBOL_CLASS cl) : RelinkableDef("") { #ifdef CLASS_INSTANCE_REGISTRY register_instance(SYMBOL, sizeof(Symbol), this); #endif char *up_name = upcase_ch(name); _sym_class = cl; _overflow = 0; _last_renaming_append = -1; rename(up_name); delete [] up_name; } inline BinRep * Symbol::overflow_ref() const { return _overflow; } inline SYMBOL_CLASS Symbol::sym_class() const { return _sym_class; } inline const char * Symbol::name_ref() const { return (const char *)_tag; } inline void Symbol::name(const char *new_name) { _tag = upcase_ch(new_name); } inline int Symbol::is_pointer() const { return 0; } #endif

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