From 18644419b50b2b14a24456e0fcdb210f231ee317 Mon Sep 17 00:00:00 2001
From: Tuowen Zhao <ztuowen@gmail.com>
Date: Sun, 18 Sep 2016 15:16:52 -0600
Subject: doc updated for code_gen
---
.../codegen/include/code_gen/CG_outputBuilder.h | 116 +++---
omegalib/codegen/include/code_gen/CG_outputRepr.h | 6 +-
omegalib/codegen/include/code_gen/CG_roseBuilder.h | 80 +---
omegalib/codegen/include/code_gen/CG_roseRepr.h | 1 -
omegalib/codegen/include/code_gen/CG_suifBuilder.h | 88 ----
omegalib/codegen/include/code_gen/CG_suifRepr.h | 36 --
omegalib/codegen/include/code_gen/codegen.h | 12 +-
omegalib/codegen/src/CG_roseBuilder.cc | 456 +--------------------
omegalib/omega/include/basic/Bag.h | 29 +-
omegalib/omega/include/basic/BoolSet.h | 18 +-
omegalib/omega/include/basic/Collection.h | 12 +-
omegalib/omega/include/basic/ConstString.h | 1 -
omegalib/omega/include/basic/DynamicArray.c | 219 ++++++++++
omegalib/omega/include/basic/DynamicArray.h | 103 +++++
omegalib/omega/include/basic/Dynamic_Array.c | 219 ----------
omegalib/omega/include/basic/Dynamic_Array.h | 103 -----
omegalib/omega/include/basic/Iterator.h | 48 ++-
omegalib/omega/include/basic/Link.h | 17 +-
omegalib/omega/include/basic/List.h | 5 -
omegalib/omega/include/omega/reach.h | 8 +-
omegalib/omega/src/reach.cc | 6 +-
omegalib/omegacalc/include/omega_calc/PT-omega.c | 8 +-
omegalib/omegacalc/src/parser.l | 2 +-
omegalib/omegacalc/src/parser.ll | 2 +-
omegalib/omegacalc/src/parser.y | 16 +-
omegalib/omegacalc/src/parser.yy | 14 +-
26 files changed, 496 insertions(+), 1129 deletions(-)
delete mode 100644 omegalib/codegen/include/code_gen/CG_suifBuilder.h
delete mode 100644 omegalib/codegen/include/code_gen/CG_suifRepr.h
create mode 100644 omegalib/omega/include/basic/DynamicArray.c
create mode 100644 omegalib/omega/include/basic/DynamicArray.h
delete mode 100644 omegalib/omega/include/basic/Dynamic_Array.c
delete mode 100644 omegalib/omega/include/basic/Dynamic_Array.h
(limited to 'omegalib')
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/DynamicArray.c b/omegalib/omega/include/basic/DynamicArray.c
new file mode 100644
index 0000000..8ede2f7
--- /dev/null
+++ b/omegalib/omega/include/basic/DynamicArray.c
@@ -0,0 +1,219 @@
+#include <assert.h>
+#include <basic/DynamicArray.h>
+
+namespace omega {
+
+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);
+// #endif
+ bounds = 0;
+ elements = 0;
+ partial = false;
+ }
+
+
+template<class T> void DynamicArray1<T>::do_construct(int d0)
+ {
+ this->bounds = new int[1];
+ this->bounds[0] = d0;
+ this->elements = new T [d0];
+ this->partial = false;
+ }
+
+template<class T> void DynamicArray2<T>::do_construct(int d0, int d1)
+ {
+ this->bounds = new int[2];
+ this->bounds[0] = d0;
+ this->bounds[1] = d1;
+ this->elements = new T [d0 * d1];
+ this->partial = false;
+ }
+
+template<class T> void DynamicArray3<T>::do_construct(int d0,int d1,int d2)
+ {
+ this->bounds = new int[3];
+ this->bounds[0] = d0;
+ this->bounds[1] = d1;
+ this->bounds[2] = d2;
+ this->elements = new T [d0 * d1 * d2];
+ this->partial = false;
+ }
+
+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;
+ this->bounds[1] = d1;
+ this->bounds[2] = d2;
+ this->bounds[3] = d3;
+ this->elements = new T [d0 * d1 * d2 * d3];
+ this->partial = false;
+ }
+
+template<class T, int d> DynamicArray<T,d>::DynamicArray()
+ {
+ do_constr();
+ }
+
+template<class T> DynamicArray1<T>::DynamicArray1(const char *)
+ {
+ this->do_constr();
+ }
+
+template<class T> DynamicArray2<T>::DynamicArray2(const char *,const char *)
+ {
+ this->do_constr();
+ }
+
+template<class T> DynamicArray3<T>::DynamicArray3(const char *,const char *,const char *)
+ {
+ this->do_constr();
+ }
+
+template<class T> DynamicArray4<T>::DynamicArray4(const char *,const char *,const char *,const char *)
+ {
+ this->do_constr();
+ }
+
+template<class T> DynamicArray1<T>::DynamicArray1(int d0)
+ {
+ do_construct(d0);
+ }
+
+template<class T> DynamicArray2<T>::DynamicArray2(int d0, int d1)
+ {
+ do_construct(d0, d1);
+ }
+
+template<class T> DynamicArray3<T>::DynamicArray3(int d0,int d1,int d2)
+ {
+ do_construct(d0, d1, d2);
+ }
+
+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 DynamicArray<T,d>::do_destruct()
+ {
+ if (! partial)
+ {
+ delete [] bounds;
+ delete [] elements;
+ }
+ }
+
+
+template<class T, int d> DynamicArray<T,d>::~DynamicArray()
+ {
+ do_destruct();
+ }
+
+
+template<class T> void DynamicArray1<T>::resize(int d0)
+ {
+ assert(!this->partial);
+ this->do_destruct();
+ if (d0 == 0)
+ this->do_constr();
+ else
+ do_construct(d0);
+ }
+
+template<class T> void DynamicArray2<T>::resize(int d0, int d1)
+ {
+ assert(!this->partial);
+ this->do_destruct();
+ if (d0 == 0 && d1 == 0)
+ this->do_constr();
+ else
+ do_construct(d0, d1);
+ }
+
+template<class T> void DynamicArray3<T>::resize(int d0, int d1, int d2)
+ {
+ assert(!this->partial);
+ this->do_destruct();
+ if (d0 == 0 && d1 == 0 && d2 == 0)
+ this->do_constr();
+ else
+ do_construct(d0, d1, d2);
+ }
+
+template<class T> void DynamicArray4<T>::resize(int d0, int d1, int d2, int d3)
+ {
+ assert(!this->partial);
+ this->do_destruct();
+ if (d0 == 0 && d1 == 0 && d2 == 0 && d3 == 0)
+ this->do_constr();
+ else
+ do_construct(d0, d1, d2, d3);
+ }
+
+
+template<class T> T& DynamicArray1<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
+
+ return this->elements[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
+
+ DynamicArray1<T> result;
+ result.bounds = this->bounds+1;
+ result.elements = this->elements + this->bounds[1] * d0;
+ result.partial = true;
+ return result;
+ }
+
+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
+ 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> 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
+
+ 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;
+ return result;
+ }
+
+
+template<class T, int d>
+ DynamicArray<T,d>::DynamicArray(DynamicArray<T,d> &D)
+ {
+ assert(D.elements != 0 && "Trying to copy an undefined array");
+ partial = true;
+ bounds = D.bounds;
+ elements = D.elements;
+ }
+
+} // namespace
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.c b/omegalib/omega/include/basic/Dynamic_Array.c
deleted file mode 100644
index 0300fd8..0000000
--- a/omegalib/omega/include/basic/Dynamic_Array.c
+++ /dev/null
@@ -1,219 +0,0 @@
-#include <assert.h>
-#include <basic/Dynamic_Array.h>
-
-namespace omega {
-
-template<class T, int d> void Dynamic_Array<T,d>::do_constr()
- {
-// #if ! defined SHUT_UP_ABOUT_STATEMENT_WITH_NO_EFFECT_IN_DYNAMIC_ARRAY_CREATION
-// assert(d > 0);
-// #endif
- bounds = 0;
- elements = 0;
- partial = false;
- }
-
-
-template<class T> void Dynamic_Array1<T>::do_construct(int d0)
- {
- this->bounds = new int[1];
- this->bounds[0] = d0;
- this->elements = new T [d0];
- this->partial = false;
- }
-
-template<class T> void Dynamic_Array2<T>::do_construct(int d0, int d1)
- {
- this->bounds = new int[2];
- this->bounds[0] = d0;
- this->bounds[1] = d1;
- this->elements = new T [d0 * d1];
- this->partial = false;
- }
-
-template<class T> void Dynamic_Array3<T>::do_construct(int d0,int d1,int d2)
- {
- this->bounds = new int[3];
- this->bounds[0] = d0;
- this->bounds[1] = d1;
- this->bounds[2] = d2;
- this->elements = new T [d0 * d1 * d2];
- this->partial = false;
- }
-
-template<class T> void Dynamic_Array4<T>::do_construct(int d0,int d1,int d2,int d3)
- {
- this->bounds = new int[4];
- this->bounds[0] = d0;
- this->bounds[1] = d1;
- this->bounds[2] = d2;
- this->bounds[3] = d3;
- this->elements = new T [d0 * d1 * d2 * d3];
- this->partial = false;
- }
-
-template<class T, int d> Dynamic_Array<T,d>::Dynamic_Array()
- {
- do_constr();
- }
-
-template<class T> Dynamic_Array1<T>::Dynamic_Array1(const char *)
- {
- this->do_constr();
- }
-
-template<class T> Dynamic_Array2<T>::Dynamic_Array2(const char *,const char *)
- {
- this->do_constr();
- }
-
-template<class T> Dynamic_Array3<T>::Dynamic_Array3(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 *)
- {
- this->do_constr();
- }
-
-template<class T> Dynamic_Array1<T>::Dynamic_Array1(int d0)
- {
- do_construct(d0);
- }
-
-template<class T> Dynamic_Array2<T>::Dynamic_Array2(int d0, int d1)
- {
- do_construct(d0, d1);
- }
-
-template<class T> Dynamic_Array3<T>::Dynamic_Array3(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)
- {
- do_construct(d0, d1, d2, d3);
- }
-
-
-template<class T, int d> void Dynamic_Array<T,d>::do_destruct()
- {
- if (! partial)
- {
- delete [] bounds;
- delete [] elements;
- }
- }
-
-
-template<class T, int d> Dynamic_Array<T,d>::~Dynamic_Array()
- {
- do_destruct();
- }
-
-
-template<class T> void Dynamic_Array1<T>::resize(int d0)
- {
- assert(!this->partial);
- this->do_destruct();
- if (d0 == 0)
- this->do_constr();
- else
- do_construct(d0);
- }
-
-template<class T> void Dynamic_Array2<T>::resize(int d0, int d1)
- {
- assert(!this->partial);
- this->do_destruct();
- if (d0 == 0 && d1 == 0)
- this->do_constr();
- else
- do_construct(d0, d1);
- }
-
-template<class T> void Dynamic_Array3<T>::resize(int d0, int d1, int d2)
- {
- assert(!this->partial);
- this->do_destruct();
- if (d0 == 0 && d1 == 0 && d2 == 0)
- this->do_constr();
- else
- do_construct(d0, d1, d2);
- }
-
-template<class T> void Dynamic_Array4<T>::resize(int d0, int d1, int d2, int d3)
- {
- assert(!this->partial);
- this->do_destruct();
- if (d0 == 0 && d1 == 0 && d2 == 0 && d3 == 0)
- this->do_constr();
- else
- do_construct(d0, d1, d2, d3);
- }
-
-
-template<class T> T& Dynamic_Array1<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
-
- return this->elements[d0];
- }
-
-template<class T> Dynamic_Array1<T> Dynamic_Array2<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;
- 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)
- {
-#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;
- 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)
- {
-#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;
- result.bounds = this->bounds+1;
- result.elements = this->elements + this->bounds[1] * this->bounds[2] * this->bounds[3] * d0;
- result.partial = true;
- return result;
- }
-
-
-template<class T, int d>
- Dynamic_Array<T,d>::Dynamic_Array(Dynamic_Array<T,d> &D)
- {
- assert(D.elements != 0 && "Trying to copy an undefined array");
- partial = true;
- bounds = D.bounds;
- elements = D.elements;
- }
-
-} // namespace
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]);
--
cgit v1.2.3-70-g09d2