added namespace global processing when definitions are inherited

Author: rmanohar

act/act_array.h

@@ -255,7 +255,11 @@ class Array {
  void moveNS (ActNamespace *orig = NULL,
  ActNamespace *newns = NULL); ///< moves to new ns
 
- Array *CloneOne ();///< only return a deep copy of the current dense range
+ Array *CloneOne ();///< only return a deep copy of the
+///current dense range
+
+ Array *fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
+ 
 
  Array *Reduce();///< return a deep copy, but elide
 ///dimensions that are derefs
@@ -594,6 +598,9 @@ class AExpr {
 
  AExpr *Clone (ActNamespace *orig = NULL, ActNamespace *newns = NULL); ///< deep copy of array expression
 
+ AExpr *fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
+
+ 
  /**
  * Return an InstType corresponding to this array expression
  * @param s is the scope

act/act_id.h

@@ -147,6 +147,17 @@ class ActId {
  * @return a freshly allocated ActID
  */
  ActId *Clone (ActNamespace *orig = NULL, ActNamespace *newns = NULL);
+
+ /**
+ * If the ID can't be found in the current namespace but can be
+ * found in the original namespace, add the namespace qualifier to the
+ * ID and return a new one.
+ * @param cur is the current namespace
+ * @param orig is the original namespace
+ * @return the updated ID, or the unmodified pointer
+ */
+ ActId *qualifyGlobals (ActNamespace *cur, ActNamespace *orig);
+ bool isQualifyGlobals (ActNamespace *cur, ActNamespace *orig);
 
  void moveNS (ActNamespace *orig = NULL, ActNamespace *newns = NULL);
 
@@ -402,6 +413,12 @@ class ActId {
 
  static struct cHashtable *idH; /**< used to canonicalize ID pointers
  post-expansion */
+
+
+ // this is used for the remaining of the type, i.e. the "."
+ // fields. Here we only check arrays.
+ ActId *_qualifyGlobals (ActNamespace *cur, ActNamespace *orig);
+ bool _isQualifyGlobals (ActNamespace *cur, ActNamespace *orig);
 };
 
 

act/array.cc

@@ -214,9 +214,9 @@ Array *Array::Clone (ActNamespace *orig, ActNamespace *newns)
 
 /*------------------------------------------------------------------------
  *
- * Array::Clone --
+ * Array::moveNS --
  *
- * Deep copy of array
+ * Deep copy of array, move it to a new namespace
  *
  *------------------------------------------------------------------------
  */
@@ -236,6 +236,26 @@ void Array::moveNS (ActNamespace *orig, ActNamespace *newns)
  }
 }
 
+/*------------------------------------------------------------------------
+ *
+ * Array::Clone --
+ *
+ * Deep copy of array
+ *
+ *------------------------------------------------------------------------
+ */
+Array *Array::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ Array *ret;
+
+ if (expanded) {
+ return this;
+ }
+
+ /* XXXX */
+ return this;
+
+}
 
 /*------------------------------------------------------------------------
  *
@@ -2175,3 +2195,5 @@ unsigned int Array::getHash (unsigned int prev, unsigned long sz)
  }
  return prev;
 }
+
+

act/body.cc

@@ -2030,3 +2030,164 @@ ActBody *ActBody::Clone(ActNamespace */*replace*/,
 {
  return NULL;
 }
+
+
+void ActBody::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ return;
+}
+
+
+void ActBody_Inst::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ t = t->fixGlobalParams (cur, orig);
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Attribute::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ Array *narr;
+ if (arr) {
+ arr = arr->fixGlobalParams (cur, orig);
+ }
+ act_attr *tmp;
+ for (tmp = a; tmp; tmp = tmp->next) {
+ tmp->e = expr_globalids (tmp->e, cur, orig);
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Conn::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ if (type == 0) {
+ u.basic.lhs = u.basic.lhs->qualifyGlobals (cur, orig);
+ u.basic.rhs = u.basic.rhs->fixGlobalParams (cur, orig);
+ }
+ else {
+ u.general.lhs = u.general.lhs->fixGlobalParams (cur, orig);
+ u.general.rhs = u.general.rhs->fixGlobalParams (cur, orig);
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Loop::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ lo = expr_globalids (lo, cur, orig);
+ hi = expr_globalids (hi, cur, orig);
+ if (b) {
+ b->fixGlobalParams (cur, orig);
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Select::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ ActBody_Select_gc *tmp;
+ for (tmp = gc; tmp; tmp = tmp->next) {
+ tmp->lo = expr_globalids (tmp->lo, cur, orig);
+ tmp->hi = expr_globalids (tmp->hi, cur, orig);
+ tmp->g = expr_globalids (tmp->g, cur, orig);
+ if (tmp->s) {
+ tmp->s->fixGlobalParams (cur, orig);
+ }
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Genloop::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ ActBody_Select_gc *tmp;
+ for (tmp = gc; tmp; tmp = tmp->next) {
+ tmp->lo = expr_globalids (tmp->lo, cur, orig);
+ tmp->hi = expr_globalids (tmp->hi, cur, orig);
+ tmp->g = expr_globalids (tmp->g, cur, orig);
+ if (tmp->s) {
+ tmp->s->fixGlobalParams (cur, orig);
+ }
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Assertion::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ if (type == 0) {
+ u.t0.e = expr_globalids (u.t0.e, cur, orig);
+ }
+ else {
+ Assert (type == 1, "Hmm");
+ u.t1.id1 = u.t1.id1->qualifyGlobals (cur, orig);
+ u.t1.id2 = u.t1.id2->qualifyGlobals (cur, orig);
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Print::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ listitem_t *li;
+ for (li = list_first (l); li; li = list_next (li)) {
+ act_func_arguments_t *f = (act_func_arguments_t *) list_value (li);
+ if (f->isstring) {
+ // nothing
+ }
+ else {
+ f->u.e = expr_globalids (f->u.e, cur, orig);
+ }
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}
+
+void ActBody_Lang::fixGlobalParams (ActNamespace *cur, ActNamespace *orig)
+{
+ switch (t) {
+ case LANG_CHP:
+ case LANG_HSE:
+ chp_fixglobals ((act_chp *)lang, cur, orig);
+ break;
+
+ case LANG_REFINE:
+ refine_fixglobals ((act_refine *)lang, cur, orig);
+ break;
+
+ case LANG_DFLOW:
+ dflow_fixglobals ((act_dataflow *)lang, cur, orig);
+ break;
+
+ case LANG_PRS:
+ prs_fixglobals ((act_prs *)lang, cur, orig);
+ break;
+ 
+ case LANG_SPEC:
+ spec_fixglobals ((act_spec *)lang, cur, orig);
+ break;
+ 
+ case LANG_SIZE:
+ sizing_fixglobals ((act_sizing *)lang, cur, orig);
+ break;
+ 
+ case LANG_INIT:
+ break;
+ 
+ case LANG_EXTERN:
+ lang_extern_fixglobals (nm, lang, cur, orig);
+ break;
+ }
+ if (Next()) {
+ Next()->fixGlobalParams (cur, orig);
+ }
+}

act/body.h

@@ -132,6 +132,15 @@ class ActBody {
  */
  int getLine () { return _line; }
 
+
+ /**
+ * If a namespace global parameter is used, add the explicit
+ * qualifier to the identifier.
+ * @param cur is the current namespace
+ * @param orig is the original namespace
+ */
+ virtual void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
+
 protected:
  int _line; ///< saved away line number information
 
@@ -194,6 +203,11 @@ class ActBody_Inst : public ActBody {
  */
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
 
+ /**
+ * Update namespace globals
+ */
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
+
  private:
  InstType *t; ///< the type
  const char *id; ///< the name of the identifier to be instantiated
@@ -235,6 +249,11 @@ class ActBody_Attribute : public ActBody {
  */
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
 
+ /**
+ * Update namespace globals
+ */
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
+
 private:
  const char *inst;
  act_attr *a;
@@ -279,7 +298,7 @@ class ActBody_Conn : public ActBody {
  void Expand (ActNamespace *, Scope *);
 
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
- 
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
 
  private:
  union {
@@ -327,6 +346,8 @@ class ActBody_Loop : public ActBody {
  void Print (FILE *fp);
 
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
+ 
 
  /**
  * @return the loop body
@@ -450,6 +471,7 @@ class ActBody_Select : public ActBody {
  void Expand (ActNamespace *, Scope *);
 
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
 
  /**
  * @return the list of guarded commands
@@ -477,7 +499,7 @@ class ActBody_Genloop : public ActBody {
  }
  void Expand (ActNamespace *, Scope *);
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
-
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
 
  ActBody_Select_gc *getGC() { return gc; }
 
@@ -533,6 +555,7 @@ class ActBody_Assertion : public ActBody {
  }
  void Expand (ActNamespace *, Scope *);
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
 
 private:
  union {
@@ -607,6 +630,7 @@ class ActBody_Print : public ActBody {
  }
  void Expand (ActNamespace *, Scope *);
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
 
 private:
  list_t *l;
@@ -734,7 +758,7 @@ class ActBody_Lang : public ActBody {
  void Expand (ActNamespace *, Scope *);
  void Print (FILE *fp);
  ActBody *Clone (ActNamespace *replace = NULL, ActNamespace *newns = NULL);
-
+ void fixGlobalParams (ActNamespace *cur, ActNamespace *orig);
 
  void *getlang() { return lang; }
  enum langtype gettype() { return t; }