Polaris: Symtab.cc Source File

Symtab.cc Go to the documentation of this file. /// /// TO DO: On the operator= classes, in setting, for instance, the /// _equivalence field to be equal, should also add that variable /// to the Equivalence\'s member list. Same applies to /// the methods that set equivalence, and all similar items. /// others to do: /// common /// /// Don\'t forget to delete pointers before reassigning them in all /// reassigning methods /// /// In the operator = functions, make sure that you\'re using clone() /// for all pointers that need to be copied, such as Expression *\'s /// /// destructors for all objects /// #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif /// #include <ctype.h> #include <stdlib.h> #include <strstream.h> #include "BinRep.h" #include "Boolean.h" #include "Collection/KeyIterator.h" #include "Collection/Map.h" #include "Declaration.h" #include "Expression/Expression.h" #include "Expression/IntrinsicTable.h" #include "IntElem.h" #include "String.h" #include "Symtab.h" #include "Symbol/FunctionSymbol.h" #include "Symbol/VariableSymbol.h" #include "VDL.h" #include "debug.h" #include "utilities/intrinsic_util.h" #include "utilities/string_util.h" #include "utilities/switches_util.h" #include "utilities/symbol_util.h" #include "Directive/Directive.h" #include "macros.h" #include "p-assert.h" template void relink_all_dptrs(Dictionary<Symbol> &, ProgramUnit &); ostream & operator << (ostream & o, const Symtab & symtab) { o << "{\n"; DictionaryIter<Symbol> iter = (Dictionary<Symbol>&) symtab._dict; while (iter.valid()) { cout << iter.current() << "\n"; ++iter; } o << "}\n"; return o; } Symtab::Symtab(const BinRep & binstr) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(SYMTAB, sizeof(Symtab), this); #endif for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { String symbol_name; iter.current()[0].to_string(symbol_name); if (dbx_symtab_debug_level >= 1) cout << "Symtab: Initializing " << symbol_name << "\n"; const BinRep &bs = iter.current()[1]; Symbol *sym = make_symbol(symbol_name, bs ); _dict.ins(sym); } } Symtab::Symtab(const Symtab &s) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(SYMTAB, sizeof(Symtab), this); #endif Symtab::operator = (s); } Symtab::~Symtab() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(SYMTAB, this); #endif } Symtab & Symtab::operator = (const Symtab &s) { _dict.clear(); for (DictionaryIter<Symbol> iter = s._dict; iter.valid(); ++iter) _dict.ins( iter.current().clone_all() ); return (*this); } Symtab * Symtab::clone() const { return new Symtab( *this ); } void Symtab::fill_in(const BinRep & binstr, ExprTable & exprs, const Dictionary<VoidPtrDef> & stmts, const Dictionary<VoidPtrDef> & commons, const Dictionary<VoidPtrDef> & equivalences) { for (Iterator<BinRep> iter = binstr.to_set(); iter.valid(); ++iter) { /// ... The name of the symbol is (String)iter.current()[0] and the binstr /// ... data for the symbol's info is iter.current()[1] String symbol_name; iter.current()[0].to_string(symbol_name); if (dbx_symtab_debug_level >= 2) cout << "Symtab: Filling in " << symbol_name << "\n"; /// ... Fill in the data for that symbol _dict[symbol_name].fill_in( iter.current()[1], exprs, stmts, commons, equivalences); if (dbx_symtab_debug_level >= 3) cout << "..." << _dict[symbol_name] << "\n"; } } typedef Map<Symbol,IntElem> TopSortMap; static int top_sort_expressions( TopSortMap &map, Expression &e ) { if (e.op() == ID_OP) return (map.find_ref(e.symbol()) != 0 ? 1 : 0); int count = 0; for (Iterator<Expression> iter = e.arg_list(); iter.valid(); ++iter) count += top_sort_expressions( map, iter.current() ); return count; } static void top_sort_parameters( TopSortMap &map ) { for (KeyIterator<Symbol,IntElem> iter = map; iter.valid(); ++iter) { iter.current_data().value( top_sort_expressions( map, *iter.current_key().expr_ref() )); } } //_ compare strings ignoring their cases static int str_case_compare( const char* str1, const char* str2 ) { int len = strlen(str2); if (strlen(str1) != len) return 1; else { char cbuf1[len+1]; for (int i = 0; i <= len; str1++) cbuf1[i++] = (islower(*str1) ? toupper(*str1) : *str1); return strcmp(cbuf1, str2); } } void Symtab::write(ostream & o, int space_for_label GIV(0), int max_line_len GIV(FORTRAN_MAX_LINE_LEN)) const { /// ... We need a dictionary of declarations. Each element of this dictionary /// ... is tagged by a type name, such as INTEGER*4, and represents a /// ... declaration line of FORTRAN declaring all variables of that type. /// ... Thus, we move through the symtab one symbol at a time, and as we /// ... find symbols with different type names, we add a new declaration line, /// ... otherwise we just add their name to the one currently in the dictionary. /// ... Thus, by the time we have traversed the entire symbol table, we have all /// ... the Declarations that we need in the dictionary. TopSortMap param_map; Dictionary<Declaration> decl_dict; DirectiveType output_language = (DirectiveType) switch_value("output_lang"); /// ... In addition, we also need a few other declarations types: Declaration saved_decl("SAVE", " ", "",space_for_label, max_line_len); Declaration intr_decl("INTRINSIC", " ", "",space_for_label, max_line_len); Declaration extern_decl("EXTERNAL", " ", "",space_for_label, max_line_len); Declaration dim_decl("DIMENSION", " ", "",space_for_label, max_line_len); Declaration param_decl("PARAMETER", " (",")",space_for_label, max_line_len); Declaration global_decl("GLOBAL", " ", "",space_for_label, max_line_len); Declaration pointer_decl("POINTER", " ","",space_for_label, max_line_len); Declaration allocatable_decl("ALLOCATABLE", " ","",space_for_label, max_line_len); for (const String *id = _dict.first_ref(); id; id = _dict.successor_ref(*id)) { const Symbol &sym = *_dict.find_ref( *id ); SYMBOL_CLASS sym_class = sym.sym_class(); if (output_language == DT_CEDAR_FORTRAN) { /// ... Check for global variables if (sym_class == VARIABLE_CLASS && sym.global()) global_decl << convert_case(sym.name_ref()); } if ((output_language == DT_CRAY_T3D) || /// ... _ (output_language == DT_SGI) || (output_language == DT_CONVEX_SPP) || /// ... > (output_language == DT_SGI_POWER) || (output_language == DT_KAP_SGI)) { /// ... Check for POINTER variables if (sym_class == VARIABLE_CLASS && sym.is_pointer()) { ostrstream str; str << "(" << convert_case(sym.name_ref()) << ","; str << convert_case(sym.assoc_variable().name_ref()) << ")"; str << '\000'; char *data = str.str(); pointer_decl << data; delete [] data; } } if ((output_language == DT_CONVEX) || (output_language == DT_CONVEX_SPP)) { /// ... > /// ... Get all allocatable variables if (sym_class == VARIABLE_CLASS && sym.allocatable()) { allocatable_decl << convert_case(sym.name_ref()); } } /// ... Check for saved variables if (sym_class == VARIABLE_CLASS && sym.saved()) saved_decl << convert_case(sym.name_ref()); // Check for intrinsic/external subroutines/functions if (sym_class == SUBROUTINE_CLASS || sym_class == FUNCTION_CLASS) { if (sym.intrinsic()) /// ... For intrinsics, make sure we use the proper name for the machine intr_decl << convert_case(translate_special_name(sym.name_ref())); if (sym.external()) { if ((output_language == DT_SGI) || (output_language == DT_SGI_POWER) || (output_language == DT_KAP_SGI)) { if ((strcmp(upcase_ch(sym.name_ref()),"MALLOC") != 0) && (strcmp(upcase_ch(sym.name_ref()),"FREE") != 0)) { extern_decl << convert_case(sym.name_ref()); } } else if (output_language == DT_CONVEX_SPP ){ /// ... > if ((strcmp(upcase_ch(sym.name_ref()),"SPPALLOC") != 0) && /// ... > (strcmp(upcase_ch(sym.name_ref()),"SPPFREE") != 0)) { /// ... > extern_decl << convert_case(sym.name_ref()); /// ... > } /// ... > } else { extern_decl << convert_case(sym.name_ref()); } } } // Check for variables/functions/symbolic constants to be included /// ... in a type statement if (sym_class == VARIABLE_CLASS || sym_class == SYMBOLIC_CONSTANT_CLASS || (sym_class == FUNCTION_CLASS && sym.intrinsic() == False)) { if (output_language != DT_CRAY_T3D || /// ... _ (str_case_compare(sym.name_ref(), _T3D_NUM_PES) && /// ... _ (sym_class != VARIABLE_CLASS || !sym.is_pointer()))) { /// ... _ String type_name_str; sym.type().format(type_name_str); Declaration *decl = decl_dict.find_ref(type_name_str); if (!decl) { /// ... This type was not already in the dictionary -- insert a /// ... new Declaration for it. decl = new Declaration(type_name_str, " ", "", space_for_label, max_line_len); decl_dict.ins(decl); } *decl << convert_case(sym.name_ref()); } /// ... _ } /// ... Look for variable arrays for a DIMENSION statement if (sym_class == VARIABLE_CLASS && sym.is_array()) { ostrstream str; str << convert_case(sym.name_ref()); if (sym.allocatable()) { switch (output_language) { case DT_CEDAR_FORTRAN: case DT_CONVEX: case DT_CONVEX_SPP: /// ... > sym.dim().print_all_colons(str); break; default: sym.dim().print(str); break; } } else { sym.dim().print(str); } str << '\000'; char *data = str.str(); dim_decl << data; delete [] data; } /// ... Look for symbolic constants and create PARAMETER stmts if (sym_class == SYMBOLIC_CONSTANT_CLASS) if (output_language != DT_CRAY_T3D || /// ... _ str_case_compare(sym.name_ref(), _T3D_NUM_PES)) /// ... _ param_map.ins(sym, new IntElem(0)); } /// ... Now output all of the declarations that we have created o << saved_decl.str_ref(); o << intr_decl.str_ref(); o << extern_decl.str_ref(); if (output_language == DT_CEDAR_FORTRAN) { /// ... Print the GLOBAL declarations o << global_decl.str_ref(); } if ((output_language == DT_CONVEX) || (output_language == DT_CONVEX_SPP)) { /// ... > /// ... Print the ALLOCATABLE declarations o << allocatable_decl.str_ref(); } for (const String *id1 = decl_dict.first_ref(); id1; id1 = decl_dict.successor_ref(*id1)) { Declaration *dec = decl_dict.find_ref( *id1 ); o << dec->str_ref(); } if ((output_language == DT_CRAY_T3D) || /// ... _ (output_language == DT_SGI) || (output_language == DT_SGI_POWER) || (output_language == DT_CONVEX_SPP) || /// ... > (output_language == DT_KAP_SGI)) { /// ... Print the POINTER declarations o << pointer_decl.str_ref(); } while (param_map.entries() > 0) { Boolean infinite_loop = True; top_sort_parameters( param_map ); for (KeyIterator<Symbol,IntElem> p_iter = param_map; p_iter.valid(); ++p_iter) { if (p_iter.current_data().value() == 0 ) { Symbol &sym = p_iter.current_key(); ostrstream str; str << convert_case(sym.name_ref()) << "="; str << *sym.expr_ref(); str << '\000'; char *data = str.str(); param_decl << data; delete [] data; param_map.del( p_iter.current_key() ); infinite_loop = False; } } if (infinite_loop) { p_assert( False, "Symtab::write: parameters in a cycle" ); break; } } o << param_decl.str_ref(); o << dim_decl.str_ref(); } Symtab::Symtab() { #ifdef CLASS_INSTANCE_REGISTRY register_instance(SYMTAB, sizeof(Symtab), this); #endif } Symbol & Symtab::ins(Symbol * new_symbol) { p_assert(new_symbol != 0, "Symtab::ins(): symbol parameter is NULL"); _dict.ins(new_symbol, 0 /* error if already exists */ ); return *new_symbol; } const Symbol * Symtab::find_ref(const char *symbol_name) const { /// ... creating a symbol with a lower case string will result in an upper case /// ... symbol name. searching for that symbol with the same string will /// ... not find it. Petersen said that all symbols should be upper case, /// ... so this check makes sure upper case strings are being used /// ... 30 September 1994, Thomas R. Lawrence int i = 0; while (symbol_name[i] != 0) { p_assert(!islower(symbol_name[i]), "Symtab::find_ref: symbols must be upper case"); i += 1; } return _dict.find_ref(symbol_name); } Symbol * Symtab::find_ref(const char *symbol_name) { /// ... creating a symbol with a lower case string will result in an upper case /// ... symbol name. searching for that symbol with the same string will /// ... not find it. Petersen said that all symbols should be upper case, /// ... so this check makes sure upper case strings are being used /// ... 30 September 1994, Thomas R. Lawrence int i = 0; while (symbol_name[i] != 0) { /// ... p_assert(!islower(symbol_name[i]), /// ... "Symtab::find_ref: symbols must be upper case"); if (islower(symbol_name[i])) p_abort( "Symtab::find_ref: symbols must be upper case" ); i += 1; } return _dict.find_ref(symbol_name); } const Symbol & Symtab::operator[] (const char *symbol_name) const { const Symbol *sym = _dict.find_ref(symbol_name); if (!sym) { cerr << "Error: Symtab: operator [ ]: Could not find symbol \"" << symbol_name << "\" in symbol table.\n"; p_assert(False, "ABORT"); } return *sym; } Symbol & Symtab::operator[] (const char *symbol_name) { Symbol *sym = _dict.find_ref(symbol_name); if (!sym) { cerr << "Error: Symtab: operator [ ]: Could not find symbol \"" << symbol_name << "\" in symbol table.\n"; p_assert(False, "ABORT"); } return *sym; } void Symtab::del(const char *tag) { _dict.del(tag); } int Symtab::entries() const { return _dict.entries(); } Symbol * Symtab::grab(const char *symbol_name) { return _dict.grab(symbol_name); } void Symtab::absorb(Symtab & other) { while (other._dict.entries()>0) rename_and_ins(other._dict.grab_arb()); } Symbol & Symtab::rename_and_ins(Symbol * sym) { p_assert(sym != 0, "Symtab::rename_and_ins(): symbol parameter was NULL"); Symbol *already_exists = find_ref(sym->_tag); if (((sym->sym_class() == FUNCTION_CLASS) || (sym->sym_class() == SUBROUTINE_CLASS)) && (sym->intrinsic() == IS_INTRINSIC)) { if (! already_exists) return ins(sym); return *already_exists; } if (!already_exists && (lookup_intrinsic(sym->_tag) == False)) { /// ... No naming conflicts -- just insert return ins(sym); } else { /// ... Successively try new renamings until no conflict is found if (!already_exists) already_exists = sym; String tag(sym->_tag); do { already_exists->renaming_suggestion(tag); } while (find_ref(tag) || (lookup_intrinsic(tag) == True)); sym->_tag = tag; /// ... Now sym has been safely renamed. Insert. return ins(sym); } } int Symtab::structures_OK() const { if (!_dict.structures_OK()) { cerr << "In context of Symtab:\n" << flush; write(cout); return 0; } return 1; } DictionaryIter<Symbol> Symtab::iterator() const { return DictionaryIter<Symbol> (CASTAWAY(Dictionary<Symbol> &) _dict); } Symbol & Symtab::ins_intrinsic(const char *name) { Symbol *s = find_ref( name ); if (s == 0) { String intrin = name; IntrinsicTable tab; int index = tab.lookup_intrinsic( intrin ); p_assert( index >= 0, "not an intrinsic function" ); s = new FunctionSymbol( intrin, tab.return_type(index), NOT_EXTERNAL, IS_INTRINSIC, NOT_FORMAL ); this->ins( s ); } p_assert( s && s->intrinsic() == IS_INTRINSIC, "not an intrinsic" ); return *s; } /// Change the pointers within a Symtab element to /// point within the given ProgramUnit. void Symtab::relink_ptrs( ProgramUnit &p) { relink_all_dptrs( _dict, p ); } void Symtab::exchange_convert( VDL &vdl ) { BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); if (b != 0) { List<BinRep> *L = new List<BinRep>; BinRep *bs; bs = new BinRep( "symtab" ); L->ins_last( bs ); bs = new BinRep( new Set<BinRep> ); L->ins_last( bs ); BinRep *br = new BinRep( L ); b->to_set().ins( br ); for (DictionaryIter<Symbol> iter = iterator(); iter.valid(); ++iter) iter.current().exchange_convert( vdl ); } }

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