Updated code generators and CGBE

Author: kevinlano

ASTBasicTerm.java

@@ -35,6 +35,9 @@ public boolean hasTag(String tagx)
   public boolean hasSingleTerm() 
   { return true; } 
 
+  public boolean isNestedSymbolTerm() 
+  { return true; }  
+
   public int arity()
   { return 1; } 
 

ASTCompositeTerm.java

@@ -62,6 +62,14 @@ public String getTag()
   public boolean hasSingleTerm() 
   { return terms.size() == 1; } 
 
+  public boolean isNestedSymbolTerm() 
+  { if (terms.size() == 1)
+    { ASTTerm t0 = (ASTTerm) terms.get(0); 
+      return t0.isNestedSymbolTerm(); 
+    }
+    return false; 
+  }  
+
   public int arity()
   { return terms.size(); } 
 
@@ -2314,6 +2322,15 @@ else if (t2.hasTag("pointer"))
       return et; 
     } 
 
+    if ("enumSpecifier".equals(tag) && 
+        terms.size() == 2 && 
+        "enum".equals(terms.get(0) + ""))
+    { // enum name    
+      String sname = ((ASTTerm) terms.get(1)).literalForm(); 
+      Type et = new Type(sname,null); 
+      return et; 
+    } 
+
 
     if ("structOrUnionSpecifier".equals(tag) && 
         terms.size() == 2)
@@ -10870,7 +10887,7 @@ else if ("next".equals(called) || "nextElement".equals(called) || "nextToken".eq
         } 
         else if ("countTokens".equals(called))
         { String tt = ASTTerm.getType(args); 
-          System.out.println(">>> Type of " + args + " is: " + tt);  
+          // System.out.println(">>> Type of " + args + " is: " + tt);  
           // if ("OclIterator".equals(tt))
           ASTTerm.setType(thisliteral,"int"); 
 

ASTSymbolTerm.java

@@ -28,6 +28,9 @@ public boolean hasTag(String tagx)
   public boolean hasSingleTerm() 
   { return false; } 
 
+  public boolean isNestedSymbolTerm() 
+  { return true; } 
+
   public String cg(CGSpec cgs)
   { return symbol; } 
 

ASTTerm.java

@@ -695,25 +695,57 @@ public static boolean allSymbolTerms(ASTTerm[] trees)
   }   
 
   public static boolean allNestedSymbolTerms(ASTTerm[] trees)
-  { if (trees.length == 0) 
+  { // All either symbols or nested symbols
+
+    if (trees.length == 0) 
     { return false; }
+
     for (int i = 0; i < trees.length; i++) 
     { ASTTerm tx = trees[i]; 
       if (tx == null) 
       { return false; } 
-      if (tx.arity() == 1) 
-      { ASTTerm ttx = tx.getTerm(0); 
 
-        if (ttx instanceof ASTSymbolTerm) { } 
-        else 
-        { return false; }
+      if (tx.arity() <= 1 && tx.isNestedSymbolTerm()) 
+      { 
+        System.out.println(">>> Nested symbol term: " + tx); 
       } 
       else 
       { return false; }  
     } 
     return true; 
   }   
 
+  public abstract boolean isNestedSymbolTerm(); 
+  
+  public static boolean recursivelyNestedEqual(
+      ASTTerm[] strees, ASTTerm[] ttrees)
+  { // Each strees[i] is a symbol, literally equal 
+    // to the targets
+
+    if (strees.length == 0) 
+    { return false; }
+
+    if (strees.length != ttrees.length) 
+    { return false; } 
+
+    for (int i = 0; i < strees.length; i++) 
+    { ASTTerm sx = strees[i];
+      ASTTerm tx = ttrees[i]; 
+ 
+      if (sx == null || tx == null) 
+      { return false; } 
+
+      String slit = sx.literalForm(); 
+      String tlit = tx.literalForm(); 
+      
+      if (slit.equals(tlit)) { } 
+      else 
+      { return false; } 
+    } 
+
+    return true; 
+  }   
+
 
   public static boolean functionalSymbolMapping(ASTTerm[] strees, ASTTerm[] ttrees)
   { // The correspondence is functional.
@@ -1110,6 +1142,121 @@ else if (xx.equals(yvect)) { }
       return res; 
     }
 
+    public static Vector createGeneralisedMappings
+        (ASTTerm[] xs, Expression trg)
+    { // Each xs[i] maps to same target. 
+      // Create a separate mapping for each different arity
+      // of xs. Extract constant symbol values. 
+
+      Vector res = new Vector(); 
+      java.util.Map aritymap = new java.util.HashMap(); 
+      Vector doms = new Vector(); 
+
+      if (xs.length > 1)
+      { for (int i = 0; i < xs.length; i++)
+        { ASTTerm xx = xs[i]; 
+         
+          if (xx != null) 
+          { int n = xx.arity(); 
+            Integer nx = new Integer(n); 
+            doms.add(nx); 
+            Vector aritynterms = 
+               (Vector) aritymap.get(nx); 
+            if (aritynterms == null) 
+            { aritynterms = new Vector(); 
+              aritynterms.add(xx);
+              aritymap.put(nx,aritynterms);  
+            }
+            else 
+            { aritynterms.add(xx); }  
+          } 
+        }
+      } 
+      else 
+      { return res; } 
+
+      for (int j = 0; j < doms.size(); j++) 
+      { // For each arity set aritymap(doms(j))
+        // identify the generalised form of the terms
+
+        Integer nx = (Integer) doms.get(j); 
+        Vector arityns = (Vector) aritymap.get(nx); 
+
+        System.out.println(">>> Arity " + nx + " source terms are: " + arityns); 
+        System.out.println(); 
+
+        if (arityns.size() == 1) 
+        { ASTTerm st = (ASTTerm) arityns.get(0); 
+          BasicExpression expr = 
+                BasicExpression.newASTBasicExpression(st); 
+          AttributeMatching am = 
+                new AttributeMatching(expr,trg); 
+          res.add(am); 
+        } 
+        else 
+        { ASTTerm st0 = (ASTTerm) arityns.get(0); 
+          BasicExpression expr = 
+                BasicExpression.newASTBasicExpression(st0); 
+          int n = nx.intValue(); 
+          for (int p = 0; p < n; p++) 
+          { if (ASTTerm.constantTerms(arityns,p))
+            { ASTTerm pterm = st0.getTerm(p); 
+              String st0p = pterm.literalForm(); 
+              Expression exprp = 
+                      new BasicExpression(st0p);                    
+              expr.setParameter(p+1, exprp); 
+            }
+            else 
+            { expr.setParameter(p+1,
+                    new BasicExpression("_" + (p+1))); 
+            } 
+          } 
+          AttributeMatching am = 
+                new AttributeMatching(expr,trg); 
+          res.add(am); 
+        }
+      }  
+
+      System.out.println(">>> Generalised matchings: " + res); 
+
+      return res; 
+    }
+
+    public static boolean constantTerms(Vector trms, int p)
+    { // The p subterms of all trms are the same 
+
+      if (trms.size() == 0) 
+      { return false; } 
+   
+      if (trms.size() == 1) 
+      { return true; } 
+
+      ASTTerm t0 = (ASTTerm) trms.get(0); 
+      if (t0.arity() <= p) 
+      { return false; } 
+
+      ASTTerm subtermp = t0.getTerm(p);
+ 
+      String lit = subtermp.literalForm(); 
+      
+      for (int i = 1; i < trms.size(); i++) 
+      { ASTTerm t = (ASTTerm) trms.get(i); 
+        ASTTerm subterm = t.getTerm(p);
+
+        // System.out.println(" " + p + " subterm of " + t + " is " + subterm + " =? " + lit); 
+ 
+        if (subterm != null && 
+            subterm.literalForm().equals(lit))
+        { } 
+        else 
+        { return false; } 
+      } 
+
+      // System.out.println(" " + p + " subterm is constant"); 
+
+      return true; 
+    } 
+
  /*   public static boolean matchingTrees(ASTTerm[] xs, ASTTerm[] ys, ModelSpecification mod)
     { // Is each ys[i] = xs[i], or corresponding under mod? 
 

Attribute.java

@@ -1795,9 +1795,21 @@ public String saveModelData(PrintWriter out)
       out.println(cname + ".upper = 1"); 
     } 
 
-    if (!instanceScope) { out.println(cname + ".isStatic = true"); } 
-    if (isFinal()) { out.println(cname + ".isReadOnly = true"); } 
-    if (unique) { out.println(cname + ".isUnique = true"); } 
+    if (instanceScope)
+    { out.println(cname + ".isStatic = false"); } 
+    else  
+    { out.println(cname + ".isStatic = true"); }
+ 
+    if (isFinal()) 
+    { out.println(cname + ".isReadOnly = true"); } 
+    else 
+    { out.println(cname + ".isReadOnly = false"); } 
+
+
+    if (unique) 
+    { out.println(cname + ".isUnique = true"); } 
+    else 
+    { out.println(cname + ".isUnique = false"); } 
 
     if (initialExpression != null) 
     { String ini = initialExpression.saveModelData(out); 

BasicExpression.java

@@ -3266,6 +3266,8 @@ else if (objectRef.elementType != null && objectRef.elementType.isEntity())
       { type = new Type(createdClass,null); 
         umlkind = UPDATEOP;
         isStatic = true;  
+        entity = (Entity) 
+          ModelElement.lookupByName(createdClass,entities); 
         multiplicity = ModelElement.ONE;
         if (parameters != null) 
         { for (int i = 0; i < parameters.size(); i++) 
@@ -3290,6 +3292,8 @@ else if (createdClass.startsWith("OclIterator"))
       { type = new Type("OclIterator",null); 
         umlkind = UPDATEOP;
         isStatic = true;  
+        entity = (Entity) 
+          ModelElement.lookupByName("OclIterator",entities); 
         multiplicity = ModelElement.ONE;
         if (parameters != null && parameters.size() > 0) 
         { Expression par1 = (Expression) parameters.get(0); 
@@ -3443,7 +3447,9 @@ else if (createdClass.startsWith("OclIterator_String"))
       if (objectRef.type != null && 
           objectRef.type.getName().equals("OclIterator")) 
       { type = new Type("Sequence", null);
-        
+        entity = (Entity) 
+          ModelElement.lookupByName("OclIterator",entities); 
+
         umlkind = ATTRIBUTE; 
         multiplicity = ModelElement.MANY; 
 
@@ -3458,6 +3464,9 @@ else if (createdClass.startsWith("OclIterator_String"))
       { type = new Type("void", null); 
         umlkind = UPDATEOP; 
         multiplicity = ModelElement.ONE; 
+        entity = (Entity) 
+          ModelElement.lookupByName(objectRef.type.getName(),
+                                    entities); 
 
         return true;
       }  
@@ -3475,7 +3484,9 @@ else if (createdClass.startsWith("OclIterator_String"))
       { type = new Type("String", null);
         umlkind = QUERY; 
         multiplicity = ModelElement.ONE; 
- 
+        entity = (Entity) 
+          ModelElement.lookupByName("OclFile",entities); 
+
         return true;
       }  
     } 
@@ -3488,6 +3499,8 @@ else if (createdClass.startsWith("OclIterator_String"))
       { type = new Type("long", null);
         umlkind = QUERY; 
         multiplicity = ModelElement.ONE; 
+        entity = (Entity) 
+          ModelElement.lookupByName("OclFile",entities); 
 
         return true;
       }  
@@ -3506,6 +3519,8 @@ else if (createdClass.startsWith("OclIterator_String"))
         umlkind = QUERY; 
         multiplicity = ModelElement.ONE; 
         // set the formal parameters
+        entity = (Entity) 
+          ModelElement.lookupByName("OclFile",entities); 
 
         return true;
       }  
@@ -3519,6 +3534,8 @@ else if (createdClass.startsWith("OclIterator_String"))
       { type = new Type("boolean", null);
         umlkind = QUERY; 
         multiplicity = ModelElement.ONE; 
+        entity = (Entity) 
+          ModelElement.lookupByName("OclProcess",entities); 
         return true;
       }  
     } 
@@ -3531,6 +3548,9 @@ else if (createdClass.startsWith("OclIterator_String"))
       { type = new Type("String", null);
         umlkind = QUERY; 
         multiplicity = ModelElement.ONE; 
+        entity = (Entity) 
+          ModelElement.lookupByName("OclProcess",entities); 
+
         return true;
       }  // and for OclType
     } 
@@ -3542,6 +3562,8 @@ else if (createdClass.startsWith("OclIterator_String"))
       umlkind = QUERY; 
       multiplicity = ModelElement.ONE; 
       isStatic = true; 
+      entity = (Entity) 
+          ModelElement.lookupByName("OclProcess",entities); 
       return true;
     } 
 
@@ -3553,7 +3575,9 @@ else if (createdClass.startsWith("OclIterator_String"))
       { type = new Type("int", null);
         umlkind = QUERY; 
         multiplicity = ModelElement.ONE; 
- 
+        entity = (Entity) 
+          ModelElement.lookupByName("OclProcess",entities); 
+
         return true;
       }  
     } 

BehaviouralFeature.java

@@ -3181,6 +3181,7 @@ else if (entity != null)
       String typeid = resultType.getUMLModelName(out); 
       out.println(opid + ".type = " + typeid);  
       if (rtname.equals("Set") || rtname.equals("Sequence") ||
+          rtname.equals("Ref") || 
           rtname.equals("Map") || rtname.equals("Function") )
       { if (elementType == null) 
         { System.err.println("Warning!: No element type for " + this); 
@@ -3278,6 +3279,7 @@ public String saveAsUSEData()
       if (i < parameters.size() - 1) { res = res + ", "; } 
     }
     res = res + ") "; 
+
     if (resultType != null)
     { String rtname = resultType.getName(); 
       if (rtname.equals("Set") || rtname.equals("Sequence"))