Polaris: Symbol.cc Source File

Symbol.cc Go to the documentation of this file. /// File Symbol.cc /// #include "../define.h" #ifdef POLARIS_GNU_PRAGMAS #pragma implementation "Symbol.h" #pragma implementation "BlockDataSymbol.h" #pragma implementation "FunctionSymbol.h" #pragma implementation "NamelistSymbol.h" #pragma implementation "ProgramSymbol.h" #pragma implementation "SubroutineSymbol.h" #pragma implementation "SymbolicConstantSymbol.h" #pragma implementation "VariableSymbol.h" #pragma implementation "PointerSymbol.h" #endif #include <stdio.h> #include <stdlib.h> #include "Symbol.h" #include "BlockDataSymbol.h" #include "FunctionSymbol.h" #include "NamelistSymbol.h" #include "ProgramSymbol.h" #include "SubroutineSymbol.h" #include "SymbolicConstantSymbol.h" #include "VariableSymbol.h" #include "PointerSymbol.h" #include "../BinRep.h" #include "../Collection/Iterator.h" #include "../Collection/RefMap.h" #include "../CommonBlock.h" #include "../Equivalence.h" #include "../ExprTable.h" #include "../Expression/Expression.h" #include "../Expression/IntConstExpr.h" #include "../ProgramUnit.h" #include "../Statement/Statement.h" #include "../String.h" #include "../utilities/expression_util.h" #include "../debug.h" #include "../macros.h" #include "../p-limits.h" #include "../p-assert.h" template class Map<Symbol,List<Expression> >; template class Map<Symbol,List<RefList<ProgramUnit> > >; template class Map<Symbol,Statement>; template class RefMap<Symbol,ProgramUnit>; template class TypedBaseMap<Symbol,List<Expression> >; template class TypedBaseMap<Symbol,List<RefList<ProgramUnit> > >; template class TypedBaseMap<Symbol,ProgramUnit>; template class TypedBaseMap<Symbol,Statement>; template class TypedBaseRefMap<Symbol,ProgramUnit>; template class ProtoMap<Symbol,List<Expression> >; template class ProtoMap<Symbol,List<RefList<ProgramUnit> > >; template class ProtoMap<Symbol,Statement>; template class ProtoRefMap<Symbol,ProgramUnit>; template class KeyIterator<Symbol,List<Expression> >; template class KeyIterator<Symbol,List<RefList<ProgramUnit> > >; template class KeyIterator<Symbol,ProgramUnit>; #define CHECK_STRUCTURES(class_name, field) \ { \ if ( ! (field).structures_OK()) { \ cerr << "In context of " << #class_name \ << ": " #field << ": " << endl; \ cerr << *this << endl; \ return 0; \ } \ } #define CHECK_PTR_STRUCTURES(class_name, field) \ { \ if ( (field) && ! (field)->structures_OK()) { \ cerr << "In context of " << #class_name \ << ": " #field << ": " << endl; \ cerr << *this << endl; \ return 0; \ } \ } /// Note: This function does NOT fill in the data fields properly-- /// it just gives them dummy values for now. Symbol * make_symbol(const char *name, const BinRep & binstr) { BinRep & insp = CASTAWAY(BinRep &) binstr; p_assert( insp.is_set(), "not a set"); /// ... Find out which kind of Symbol to make -- look at the "class" field String class_type; insp["class"].to_string(class_type); if (class_type == "PROGRAM") return new ProgramSymbol(name, 0); else if (class_type == "ROUTINE") { /// ... Note: This could either be a SubroutineSymbol or FunctionSymbol /// ... If it has a "type" class, it's a FunctionSymbol, else it's /// ... a SubroutineSymbol if (insp["type"].is_omega()) { return new SubroutineSymbol(name, NOT_EXTERNAL, NOT_INTRINSIC, NOT_FORMAL); } return new FunctionSymbol(name, make_type(UNDEFINED_TYPE), NOT_EXTERNAL, NOT_INTRINSIC, NOT_FORMAL); } else if (class_type == "VARIABLE") { return new VariableSymbol(name, make_type(UNDEFINED_TYPE), NOT_FORMAL, NOT_SAVED); } else if (class_type == "SYMBOLIC_CONSTANT") { return new SymbolicConstantSymbol(name, 0); } else if (class_type == "BLOCKDATA") { return new BlockDataSymbol(name); } else if (class_type == "NAMELIST") { return new NamelistSymbol(name); } else if (class_type == "UNKNOWN") { cerr << "KAP/Polaris error: [class, UNKNOWN] assuming VARIABLE" << endl; return new VariableSymbol(name, make_type(UNDEFINED_TYPE), NOT_FORMAL, NOT_SAVED); } cerr << "Error: file Symbol.cc: " << "make_symbol(): Unrecognized symbol class '" << class_type << "'" << endl; p_abort( "(see above message)" ); return 0; } /// Returns 1 if binstr is the string "T", else 0 if binstr is the string /// "F", else aborts with an error (printing out error_context as the /// context of the error int convert_true_false(const BinRep & insp, const BinRep & error_context) { String true_false; if (insp.is_boolean()) return insp.to_boolean(); else { insp.to_string(true_false); if (true_false == "T") return 1; else if (true_false == "F") return 0; cerr << "Error: Symbol or derivative: " << "Expected \"T\" or \"F\" but found \"" << true_false << "\" in binstr:" << endl; cerr << error_context << endl; p_abort( "(see above message)" ); } return 0; } /// class Symbol static const char *class_name[] = { "Undefined Class Type", /// ... UNDEFINED_CLASS "ProgramSymbol", /// ... PROGRAM_CLASS "FunctionSymbol", /// ... FUNCTION_CLASS, "SubroutineSymbol", /// ... SUBROUTINE_CLASS "VariableSymbol", /// ... VARIABLE_CLASS "SymbolicConstantSymbol", /// ... SYMBOLIC_CONSTANT_CLASS "BlockDataSymbol", /// ... BLOCK_DATA_CLASS "NamelistSymbol", /// ... NAMELIST_CLASS }; ostream & operator << (ostream & o, const Symbol & other) { other.print(o); return o; } int Symbol::_get_size(const BinRep & insp, const BinRep & binstr_context) const { /// ... Pull the size out of this binstr insp -- it should already be /// ... positioned on the size itself (not the ["size", ...] tuple). /// ... If it is too large, cause an error and print a message. /// ... The binstr_context is simply the context of the entire binstr so /// ... that it may be printed out in case of an error to track down where the /// ... offending size was if (insp.is_integer()) { int size = insp.to_integer(); if (size >= 0 && size <= MAX_SCALAR_SIZE) return size; } cerr << "Error: Some derived class of Symbol: " << "Error in \"size\" field or else size was too large " << "(current maximum scalar expression size is " << MAX_SCALAR_SIZE << ") in binstr " << binstr_context << endl; p_abort( "(see above message)" ); return 0; } void Symbol::_ref_error(const char *func_name) const { cerr << "Error: "; if (_sym_class<0 || _sym_class>BLOCK_DATA_CLASS) { cerr << "Some Derived Class of Symbol " << "(invalid _sym_class value = " << (int ) _sym_class << "): "; } else cerr << class_name[_sym_class] << ": "; cerr << "The '" << func_name << "' method of this class is not valid." << " Check the header file for this class to see which " << "virtual functions defined in Symbol.h are actually valid" << " for this class.\n"; p_abort("(see above message)"); } Symbol::~Symbol() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(SYMBOL, this); #endif if (_overflow) delete _overflow; _overflow = 0; } const Symbol & Symbol::assoc_variable() const { static Symbol *dummy = 0; p_abort("Symbol::assoc_variable() not over-ridden by subclass"); /// ... This return should never happen. return *dummy; } Symbol & Symbol::assoc_variable() { static Symbol *dummy = 0; p_abort("Symbol::assoc_variable() not over-ridden by subclass"); /// ... This return should never happen. return *dummy; } const Type & Symbol::type() const { p_abort("Symbol::type() not over-ridden by subclass"); /// ... This call should never happen. Type *undef_type = new Type(make_type(UNDEFINED_TYPE)); return *undef_type; } void Symbol::_dims (ArrayDims * /* dims */) { p_abort("Symbol::_dims() not over-ridden by subclass"); } int Symbol::size() const { p_abort("Symbol::size() not over-ridden by subclass"); return 0; } Definition * Symbol::definition_clone() const { return clone(); } //------------------------------------------------------------------------ EXTERNAL_BOOL Symbol::external() const { return NOT_EXTERNAL; } void Symbol::external(EXTERNAL_BOOL NOTUSED(ourbool)) { _ref_error("external(EXTERNAL_BOOL NOTUSED(ourbool))"); } INTRINSIC_BOOL Symbol::intrinsic() const { return NOT_INTRINSIC; } void Symbol::intrinsic(INTRINSIC_BOOL NOTUSED(ourbool)) { _ref_error("intrinsic(INTRINSIC_BOOL NOTUSED(ourbool))"); } const Statement * Symbol::entry_ref() const { return 0; } Statement * Symbol::entry_ref() { return 0; } void Symbol::entry(Statement * NOTUSED(s)) { _ref_error("entry(Statement * NOTUSED(s))"); } void Symbol::type(const Type & NOTUSED(type)) { _ref_error("type(const Type & NOTUSED(type))"); } Equivalence * Symbol::equivalence_ref() const { return 0; } void Symbol::equivalence(Equivalence & NOTUSED(e), int NOTUSED(byte_base)) { _ref_error("equivalence(Equivalence & NOTUSED(e), int NOTUSED(byte_base))"); } void Symbol::clear_equivalence() { _ref_error("clear_equivalence()"); } void /// ... _ Symbol::shared_expr(Expression *shared) { if (shared) delete shared; /// ... Nothing else happens: Any others than VariableSymbol must be private } void /// ... _ Symbol::set_to_private() { /// ... Nothing happens } Expression * /// ... _ Symbol::shared_expr() const { return 0; /// ... Any others than VariableSymbol are private by default } const ArrayDims & Symbol::dim() const { static ArrayDims *dummy = 0; _ref_error("ArrayDims & dim() const"); return *dummy; } ArrayDims & Symbol::dim() { static ArrayDims *dummy = 0; _ref_error("ArrayDims & dim() const"); return *dummy; } const SharedDims & Symbol::shared_dim() const { static SharedDims *dummy = 0; _ref_error("SharedDims & shared_dim() const"); return *dummy; } SharedDims & Symbol::shared_dim() { static SharedDims *dummy = 0; _ref_error("SharedDims & shared_dim() const"); return *dummy; } FORMAL_BOOL Symbol::formal() const { return NOT_FORMAL; } void Symbol::formal(FORMAL_BOOL NOTUSED(ourbool)) { _ref_error("formal(FORMAL_BOOL NOTUSED(ourbool))"); } INITIAL_BOOL Symbol::initial_value() const { return NOT_INITIALIZED; } void Symbol::initial_value(INITIAL_BOOL NOTUSED(ourbool)) { _ref_error("initial_value(INITIAL_BOOL NOTUSED(ourbool))"); } SAVED_BOOL Symbol::saved() const { return NOT_SAVED; } void Symbol::saved(SAVED_BOOL NOTUSED(ourbool)) { _ref_error("saved(SAVED_BOOL NOTUSED(ourbool))"); } GLOBAL_BOOL Symbol::global() const { return NOT_GLOBAL; } ALLOC_BOOL Symbol::allocatable() const { return NOT_ALLOCATABLE; } void Symbol::global(GLOBAL_BOOL NOTUSED(ourbool)) { _ref_error("global(GLOBAL_BOOL NOTUSED(ourbool))"); } void Symbol::allocatable(ALLOC_BOOL NOTUSED(ourbool)) { _ref_error("allocatable(ALLOC_BOOL NOTUSED(ourbool))"); } const CommonBlock * Symbol::common_ref() const { return 0; } CommonBlock * Symbol::common_ref() { return 0; } void Symbol::common(CommonBlock & NOTUSED(cb), int NOTUSED(index)) { _ref_error("common(CommonBlock & NOTUSED(cb), int NOTUSED(index))"); } void Symbol::clear_common() { _ref_error("clear_common()"); } const Expression * Symbol::expr_ref() const { return 0; } Expression * Symbol::expr_ref() { return 0; } void Symbol::expr(Expression * NOTUSED(e)) { _ref_error("expr(Expression * NOTUSED(e))"); } int Symbol::is_entry() { return False; } int Symbol::is_scalar() const { return False; } int Symbol::is_array() const { return False; } int Symbol::is_shared() const { return False; } //------------------------------------------------------------------------ int Symbol::structures_OK() const { CHECK_STRUCTURES(Symbol, _tag); CHECK_PTR_STRUCTURES(Symbol, _overflow); return 1; } void Symbol::exchange_convert( VDL &vdl ) { BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->to_set(); BinRep *br = new BinRep( new List<BinRep> ); BinRep *bs = new BinRep( name_ref() ); BinRep *bt = new BinRep( new Set<BinRep> ); br->to_tuple().ins_last( bs ); br->to_tuple().ins_last( bt ); S.ins( br ); Set<BinRep> & T = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); if (entry_ref() != 0) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "entry" )); br->to_tuple().ins_last(new BinRep( entry_ref()->tag())); T.ins( br ); } if ( equivalence_ref() != 0) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "equivalence" )); br->to_tuple().ins_last(new BinRep( equivalence_ref()->name_ref())); T.ins( br ); } if ( common_ref() != 0) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "common" )); br->to_tuple().ins_last(new BinRep( common_ref()->name_ref())); T.ins( br ); } if ( intrinsic() == IS_INTRINSIC ) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "intrinsic" )); br->to_tuple().ins_last(new BinRep( "T" )); T.ins( br ); } if ( external() == IS_EXTERNAL ) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "external" )); br->to_tuple().ins_last(new BinRep( "T" )); T.ins( br ); } if ( formal() == IS_FORMAL ) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "formal" )); br->to_tuple().ins_last(new BinRep( "T" )); T.ins( br ); } if ( global() == IS_GLOBAL ) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "global" )); br->to_tuple().ins_last(new BinRep( "T" )); T.ins( br ); } if ( allocatable() == IS_ALLOCATABLE ) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "allocatable" )); br->to_tuple().ins_last(new BinRep( "T" )); T.ins( br ); } switch (type().data_type()) { case UNKNOWN_TYPE: case UNDEFINED_TYPE: break; default: br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "type" )); br->to_tuple().ins_last(new BinRep( type().name_ref() )); T.ins( br ); br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "size" )); br->to_tuple().ins_last(new BinRep( type().size())); T.ins( br ); } } void Symbol::renaming_suggestion(String & new_name) { char buf[20]; sprintf(buf, "%d", ++_last_renaming_append); new_name = _tag; new_name += buf; } /// class ProgramSymbol ProgramSymbol & ProgramSymbol::operator = (const ProgramSymbol & psym) { _last_renaming_append = -1; _tag = psym._tag; if (_overflow) delete _overflow; _overflow = ((psym._overflow) ? new BinRep(*psym._overflow) : 0); _entry = psym._entry; return *this; } Symbol * ProgramSymbol::clone() const { return new ProgramSymbol(*this); } Symbol * ProgramSymbol::clone_all() const { return new ProgramSymbol(*this); } ProgramSymbol::~ProgramSymbol() { /// ... nothing to do (_entry should NOT be deleted) } const Statement * ProgramSymbol::entry_ref() const { return _entry; } Statement * ProgramSymbol::entry_ref() { return _entry; } void ProgramSymbol::entry(Statement * s) { /// ... Old _entry should NOT be deleted _entry = s; } const Type & ProgramSymbol::type() const { Type *undef_type = new Type(make_type(VOID_TYPE)); return *undef_type; /// Type t(make_type(VOID_TYPE)); /// return make_type(VOID_TYPE); } void ProgramSymbol::print(ostream & o) const { o << "[sym \"" << _tag << "\" (class PROGRAM)"; /// ... the _entry field o << ", entry="; if (_entry) o << _entry->tag(); else o << "Null"; /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; o << "]"; } void ProgramSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); BinRep *br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "class" )); br->to_tuple().ins_last(new BinRep( "PROGRAM" )); S.ins( br ); } void ProgramSymbol::fill_in(const BinRep & binstr, ExprTable & NOTUSED(exprs), const Dictionary<VoidPtrDef>& stmts, const Dictionary<VoidPtrDef>& NOTUSED(commons), const Dictionary<VoidPtrDef>& NOTUSED(equivalences)) { _entry = 0; if (_overflow) delete _overflow; _overflow = 0; for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String field; iter.current()[0].to_string(field); if (field == "class") { String class_type; iter.current()[1].to_string(class_type); p_assert(class_type == "PROGRAM", "not of class PROGRAM"); } else if (field == "entry") { String entry_str; iter.current()[1].to_string(entry_str); _entry = (Statement *) stmts[entry_str].ptr_ref(); } else { /// ... Unrecognized -- add to overflow warn_overflow_map("ProgramSymbol", iter.current()); if (!_overflow) { _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); } _overflow->ins(iter.current()); } } } int ProgramSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; CHECK_PTR_STRUCTURES(ProgramSymbol, _entry); return 1; } void ProgramSymbol::relink_dptrs(ProgramUnit & p) { if (_entry) { _entry = p.stmts().find_ref(_entry->tag()); p_assert(_entry, "ProgramSymbol has NULL pointer"); } } /// class FunctionSymbol FunctionSymbol::FunctionSymbol(const char *name, const Type & type, EXTERNAL_BOOL external, INTRINSIC_BOOL intrinsic, FORMAL_BOOL formal, Statement * entry GIV(0)) : Symbol(name, FUNCTION_CLASS) { _equivalence = 0; _type = type; _external = external; _intrinsic = intrinsic; _formal = formal; _entry = entry; } FunctionSymbol::FunctionSymbol(const FunctionSymbol & fsym) : Symbol(fsym._tag, FUNCTION_CLASS) { *this = fsym; } FunctionSymbol::~FunctionSymbol() { /// ... nothing to do (_entry should NOT be deleted) } Symbol * FunctionSymbol::clone() const { FunctionSymbol *s = new FunctionSymbol(*this); s->_equivalence = 0; return s; } Symbol * FunctionSymbol::clone_all() const { return new FunctionSymbol(*this); } FunctionSymbol & FunctionSymbol::operator = (const FunctionSymbol & fsym) { _last_renaming_append = -1; _tag = fsym._tag; if (_overflow) delete _overflow; _overflow = (fsym._overflow ? new BinRep(*fsym._overflow) : 0); _equivalence = fsym._equivalence; _external = fsym._external; _intrinsic = fsym._intrinsic; _formal = fsym._formal; _entry = fsym._entry; _type = fsym._type; return *this; } EXTERNAL_BOOL FunctionSymbol::external() const { return (EXTERNAL_BOOL) _external; } void FunctionSymbol::external(EXTERNAL_BOOL ourbool) { _external = ourbool; } INTRINSIC_BOOL FunctionSymbol::intrinsic() const { return (INTRINSIC_BOOL) _intrinsic; } void FunctionSymbol::intrinsic(INTRINSIC_BOOL ourbool) { _intrinsic = ourbool; } FORMAL_BOOL FunctionSymbol::formal() const { return (FORMAL_BOOL) _formal; } void FunctionSymbol::formal(FORMAL_BOOL ourbool) { _formal = ourbool; } const Statement * FunctionSymbol::entry_ref() const { return _entry; } Statement * FunctionSymbol::entry_ref() { return _entry; } void FunctionSymbol::entry(Statement * s) { _entry = s; } const Type & FunctionSymbol::type() const { return _type; } void FunctionSymbol::type(const Type & type) { _type = type; } Equivalence * FunctionSymbol::equivalence_ref() const { return _equivalence; } void FunctionSymbol::equivalence(Equivalence & e, int byte_base) { /// ... Return if no change to be made if (&e == _equivalence) return; /// ... Delete from old equivalence if it was in one clear_equivalence(); /// ... Add to new equivalence class /// ... Insert into equivalence's list e._members.ins_first(new EquivalenceMember(*this, byte_base)); /// ... Point to the equivalence _equivalence = &e; } void FunctionSymbol::clear_equivalence() { /// ... Delete from old equivalence if it was in one if (_equivalence) { EquivalenceMember *mem; if ((mem = _equivalence->find_ref(*this)) != 0) _equivalence->_members.del(*mem); else { #if 0 // No longer an error 6/8/94. // cerr << "Error: FunctionSymbol: Tried to delete symbol " << *this << " from equivalence class " << *_equivalence << ", but could not find the symbol in the " << "equivalence.\n"; p_abort("(see above message)"); #endif } } _equivalence = 0; } int FunctionSymbol::is_entry() { return !_external && !_intrinsic; } void FunctionSymbol::print(ostream & o) const { o << "[sym \"" << _tag << "\" (class FUNCTION)"; String type_str; _type.format(type_str); o << ", type=" << type_str; /// ... the _intrinsic field if (_intrinsic) o << ", Intrinsic"; /// ... the _external field if (_external) o << ", External"; /// ... the _formal field if (_formal) o << ", Formal"; /// ... the _entry field o << ", entry="; if (_entry) o << _entry->tag(); else o << "Null"; /// ... _equivalence field if (_equivalence) o << ", equiv=" << _equivalence->name_ref(); /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; o << "]"; } void FunctionSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); BinRep *br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "class" )); br->to_tuple().ins_last(new BinRep( "ROUTINE" )); S.ins( br ); } void FunctionSymbol::fill_in(const BinRep & binstr, ExprTable & NOTUSED(exprs), const Dictionary<VoidPtrDef>& stmts, const Dictionary<VoidPtrDef>& NOTUSED(commons), const Dictionary<VoidPtrDef>& equivalences) { if (_overflow) delete _overflow; _overflow = 0; _type.set(UNDEFINED_TYPE); _entry = 0; _equivalence = 0; _intrinsic = _external = _formal = 0; String type_declaration; int size_declaration = 0; int size_was_defaulted = 0; for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String field; iter.current()[0].to_string(field); if (field == "class") { String class_type; iter.current()[1].to_string(class_type); p_assert(class_type == "ROUTINE", "not of class ROUTINE"); } else if (field == "entry") { String entry_str; iter.current()[1].to_string(entry_str); _entry = (Statement *) stmts[entry_str].ptr_ref(); } else if (field == "equivalence") { String equiv_str; iter.current()[1].to_string(equiv_str); _equivalence = (Equivalence *) equivalences[equiv_str].ptr_ref(); } else if (field == "intrinsic") { _intrinsic = convert_true_false(iter.current()[1], binstr); } else if (field == "external") { _external = convert_true_false(iter.current()[1], binstr); } else if (field == "formal") { _formal = convert_true_false(iter.current()[1], binstr); } else if (field == "type") { /// ... Save this field for later processing iter.current()[1].to_string(type_declaration); } else if (field == "size") { /// ... Save this field for later processing size_declaration = _get_size(iter.current()[1], binstr); } else if (field == "sizedef") { size_was_defaulted = convert_true_false(iter.current()[1], binstr); } else { /// ... Unrecognized -- add to overflow warn_overflow_map("FunctionSymbol", iter.current()); if (!_overflow) { _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); } _overflow->ins(iter.current()); } } /// ... Now process the _type field if (!type_declaration.defined()) { cerr << "Error: FunctionSymbol::FunctionSymbol: No type was declared " << "for binstr object: " << binstr << endl; p_abort("(see above message)"); } if (size_was_defaulted) _type.set(type_declaration); else _type.set(type_declaration, size_declaration); } int FunctionSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; CHECK_PTR_STRUCTURES(FunctionSymbol, _entry); CHECK_PTR_STRUCTURES(FunctionSymbol, _equivalence); CHECK_STRUCTURES(FunctionSymbol, _type); return 1; } void FunctionSymbol::relink_dptrs(ProgramUnit & p) { if (_entry) { _entry = p.stmts().find_ref(_entry->tag()); p_assert(_entry, "FunctionSymbol has NULL pointer"); } } /// class SubroutineSymbol SubroutineSymbol::SubroutineSymbol(const char *name, EXTERNAL_BOOL external, INTRINSIC_BOOL intrinsic, FORMAL_BOOL formal, Statement * entry GIV(0)) : Symbol(name, SUBROUTINE_CLASS) { _entry = entry; _external = external; _intrinsic = intrinsic; _formal = formal; } SubroutineSymbol::SubroutineSymbol(const SubroutineSymbol & rsym) : Symbol(rsym._tag, SUBROUTINE_CLASS) { *this = rsym; } SubroutineSymbol::~SubroutineSymbol() { /// ... nothing to do (_entry should NOT be deleted) } SubroutineSymbol & SubroutineSymbol::operator = (const SubroutineSymbol & rsym) { _last_renaming_append = -1; _tag = rsym._tag; if (_overflow) delete _overflow; _overflow = ((rsym._overflow) ? new BinRep(*rsym._overflow) : 0); _external = rsym._external; _intrinsic = rsym._intrinsic; _entry = rsym._entry; _formal = rsym._formal; return *this; } const Type & SubroutineSymbol::type() const { Type *undef_type = new Type(make_type(VOID_TYPE)); return *undef_type; } Symbol * SubroutineSymbol::clone() const { return new SubroutineSymbol(*this); } Symbol * SubroutineSymbol::clone_all() const { return new SubroutineSymbol(*this); } EXTERNAL_BOOL SubroutineSymbol::external() const { return (EXTERNAL_BOOL) _external; } void SubroutineSymbol::external(EXTERNAL_BOOL ourbool) { _external = ourbool; } INTRINSIC_BOOL SubroutineSymbol::intrinsic() const { return (INTRINSIC_BOOL) _intrinsic; } void SubroutineSymbol::intrinsic(INTRINSIC_BOOL ourbool) { _intrinsic = ourbool; } FORMAL_BOOL SubroutineSymbol::formal() const { return (FORMAL_BOOL) _formal; } void SubroutineSymbol::formal(FORMAL_BOOL ourbool) { _formal = ourbool; } const Statement * SubroutineSymbol::entry_ref() const { return _entry; } Statement * SubroutineSymbol::entry_ref() { return _entry; } void SubroutineSymbol::entry(Statement * entry) { _entry = entry; } int SubroutineSymbol::is_entry() { return !_external && !_intrinsic; } void SubroutineSymbol::print(ostream & o) const { o << "[sym \"" << _tag << "\" (class SUBROUTINE)"; /// ... the _intrinsic field if (_intrinsic) o << ", Intrinsic"; /// ... the _external field if (_external) o << ", External"; /// ... the _formal field if (_formal) o << ", Formal"; /// ... the _entry field o << ", entry="; if (_entry) o << _entry->tag(); else o << "Null"; /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; o << "]"; } void SubroutineSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); BinRep *br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "class" )); br->to_tuple().ins_last(new BinRep( "ROUTINE" )); S.ins( br ); } void SubroutineSymbol::fill_in(const BinRep & binstr, ExprTable & NOTUSED(exprs), const Dictionary<VoidPtrDef>& stmts, const Dictionary<VoidPtrDef>& NOTUSED(commons), const Dictionary<VoidPtrDef>& NOTUSED(equivalences)) { if (_overflow) delete _overflow; _overflow = 0; _entry = 0; _intrinsic = _external = _formal = 0; for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String field; iter.current()[0].to_string(field); if (field == "class") { String class_type; iter.current()[1].to_string(class_type); p_assert(class_type == "ROUTINE", "not of class ROUTINE"); } else if (field == "entry") { String entry_str; iter.current()[1].to_string(entry_str); _entry = (Statement *) stmts[entry_str].ptr_ref(); } else if (field == "intrinsic") { _intrinsic = convert_true_false(iter.current()[1], binstr); } else if (field == "external") { _external = convert_true_false(iter.current()[1], binstr); } else if (field == "formal") { _formal = convert_true_false(iter.current()[1], binstr); } else if (field == "sizedef") { /// ... nothing to do } else { /// ... Unrecognized -- add to overflow warn_overflow_map("SubroutineSymbol", iter.current()); if (!_overflow) { _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); } _overflow->ins(iter.current()); } } } int SubroutineSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; CHECK_PTR_STRUCTURES(SubroutineSymbol, _entry); return 1; } void SubroutineSymbol::relink_dptrs(ProgramUnit & p) { if (_entry && _entry->stmt_class() != UNDEFINED_STMT && _entry->tag() && _entry->tag_defined()) { _entry = p.stmts().find_ref(_entry->tag()); p_assert(_entry, "SubroutineSymbol has NULL pointer"); } } /// Class VariableSymbol VariableSymbol::VariableSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : Symbol(name, VARIABLE_CLASS) { _equivalence = 0; _common = 0; _type = type; _shared_expr = 0; /// ... _ _gsa_base_symbol = 0; _formal = formal; _allocatable = 0; _saved = saved; _initial_value = 0; _global = NOT_GLOBAL; if (bounds1) _dim.ins_last(bounds1); if (bounds2) _dim.ins_last(bounds2); if (bounds3) _dim.ins_last(bounds3); if (bounds4) _dim.ins_last(bounds4); if (bounds5) _dim.ins_last(bounds5); if (bounds6) _dim.ins_last(bounds6); if (bounds7) _dim.ins_last(bounds7); _type.redimension(_dim.entries()); } VariableSymbol::VariableSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : Symbol(name, VARIABLE_CLASS) { _equivalence = 0; _common = 0; _type = type; _gsa_base_symbol = 0; _formal = formal; _allocatable = 0; _saved = saved; _initial_value = 0; _global = global; if (bounds1) _dim.ins_last(bounds1); if (bounds2) _dim.ins_last(bounds2); if (bounds3) _dim.ins_last(bounds3); if (bounds4) _dim.ins_last(bounds4); if (bounds5) _dim.ins_last(bounds5); if (bounds6) _dim.ins_last(bounds6); if (bounds7) _dim.ins_last(bounds7); _type.redimension(_dim.entries()); } VariableSymbol::VariableSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayDims * dims) : Symbol(name, VARIABLE_CLASS) { _equivalence = 0; _common = 0; _type = type; _shared_expr = 0; /// ... _ _gsa_base_symbol = 0; _formal = formal; _saved = saved; _initial_value = 0; _allocatable = 0; _global = global; _dim = *dims; _type.redimension(_dim.entries()); } VariableSymbol::VariableSymbol(const char *name, const Type & type, ALLOC_BOOL allocatable, FORMAL_BOOL formal, SAVED_BOOL saved, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : Symbol(name, VARIABLE_CLASS) { _equivalence = 0; _common = 0; _type = type; _shared_expr = 0; /// ... _ _gsa_base_symbol = 0; _formal = formal; _allocatable = allocatable; _saved = saved; _initial_value = 0; _global = NOT_GLOBAL; if (bounds1) _dim.ins_last(bounds1); if (bounds2) _dim.ins_last(bounds2); if (bounds3) _dim.ins_last(bounds3); if (bounds4) _dim.ins_last(bounds4); if (bounds5) _dim.ins_last(bounds5); if (bounds6) _dim.ins_last(bounds6); if (bounds7) _dim.ins_last(bounds7); _type.redimension(_dim.entries()); } VariableSymbol::VariableSymbol(const char *name, const Type & type, ALLOC_BOOL allocatable, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : Symbol(name, VARIABLE_CLASS) { _equivalence = 0; _common = 0; _type = type; _formal = formal; _allocatable = allocatable; _saved = saved; _initial_value = 0; _global = global; _shared_expr = 0; /// ... _ _gsa_base_symbol = 0; if (bounds1) _dim.ins_last(bounds1); if (bounds2) _dim.ins_last(bounds2); if (bounds3) _dim.ins_last(bounds3); if (bounds4) _dim.ins_last(bounds4); if (bounds5) _dim.ins_last(bounds5); if (bounds6) _dim.ins_last(bounds6); if (bounds7) _dim.ins_last(bounds7); _type.redimension(_dim.entries()); } VariableSymbol::VariableSymbol(const char *name, const Type & type, ALLOC_BOOL allocatable, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayDims * dims) : Symbol(name, VARIABLE_CLASS) { _equivalence = 0; _common = 0; _type = type; _shared_expr = 0; /// ... _ _gsa_base_symbol = 0; _formal = formal; _saved = saved; _initial_value = 0; _allocatable = allocatable; _global = global; _dim = *dims; _type.redimension(_dim.entries()); } VariableSymbol::~VariableSymbol() { if (_shared_expr && (_shared_expr->op() == ID_OP || _shared_expr->op() == DISTRIBUTE_OP)) delete _shared_expr; /// ... _ /// ... Nothing else to do (_equivalence and _common should NOT be deleted) } VariableSymbol & VariableSymbol::operator = (const VariableSymbol & vsym) { _last_renaming_append = -1; _tag = vsym._tag; if (_overflow) delete _overflow; _overflow = (vsym._overflow ? new BinRep(*vsym._overflow) : 0); _gsa_base_symbol = vsym._gsa_base_symbol; _type = vsym._type; _equivalence = vsym._equivalence; _dim = vsym._dim; _shared_dim = vsym._shared_dim; _formal = vsym._formal; _global = vsym._global; _allocatable = vsym._allocatable; _saved = vsym._saved; _common = vsym._common; _initial_value = vsym._initial_value; if (vsym._shared_expr) if (vsym._shared_expr->op() == ID_OP || vsym._shared_expr->op() == DISTRIBUTE_OP) /// ... _ _shared_expr = vsym._shared_expr->clone(); else _shared_expr = vsym._shared_expr; else _shared_expr = 0; return *this; } Symbol * VariableSymbol::clone() const { VariableSymbol *s = new VariableSymbol(*this); s->_equivalence = 0; s->_common = 0; s->_gsa_base_symbol = this->_gsa_base_symbol; if (s->_shared_expr) { if (s->_shared_expr->op() == ID_OP || s->_shared_expr->op() == DISTRIBUTE_OP) delete s->_shared_expr; s->_shared_expr = 0; /// ... _ cloned one must be private initially } return s; } Symbol * VariableSymbol::clone_all() const { return new VariableSymbol(*this); } const Type & VariableSymbol::type() const { return _type; } void VariableSymbol::type(const Type & type) { _type = type; } Equivalence * VariableSymbol::equivalence_ref() const { return _equivalence; } void VariableSymbol::equivalence(Equivalence & e, int byte_base) { /// ... Return if no change to be made if (&e == _equivalence) return; /// ... Delete from old equivalence if it was in one clear_equivalence(); /// ... Add to new equivalence class /// ... Insert into equivalence's list e._members.ins_first(new EquivalenceMember(*this, byte_base)); /// ... Point to the equivalence _equivalence = &e; } void VariableSymbol::clear_equivalence() { /// ... Delete from old equivalence if it was in one if (_equivalence) { EquivalenceMember *mem; if ((mem = _equivalence->find_ref(*this)) != 0) _equivalence->_members.del(*mem); else { #if 0 // No longer an error: 6/8/94 // cerr << "Error: VariableSymbol: Tried to delete symbol " << *this << " from equivalence class " << *_equivalence << ", but could not find the symbol in the " << "equivalence." << endl; p_abort("(see above message)"); #endif } } _equivalence = 0; } Expression * /// ... _ VariableSymbol::shared_expr() const { return _shared_expr; } void /// ... _ VariableSymbol::set_to_private() { _shared_expr = 0; /// ... go back to default value: private } void /// ... _ VariableSymbol::shared_expr(Expression *shared) { _shared_expr = shared; } const ArrayDims & VariableSymbol::dim() const { return (const ArrayDims &) _dim; } ArrayDims & VariableSymbol::dim() { return (ArrayDims &) _dim; } const SharedDims & VariableSymbol::shared_dim() const { return (const SharedDims &) _shared_dim; } SharedDims & VariableSymbol::shared_dim() { return (SharedDims &) _shared_dim; } FORMAL_BOOL VariableSymbol::formal() const { return (FORMAL_BOOL) _formal; } void VariableSymbol::formal(FORMAL_BOOL ourbool) { _formal = ourbool; } ALLOC_BOOL VariableSymbol::allocatable() const { return (ALLOC_BOOL) _allocatable; } void VariableSymbol::allocatable(ALLOC_BOOL ourbool) { _allocatable = ourbool; } GLOBAL_BOOL VariableSymbol::global() const { return (GLOBAL_BOOL) _global; } void VariableSymbol::global(GLOBAL_BOOL ourbool) { _global = ourbool; } INITIAL_BOOL VariableSymbol::initial_value() const { return (INITIAL_BOOL) _initial_value; } void VariableSymbol::initial_value(INITIAL_BOOL ourbool) { _initial_value = ourbool; } SAVED_BOOL VariableSymbol::saved() const { return (SAVED_BOOL) _saved; } void VariableSymbol::saved(SAVED_BOOL ourbool) { _saved = ourbool; } const CommonBlock * VariableSymbol::common_ref() const { return _common; } CommonBlock * VariableSymbol::common_ref() { return _common; } void VariableSymbol::common(CommonBlock & cb, int index) { /// ... Return if no change to be made if (&cb == _common) return; /// ... Delete from old common block if it was in one clear_common(); /// ... Add to new common block /// ... Insert into common block's list cb._body.ins(*this, (int) index); /// ... Point to the common block _common = &cb; } void VariableSymbol::clear_common() { /// ... Delete from old common block if it was in one if (_common) { /// ... Search for the symbol in the common block int index = 0, found_index = -1; Iterator<Symbol> iter = _common->iterator(); while (iter.valid()) { if (&iter.current() == this) { found_index = index; break; } ++index; ++iter; } if (found_index >= 0) _common->_body.del((int) found_index); } _common = 0; } int VariableSymbol::is_scalar() const { return (_dim.entries() == 0); } int VariableSymbol::is_array() const { return (_dim.entries() > 0); } int VariableSymbol::is_shared() const { return (_shared_dim.entries() > 0); } int VariableSymbol::size() const { int total_size; total_size = type().size(); if (is_array()) { for (Iterator<ArrayBounds> iter = dim(); iter.valid(); ++iter) { int lb_value = 0, ub_value = 0; if (total_size > 0) { Expression *lb = iter.current().lower_ref(); if (lb == 0) lb_value = 1; else { lb = simplify( replace_parameters(lb->clone()) ); if (lb->op() == INTEGER_CONSTANT_OP) lb_value = lb->value(); else total_size = 0; delete lb; } Expression *ub = iter.current().upper_ref(); if (ub == 0) total_size = 0; else { ub = simplify( replace_parameters(ub->clone()) ); if (ub->op() == INTEGER_CONSTANT_OP) ub_value = ub->value(); else total_size = 0; delete ub; } total_size = total_size * (ub_value - lb_value + 1); } } } return total_size; } void VariableSymbol::print(ostream & o) const { o << "[sym \""; o << _tag << "\" (class VARIABLE)"; /// ... the _type field o << ", type="; if (is_array()) o << "ARRAY of "; o << _type; /// ... the _formal field if (_formal) o << ", Formal"; /// ... the _global field if (_global) o << ", Global"; /// ... the _alloc field if (_allocatable) o << ", Allocatable"; if (_initial_value) o << ", Initialized"; /// ... the _saved field if (_saved) o << ", Saved"; /// ... the _equivalence field if (_equivalence) o << ", equiv=" << _equivalence->name_ref(); /// ... the _common field if (_common) o << ", common=" << _common->name_ref(); /// ... the _dim field if (is_array()) o << ", dim=" << _dim; /// ... the _shared_dim field if (is_shared()) o << ", shared_dim=" << _shared_dim; o << ", gsa_base_symbol=" << _gsa_base_symbol; /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; if (_shared_expr) { /// ... _ if(_shared_expr->op() == ID_OP || _shared_expr->op() == DISTRIBUTE_OP) { o << ", SHARED"; } else { o << ", PRIVATE"; } } o << "]"; } void VariableSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); BinRep *br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "class" )); br->to_tuple().ins_last(new BinRep( "VARIABLE" )); S.ins( br ); } void VariableSymbol::fill_in(const BinRep & binstr, ExprTable & exprs, const Dictionary<VoidPtrDef>& NOTUSED(stmts), const Dictionary<VoidPtrDef>& commons, const Dictionary<VoidPtrDef>& equivalences) { if (_overflow) delete _overflow; _overflow = 0; _type.set(UNDEFINED_TYPE); /// ... Only zero the fields which haven't been set yet /// ... _initial_value, if it exists, should have already been /// ... set by this time, so it is not changed. _formal = 0; _global = 0; _gsa_base_symbol = 0; _allocatable = 0; _equivalence = 0; _common = 0; _saved = 0; String type_declaration; int size_declaration = 0; int size_was_defaulted = 0; for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String field; iter.current()[0].to_string(field); if (field == "class") { String class_type; iter.current()[1].to_string(class_type); if (class_type == "UNKNOWN") { cerr << "KAP/Polaris warning: " << "[\"class\", \"UNKNOWN\"] assuming \"VARIABLE\"" << endl; class_type = "VARIABLE"; } p_assert(class_type == "VARIABLE", "not of class VARIABLE"); } else if (field == "equivalence") { String equiv_str; iter.current()[1].to_string(equiv_str); _equivalence = (Equivalence *) equivalences[equiv_str].ptr_ref(); } else if (field == "common") { String common_str; iter.current()[1].to_string(common_str); _common = (CommonBlock *) commons[common_str].ptr_ref(); } else if (field == "formal") { _formal = convert_true_false(iter.current()[1], binstr); } else if (field == "global") { _global = convert_true_false(iter.current()[1], binstr); } else if (field == "allocatable") { _allocatable = convert_true_false(iter.current()[1], binstr); } else if (field == "saved") { _saved = convert_true_false(iter.current()[1], binstr); } else if (field == "dim") { _dim.convert( iter.current()[1], exprs); } else if (field == "type") { /// ... Save this field for later processing iter.current()[1].to_string(type_declaration); } else if (field == "size") { /// ... Save this field for later processing size_declaration = _get_size(iter.current()[1], binstr); } else if (field == "sizedef") { size_was_defaulted = convert_true_false(iter.current()[1], binstr); } else { /// ... Unrecognized -- add to overflow warn_overflow_map("VariableSymbol", iter.current()); if (!_overflow) { _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); } _overflow->ins(iter.current()); } } /// ... Now process the _type field if (!type_declaration.defined()) { cerr << "KAP/Polaris warning: No type was declared " << "assuming \"INTEGER\"" << endl; type_declaration = "INTEGER"; } if (size_was_defaulted) _type.set(type_declaration); else _type.set(type_declaration, size_declaration); } int VariableSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; CHECK_STRUCTURES(VariableSymbol, _type); CHECK_PTR_STRUCTURES(VariableSymbol, _equivalence); CHECK_PTR_STRUCTURES(VariableSymbol, _common); CHECK_STRUCTURES(VariableSymbol, _dim); CHECK_STRUCTURES(VariableSymbol, _shared_dim); return 1; } void VariableSymbol::relink_dptrs(ProgramUnit & p) { if (_equivalence) { _equivalence = p.equivalences().find_ref(_equivalence->name_ref()); p_assert(_equivalence, "VariableSymbol has NULL equivalence pointer"); } if (_common) { _common = p.common_blocks().find_ref(_common->name_ref()); p_assert(_common, "VariableSymbol has NULL common pointer"); } if (_gsa_base_symbol) { _gsa_base_symbol = p.symtab().find_ref(_gsa_base_symbol->name_ref()); } Iterator<ArrayBounds> iter = _dim; while (iter.valid()) { if (iter.current().lower_ref()) iter.current().lower_ref()->relink_eptrs(p); if (iter.current().upper_ref()) iter.current().upper_ref()->relink_eptrs(p); ++iter; } /// ... _ if (_shared_expr && (_shared_expr->op() == ID_OP || _shared_expr->op() == DISTRIBUTE_OP)) { Symbol * symref = p.symtab().find_ref(_tag); p_assert(symref, "VariableSymbol has NULL shared pointer"); _shared_expr->symbol(*symref); } } /// Class PointerSymbol PointerSymbol::PointerSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : VariableSymbol(name, type, formal, saved, bounds1, bounds2, bounds3, bounds4, bounds5, bounds6, bounds7) { _assoc_variable = 0; } PointerSymbol::PointerSymbol(const char *name, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : VariableSymbol(name, type, formal, saved, global, bounds1, bounds2, bounds3, bounds4, bounds5, bounds6, bounds7) { _assoc_variable = 0; } PointerSymbol::PointerSymbol(const char *name, Symbol &assoc, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : VariableSymbol(name, type, formal, saved, bounds1, bounds2, bounds3, bounds4, bounds5, bounds6, bounds7) { _assoc_variable = &assoc; } PointerSymbol::PointerSymbol(const char *name, Symbol &assoc, const Type & type, FORMAL_BOOL formal, SAVED_BOOL saved, GLOBAL_BOOL global, ArrayBounds * bounds1 GIV(0), ArrayBounds * bounds2 GIV(0), ArrayBounds * bounds3 GIV(0), ArrayBounds * bounds4 GIV(0), ArrayBounds * bounds5 GIV(0), ArrayBounds * bounds6 GIV(0), ArrayBounds * bounds7 GIV(0)) : VariableSymbol(name, type, formal, saved, global, bounds1, bounds2, bounds3, bounds4, bounds5, bounds6, bounds7) { _assoc_variable = &assoc; } PointerSymbol::~PointerSymbol() { /// ... Nothing to do } PointerSymbol & PointerSymbol::operator = (const PointerSymbol & vsym) { _last_renaming_append = -1; _tag = vsym._tag; if (_overflow) delete _overflow; _overflow = (vsym._overflow ? new BinRep(*vsym._overflow) : 0); _type = vsym._type; _equivalence = vsym._equivalence; _dim = vsym._dim; _shared_dim = vsym._shared_dim; _formal = vsym._formal; _global = vsym._global; _allocatable = vsym._allocatable; _saved = vsym._saved; _common = vsym._common; _initial_value = vsym._initial_value; _assoc_variable = vsym._assoc_variable; return *this; } Symbol * PointerSymbol::clone() const { PointerSymbol *s = new PointerSymbol(*this); s->_equivalence = 0; s->_common = 0; return s; } Symbol * PointerSymbol::clone_all() const { return new PointerSymbol(*this); } const Symbol & PointerSymbol::assoc_variable() const { return *_assoc_variable; } Symbol & PointerSymbol::assoc_variable() { return *_assoc_variable; } void PointerSymbol::print(ostream & o) const { o << "[sym \""; o << _tag << "\" (class VARIABLE)"; if (_assoc_variable) { o << "[POINTER associated with " << _assoc_variable->name_ref() << "]"; } else { o << "[POINTER not associated with a target]"; } /// ... the _type field o << ", type="; if (is_array()) o << "ARRAY of "; o << _type; /// ... the _formal field if (_formal) o << ", Formal"; /// ... the _allocatable field if (_allocatable) o << ", Allocatable"; /// ... the _global field if (_global) o << ", Global"; if (_initial_value) o << ", Initialized"; /// ... the _saved field if (_saved) o << ", Saved"; /// ... the _equivalence field if (_equivalence) o << ", equiv=" << _equivalence->name_ref(); /// ... the _common field if (_common) o << ", common=" << _common->name_ref(); /// ... the _dim field if (is_array()) o << ", dim=" << _dim; /// ... the _shared_dim field if (is_shared()) o << ", shared_dim=" << _shared_dim; /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; o << "]"; } void PointerSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); VariableSymbol::exchange_convert( vdl ); } void PointerSymbol::fill_in(const BinRep & binstr, ExprTable & exprs, const Dictionary<VoidPtrDef>& NOTUSED(stmts), const Dictionary<VoidPtrDef>& commons, const Dictionary<VoidPtrDef>& equivalences) { _assoc_variable = 0; static Dictionary<VoidPtrDef> *dummy = 0; VariableSymbol::fill_in(binstr, exprs, *dummy , commons, equivalences); } int PointerSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; if (!VariableSymbol::structures_OK()) return 0; if (_assoc_variable) return 1; else return 0; } void PointerSymbol::relink_dptrs(ProgramUnit & p) { if (_equivalence) { _equivalence = p.equivalences().find_ref(_equivalence->name_ref()); p_assert(_equivalence, "PointerSymbol has NULL equivalence pointer"); } if (_common) { _common = p.common_blocks().find_ref(_common->name_ref()); p_assert(_common, "PointerSymbol has NULL common pointer"); } Iterator<ArrayBounds> iter = _dim; while (iter.valid()) { if (iter.current().lower_ref()) iter.current().lower_ref()->relink_eptrs(p); if (iter.current().upper_ref()) iter.current().upper_ref()->relink_eptrs(p); ++iter; } if (_assoc_variable) { _assoc_variable = p.symtab().find_ref(_assoc_variable->name_ref()); p_assert(_assoc_variable, "PointerSymbol has NULL assoc variable"); } } /// class SymbolicConstantSymbol Symbol * SymbolicConstantSymbol::clone() const { return new SymbolicConstantSymbol(*this); } Symbol * SymbolicConstantSymbol::clone_all() const { return new SymbolicConstantSymbol(*this); } SymbolicConstantSymbol::~SymbolicConstantSymbol() { /// ... Since _expr "lives" in the SymbolicConstantSymbol (it's not a /// ... pointer to an Expression somewhere else), it must be deleted. if (_expr) delete _expr; _expr = 0; } const Type & SymbolicConstantSymbol::type() const { p_assert(_expr != 0, "SymbolicConstantSymbol::type(): _expr field is NULL"); return (Type &) _type; } const Expression * SymbolicConstantSymbol::expr_ref() const { return _expr; } Expression * SymbolicConstantSymbol::expr_ref() { return _expr; } void SymbolicConstantSymbol::expr(Expression * e) { if (_expr) delete _expr; _expr = e; } /// Check this function out SymbolicConstantSymbol & SymbolicConstantSymbol::operator = (const SymbolicConstantSymbol & scsym) { _last_renaming_append = -1; _tag = scsym._tag; if (_overflow) delete _overflow; _overflow = ((scsym._overflow) ? new BinRep(*scsym._overflow) : 0); if (_expr) delete _expr; _expr = scsym._expr->clone(); _type = scsym._type; return *this; } void SymbolicConstantSymbol::print(ostream & o) const { o << "[sym \"" << _tag << "\" (class SYMBOLIC_CONSTANT)"; /// ... the _type field o << ", type=" << (Type &) _type; /// ... the _expr field o << ", expr="; if (_expr) o << *_expr; else o << "Null"; /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; o << "]"; } void SymbolicConstantSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); BinRep *br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "class" )); br->to_tuple().ins_last(new BinRep( "SYMBOLIC_CONSTANT" )); S.ins( br ); if (expr_ref() != 0) { br = new BinRep(new List<BinRep>); br->to_tuple().ins_last( new BinRep( "expr" )); br->to_tuple().ins_last( new BinRep( expr_ref()->exchange_expr(vdl) )); S.ins( br ); } } void SymbolicConstantSymbol::fill_in( const BinRep & binstr, ExprTable & exprs, const Dictionary<VoidPtrDef> & NOTUSED(stmts), const Dictionary<VoidPtrDef> & NOTUSED(commons), const Dictionary<VoidPtrDef>& NOTUSED(equivalences) ) { if (_overflow) delete _overflow; _overflow = 0; if (_expr) delete _expr; _expr = 0; String type_declaration; int size_declaration = 0; int size_was_defaulted = 0; for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String field; iter.current()[0].to_string(field); if (field == "class") { String class_type; iter.current()[1].to_string(class_type); p_assert(class_type == "SYMBOLIC_CONSTANT", "not a SYM_CONST"); } else if (field == "data") { IntConstExpr *iexpr = new IntConstExpr(0); iexpr->value(iter.current()[1].to_integer()); _expr = iexpr; } else if (field == "expr") { int index = iter.current()[1].to_integer(); _expr = exprs[index]; } else if (field == "type") { /// ... Save this field for later processing iter.current()[1].to_string(type_declaration); } else if (field == "size") { /// ... Save this field for later processing size_declaration = _get_size(iter.current()[1], binstr); } else if (field == "sizedef") { size_was_defaulted = convert_true_false(iter.current()[1], binstr); } else { /// ... Unrecognized -- add to overflow warn_overflow_map("SymbolicConstantSymbol", iter.current()); if (!_overflow) { _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); } _overflow->ins(iter.current()); } } /// ... Now process the _type field if (!type_declaration.defined()) { cerr << "Error: SymbolicConstantSymbol::SymbolicConstantSymbol: " << "No type was declared for binstr object: " << binstr << endl; p_abort("(see above message)"); } p_assert(_expr != 0, "Expression field is null after filling in a " "SymbolicConstantSymbol from a binstring -- perhaps the " "Polaris structure sent in contained an error"); /// ... Now check the type that was sent in Type type; if (size_was_defaulted) type.set(type_declaration); else type.set(type_declaration, size_declaration); type.redimension(0); _type = type; /// if (type != _expr->type()) { /// cerr << "SymbolicConstantSymbol::fill_in(): " /// << "The type information in the binstr was " << endl; /// cerr << type << ", but the expression field's type was " /// << _expr->type() << "." << endl; /// cerr << "The type information in the expression field" /// << " is being used and the other" << endl; /// cerr << "ignored. The expression field is:" << endl; /// cerr << " " << *_expr << endl << endl; /// } } int SymbolicConstantSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; if (_expr == 0) { cerr << "SymbolicConstantSymbol::structures_OK(): " << "found a NULL _expr field."; cerr << "In context of SymbolicConstantSymbol:\n " << flush << *this << endl; return 0; } CHECK_PTR_STRUCTURES(SymbolicConstantSymbol, _expr); return 1; } void SymbolicConstantSymbol::relink_dptrs(ProgramUnit & p) { if (_expr) _expr->relink_eptrs(p); } /// class BlockDataSymbol BlockDataSymbol & BlockDataSymbol::operator = (const BlockDataSymbol & other) { _last_renaming_append = -1; _tag = other._tag; if (_overflow) delete _overflow; _overflow = ((other._overflow) ? new BinRep(*other._overflow) : 0); return *this; } Symbol * BlockDataSymbol::clone() const { return new BlockDataSymbol(*this); } Symbol * BlockDataSymbol::clone_all() const { return new BlockDataSymbol(*this); } BlockDataSymbol::~BlockDataSymbol() { /// ... nothing to do } const Type & BlockDataSymbol::type() const { Type *undef_type = new Type(make_type(UNDEFINED_TYPE)); return *undef_type; } void BlockDataSymbol::print(ostream & o) const { o << "[sym \"" << _tag << "\" (class BLOCKDATA)"; /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; o << "]"; } void BlockDataSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); BinRep *br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "class" )); br->to_tuple().ins_last(new BinRep( "BLOCK_DATA" )); S.ins( br ); } void BlockDataSymbol::fill_in(const BinRep & binstr, ExprTable & NOTUSED(exprs), const Dictionary<VoidPtrDef>& NOTUSED(stmts), const Dictionary<VoidPtrDef>& NOTUSED(commons), const Dictionary<VoidPtrDef>& NOTUSED(equivalences)) { if (_overflow) delete _overflow; _overflow = 0; for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String field; iter.current()[0].to_string(field); if (field == "class") { String class_type; iter.current()[1].to_string(class_type); p_assert(class_type == "BLOCKDATA", "class is not BLOCKDATA"); } else { /// ... Unrecognized -- add to overflow warn_overflow_map("BlockDataSymbol", iter.current()); if (!_overflow) { _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); } _overflow->ins(iter.current()); } } } int BlockDataSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; return 1; } void BlockDataSymbol::relink_dptrs(ProgramUnit & /* p */) { /// Nothing to do } /// class NamelistSymbol NamelistSymbol & NamelistSymbol::operator = (const NamelistSymbol & other) { _last_renaming_append = -1; _tag = other._tag; if (_overflow) delete _overflow; _overflow = ((other._overflow) ? new BinRep(*other._overflow) : 0); return *this; } Symbol * NamelistSymbol::clone() const { return new NamelistSymbol(*this); } Symbol * NamelistSymbol::clone_all() const { return new NamelistSymbol(*this); } NamelistSymbol::~NamelistSymbol() { /// ... nothing to do } const Type & NamelistSymbol::type() const { Type *undef_type = new Type(make_type(UNDEFINED_TYPE)); return *undef_type; } void NamelistSymbol::print(ostream & o) const { o << "[sym \"" << _tag << "\" (class NAMELIST)"; /// ... the _overflow field if (_overflow) o << ", overflow=" << *_overflow; o << "]"; } void NamelistSymbol::exchange_convert( VDL &vdl ) { Symbol::exchange_convert( vdl ); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); Set<BinRep> & S = b->find_ref("symtab")->find_ref( name_ref() )->to_set(); BinRep *br = new BinRep(new List<BinRep>); br->to_tuple().ins_last(new BinRep( "class" )); br->to_tuple().ins_last(new BinRep( "NAMELIST" )); S.ins( br ); } void NamelistSymbol::fill_in(const BinRep & binstr, ExprTable & NOTUSED(exprs), const Dictionary<VoidPtrDef>& NOTUSED(stmts), const Dictionary<VoidPtrDef>& NOTUSED(commons), const Dictionary<VoidPtrDef>& NOTUSED(equivalences)) { if (_overflow) delete _overflow; _overflow = 0; for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String field; iter.current()[0].to_string(field); if (field == "class") { String class_type; iter.current()[1].to_string(class_type); p_assert(class_type == "NAMELIST", "class is not NAMELIST"); } else { /// ... Unrecognized -- add to overflow warn_overflow_map("NamelistSymbol", iter.current()); if (!_overflow) { _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); } _overflow->ins(iter.current()); } } } int NamelistSymbol::structures_OK() const { if (!Symbol::structures_OK()) return 0; return 1; } void NamelistSymbol::relink_dptrs(ProgramUnit & /* p */) { /// Nothing to do }

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