Polaris: ExprTable.cc Source File

ExprTable.cc Go to the documentation of this file. /// #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif /// #include <iostream.h> #include "BinRep.h" #include "String.h" #include "Collection/List.h" #include "Collection/Iterator.h" #include "Expression/Expression.h" #include "Expression/Expression.all.h" #include "ExprTable.h" #include "p-assert.h" /// Bounds checks if n is within the proper bounds ExprTable::~ExprTable() { /// boolean all_deleted = true; for (int i = 0; i<_size + 1; i++) { if (!_final[i]) delete _table[i]; else _table[i] = NULL; } delete [] _table; delete [] _final; _size = 0; _table = NULL; _final = NULL; } int ExprTable::bounds(int n) const { if ((n > 0) && (n <= _size)) return 1; cerr << "ExprTable: ExprTable[" << n << "] out of range: 1.." << _size << endl; return 0; } /// get_expr_obj takes a string indicating the operator type of an expression. /// It returns the correct object for that expression type with the expr.op /// field set. If the data-type of the expression is not immediately apparent /// it is set to a default (usually INTEGER_TYPE) Expression * ExprTable::get_expr_obj(const String & s) { Expression *e; if (s == "INTEGER_CONSTANT") return (e = new IntConstExpr(0)); else if (s == "REAL_CONSTANT") return (e = new RealConstExpr(REAL_TYPE,"0.0")); else if (s == "STRING_CONSTANT") return (e = new StringConstExpr("")); else if (s == "LOGICAL_CONSTANT") return (e = new LogicalConstExpr("")); else if (s == "KEY") return (e = new KeyExpr("")); else if (s == "HOLLERITH_CONSTANT") return (e = new HollerithConstExpr("")); else if (s == "COMPLEX") return (e = new ComplexExpr(new RealConstExpr(REAL_TYPE,"0.0"), new RealConstExpr(REAL_TYPE,"0.0"))); else if (s == "ARRAY_REF") return (e = new ArrayRefExpr(INTEGER_TYPE)); else if (s == "SUBSTRING") return (e = new SubStringExpr(make_type(CHARACTER_TYPE))); else if (s == "FUNCTION_CALL") return (e = new FunctionCallExpr(INTEGER_TYPE)); else if (s == "INTRINSIC_CALL") return (e = new IntrinsicCallExpr(INTEGER_TYPE)); else if (s == "LAMBDA_CALL") return (e = new LambdaCallExpr(INTEGER_TYPE)); else if (s == "ARG#") return (e = new ArgNumberExpr(INTEGER_TYPE)); else if (s == "RETURN*") return (e = new ReturnStarExpr); else if (s == "LABEL") { p_abort( "Internal Error: The conversion of a binstring to an " "Expression came across an old \"label\" op, which was " "believed to no longer be attainable outside of the " "scanner. Please report this bug to the development " "group. To the development group: See the comments " "in the LabelExpr::convert() routine."); return 0; } else if (s == "IO*") return (e = new IOStarExpr); else if (s == "ID") return (e = new IDExpr(INTEGER_TYPE)); else if (s == "U+") return (e = new UnaryExpr(U_PLUS_OP, INTEGER_TYPE)); else if (s == "U-") return (e = new UnaryExpr(U_MINUS_OP, INTEGER_TYPE)); else if (s == "()") return (e = new UnaryExpr(PAREN_OP, INTEGER_TYPE)); else if (s == ".NOT.") return (e = new UnaryExpr(NOT_OP, INTEGER_TYPE)); else if (s == ".EQ.") return (e = new BinaryExpr(EQ_OP, INTEGER_TYPE)); else if (s == ".NE.") return (e = new BinaryExpr(NE_OP, INTEGER_TYPE)); else if (s == ".LT.") return (e = new BinaryExpr(LT_OP, INTEGER_TYPE)); else if (s == ".LE.") return (e = new BinaryExpr(LE_OP, INTEGER_TYPE)); else if (s == ".GT.") return (e = new BinaryExpr(GT_OP, INTEGER_TYPE)); else if (s == ".GE.") return (e = new BinaryExpr(GE_OP, INTEGER_TYPE)); else if (s == "-") return (e = new BinaryExpr(SUB_OP, INTEGER_TYPE)); else if (s == "/") return (e = new BinaryExpr(DIV_OP, INTEGER_TYPE)); else if (s == "**") return (e = new BinaryExpr(EXP_OP, INTEGER_TYPE)); else if (s == "/// ... ") return (e = new NonBinaryExpr(CONCAT_OP, INTEGER_TYPE)); else if (s == "KEYPAIR") return (e = new BinaryExpr(KEYPAIR_OP, UNKNOWN_TYPE)); else if (s == ".OR.") return (e = new NonBinaryExpr(OR_OP, INTEGER_TYPE)); else if (s == ".AND.") return (e = new NonBinaryExpr(AND_OP, INTEGER_TYPE)); else if (s == ".EQV.") return (e = new NonBinaryExpr(EQV_OP, INTEGER_TYPE)); else if (s == ".NEQV.") return (e = new NonBinaryExpr(NEQV_OP, INTEGER_TYPE)); else if (s == "+") return (e = new NonBinaryExpr(ADD_OP, INTEGER_TYPE)); else if (s == "*") return (e = new NonBinaryExpr(MULT_OP, INTEGER_TYPE)); else if (s == ",") return (e = new CommaExpr); else if (s == "DO") return (e = new DoExpr); else if (s == "=") return (e = new EqualExpr(INTEGER_TYPE)); else if (s == ":") return (e = new NonBinaryExpr(COLON_OP, VOID_TYPE)); else if (s == "REP*") return (e = new BinaryExpr(REPSTAR_OP, INTEGER_TYPE)); cerr << "get_expr_obj: Unidentified op type: " << s << endl; return NULL; } /// ////////////// **** get_table **** ///////////////////////////////// /// /// get_table takes a BinRep which should /// be a tuple of Expression sets. get_table fills in the expr. table with /// the intermediate form of the expression table and returns the /// number of filled entries in exprtable. void ExprTable::get_table(const BinRep &bs, Symtab & symtab) { int count = 0; /// ... the current expression number if (! bs.is_tuple()) { cerr << "ExprTable::get_table's " << "bin-string is not a proper expression table\n"; return; } /// ... iterate through expression sets: for (Iterator<BinRep> iter = bs.to_tuple(); iter.valid(); ++iter) { BinRep & insp = iter.current(); if (insp.is_omega()) { /// ... it is possible for an expression to be OM. _table[++count] = new OmegaExpr; } else { if (!insp.is_set()) { cerr << "ExprTable::get_table: Set expected\n"; return; } /// ... Get the op field BinRep data = insp["op"]; if (data.is_omega()) { cerr << "ExprTable::get_table: No op field in expression\n"; return; } String data_string; data.to_string(data_string); Expression *cur = get_expr_obj(data_string); /// ... get the correct object type cur->convert(insp, symtab); /// ... Fill in cur`s data values _table[++count] = cur; if (count>_size) { p_abort( "ExprTable::get_table: " "Too many expressions for table size" ); } cur = NULL; } } } /// /////////////////// **** get_expr **** /////////////////////// /// /// get_expr takes an integer corresponding to an entry in the /// expression table, exprtable. It returns a copy of the /// complete expression object which contains the complete /// expression for that entry. Upon completion, exprtable[entry] /// also points to the complete expression object corresponding to that entry. /// The same is true for all of the expression\'s sub-expressions. Expression * ExprTable::get_expr(int entry) { /// ... if already gotten, return a copy of it if (_final[entry] != 0) return (_table[entry])->clone(); Expression *e = _table[entry]; /// ... range should already have been checked _final[entry] = 1; if (!e) { cerr << "ExprTable::get_expr: _table[entry] not valid\n"; return NULL; } OP_TYPE op = e->op(); switch (op) { /// ... all cases where exprtable[entry] contains no sub-expresesions so /// ... nothing needs to be done. case INTEGER_CONSTANT_OP: case REAL_CONSTANT_OP: case STRING_CONSTANT_OP: case HOLLERITH_CONSTANT_OP: case LOGICAL_CONSTANT_OP: case LABEL_OP: case IO_STAR_OP: case OMEGA_OP: case FORMAT_OP: case ARG_OP: break; case COMPLEX_OP: { Expression *realp = get_expr(e->real_part().entry()); Expression *imagp = get_expr(e->imaginary_part().entry()); e->real_part(realp); e->imaginary_part(imagp); } break; case ARRAY_REF_OP: { Expression *ar = get_expr(e->array().entry()); e->array(ar); ar = get_expr(e->subscript().entry()); e->subscript(ar); } break; case SUBSTRING_OP: { Expression *ba = get_expr(e->string().entry()); Expression *bo = get_expr(e->bound().entry()); e->string(ba); e->bound(bo); } break; case FUNCTION_CALL_OP: { Expression *fun = get_expr(e->function().entry()); e->function(fun); if (e->parameters_valid()) { fun = & e->parameters_guarded(); if (fun->op() != OMEGA_OP) fun = get_expr(fun->entry()); e->parameters(fun); } else { e->parameters(new CommaExpr); } } break; case INTRINSIC_CALL_OP: { Expression *fun = get_expr(e->intrinsic().entry()); e->intrinsic(fun); if (e->parameters_valid()) { fun = get_expr(e->parameters_guarded().entry()); e->parameters(fun); } } break; case LAMBDA_CALL_OP: { Expression *fun = get_expr(e->lambda_expr().entry()); e->lambda_expr(fun); fun = get_expr(e->parameters_guarded().entry()); e->parameters(fun); } break; case RETURN_OP: { if (e->expr_valid()) { Expression *ar = get_expr(e->expr_guarded().entry()); e->expr(ar); } else e->expr(NULL); } break; case ID_OP: { if (e->substituted_valid()) { Expression *sub = get_expr(e->substituted_guarded().entry()); e->substituted(sub); } /// ... possible values should already be in the list } break; case U_PLUS_OP: case U_MINUS_OP: case NOT_OP: case PAREN_OP: { Expression *exp = get_expr(e->expr_guarded().entry()); e->expr(exp); } break; case EQ_OP: case NE_OP: case LT_OP: case LE_OP: case GT_OP: case GE_OP: case SUB_OP: case DIV_OP: case EXP_OP: case REPSTAR_OP: case KEYPAIR_OP: { if (e->left_guarded().op() != OMEGA_OP) { Expression *lf = get_expr(e->left_guarded().entry()); e->left(lf); } Expression *rt = get_expr(e->right_guarded().entry()); e->right(rt); } break; case COLON_OP: { /// ... _left of a COLON_OP can be OM Iterator<Expression> iter = e->arg_list(); Expression *newe; /// ... pointer to ExprTable entry objects while (! iter.end()) { if (iter.current().op() == TABLE_ENTRY) { newe = get_expr(iter.current().entry()); e->arg_list().modify(iter.current(), newe); } iter.next(); } } break; case CONCAT_OP: case OR_OP: case AND_OP: case EQV_OP: case NEQV_OP: case ADD_OP: case MULT_OP: case COMMA_OP: { Iterator<Expression> iter = e->arg_list(); Expression *newe; /// ... pointer to ExprTable entry objects while (! iter.end()) { newe = get_expr(iter.current().entry()); e->arg_list().modify(iter.current(), newe); iter.next(); } } break; case DO_OP: { Expression *io = get_expr(e->iolist().entry()); Expression *it = get_expr(e->iterator().entry()); e->iolist(io); e->iterator(it); } break; case EQUAL_OP: { Expression *in = get_expr(e->index_id().entry()); e->index_id(in); in = get_expr(e->iteration_space().entry()); e->iteration_space(in); } break; case TABLE_ENTRY: p_abort( "ExprTable::get_expr: called on a TableExpr"); break; default: break; } return e; } Expression * convert_expr(BinRep & insp, ExprTable & etable, const char *caller) { if (!insp.is_integer()) { cerr << caller << "::convert_expr: integer expected.\n"; p_abort( "(see above message)" ); } return (etable[insp.to_integer()]); }

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