diff options
Diffstat (limited to 'omegalib')
25 files changed, 306 insertions, 939 deletions
diff --git a/omegalib/codegen/include/code_gen/CG_outputBuilder.h b/omegalib/codegen/include/code_gen/CG_outputBuilder.h index 2203235..19dc440 100644 --- a/omegalib/codegen/include/code_gen/CG_outputBuilder.h +++ b/omegalib/codegen/include/code_gen/CG_outputBuilder.h @@ -29,76 +29,57 @@ namespace omega { +//! abstract base class of comiler IR code builder class CG_outputBuilder { public: CG_outputBuilder() {} virtual ~CG_outputBuilder() {} - //--------------------------------------------------------------------------- - // substitute variables in stmt - //--------------------------------------------------------------------------- + //! substitute variables in stmt virtual CG_outputRepr *CreateSubstitutedStmt(int indent, CG_outputRepr *stmt, const std::vector<std::string> &vars, std::vector<CG_outputRepr *> &subs) const = 0; - //--------------------------------------------------------------------------- - // assignment stmt generation - //--------------------------------------------------------------------------- + //! assignment stmt generation virtual CG_outputRepr *CreateAssignment(int indent, CG_outputRepr *lhs, CG_outputRepr *rhs) const = 0; - //--------------------------------------------------------------------------- - // function invocation generation - //--------------------------------------------------------------------------- + //! function invocation generation virtual CG_outputRepr *CreateInvoke(const std::string &funcName, std::vector<CG_outputRepr *> &argList) const = 0; - //--------------------------------------------------------------------------- - // comment generation - //--------------------------------------------------------------------------- + //! comment generation virtual CG_outputRepr *CreateComment(int indent, const std::string &commentText) const = 0; - //--------------------------------------------------------------------------- - // Attribute generation - //--------------------------------------------------------------------------- + //! Attribute generation virtual CG_outputRepr* CreateAttribute(CG_outputRepr *control, const std::string &commentText) const = 0; - //--------------------------------------------------------------------------- - // Pragma Attribute - // -------------------------------------------------------------------------- + //! Pragma Attribute virtual CG_outputRepr* CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &pragmaText) const = 0; - //--------------------------------------------------------------------------- - // Prefetch Attribute - //--------------------------------------------------------------------------- + //! Prefetch Attribute virtual CG_outputRepr* CreatePrefetchAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &arrName, int hint) const = 0; - //--------------------------------------------------------------------------- - // generate if stmt, true/false stmt can be NULL but not the condition - //--------------------------------------------------------------------------- + //! generate if stmt, true/false stmt can be NULL but not the condition virtual CG_outputRepr *CreateIf(int indent, CG_outputRepr *guardCondition, CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const = 0; - //--------------------------------------------------------------------------- - // generate loop inductive variable (loop control structure) - //--------------------------------------------------------------------------- + //! generate loop inductive variable (loop control structure) virtual CG_outputRepr *CreateInductive(CG_outputRepr *index, CG_outputRepr *lower, CG_outputRepr *upper, CG_outputRepr *step) const = 0; - //--------------------------------------------------------------------------- - // generate loop stmt from loop control and loop body, NULL parameter allowed - //--------------------------------------------------------------------------- + //! generate loop stmt from loop control and loop body, NULL parameter allowed virtual CG_outputRepr *CreateLoop(int indent, CG_outputRepr *control, CG_outputRepr *stmtList) const = 0; - //--------------------------------------------------------------------------- - // copy operation, NULL parameter allowed. this function makes pointer - // handling uniform regardless NULL status - //--------------------------------------------------------------------------- + //! copy operation, NULL parameter allowed. + /*! + * this function makes pointer handling uniform regardless NULL status + */ virtual CG_outputRepr *CreateCopy(CG_outputRepr *original) const { if (original == NULL) return NULL; @@ -106,69 +87,72 @@ public: return original->clone(); } - //--------------------------------------------------------------------------- - // basic integer number creation - //--------------------------------------------------------------------------- + //! basic integer number creation virtual CG_outputRepr *CreateInt(int num) const = 0; virtual bool isInteger(CG_outputRepr *op) const = 0; - //--------------------------------------------------------------------------- - // basic identity/variable creation - //--------------------------------------------------------------------------- + //! basic identity/variable creation virtual CG_outputRepr *CreateIdent(const std::string &varName) const = 0; - //--------------------------------------------------------------------------- - // binary arithmetic operations, NULL parameter means 0, - // Note: - // integer division truncation method undefined, only use when lop is known - // to be multiple of rop, otherwise use integer floor instead - //--------------------------------------------------------------------------- + //! Addition operations, NULL parameter means 0, virtual CG_outputRepr *CreatePlus(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + //! Subtraction operations, NULL parameter means 0, virtual CG_outputRepr *CreateMinus(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + //! Multiplication operations, NULL parameter means 0, virtual CG_outputRepr *CreateTimes(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + //! Division operations, NULL parameter means 0, + /*! + * integer division truncation method undefined, only use when lop is known + * to be multiple of rop, otherwise use integer floor instead + */ virtual CG_outputRepr *CreateDivide(CG_outputRepr *lop, CG_outputRepr *rop) const { return CreateIntegerFloor(lop, rop); } - //--------------------------------------------------------------------------- - // integer arithmetic functions, NULL parameter means 0, second parameter - // must be postive (i.e. b > 0 below), otherwise function undefined - // Note: - // ceil(a, b) = -floor(-a, b) or floor(a+b-1, b) or floor(a-1, b)+1 - // mod(a, b) = a-b*floor(a, b) - // where result must lie in range [0,b) - // floor(a, b) = a/b if a >= 0 - // (a-b+1)/b if a < 0 - // where native '/' operator behaves as 5/2 = 2, (-5)/2 = -2 - //--------------------------------------------------------------------------- + //! integer floor functions, NULL parameter means 0 + /*! + * second parameter must be postive (i.e. b > 0 below), otherwise function undefined + * + * floor(a, b) + * * = a/b if a >= 0 + * * = (a-b+1)/b if a < 0 + */ virtual CG_outputRepr *CreateIntegerFloor(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + //! integer mod functions, NULL parameter means 0 + /*! + * second parameter must be postive (i.e. b > 0 below), otherwise function undefined + * + * mod(a, b) = a-b*floor(a, b) where result must lie in range [0,b) + */ virtual CG_outputRepr *CreateIntegerMod(CG_outputRepr *lop, CG_outputRepr *rop) const { CG_outputRepr *lop2 = CreateCopy(lop); CG_outputRepr *rop2 = CreateCopy(rop); return CreateMinus(lop2, CreateTimes(rop2, CreateIntegerFloor(lop, rop))); } + //! integer ceil functions, NULL parameter means 0 + /*! + * second parameter must be postive (i.e. b > 0 below), otherwise function undefined + * + * ceil(a, b) = -floor(-a, b) or floor(a+b-1, b) or floor(a-1, b)+1 + */ virtual CG_outputRepr *CreateIntegerCeil(CG_outputRepr *lop, CG_outputRepr *rop) const { return CreateMinus(NULL, CreateIntegerFloor(CreateMinus(NULL, lop), rop)); } - //--------------------------------------------------------------------------- - // binary logical operation, NULL parameter means TRUE - //--------------------------------------------------------------------------- + //! binary logical operation, NULL parameter means TRUE virtual CG_outputRepr *CreateAnd(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; - //--------------------------------------------------------------------------- - // binary condition operations - //--------------------------------------------------------------------------- + //! binary conditional Greater than or equal to virtual CG_outputRepr *CreateGE(CG_outputRepr *lop, CG_outputRepr *rop) const { return CreateLE(rop, lop); } + //! binary conditional Less than or equal to virtual CG_outputRepr *CreateLE(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + //! binary conditional equal to virtual CG_outputRepr *CreateEQ(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; - //--------------------------------------------------------------------------- - // join stmts together, NULL parameter allowed - //--------------------------------------------------------------------------- + //! join stmts together, NULL parameter allowed virtual CG_outputRepr *StmtListAppend(CG_outputRepr *list1, CG_outputRepr *list2) const = 0; }; diff --git a/omegalib/codegen/include/code_gen/CG_outputRepr.h b/omegalib/codegen/include/code_gen/CG_outputRepr.h index 92f3d9f..0897007 100644 --- a/omegalib/codegen/include/code_gen/CG_outputRepr.h +++ b/omegalib/codegen/include/code_gen/CG_outputRepr.h @@ -20,9 +20,11 @@ namespace omega { class CG_outputRepr { public: CG_outputRepr() {} - virtual ~CG_outputRepr() { /* shallow delete */ } + //! shallow delete + virtual ~CG_outputRepr() { } virtual CG_outputRepr *clone() const = 0; - virtual void clear() { /* delete actual IR code wrapped inside */ } + //! delete actual IR code wrapped inside + virtual void clear() { } virtual void dump() const {} }; diff --git a/omegalib/codegen/include/code_gen/CG_roseBuilder.h b/omegalib/codegen/include/code_gen/CG_roseBuilder.h index 93b708e..5dad663 100644 --- a/omegalib/codegen/include/code_gen/CG_roseBuilder.h +++ b/omegalib/codegen/include/code_gen/CG_roseBuilder.h @@ -14,98 +14,60 @@ public: CG_roseBuilder(int isFortran, SgGlobal* global, SgGlobal* global_scope, SgSymbolTable* symtab1, SgSymbolTable* symtab2, SgNode* root); ~CG_roseBuilder(); - //--------------------------------------------------------------------------- - // place holder generation - //--------------------------------------------------------------------------- - // CG_outputRepr* CreatePlaceHolder(int indent, CG_outputRepr *stmt, - // Tuple<CG_outputRepr*> &funcList, - // Tuple<std::string> &loop_vars) const; - - - //--------------------------------------------------------------------------- - // substitute variables in stmt - //--------------------------------------------------------------------------- - - - + //! substitute variables in stmt CG_outputRepr *CreateSubstitutedStmt(int indent, CG_outputRepr *stmt, const std::vector<std::string> &vars, std::vector<CG_outputRepr *> &subs) const; - //--------------------------------------------------------------------------- - // assignment generation - //--------------------------------------------------------------------------- + //! assignment generation CG_outputRepr* CreateAssignment(int indent, CG_outputRepr* lhs, CG_outputRepr* rhs) const; - //--------------------------------------------------------------------------- - // function invocation generation - //--------------------------------------------------------------------------- + //! function invocation generation CG_outputRepr* CreateInvoke(const std::string &funcName, std::vector<CG_outputRepr *> &argList) const; - //--------------------------------------------------------------------------- - // comment generation - //--------------------------------------------------------------------------- + //! comment generation CG_outputRepr* CreateComment(int indent, const std::string &commentText) const; - //--------------------------------------------------------------------------- - // Attribute generation - //--------------------------------------------------------------------------- + //! Attribute generation CG_outputRepr* CreateAttribute(CG_outputRepr *control, const std::string &commentText) const; - //--------------------------------------------------------------------------- - // Pragma Attribute - //--------------------------------------------------------------------------- + //! Pragma Attribute CG_outputRepr* CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &pragmaText) const; - //--------------------------------------------------------------------------- - // Prefetch Attribute - //--------------------------------------------------------------------------- + //! Prefetch Attribute CG_outputRepr* CreatePrefetchAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &arrName, int hint) const; - //--------------------------------------------------------------------------- - // if stmt gen operations - //--------------------------------------------------------------------------- + //! if stmt gen operations CG_outputRepr* CreateIf(int indent, CG_outputRepr* guardCondition, CG_outputRepr* true_stmtList, CG_outputRepr* false_stmtList) const; - //--------------------------------------------------------------------------- - // inductive variable generation, to be used in CreateLoop as control - //--------------------------------------------------------------------------- + //! inductive variable generation, to be used in CreateLoop as control CG_outputRepr* CreateInductive(CG_outputRepr* index, CG_outputRepr* lower, CG_outputRepr* upper, CG_outputRepr* step) const; - //--------------------------------------------------------------------------- - // loop stmt generation - //--------------------------------------------------------------------------- + //! loop stmt generation CG_outputRepr* CreateLoop(int indent, CG_outputRepr* control, CG_outputRepr* stmtList) const; - //--------------------------------------------------------------------------- - // basic operations - //--------------------------------------------------------------------------- CG_outputRepr* CreateInt(int num ) const; bool isInteger(CG_outputRepr *op) const; CG_outputRepr* CreateIdent(const std::string &varName) const; - //--------------------------------------------------------------------------- - // binary arithmetic operations - //--------------------------------------------------------------------------- + //! binary arithmetic operations CG_outputRepr* CreatePlus(CG_outputRepr* lop, CG_outputRepr* rop) const; CG_outputRepr* CreateMinus(CG_outputRepr* lop, CG_outputRepr* rop) const; CG_outputRepr* CreateTimes(CG_outputRepr* lop, CG_outputRepr* rop) const; CG_outputRepr* CreateIntegerFloor(CG_outputRepr* lop, CG_outputRepr* rop) const; CG_outputRepr* CreateIntegerMod(CG_outputRepr* lop, CG_outputRepr* rop) const; - //--------------------------------------------------------------------------- - // binary logical operations - //--------------------------------------------------------------------------- + //! binary logical operations CG_outputRepr* CreateAnd(CG_outputRepr* lop, CG_outputRepr* rop) const; //--------------------------------------------------------------------------- @@ -118,30 +80,14 @@ public: //--------------------------------------------------------------------------- // stmt list gen operations //--------------------------------------------------------------------------- - // CG_outputRepr* - // CreateStmtList(CG_outputRepr *singleton = NULL) const; - // CG_outputRepr* - // StmtListInsertLast(CG_outputRepr* list, CG_outputRepr* node) const; CG_outputRepr* StmtListAppend(CG_outputRepr* list1, CG_outputRepr* list2) const; - //CG_outputRepr* CreateDim3(const char* varName, int arg1, int arg2) const; CG_outputRepr* CreateDim3(const char* varName, CG_outputRepr* arg1, CG_outputRepr* arg2, CG_outputRepr* arg3 = NULL) const; // Manu:: added for fortran support bool isInputFortran() const; - //--------------------------------------------------------------------------- - // kernel generation - //--------------------------------------------------------------------------- - // CG_outputRepr* CreateKernel(immed_list* iml) const; - - //--------------------------------------------------------------------------- - // Add a modifier to a type (for things like __global__) - //--------------------------------------------------------------------------- - //type_node* ModifyType(type_node* base, const char* modifier) const; - - private: SgSymbolTable *symtab_; SgSymbolTable *symtab2_; @@ -152,8 +98,6 @@ private: }; extern char *k_ocg_comment; - //bool substitute(SgExpression *in, SgVariableSymbol *sym, SgExpression *expr, SgNode* root, SgExpression* parent); - //bool substitute(SgStatement *tn, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab); std::vector<SgVarRefExp *>substitute(SgNode *tnl, const SgVariableSymbol *sym, SgExpression *expr,SgNode* root) ; diff --git a/omegalib/codegen/include/code_gen/CG_roseRepr.h b/omegalib/codegen/include/code_gen/CG_roseRepr.h index 4861db7..28553e7 100644 --- a/omegalib/codegen/include/code_gen/CG_roseRepr.h +++ b/omegalib/codegen/include/code_gen/CG_roseRepr.h @@ -29,7 +29,6 @@ public: // Dump operations //--------------------------------------------------------------------------- void Dump() const; - //void DumpToFile(FILE *fp = stderr) const; private: // only one of _tnl and _op would be active at any time, depending on // whether it is building a statement list or an expression tree diff --git a/omegalib/codegen/include/code_gen/CG_suifBuilder.h b/omegalib/codegen/include/code_gen/CG_suifBuilder.h deleted file mode 100644 index 9f57e3d..0000000 --- a/omegalib/codegen/include/code_gen/CG_suifBuilder.h +++ /dev/null @@ -1,88 +0,0 @@ -#ifndef CG_suifBuilder_h -#define CG_suifBuilder_h - -#include <basic/Tuple.h> -#include <code_gen/CG_outputBuilder.h> -#include <code_gen/CG_suifRepr.h> -#include <string> - -namespace omega { - - -class CG_suifBuilder: public CG_outputBuilder { -public: - //CG_suifBuilder(proc_symtab *symtab) {symtab_ = symtab;} - CG_suifBuilder(proc_symtab *symtab); - //protonu--initializing code_gen stuff for cuda - //this looks like a flaw in my design - //end--protonu - ~CG_suifBuilder() {} - - CG_outputRepr* CreatePlaceHolder(int indent, CG_outputRepr *stmt, - Tuple<CG_outputRepr*> &funcList, - Tuple<std::string> &loop_vars) const; - CG_outputRepr* CreateAssignment(int indent, CG_outputRepr* lhs, - CG_outputRepr* rhs) const; - CG_outputRepr* CreateInvoke(const std::string &fname, - Tuple<CG_outputRepr*> &argList) const; - CG_outputRepr* CreateComment(int indent, const std::string &commentText) const; - CG_outputRepr* CreateAttribute(CG_outputRepr *control, - const std::string &commentText) const; - - CG_outputRepr* CreateIf(int indent, CG_outputRepr* guardCondition, - CG_outputRepr* true_stmtList, CG_outputRepr* false_stmtList) const; - CG_outputRepr* CreateInductive(CG_outputRepr* index, - CG_outputRepr* lower, - CG_outputRepr* upper, - CG_outputRepr* step) const; - CG_outputRepr* CreateLoop(int indent, CG_outputRepr* control, - CG_outputRepr* stmtList) const; - CG_outputRepr* CreateInt(int) const; - CG_outputRepr* CreateIdent(const std::string &idStr) const; - CG_outputRepr* CreatePlus(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateMinus(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateTimes(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateIntegerDivide(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateIntegerMod(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateAnd(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateGE(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateLE(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* CreateEQ(CG_outputRepr*, CG_outputRepr*) const; - CG_outputRepr* StmtListAppend(CG_outputRepr* list1, CG_outputRepr* list2) const; - //--------------------------------------------------------------------------- - // pragma generation - //--------------------------------------------------------------------------- - virtual CG_outputRepr* CreatePragma(int indent, const std::string &pragmaText) const; - - //--------------------------------------------------------------------------- - // dim3 generation - //--------------------------------------------------------------------------- - virtual CG_outputRepr* CreateDim3(immed varName, immed arg1, immed arg2) const; - virtual CG_outputRepr* CreateDim3(immed varName, immed arg1, immed arg2, immed arg3) const; - - - //--------------------------------------------------------------------------- - // kernel generation - //--------------------------------------------------------------------------- - virtual CG_outputRepr* CreateKernel(immed_list* iml) const; - - //--------------------------------------------------------------------------- - // Add a modifier to a type (for things like __global__) - //--------------------------------------------------------------------------- - type_node* ModifyType(type_node* base, const char* modifier) const; -private: - proc_symtab *symtab_; -}; - -extern char *k_ocg_comment; - -bool substitute(instruction *in, var_sym *sym, operand expr, - base_symtab *st=NULL); -bool substitute(tree_node *tn, var_sym *sym, operand expr, - base_symtab *st=NULL); -bool substitute(tree_node_list *tnl, var_sym *sym, operand expr, - base_symtab *st = NULL); - -} - -#endif diff --git a/omegalib/codegen/include/code_gen/CG_suifRepr.h b/omegalib/codegen/include/code_gen/CG_suifRepr.h deleted file mode 100644 index ce7c6cd..0000000 --- a/omegalib/codegen/include/code_gen/CG_suifRepr.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef CG_suifRepr_h -#define CG_suifRepr_h - -#include <code_gen/CG_outputRepr.h> -#include <suif1.h> - -namespace omega { - -class CG_suifRepr : public CG_outputRepr { - friend class CG_suifBuilder; -public: - CG_suifRepr(); - CG_suifRepr(tree_node_list *tnl); - CG_suifRepr(operand op); - virtual ~CG_suifRepr(); - virtual CG_outputRepr *clone(); - virtual void clear(); - - tree_node_list* GetCode() const; - operand GetExpression() const; - - //--------------------------------------------------------------------------- - // Dump operations - //--------------------------------------------------------------------------- - virtual void Dump() const; - virtual void DumpToFile(FILE *fp = stderr) const; -private: - // only one of _tnl and _op would be active at any time, depending on - // whether it is building a statement list or an expression tree - tree_node_list *tnl_; - operand op_; -}; - -} // namespace - -#endif diff --git a/omegalib/codegen/include/code_gen/codegen.h b/omegalib/codegen/include/code_gen/codegen.h index 469653d..cb63bfd 100755 --- a/omegalib/codegen/include/code_gen/codegen.h +++ b/omegalib/codegen/include/code_gen/codegen.h @@ -15,10 +15,14 @@ public: static const int var_substitution_threshold; protected: - std::vector<std::vector<Relation> > projected_IS_; // projected_IS_[level-1][new stmt#] - std::vector<Relation> xforms_; // transformations[original stmt#] - Relation known_; // no need to generate code for constraints satisfied in known - std::vector<int> remap_; // map new stmt# to original stmt# + //! projected_IS_[level-1][new stmt#] + std::vector<std::vector<Relation> > projected_IS_; + //! transformations[original stmt#] + std::vector<Relation> xforms_; + //! no need to generate code for constraints satisfied in known + Relation known_; + //! map new stmt# to original stmt# + std::vector<int> remap_; public: CodeGen(const std::vector<Relation> &xforms, const std::vector<Relation> &IS, const Relation &known = Relation::Null(), diff --git a/omegalib/codegen/src/CG_roseBuilder.cc b/omegalib/codegen/src/CG_roseBuilder.cc index eb16830..7e12634 100644 --- a/omegalib/codegen/src/CG_roseBuilder.cc +++ b/omegalib/codegen/src/CG_roseBuilder.cc @@ -33,22 +33,6 @@ namespace omega { //----------------------------------------------------------------------------- char *k_ocg_comment; -// void __attribute__ ((constructor)) my_init(void) { -// ANNOTE(k_ocg_comment, "omega_comment", TRUE); -// } - -/* - const char *libcode_gen_ver_string = ""; - const char *libcode_gen_who_string = ""; - const char *libcode_gen_suif_string = ""; - - void init_code_gen(int&, char* []) { - ANNOTE(k_ocg_comment, "omega_comment", TRUE); - } - - void exit_code_gen(void) { - } - */ CG_roseBuilder::CG_roseBuilder(int is_fortran, SgGlobal* global, SgGlobal* firstScope, SgSymbolTable* symtab, SgSymbolTable* symtab2, SgNode* root) : isFortran(is_fortran), global_(global), global_scope(firstScope), symtab_(symtab), symtab2_( @@ -77,8 +61,6 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, SgNode *tnl; SgStatement* statement; if (list != NULL) { - //statement = *((*list).begin()); - //tnl = isSgNode(statement); delete stmt; for (int i = 0; i < subs.size(); i++) { if (subs[i] == NULL) @@ -92,8 +74,6 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, statement = (*it); tnl = isSgNode(statement); - // std::string master = tnl->unparseToString(); - int j; int not_in_symtab_; @@ -109,15 +89,12 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, vs = symtab2_->find_variable(SgName(vars[i].c_str())); } if (vs != NULL) { - //std::string x = vars[i].c_str() ; - //std::string y = isSgNode(op)->unparseToString(); std::vector<SgVarRefExp *> array = substitute(tnl, (const SgVariableSymbol*) vs, op, root_); for (std::vector<SgVarRefExp *>::iterator it = array.begin(); it != array.end(); it++) { - // std::string z = isSgNode(array[j])->unparseToString(); if (isSgVarRefExp(op)) { if (strcmp( isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), @@ -125,9 +102,6 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, (*it)->set_symbol( isSgVarRefExp(op)->get_symbol()); - // std::string z = isSgNode(array[j])->unparseToString(); - - // isSgBinaryOp(array[j]->get_parent())->replace_expression(array[j], op); } } else if (isSgExpression(op)) { @@ -146,10 +120,6 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, } } - /* std::vector<SgVarRefExp *> array2 = substitute (tnl,(const SgVariableSymbol*) vs, op, root_); - if(array2.size() != 0) - throw ir_error("variable replacement unsuccessful"); - */ } } @@ -166,7 +136,6 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, } else { tnl = static_cast<CG_roseRepr *>(stmt)->tnl_; - //std::string master = tnl->unparseToString(); if (tnl == NULL) throw ir_error("both list and tnl are null!!"); @@ -195,8 +164,6 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, vs = symtab2_->find_variable(SgName(vars[i].c_str())); } if (vs != NULL) { - //std::string x = vars[i].c_str() ; - //std::string y = isSgNode(op)->unparseToString(); std::vector<SgVarRefExp *> array = substitute(tnl, vs, op, root_); @@ -204,27 +171,17 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, if (strcmp( isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), vs->get_name().getString().c_str())) { - // symtab2_->remove(vs); } } - /* else if(not_in_symtab_ && isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())){ - if(strcmp(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()->get_name().getString().c_str(),\ - vs->get_name().getString().c_str())){ - symtab2_->remove(vs); - } - }*/ - //symtab2_->remove(vs); + for (std::vector<SgVarRefExp *>::iterator j = array.begin(); j != array.end(); j++) { - // std::string z = isSgNode(array[j])->unparseToString(); if (isSgVarRefExp(op)) { if (strcmp( isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), vs->get_name().getString().c_str())) { (*j)->set_symbol(isSgVarRefExp(op)->get_symbol()); - //isSgBinaryOp(array[j]->get_parent())->replace_expression(array[j], op); - // std::string z = isSgNode(array[j])->unparseToString(); } } else if (isSgExpression(op)) { @@ -240,78 +197,11 @@ CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, } else throw ir_error("unrecognized expression type"); - /* if(strcmp(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()->get_name().getString().c_str(),\ - vs->get_name().getString().c_str() )){ - array[j]->set_symbol(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()); - - */ } } - /* std::vector<SgVarRefExp *> array2 = substitute (tnl,(const SgVariableSymbol*) vs, op, root_); - if(array2.size() != 0) - throw ir_error("variable replacement unsuccessful"); - */ } - /* SgExpression* exp = NULL; - - if(stmt1 = isSgStatement(tnl)){ - if (SgExprStatement* expr_stmt = isSgExprStatement(stmt1)) - exp = expr_stmt->get_expression(); - else if( block = isSgBasicBlock(tnl)){ - SgStatementPtrList& stmts = block->get_statements(); - SgExpression* exp2; - for(int i =0; i < stmts.size(); i++){ - if(isSgExprStatement(stmts[i])){ - exp2 = isSgExprStatement(stmts[i])->get_expression(); - if(exp2 != NULL){ - - if(isSgBinaryOp(exp2)) { - substitute(isSgBinaryOp(exp2)->get_lhs_operand(), vs, op, root_, exp2); - substitute(isSgBinaryOp(exp2)->get_rhs_operand(), vs, op, root_, exp2); - } - else if (isSgUnaryOp(exp2)) - substitute(isSgUnaryOp(exp2)->get_operand(), vs, op, root_, exp2); - - - }//end if - - }//end if - }//end for - - }//end else - else if(SgForStatement* for_stmt = isSgForStatement(tnl)){ - SgForStatement* temp = for_stmt; - while(isSgForStatement(temp)){ - - - - } - - - - - } - - - }//end if - else - exp = isSgExpression(tnl); - - if(exp != NULL){ - if(isSgBinaryOp(exp)) { - substitute(isSgBinaryOp(exp)->get_lhs_operand(), vs, op, root_, exp); - substitute(isSgBinaryOp(exp)->get_rhs_operand(), vs, op, root_, exp); - } - else if (isSgUnaryOp(exp)) - substitute(isSgUnaryOp(exp)->get_operand(), vs, op, root_, exp); - - } - // if (op.is_instr()) - // delete op.instr(); - } - */ } return new CG_roseRepr(tnl); } @@ -352,9 +242,6 @@ CG_outputRepr* CG_roseBuilder::CreateAssignment(int, CG_outputRepr *lhs, CG_outputRepr* CG_roseBuilder::CreateInvoke(const std::string &fname, std::vector<CG_outputRepr *> &list) const { - // Manu:: debug -// std::cout << "--------- CreateInvoke --------- \n"; - if (fname == std::string("max") || fname == std::string("min")) { if (list.size() == 0) { return NULL; @@ -389,7 +276,6 @@ CG_outputRepr* CG_roseBuilder::CreateInvoke(const std::string &fname, SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op2), new CG_roseRepr(op1)))->op_; appendExpression(arg_list, cond); ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); -// std::cout << "--------- CreateInvoke:: " << isSgNode(ins)->unparseToString().c_str() << "\n"; } } else { @@ -404,7 +290,6 @@ CG_outputRepr* CG_roseBuilder::CreateInvoke(const std::string &fname, SgExpression *cond = static_cast<CG_roseRepr *>(CreateLE(new CG_roseRepr(op1), new CG_roseRepr(op2)))->op_; appendExpression(arg_list, cond); ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); -// std::cout << "--------- CreateInvoke:: " << isSgNode(ins)->unparseToString().c_str() << "\n"; } } @@ -442,10 +327,6 @@ CG_outputRepr* CG_roseBuilder::CreateComment(int, CG_outputRepr* CG_roseBuilder::CreateIf(int, CG_outputRepr *guardList, CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { - // static int if_counter = 1; - // std::string s = std::string("omegaif_")+to_string(if_counter++); - // SgLabelStatement* label =buildLabelStatement(SgName(const_cast<char *>(s.c_str()))); - if (true_stmtList == NULL && false_stmtList == NULL) { delete guardList; return NULL; @@ -517,11 +398,6 @@ CG_outputRepr* CG_roseBuilder::CreateIf(int, CG_outputRepr *guardList, SgIfStmt* ti = buildIfStmt(header, isSgStatement(then_part), isSgStatement(else_part)); -// label->set_scope(ti);//may have to be shifted to after symbol table insertion -// SgLabelSymbol* if_label = isSgLabelSymbol(label->get_symbol_from_symbol_table()); - -// symtab_->insert( SgName(const_cast<char *>(s.c_str())) , isSgSymbol(if_label)); - delete guardList; delete true_stmtList; delete false_stmtList; @@ -551,10 +427,6 @@ CG_outputRepr* CG_roseBuilder::CreateInductive(CG_outputRepr *index, SgExpression* upper_bound = static_cast<CG_roseRepr*>(upper)->op_; SgExpression* step_size = static_cast<CG_roseRepr*>(step)->op_; - /* label_sym *contLabel = new label_sym(""); - label_sym *brkLabel = new label_sym(""); may not be required on rose?! - */ - SgStatement* for_init_stmt = buildAssignStatement(index_sym, lower_bound); SgLessOrEqualOp* cond = buildLessOrEqualOp(index_sym, upper_bound); SgExprStatement* test = buildExprStatement(cond); @@ -570,7 +442,6 @@ CG_outputRepr* CG_roseBuilder::CreateInductive(CG_outputRepr *index, // Manu if (isInputFortran()) { - // std::cout << "CG_roseBuilder:: need to construct a fortran do statement\n"; SgFortranDo * forStmt=new SgFortranDo(Sg_File_Info::generateDefaultFileInfoForTransformationNode()); forStmt->set_has_end_statement(true); forStmt->set_bound(upper_bound); @@ -578,7 +449,6 @@ CG_outputRepr* CG_roseBuilder::CreateInductive(CG_outputRepr *index, forStmt->set_initialization(isSgExprStatement(for_init_stmt)->get_expression()); return new CG_roseRepr(isSgNode(forStmt)); } else { -// std::cout << "CG_roseBuilder:: for statement is fine\n"; return new CG_roseRepr(isSgNode(for_stmt)); @@ -647,20 +517,11 @@ CG_outputRepr* CG_roseBuilder::CreateLoop(int, CG_outputRepr *control, if (isInputFortran()) { tfd = isSgFortranDo(tnl); } - // Manu:: debug -/* if (!tf) { - std::cout << "CreateLoop:: Not a for loop\n"; - if (isSgFortranDo(tnl)) - std::cout << "CreateLoop:: It is a fortran do loop\n"; - } -*/ - SgStatementPtrList * body = static_cast<CG_roseRepr*>(stmtList)->list_; if (body != NULL) { if (!((*body).empty())) { if ((*body).size() == 1) { - // if(isSgBasicBlock(*((*body).begin()))){ if (!isInputFortran()) { // Manu:: added if-else for fortran support tf->set_loop_body(*((*body).begin())); (*((*body).begin()))->set_parent(tf); @@ -670,14 +531,6 @@ CG_outputRepr* CG_roseBuilder::CreateLoop(int, CG_outputRepr *control, bb1->append_statement(*((*body).begin())); tfd->set_body(bb1); } - // } - /* else{ - SgBasicBlock* bb1 = buildBasicBlock(); - bb1->set_parent(tf); - bb1->append_statement(*((*body).begin())); - tf->set_loop_body(bb1); - - }*/ } else { // Manu:: support for fortran label (do - continue) SgName *sname = NULL; @@ -904,9 +757,6 @@ CG_outputRepr* CG_roseBuilder::CreateIntegerMod(CG_outputRepr *lop, //----------------------------------------------------------------------------- CG_outputRepr* CG_roseBuilder::CreateAnd(CG_outputRepr *lop, CG_outputRepr *rop) const { - /*if (rop == NULL || lop == NULL) { - return NULL; - }*/ if (rop == NULL) return lop; @@ -928,11 +778,6 @@ CG_outputRepr* CG_roseBuilder::CreateAnd(CG_outputRepr *lop, //----------------------------------------------------------------------------- // binary relational operations //----------------------------------------------------------------------------- -/*CG_outputRepr* CG_roseBuilder::CreateGE(CG_outputRepr *lop, - CG_outputRepr *rop) const { - return CreateLE(rop, lop); -}*/ - CG_outputRepr* CG_roseBuilder::CreateLE(CG_outputRepr *lop, CG_outputRepr *rop) const { if (rop == NULL || lop == NULL) { @@ -972,44 +817,6 @@ CG_outputRepr* CG_roseBuilder::CreateEQ(CG_outputRepr *lop, //----------------------------------------------------------------------------- // stmt list gen operations //----------------------------------------------------------------------------- -/*CG_outputRepr* CG_roseBuilder::CreateStmtList(CG_outputRepr *singleton) const { - - if (singleton == NULL) { - return new CG_roseRepr(new SgStatementPtrList); - } - - SgStatementPtrList *tnl = static_cast<CG_roseRepr *>(singleton)->list_; - SgNode* sgn = static_cast<CG_roseRepr *>(singleton)->tnl_; - - if (tnl == NULL) - tnl = new SgStatementPtrList; - - if (sgn == NULL) { - SgExpression* op = static_cast<CG_roseRepr *>(singleton)->op_; - - if (op != NULL) - (*tnl).push_back( - buildExprStatement( - static_cast<CG_roseRepr *>(singleton)->op_)); - - } else - (*tnl).push_back(isSgStatement(sgn)); - - delete singleton; - return new CG_roseRepr(tnl); - -// tnl = isSgNode(buildBasicBlock(buildExprStatement(static_cast<CG_roseRepr *>(singleton)->op_))); - -// delete singleton; -// return new CG_roseRepr(tnl); - -} - -CG_outputRepr* CG_roseBuilder::StmtListInsertLast(CG_outputRepr *list, - CG_outputRepr *node) const { - return StmtListAppend(list, node); -} -*/ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, CG_outputRepr *list2) const { @@ -1019,10 +826,6 @@ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, return list2; } - // SgStatement* parent; - // SgStatement* stmt1; - // SgStatement* stmt2; - SgStatementPtrList* new_list; SgStatementPtrList* tnl1 = static_cast<CG_roseRepr *>(list1)->list_; @@ -1041,20 +844,6 @@ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, if (tnl2 && two) throw ir_error("error in stmtlistappend!!"); -// SgNode* sg1 = static_cast<CG_roseRepr *>(list1)->tnl_; - -//if((*tnl1).empty()){ - -// if(SgStatement* stmt = isSgStatement(sg1)) -// (*tnl1).push_back(stmt); -//else if(isSgScopeStatement(sg1)){ -// SgStatementPtrList scopeStmtPtrLst = isSgScopeStatement(sg1)->generateStatementList(); - -// for(SgStatementPtrList::iterator it1 = scopeStmtPtrLst.begin();it1 != scopeStmtPtrLst.end(); it1++) -// (*tnl1).push_back(*it1); -//} -//} - if ((tnl1 == NULL) && (tnl2 == NULL)) { if ((one != NULL) && (two != NULL)) { @@ -1079,12 +868,6 @@ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, } else { if ((tnl2 != NULL) && (tnl1 == NULL)) { - /* for(SgStatementPtrList::iterator it = (*tnl2).begin(); it != (*tnl2).end(); it++) - { - (*tnl1).push_back(*it); - - } - */ if (one == NULL) return list2; else { @@ -1096,7 +879,6 @@ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, (*new_list).push_back(*it); } - //delete list2; return static_cast<CG_outputRepr *>(new CG_roseRepr(new_list)); } } else if ((tnl1 != NULL) && (tnl2 == NULL)) { @@ -1105,7 +887,6 @@ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, else { (*tnl1).push_back(isSgStatement(two)); - // delete list1; return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1)); } @@ -1118,53 +899,10 @@ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, } - // delete list2; - // delete list1; return static_cast<CG_outputRepr *>(new CG_roseRepr(tnl1)); } -//else{ -// SgNode* tnll2 = static_cast<CG_roseRepr *>(list2)->tnl_; -// if(tnll2 != NULL){ -// if(isSgStatement(tnll2)) -// (*tnl1).push_back(isSgStatement(tnll2)); -// else if(isSgScopeStatement(tnll2)){ -// SgStatementPtrList scopeStmtPtrLst1 = isSgScopeStatement(tnll2)->generateStatementList(); - -// for(SgStatementPtrList::iterator it2 = scopeStmtPtrLst1.begin();it2 != scopeStmtPtrLst1.end(); it2++) -// (*tnl1).push_back(*it2); - -// } -//} -// else{ -// SgStatement* stmt2 = isSgStatement(buildExprStatement(static_cast<CG_roseRepr *>(list2)->op_)); -// (*tnl1).push_back(stmt2); - -// } - -//} - // stmt2 = isSgStatement(tnl2); - -// std::string c = tnl1->unparseToString(); - -// std::string d = isSgNode(stmt2)->unparseToString(); - -// if(isSgForStatement(tnl1) || isSgBasicBlock(tnl1)) -// isSgScopeStatement(tnl1)->append_statement(stmt2); -// else -// { - // stmt1 = isSgStatement(tnl1); - // parent = isSgStatement(tnl1->get_parent()); - // if(isSgForStatement(tnl1->get_parent()) || isSgBasicBlock(tnl1->get_parent())) - // isSgScopeStatement(tnl1->get_parent())->append_statement(stmt2); - // else if (isSgStatement(tnl1->get_parent())) - // isSgStatement(tnl1->get_parent())->insert_statement(stmt1, stmt2, false); - -// } } -// delete list2; - -// return list1; } @@ -1172,14 +910,7 @@ CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, CG_outputRepr* arg1, CG_outputRepr* arg2, CG_outputRepr* arg3) const { - //SgName type_name("dim3"); - //SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); - // SgClassDeclaration * type_decl = isSgClassDeclaration( - // type_symbol->get_declaration()); - - //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); - - SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( + SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( SgName("dim3")); SgExprListExp * ctor_args; @@ -1203,103 +934,11 @@ CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, CG_outputRepr* ar SgStatementPtrList *tnl2 = new SgStatementPtrList; - // (*tnl2).push_back(var_decl); (*tnl2).push_back(decl); return new CG_roseRepr(tnl2); } -/*CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, int arg1, - int arg2) const { - - SgName type_name("dim3"); - SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); - SgClassDeclaration * type_decl = isSgClassDeclaration( - type_symbol->get_declaration()); - - //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); - - SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( - SgName("dim3")); - - SgExprListExp * ctor_args = buildExprListExp(buildIntVal(arg1), - buildIntVal(arg2)); - - SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( - buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); - - char joined_str[20]; - - strcpy(joined_str, "dim3 "); - strcat(joined_str, varName); - - SgExprStatement* decl = buildAssignStatement( - buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), - dim3_func_call); - - SgStatementPtrList *tnl2 = new SgStatementPtrList; - - // (*tnl2).push_back(var_decl); - (*tnl2).push_back(decl); - return new CG_roseRepr(tnl2); -} - -CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, int arg1, - int arg2, int arg3) const { - - SgName type_name("dim3"); - SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); - SgClassDeclaration * type_decl = isSgClassDeclaration( - type_symbol->get_declaration()); - - //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); - - SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( - SgName("dim3")); - - SgExprListExp * ctor_args = buildExprListExp(buildIntVal(arg1), - buildIntVal(arg2), buildIntVal(arg3)); - - SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( - buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); - - char joined_str[20]; - - strcpy(joined_str, "dim3 "); - strcat(joined_str, varName); - - SgExprStatement* decl = buildAssignStatement( - buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), - dim3_func_call); - - SgStatementPtrList *tnl2 = new SgStatementPtrList; - - // (*tnl2).push_back(var_decl); - (*tnl2).push_back(decl); - return new CG_roseRepr(tnl2); - - - -} -*/ - -/*CG_outputRepr* CG_suifBuilder::CreateKernel(immed_list* iml) const { - instruction *ins = new in_rrr(io_mrk); - ins->append_annote(k_cuda_kernel, iml); - tree_node_list *tnl = new tree_node_list; - tnl->append(new tree_instr(ins)); - return new CG_suifRepr(tnl); - } - - type_node* CG_suifBuilder::ModifyType(type_node* base, const char* modifier) const { - modifier_type* result = new modifier_type(TYPE_NULL, base); - immed_list *iml = new immed_list; - iml->append(immed((char*)modifier)); - result->append_annote(k_cuda_modifier, iml); - return result; - } - */ - std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, SgExpression* expr, SgNode* root) { @@ -1367,13 +1006,6 @@ std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, std::copy(a.begin(), a.end(), back_inserter(arrays)); } } - /*else if(isSgFortranDo(stmt)){ - SgFortranDo *tfortran = isSgFortranDo(stmt); - omega::CG_roseRepr *r = new omega::CG_roseRepr(isSgStatement(tfortran->get_body())); - std::vector<IR_ArrayRef *> a = FindArrayRef(r); - delete r; - std::copy(a.begin(), a.end(), back_inserter(arrays)); - }*/ else if (isSgVariableDeclaration(stmt)) { if (SgExpression *init = isSgVariableDeclaration(stmt)->get_variables().front()->get_initializer()) { @@ -1386,9 +1018,6 @@ std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, } } else if (isSgIfStmt(stmt)) { SgIfStmt* tni = isSgIfStmt(stmt); - //tni->get_conditional()->set_parent(tni); - //tni->get_true_body()->set_parent(tni); - //tni->get_false_body()->set_parent(tni); std::vector<SgVarRefExp *> a = substitute( isSgNode(tni->get_conditional()), sym, expr, root); std::copy(a.begin(), a.end(), back_inserter(arrays)); @@ -1405,13 +1034,11 @@ std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, isSgNode(isSgExprStatement(stmt)->get_expression()), sym, expr, root); std::copy(a.begin(), a.end(), back_inserter(arrays)); - } //end else if - } //end if + } + } else { op = isSgExpression(in); - // std::string x = isSgNode(op)->unparseToString(); std::string y = sym->get_name().getString(); -// std::cout << "------substitute else:: " << in->unparseToString().c_str() << ", " << y.c_str() << "\n"; if (isSgBinaryOp(op)) { @@ -1425,9 +1052,6 @@ std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, isSgBinaryOp(op)->get_rhs_operand(), sym, expr, root); std::copy(a1.begin(), a1.end(), back_inserter(arrays)); } else if (isSgUnaryOp(op)) { - //isSgUnaryOp(op)->get_operand()->set_parent(op); - //std::string x = isSgNode(op)->unparseToString(); - //std::cout<<x<<std::endl; std::vector<SgVarRefExp *> a = substitute( isSgUnaryOp(op)->get_operand(), sym, expr, root); std::copy(a.begin(), a.end(), back_inserter(arrays)); @@ -1435,12 +1059,9 @@ std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, std::string z = isSgVarRefExp(op)->get_symbol()->get_name().getString(); if (!strcmp(z.c_str(), y.c_str())) { - //isSgVarRefExp(op)->set_symbol(isSgVarRefExp(expr)->get_symbol()); arrays.push_back(isSgVarRefExp(op)); - //replaceVariableReferences(root, isSgVarRefExp(in)->get_symbol(), temp); - //r = true; - } //end if - } //end else if + } + } else if (isSgCallExpression(op)) { SgExprListExp* exprs = isSgCallExpression(op)->get_args(); SgExpressionPtrList &expr_list = exprs->get_expressions(); @@ -1463,71 +1084,10 @@ std::vector<SgVarRefExp *> substitute(SgNode *in, const SgVariableSymbol *sym, } - //end else if - //else if(!isSgValueExp(op)) - // throw ir_error("unrecognized expression type"); - } //end else - } //end if - - /* bool r = false; - if (isSgVarRefExp(in) && (isSgVarRefExp(in)->get_symbol() == sym)) { - omega::CG_roseRepr *result = new omega::CG_roseRepr(expr); - SgExpression* expr1 = result->GetExpression(); - delete result; - SgVariableSymbol* temp = isSgVarRefExp(expr1)->get_symbol(); - parent->replace_expression(in, expr1); - replaceVariableReferences(root, isSgVarRefExp(in)->get_symbol(), temp); - r = true; - } - else if(isSgBinaryOp(in)){ - substitute(isSgBinaryOp(in)->get_lhs_operand(), sym, expr, root, in); - substitute(isSgBinaryOp(in)->get_rhs_operand(), sym, expr, root, in); - } - else if(isSgUnaryOp(in)) - substitute(isSgUnaryOp(in)->get_operand(), sym, expr, root, in); - - */ + } + } return arrays; } -/*bool substitute(SgStatement *tn, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab) { - if (tn == NULL) - return false; - - bool r = false; - if( tn != NULL){ - if(isSgExpression(tn)){ - r = substitute(isSgExpression(tn), sym, expr, root, isSgExpression(tn)) || r; - - } - else { - omega::CG_roseRepr *result = new omega::CG_roseRepr(expr); - SgExpression* expr1 = result->GetExpression(); - tn->replace_expression(buildVarRefExp(sym), expr1); - for (unsigned i = 0; i < tn->get_numberOfTraversalSuccessors(); i++) - r = substitute(isSgStatement(tn->get_traversalSuccessorByIndex(i)), sym, expr, root, symtab) || r; - - } - } - return r; - } - - bool substitute(SgNode *tnl, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab) { - if (tnl == NULL) - return false; - - bool r = false; - - for(int i=0; i < tnl->get_numberOfTraversalSuccessors(); i++){ - - SgNode* tn = tnl->get_traversalSuccessorByIndex(i); - r = substitute(isSgStatement(tn), sym, expr, root, symtab) || r; - } - - - return r; - } - */ - } // namespace diff --git a/omegalib/omega/include/basic/Bag.h b/omegalib/omega/include/basic/Bag.h index 42285d0..3bd7143 100644 --- a/omegalib/omega/include/basic/Bag.h +++ b/omegalib/omega/include/basic/Bag.h @@ -14,13 +14,14 @@ virtual ~Bag(); Bag(); Bag(const Bag<T>&); Bag & operator=(const Bag<T>&); -virtual void operator |= (const Bag<T> & b); // add elements in b + //! add elements in b + virtual void operator |= (const Bag<T> & b); Iterator<T> *new_iterator(); bool empty() const; void remove(T); -virtual void insert(T); + virtual void insert(T); void clear(); -virtual bool contains(T) const; + virtual bool contains(T) const; int size() const; T extract(); // protected: breaks g++ 261 @@ -31,10 +32,11 @@ virtual bool contains(T) const; template<class T> class Ordered_Bag : public Bag<T> { public: Ordered_Bag(); -// virtual ~Ordered_Bag(); Ordered_Bag(const Ordered_Bag<T>& B) : Bag<T>(B) {} void insert(T); -virtual void operator |= (const Ordered_Bag<T> & b); // add elements in b + //! add elements in b + virtual void operator |= (const Ordered_Bag<T> & b); + //! add elements in b void operator |= (const Bag<T> & b); bool contains(T) const; bool operator == (const Ordered_Bag<T>&) const; @@ -45,21 +47,26 @@ virtual void operator |= (const Ordered_Bag<T> & b); // add elements in b template <class T> class Set : public Ordered_Bag <T> { public: Set(); -// virtual ~Set(); Set(T); Set(const Set<T>& S) : Ordered_Bag<T>(S) {} bool contains (const Set<T>& b) const; bool contains (T t) const { return Ordered_Bag<T>::contains(t); } // the above makes "standard" C++ happy - -virtual void operator |= (const Set<T> & b); // add elements in b + + //! add elements in b + virtual void operator |= (const Set<T> & b); + //! add elements in b void operator |= (const Ordered_Bag<T> & b); + //! add elements in b void operator |= (const Bag<T> & b); - void operator -= (const Set<T> & b); // delete items also in b - void operator &= (const Set<T> & b); // delete items not in b - bool operator & (const Set<T> &) const; // check for elements in common + //! delete items also in b + void operator -= (const Set<T> & b); + //! delete items not in b + void operator &= (const Set<T> & b); + //! check for elements in common + bool operator & (const Set<T> &) const; }; } // namespace diff --git a/omegalib/omega/include/basic/BoolSet.h b/omegalib/omega/include/basic/BoolSet.h index dc9ef83..a78af2e 100755 --- a/omegalib/omega/include/basic/BoolSet.h +++ b/omegalib/omega/include/basic/BoolSet.h @@ -25,7 +25,8 @@ #include <iterator> namespace omega { - + + //! BoolSet class, used as a set of integers from 0 to n-1 where n is a very small integer. template<typename T = unsigned int> class BoolSet { protected: @@ -50,17 +51,20 @@ public: BoolSet<T> &operator|=(const BoolSet<T> &); BoolSet<T> &operator&=(const BoolSet<T> &); BoolSet<T> &operator-=(const BoolSet<T> &); - - template<typename TT> friend BoolSet<TT> operator|(const BoolSet<TT> &, const BoolSet<TT> &); // union - template<typename TT> friend BoolSet<TT> operator&(const BoolSet<TT> &, const BoolSet<TT> &); // intersection - template<typename TT> friend BoolSet<TT> operator-(const BoolSet<TT> &, const BoolSet<TT> &); // difference - template<typename TT> friend BoolSet<TT> operator~(const BoolSet<TT> &); // complement + + //! union + template<typename TT> friend BoolSet<TT> operator|(const BoolSet<TT> &, const BoolSet<TT> &); + //! intersection + template<typename TT> friend BoolSet<TT> operator&(const BoolSet<TT> &, const BoolSet<TT> &); + //! difference + template<typename TT> friend BoolSet<TT> operator-(const BoolSet<TT> &, const BoolSet<TT> &); + //! complement + template<typename TT> friend BoolSet<TT> operator~(const BoolSet<TT> &); template<typename TT> friend bool operator==(const BoolSet<TT> &, const BoolSet<TT> &); template<typename TT> friend bool operator!=(const BoolSet<TT> &, const BoolSet<TT> &); template<typename TT> friend std::ostream& operator<<(std::ostream &, const BoolSet<TT> &); template<typename TT> friend bool operator<(const BoolSet<TT> &, const BoolSet<TT> &); -// iterator related public: class iterator; class const_iterator; diff --git a/omegalib/omega/include/basic/Collection.h b/omegalib/omega/include/basic/Collection.h index c7e4eef..80ddf48 100644 --- a/omegalib/omega/include/basic/Collection.h +++ b/omegalib/omega/include/basic/Collection.h @@ -7,10 +7,7 @@ template<class T> class Iterator; template<class T> class Any_Iterator; -/* - * protocol for any kind of collection - */ - +//! protocol for any kind of collection template<class T> class Collection { public: virtual Iterator<T> *new_iterator() = 0; @@ -20,21 +17,20 @@ public: }; -/* +/*! * protocol for collections whose elements are ordered * by the way they are entered into the collection, and * whose elements can be accessed by "index" * * note that the implementation need not be a linked list */ - template<class T> class Sequence : public Collection<T> { public: virtual const T &operator[](int) const = 0; virtual T &operator[](int) = 0; - virtual int index(const T &) const = 0; // Y in X --> X[X.index(Y)] == Y -}; + /*! Y in X --> X[X.index(Y)] == Y */ + virtual int index(const T &) const = 0; }; } // namespace diff --git a/omegalib/omega/include/basic/ConstString.h b/omegalib/omega/include/basic/ConstString.h index 5149e55..f149c9d 100644 --- a/omegalib/omega/include/basic/ConstString.h +++ b/omegalib/omega/include/basic/ConstString.h @@ -10,7 +10,6 @@ namespace omega { // global, but if it and its size are static to Const_String, // the compiler still doesn't seem to like the definition, // or the declaration either for that matter. - class ConstStringRep { public: const char *name; diff --git a/omegalib/omega/include/basic/Dynamic_Array.c b/omegalib/omega/include/basic/DynamicArray.c index 0300fd8..8ede2f7 100644 --- a/omegalib/omega/include/basic/Dynamic_Array.c +++ b/omegalib/omega/include/basic/DynamicArray.c @@ -1,9 +1,9 @@ #include <assert.h> -#include <basic/Dynamic_Array.h> +#include <basic/DynamicArray.h> namespace omega { -template<class T, int d> void Dynamic_Array<T,d>::do_constr() +template<class T, int d> void DynamicArray<T,d>::do_constr() { // #if ! defined SHUT_UP_ABOUT_STATEMENT_WITH_NO_EFFECT_IN_DYNAMIC_ARRAY_CREATION // assert(d > 0); @@ -14,7 +14,7 @@ template<class T, int d> void Dynamic_Array<T,d>::do_constr() } -template<class T> void Dynamic_Array1<T>::do_construct(int d0) +template<class T> void DynamicArray1<T>::do_construct(int d0) { this->bounds = new int[1]; this->bounds[0] = d0; @@ -22,7 +22,7 @@ template<class T> void Dynamic_Array1<T>::do_construct(int d0) this->partial = false; } -template<class T> void Dynamic_Array2<T>::do_construct(int d0, int d1) +template<class T> void DynamicArray2<T>::do_construct(int d0, int d1) { this->bounds = new int[2]; this->bounds[0] = d0; @@ -31,7 +31,7 @@ template<class T> void Dynamic_Array2<T>::do_construct(int d0, int d1) this->partial = false; } -template<class T> void Dynamic_Array3<T>::do_construct(int d0,int d1,int d2) +template<class T> void DynamicArray3<T>::do_construct(int d0,int d1,int d2) { this->bounds = new int[3]; this->bounds[0] = d0; @@ -41,7 +41,7 @@ template<class T> void Dynamic_Array3<T>::do_construct(int d0,int d1,int d2) this->partial = false; } -template<class T> void Dynamic_Array4<T>::do_construct(int d0,int d1,int d2,int d3) +template<class T> void DynamicArray4<T>::do_construct(int d0,int d1,int d2,int d3) { this->bounds = new int[4]; this->bounds[0] = d0; @@ -52,53 +52,53 @@ template<class T> void Dynamic_Array4<T>::do_construct(int d0,int d1,int d2,int this->partial = false; } -template<class T, int d> Dynamic_Array<T,d>::Dynamic_Array() +template<class T, int d> DynamicArray<T,d>::DynamicArray() { do_constr(); } -template<class T> Dynamic_Array1<T>::Dynamic_Array1(const char *) +template<class T> DynamicArray1<T>::DynamicArray1(const char *) { this->do_constr(); } -template<class T> Dynamic_Array2<T>::Dynamic_Array2(const char *,const char *) +template<class T> DynamicArray2<T>::DynamicArray2(const char *,const char *) { this->do_constr(); } -template<class T> Dynamic_Array3<T>::Dynamic_Array3(const char *,const char *,const char *) +template<class T> DynamicArray3<T>::DynamicArray3(const char *,const char *,const char *) { this->do_constr(); } -template<class T> Dynamic_Array4<T>::Dynamic_Array4(const char *,const char *,const char *,const char *) +template<class T> DynamicArray4<T>::DynamicArray4(const char *,const char *,const char *,const char *) { this->do_constr(); } -template<class T> Dynamic_Array1<T>::Dynamic_Array1(int d0) +template<class T> DynamicArray1<T>::DynamicArray1(int d0) { do_construct(d0); } -template<class T> Dynamic_Array2<T>::Dynamic_Array2(int d0, int d1) +template<class T> DynamicArray2<T>::DynamicArray2(int d0, int d1) { do_construct(d0, d1); } -template<class T> Dynamic_Array3<T>::Dynamic_Array3(int d0,int d1,int d2) +template<class T> DynamicArray3<T>::DynamicArray3(int d0,int d1,int d2) { do_construct(d0, d1, d2); } -template<class T> Dynamic_Array4<T>::Dynamic_Array4(int d0,int d1,int d2,int d3) +template<class T> DynamicArray4<T>::DynamicArray4(int d0,int d1,int d2,int d3) { do_construct(d0, d1, d2, d3); } -template<class T, int d> void Dynamic_Array<T,d>::do_destruct() +template<class T, int d> void DynamicArray<T,d>::do_destruct() { if (! partial) { @@ -108,13 +108,13 @@ template<class T, int d> void Dynamic_Array<T,d>::do_destruct() } -template<class T, int d> Dynamic_Array<T,d>::~Dynamic_Array() +template<class T, int d> DynamicArray<T,d>::~DynamicArray() { do_destruct(); } -template<class T> void Dynamic_Array1<T>::resize(int d0) +template<class T> void DynamicArray1<T>::resize(int d0) { assert(!this->partial); this->do_destruct(); @@ -124,7 +124,7 @@ template<class T> void Dynamic_Array1<T>::resize(int d0) do_construct(d0); } -template<class T> void Dynamic_Array2<T>::resize(int d0, int d1) +template<class T> void DynamicArray2<T>::resize(int d0, int d1) { assert(!this->partial); this->do_destruct(); @@ -134,7 +134,7 @@ template<class T> void Dynamic_Array2<T>::resize(int d0, int d1) do_construct(d0, d1); } -template<class T> void Dynamic_Array3<T>::resize(int d0, int d1, int d2) +template<class T> void DynamicArray3<T>::resize(int d0, int d1, int d2) { assert(!this->partial); this->do_destruct(); @@ -144,7 +144,7 @@ template<class T> void Dynamic_Array3<T>::resize(int d0, int d1, int d2) do_construct(d0, d1, d2); } -template<class T> void Dynamic_Array4<T>::resize(int d0, int d1, int d2, int d3) +template<class T> void DynamicArray4<T>::resize(int d0, int d1, int d2, int d3) { assert(!this->partial); this->do_destruct(); @@ -155,7 +155,7 @@ template<class T> void Dynamic_Array4<T>::resize(int d0, int d1, int d2, int d3) } -template<class T> T& Dynamic_Array1<T>::operator[](int d0) +template<class T> T& DynamicArray1<T>::operator[](int d0) { #if !defined (NDEBUG) assert(this->elements != 0 && "Trying to dereference undefined array"); @@ -165,41 +165,41 @@ template<class T> T& Dynamic_Array1<T>::operator[](int d0) return this->elements[d0]; } -template<class T> Dynamic_Array1<T> Dynamic_Array2<T>::operator[](int d0) +template<class T> DynamicArray1<T> DynamicArray2<T>::operator[](int d0) { #if !defined (NDEBUG) assert(this->elements != 0 && "Trying to dereference undefined array"); assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds"); #endif - Dynamic_Array1<T> result; + DynamicArray1<T> result; result.bounds = this->bounds+1; result.elements = this->elements + this->bounds[1] * d0; result.partial = true; return result; } -template<class T> Dynamic_Array2<T> Dynamic_Array3<T>::operator[](int d0) +template<class T> DynamicArray2<T> DynamicArray3<T>::operator[](int d0) { #if !defined (NDEBUG) assert(this->elements != 0 && "Trying to dereference undefined array"); assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds"); #endif - Dynamic_Array2<T> result; + DynamicArray2<T> result; result.bounds = this->bounds+1; result.elements = this->elements + this->bounds[1] * this->bounds[2] * d0; result.partial = true; return result; } -template<class T> Dynamic_Array3<T> Dynamic_Array4<T>::operator[](int d0) +template<class T> DynamicArray3<T> DynamicArray4<T>::operator[](int d0) { #if !defined (NDEBUG) assert(this->elements != 0 && "Trying to dereference undefined array"); assert(0 <= d0 && d0 < this->bounds[0] && "Array subscript out of bounds"); #endif - Dynamic_Array3<T> result; + DynamicArray3<T> result; result.bounds = this->bounds+1; result.elements = this->elements + this->bounds[1] * this->bounds[2] * this->bounds[3] * d0; result.partial = true; @@ -208,7 +208,7 @@ template<class T> Dynamic_Array3<T> Dynamic_Array4<T>::operator[](int d0) template<class T, int d> - Dynamic_Array<T,d>::Dynamic_Array(Dynamic_Array<T,d> &D) + DynamicArray<T,d>::DynamicArray(DynamicArray<T,d> &D) { assert(D.elements != 0 && "Trying to copy an undefined array"); partial = true; diff --git a/omegalib/omega/include/basic/DynamicArray.h b/omegalib/omega/include/basic/DynamicArray.h new file mode 100644 index 0000000..ac9bae4 --- /dev/null +++ b/omegalib/omega/include/basic/DynamicArray.h @@ -0,0 +1,103 @@ +#ifndef Already_Included_DynamicArray +#define Already_Included_DynamicArray + +namespace omega { + +template <class T> class DynamicArray2; +template <class T> class DynamicArray3; +template <class T> class DynamicArray4; + +template <class T, int d> class DynamicArray + { + public: + DynamicArray(DynamicArray<T,d> &D); + ~DynamicArray(); + + protected: + DynamicArray(); + bool partial; + int *bounds; + T *elements; + + void do_constr(); + void do_destruct(); + }; + + +template <class T> class DynamicArray1 : public DynamicArray<T,1> + { + public: + DynamicArray1(const char *s0 = 0); + DynamicArray1(int d0); + void resize(int d0); + T& operator[](int d); + + friend class DynamicArray2<T>; + + private: + void do_construct(int d0); + }; + + +template <class T> class DynamicArray2 : public DynamicArray<T,2> + { + public: + DynamicArray2(const char *s0 = 0, const char *s1 = 0); + DynamicArray2(int d0, int d1); + void resize(int d0, int d1); + DynamicArray1<T> operator[](int d); + + friend class DynamicArray3<T>; + + private: + void do_construct(int d0, int d1); + }; + + +template <class T> class DynamicArray3 : public DynamicArray<T,3> + { + public: + DynamicArray3(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0); + DynamicArray3(int d0, int d1, int d2); + void resize(int d0, int d1, int d2); + DynamicArray2<T> operator[](int d); + + friend class DynamicArray4<T>; + + private: + void do_construct(int d0, int d1, int d2); + }; + +template <class T> class DynamicArray4 : public DynamicArray<T,4> + { + public: + DynamicArray4(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0, const char *s3 = 0); + DynamicArray4(int d0, int d1, int d2, int d3); + void resize(int d0, int d1, int d2, int d3); + DynamicArray3<T> operator[](int d); + + private: + void do_construct(int d0, int d1, int d2, int d3); + }; + +} // namespace + +#if ! defined DONT_INCLUDE_TEMPLATE_CODE +#include <basic/DynamicArray.c> +#endif + +#define instantiate_DynamicArray1(T) template class DynamicArray1<T>; \ + template class DynamicArray<T,1>; + +#define instantiate_DynamicArray2(T) template class DynamicArray2<T>; \ + template class DynamicArray<T,2>; \ + instantiate_DynamicArray1(T); + +#define instantiate_DynamicArray3(T) template class DynamicArray3<T>; \ + template class DynamicArray<T,3>; \ + instantiate_DynamicArray2(T); + +#define instantiate_DynamicArray4(T) template class DynamicArray4<T>; \ + template class DynamicArray<T,4>; \ + instantiate_DynamicArray3(T); +#endif diff --git a/omegalib/omega/include/basic/Dynamic_Array.h b/omegalib/omega/include/basic/Dynamic_Array.h deleted file mode 100644 index c0bdf12..0000000 --- a/omegalib/omega/include/basic/Dynamic_Array.h +++ /dev/null @@ -1,103 +0,0 @@ -#ifndef Already_Included_Dynamic_Array -#define Already_Included_Dynamic_Array - -namespace omega { - -template <class T> class Dynamic_Array2; -template <class T> class Dynamic_Array3; -template <class T> class Dynamic_Array4; - -template <class T, int d> class Dynamic_Array - { - public: - Dynamic_Array(Dynamic_Array<T,d> &D); - ~Dynamic_Array(); - - protected: - Dynamic_Array(); - bool partial; - int *bounds; - T *elements; - - void do_constr(); - void do_destruct(); - }; - - -template <class T> class Dynamic_Array1 : public Dynamic_Array<T,1> - { - public: - Dynamic_Array1(const char *s0 = 0); - Dynamic_Array1(int d0); - void resize(int d0); - T& operator[](int d); - - friend class Dynamic_Array2<T>; - - private: - void do_construct(int d0); - }; - - -template <class T> class Dynamic_Array2 : public Dynamic_Array<T,2> - { - public: - Dynamic_Array2(const char *s0 = 0, const char *s1 = 0); - Dynamic_Array2(int d0, int d1); - void resize(int d0, int d1); - Dynamic_Array1<T> operator[](int d); - - friend class Dynamic_Array3<T>; - - private: - void do_construct(int d0, int d1); - }; - - -template <class T> class Dynamic_Array3 : public Dynamic_Array<T,3> - { - public: - Dynamic_Array3(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0); - Dynamic_Array3(int d0, int d1, int d2); - void resize(int d0, int d1, int d2); - Dynamic_Array2<T> operator[](int d); - - friend class Dynamic_Array4<T>; - - private: - void do_construct(int d0, int d1, int d2); - }; - -template <class T> class Dynamic_Array4 : public Dynamic_Array<T,4> - { - public: - Dynamic_Array4(const char *s0 = 0, const char *s1 = 0, const char *s2 = 0, const char *s3 = 0); - Dynamic_Array4(int d0, int d1, int d2, int d3); - void resize(int d0, int d1, int d2, int d3); - Dynamic_Array3<T> operator[](int d); - - private: - void do_construct(int d0, int d1, int d2, int d3); - }; - -} // namespace - -#if ! defined DONT_INCLUDE_TEMPLATE_CODE -#include <basic/Dynamic_Array.c> -#endif - -#define instantiate_Dynamic_Array1(T) template class Dynamic_Array1<T>; \ - template class Dynamic_Array<T,1>; - -#define instantiate_Dynamic_Array2(T) template class Dynamic_Array2<T>; \ - template class Dynamic_Array<T,2>; \ - instantiate_Dynamic_Array1(T); - -#define instantiate_Dynamic_Array3(T) template class Dynamic_Array3<T>; \ - template class Dynamic_Array<T,3>; \ - instantiate_Dynamic_Array2(T); - -#define instantiate_Dynamic_Array4(T) template class Dynamic_Array4<T>; \ - template class Dynamic_Array<T,4>; \ - instantiate_Dynamic_Array3(T); -#endif diff --git a/omegalib/omega/include/basic/Iterator.h b/omegalib/omega/include/basic/Iterator.h index 8975d9e..f62874c 100644 --- a/omegalib/omega/include/basic/Iterator.h +++ b/omegalib/omega/include/basic/Iterator.h @@ -16,24 +16,24 @@ namespace omega { #define foreachSeparated(x,T,S,A,B) do {for (omega::Any_Iterator<T> __P_##x = (S).any_iterator();__P_##x;) {T & x = *__P_##x; A; __P_##x++; if (__P_##x) B;}} while (0) -/* - * Abstract base class Iterator<type> +/*! + * \brief Abstract base class Iterator<type> + * * Supports two styles of iteration: - * + * ~~~ * for ( ... initialize i (typically i = collection) ... ; i ; i++ ) * operate_on(*i) - * + * ~~~ * or - * + * ~~~ * for ( ... initialize i ... ; i.live() ; i.next() ) * operate_on(i.curr()) - * - * >>> IF THE COLLECTION IS CHANGED, THE ITERATOR IS NO LONGER VALID <<< + * ~~~ + * **IF THE COLLECTION IS CHANGED, THE ITERATOR IS NO LONGER VALID** * * For collections that are not "Sequence"s, the order in * which the elements are returned may not be consistent. */ - template<class T> class Iterator { public: virtual const T & operator*() const = 0; @@ -54,9 +54,8 @@ public: }; -// A generator is like an iterator but it gives out values, -// which may or may not exist in some writable collection - +//! A generator is like an iterator but it gives out values +/*! Values may or may not exist in some writable collection */ template<class T> class Generator { public: virtual T operator*() const = 0; @@ -74,14 +73,13 @@ public: -// Delegate to any kind of iterator (on the heap) -// If created via a reference, become a copy of the iterator -// If created via a pointer, manipulate that pointer and free *p when this dies -// -// Mostly useful for Collection::iterator -// Iterator::Iterator(Collection) - - +//! Delegate to any kind of iterator (on the heap) +/*! + * * If created via a reference, become a copy of the iterator + * * If created via a pointer, manipulate that pointer and free *p when this dies + * + * Mostly useful for Collection::iterator `Iterator::Iterator(Collection)` + */ template<class T> class Any_Iterator : public Iterator<T> { public: Any_Iterator(Collection<T> &c); @@ -101,13 +99,13 @@ public: Iterator<T> *new_copy() const { return new Any_Iterator<T>((*me).new_copy()); } private: - Any_Iterator(Iterator<T> *p) // take over *p, *p MUST BE ON THE HEAP - { me = p; } + //! take over *p, *p MUST BE ON THE HEAP + Any_Iterator(Iterator<T> *p) { me = p; } friend class Collection<T>; -#if 0 - // Couldn't make this work with g++258 - friend Any_Iterator<T> Collection<T>::any_iterator(); -#endif +/* + * // Couldn't make this work with g++258 + * friend Any_Iterator<T> Collection<T>::any_iterator(); + */ Iterator<T> *me; }; diff --git a/omegalib/omega/include/basic/Link.h b/omegalib/omega/include/basic/Link.h index ede7a2b..bdf169c 100644 --- a/omegalib/omega/include/basic/Link.h +++ b/omegalib/omega/include/basic/Link.h @@ -16,20 +16,19 @@ namespace omega { #endif #endif -/* - List_Element: one item in a list and the pointer to the next. - Each such object should be pointed to by either exactly one - other List_Element or by some other pointer(s), exactly one - of which will delete the List_Element. - ListElements should ONLY be allocated on the heap. - */ - #if ListElementFreeList // g++ 2.5.8 does not allow static data in template classes, so... extern void *kludgy_List_Element_new(size_t size); extern void kludgy_List_Element_delete(void *ptr, size_t size); #endif - +/*! + * \brief List_Element: one item in a list and the pointer to the next. + * + * Each such object should be pointed to by either exactly one + * other List_Element or by some other pointer(s), exactly one + * of which will delete the List_Element. + * ListElements should ONLY be allocated on the heap. + */ template <class T> class List_Element { public: #if ListElementFreeList diff --git a/omegalib/omega/include/basic/List.h b/omegalib/omega/include/basic/List.h index c6fc062..ee394d9 100644 --- a/omegalib/omega/include/basic/List.h +++ b/omegalib/omega/include/basic/List.h @@ -4,11 +4,6 @@ /* * Linked lists with an interface like a bit of libg++'s SLList class */ - - -#if 0 -#include <basic/assert.h> /* List requires assert which needs Exit which */ -#endif /* needs List! just include assert in List.c */ #include <stdio.h> // for NULL #include <basic/Iterator.h> #include <basic/Collection.h> diff --git a/omegalib/omega/include/omega/reach.h b/omegalib/omega/include/omega/reach.h index ff4bf79..76d7dee 100644 --- a/omegalib/omega/include/omega/reach.h +++ b/omegalib/omega/include/omega/reach.h @@ -7,15 +7,15 @@ class reachable_information { public: Tuple<std::string> node_names; Tuple<int> node_arity; - Dynamic_Array1<Relation> start_nodes; - Dynamic_Array2<Relation> transitions; + DynamicArray1<Relation> start_nodes; + DynamicArray2<Relation> transitions; }; -Dynamic_Array1<Relation> * +DynamicArray1<Relation> * Reachable_Nodes(reachable_information * reachable_info); -Dynamic_Array1<Relation> * +DynamicArray1<Relation> * I_Reachable_Nodes(reachable_information * reachable_info); } // namespace diff --git a/omegalib/omega/src/reach.cc b/omegalib/omega/src/reach.cc index bde785c..6569edb 100644 --- a/omegalib/omega/src/reach.cc +++ b/omegalib/omega/src/reach.cc @@ -1,12 +1,12 @@ #include <omega.h> #include <omega/Relations.h> -#include <basic/Dynamic_Array.h> +#include <basic/DynamicArray.h> #include <omega/reach.h> namespace omega { -typedef Dynamic_Array1<Relation> Rel_Array1; -typedef Dynamic_Array2<Relation> Rel_Array2; +typedef DynamicArray1<Relation> Rel_Array1; +typedef DynamicArray2<Relation> Rel_Array2; // This is from parallelism.c, modified diff --git a/omegalib/omegacalc/include/omega_calc/PT-omega.c b/omegalib/omegacalc/include/omega_calc/PT-omega.c index ad6b979..b0f5227 100644 --- a/omegalib/omegacalc/include/omega_calc/PT-omega.c +++ b/omegalib/omegacalc/include/omega_calc/PT-omega.c @@ -9,7 +9,7 @@ #include <basic/Tuple.h> #include <basic/Section.h> #include <basic/Exit.h> -#include <basic/Dynamic_Array.h> +#include <basic/DynamicArray.h> #include <omega.h> #include <omega/AST.h> @@ -64,9 +64,9 @@ instantiate_Map(EQ_Handle,Variable_ID); instantiate_Map(Variable_ID,Set<Variable_ID>); instantiate_Map(Const_String, Relation *); -instantiate_Dynamic_Array1(Coef_Var_Decl *); -instantiate_Dynamic_Array1(Relation); -instantiate_Dynamic_Array2(Relation); +instantiate_DynamicArray1(Coef_Var_Decl *); +instantiate_DynamicArray1(Relation); +instantiate_DynamicArray2(Relation); /* Stuff required by calculator: */ diff --git a/omegalib/omegacalc/src/parser.l b/omegalib/omegacalc/src/parser.l index ac2b448..04933f4 100644 --- a/omegalib/omegacalc/src/parser.l +++ b/omegalib/omegacalc/src/parser.l @@ -4,7 +4,7 @@ #include <sstream> #include <iostream> #include <omega_calc/AST.h> -#include <basic/Dynamic_Array.h> +#include <basic/DynamicArray.h> using namespace omega; #include "y.tab.h" diff --git a/omegalib/omegacalc/src/parser.ll b/omegalib/omegacalc/src/parser.ll index 86de3a4..e095f24 100755 --- a/omegalib/omegacalc/src/parser.ll +++ b/omegalib/omegacalc/src/parser.ll @@ -20,7 +20,7 @@ #include <iostream> #include <fstream> #include <omega_calc/AST.h> -#include <basic/Dynamic_Array.h> +#include <basic/DynamicArray.h> #include "parser.tab.hh" #include <omega_calc/myflex.h> diff --git a/omegalib/omegacalc/src/parser.y b/omegalib/omegacalc/src/parser.y index 7369b94..d365797 100644 --- a/omegalib/omegacalc/src/parser.y +++ b/omegalib/omegacalc/src/parser.y @@ -14,7 +14,7 @@ %{ -#include <basic/Dynamic_Array.h> +#include <basic/DynamicArray.h> #include <basic/Iterator.h> #include <code_gen/code_gen.h> #include <omega_calc/AST.h> @@ -102,8 +102,8 @@ void flushScanBuffer(); Relation * RELATION; tupleDescriptor * TUPLE_DESCRIPTOR; RelTuplePair * REL_TUPLE_PAIR; - Dynamic_Array2<Relation> * RELATION_ARRAY_2D; - Dynamic_Array1<Relation> * RELATION_ARRAY_1D; + DynamicArray2<Relation> * RELATION_ARRAY_2D; + DynamicArray1<Relation> * RELATION_ARRAY_1D; Tuple<std::string> *STRING_TUPLE; std::string *STRING_VALUE; } @@ -407,7 +407,7 @@ inputItem : ';' /*empty*/ } | reachable ';' { flushScanBuffer(); - Dynamic_Array1<Relation> &final = *$1; + DynamicArray1<Relation> &final = *$1; bool any_sat = false; int i,n_nodes = reachable_info->node_names.size(); for(i = 1; i <= n_nodes; i++) @@ -1582,13 +1582,13 @@ exp : COEF {$$ = new Exp($1);} reachable : REACHABLE_FROM nodeNameList nodeSpecificationList { - Dynamic_Array1<Relation> *final = Reachable_Nodes(reachable_info); + DynamicArray1<Relation> *final = Reachable_Nodes(reachable_info); $$ = final; } ; reachable_of : REACHABLE_OF VAR IN nodeNameList nodeSpecificationList { - Dynamic_Array1<Relation> *final = Reachable_Nodes(reachable_info); + DynamicArray1<Relation> *final = Reachable_Nodes(reachable_info); int index = reachable_info->node_names.index(std::string($2)); if (index == 0) { yyerror(std::string("no such node ") + to_string($2)); @@ -1629,7 +1629,7 @@ nodeSpecificationList : OPEN_BRACE realNodeSpecificationList CLOSE_BRACE { int i,j; int n_nodes = reachable_info->node_names.size(); Tuple<int> &arity = reachable_info->node_arity; - Dynamic_Array2<Relation> &transitions = reachable_info->transitions; + DynamicArray2<Relation> &transitions = reachable_info->transitions; /* fixup unspecified transitions to be false */ /* find arity */ @@ -1656,7 +1656,7 @@ nodeSpecificationList : OPEN_BRACE realNodeSpecificationList CLOSE_BRACE { transitions[i][j] = Relation::False(arity[i],arity[j]); /* fixup unused start node positions */ - Dynamic_Array1<Relation> &nodes = reachable_info->start_nodes; + DynamicArray1<Relation> &nodes = reachable_info->start_nodes; for(i = 1; i <= n_nodes; i++) if(nodes[i].is_null()) nodes[i] = Relation::False(arity[i]); diff --git a/omegalib/omegacalc/src/parser.yy b/omegalib/omegacalc/src/parser.yy index 896f926..c2821cc 100755 --- a/omegalib/omegacalc/src/parser.yy +++ b/omegalib/omegacalc/src/parser.yy @@ -14,7 +14,7 @@ %{ //#define YYDEBUG 1 -#include <basic/Dynamic_Array.h> +#include <basic/DynamicArray.h> #include <basic/Iterator.h> #include <omega_calc/AST.h> #include <omega/hull.h> @@ -121,7 +121,7 @@ void flushScanBuffer(); omega::Relation *RELATION; tupleDescriptor *TUPLE_DESCRIPTOR; std::pair<std::vector<omega::Relation>, std::vector<omega::Relation> > *REL_TUPLE_PAIR; - omega::Dynamic_Array1<omega::Relation> * RELATION_ARRAY_1D; + omega::DynamicArray1<omega::Relation> * RELATION_ARRAY_1D; std::string *STRING_VALUE; } @@ -473,7 +473,7 @@ inputItem : ';' /*empty*/ } | reachable ';' { flushScanBuffer(); - Dynamic_Array1<Relation> &final = *$1; + DynamicArray1<Relation> &final = *$1; bool any_sat = false; int i,n_nodes = reachable_info->node_names.size(); for(i = 1; i <= n_nodes; i++) @@ -1661,13 +1661,13 @@ exp : COEF {$$ = new Exp($1);} reachable : REACHABLE_FROM nodeNameList nodeSpecificationList { - Dynamic_Array1<Relation> *final = Reachable_Nodes(reachable_info); + DynamicArray1<Relation> *final = Reachable_Nodes(reachable_info); $$ = final; } ; reachable_of : REACHABLE_OF VAR IN nodeNameList nodeSpecificationList { - Dynamic_Array1<Relation> *final = Reachable_Nodes(reachable_info); + DynamicArray1<Relation> *final = Reachable_Nodes(reachable_info); int index = reachable_info->node_names.index(std::string($2)); if (index == 0) { yyerror(std::string("no such node ") + to_string($2)); @@ -1708,7 +1708,7 @@ nodeSpecificationList : OPEN_BRACE realNodeSpecificationList CLOSE_BRACE { int i,j; int n_nodes = reachable_info->node_names.size(); Tuple<int> &arity = reachable_info->node_arity; - Dynamic_Array2<Relation> &transitions = reachable_info->transitions; + DynamicArray2<Relation> &transitions = reachable_info->transitions; /* fixup unspecified transitions to be false */ /* find arity */ @@ -1735,7 +1735,7 @@ nodeSpecificationList : OPEN_BRACE realNodeSpecificationList CLOSE_BRACE { transitions[i][j] = Relation::False(arity[i],arity[j]); /* fixup unused start node positions */ - Dynamic_Array1<Relation> &nodes = reachable_info->start_nodes; + DynamicArray1<Relation> &nodes = reachable_info->start_nodes; for(i = 1; i <= n_nodes; i++) if(nodes[i].is_null()) nodes[i] = Relation::False(arity[i]); |