Updated CGBE

Author: kevinlano

ASTCompositeTerm.java

@@ -34,6 +34,8 @@ public class ASTCompositeTerm extends ASTTerm
   public static Type doubleType = new Type("double", null); 
   public static Type voidType = new Type("void", null); 
 
+  public static Statement skipStatement = 
+                     new InvocationStatement("skip"); 
 
   public ASTCompositeTerm(String t)
   { tag = t; 
@@ -5612,6 +5614,83 @@ public Statement cfunctioncallPresideeffect(String fname,
       sqstat.addStatement(forstat);   
       return sqstat; 
     }  
+    else if ("strtok".equals(fname) && args.size() == 2)
+    { // if s /= "" then _tok_string := s else skip ;
+      // if _tok_string->hasMatch(ct) 
+      // then tok_token := _tok_string->firstMatch(ct); 
+      //   _tok_ind := _tok_string->indexOf(_tok_token) + _tok_token.size;
+      //   _tok_string := _tok_string.substring(_tok_ind)
+      // else _tok_token := ""; _tok_ind := 0; 
+      //   _tok_string := "" 
+
+      Expression s = (Expression) args.get(0);
+      Expression ct = (Expression) args.get(1);
+      s.setType(new Type("String", null)); 
+      ct.setType(new Type("String", null));
+
+      Expression indexexpr = 
+         BasicExpression.newVariableBasicExpression("_tok_ind");   
+      indexexpr.setType(new Type("int", null));
+      Expression tokenexpr = 
+         BasicExpression.newVariableBasicExpression(
+                        "_tok_token");   
+      tokenexpr.setType(new Type("String", null));
+      Expression tokstringexpr = 
+         BasicExpression.newVariableBasicExpression(
+                        "_tok_string");   
+      tokstringexpr.setType(new Type("String", null));
+      
+      Expression nonempty = 
+        new BinaryExpression("/=",s,emptyStringExpression);
+      nonempty.setType(new Type("boolean", null)); 
+      AssignStatement assigns = 
+        new AssignStatement(tokstringexpr, s);   
+      ConditionalStatement cond1 = 
+        new ConditionalStatement(
+                   nonempty,assigns,skipStatement);
+      
+      SequenceStatement stat0 = new SequenceStatement();
+      AssignStatement asgn1 = 
+        new AssignStatement(tokenexpr,  
+          new BinaryExpression("->firstMatch", 
+                               tokstringexpr, ct)); 
+      stat0.addStatement(asgn1); 
+      Expression indof = 
+        new BinaryExpression("->indexOf", tokstringexpr, ct);
+      Expression sizetok = 
+        new UnaryExpression("->size", tokenexpr);  
+      AssignStatement asgn2 = 
+        new AssignStatement(indexexpr,  
+          new BinaryExpression("+", indof, sizetok)); 
+      stat0.addStatement(asgn2); 
+      Expression substr = 
+        BasicExpression.newFunctionBasicExpression("substring", 
+                                      tokstringexpr, indexexpr); 
+      AssignStatement asgn3 = 
+        new AssignStatement(tokstringexpr, substr); 
+      stat0.addStatement(asgn3); 
+
+      SequenceStatement stat1 = new SequenceStatement();
+      AssignStatement asgn4 = 
+        new AssignStatement(tokenexpr, emptyStringExpression);   
+      stat1.addStatement(asgn4); 
+      AssignStatement asgn5 = 
+        new AssignStatement(indexexpr, zeroExpression); 
+      stat1.addStatement(asgn5); 
+      AssignStatement asgn6 = 
+        new AssignStatement(
+               tokstringexpr, emptyStringExpression); 
+      stat1.addStatement(asgn6); 
+      
+      Expression test = 
+        new BinaryExpression("->hasMatch", tokstringexpr, ct); 
+      ConditionalStatement cond2 =
+        new ConditionalStatement(test,stat0,stat1);
+      SequenceStatement res = new SequenceStatement(); 
+      res.addStatement(cond1); 
+      res.addStatement(cond2); 
+      return res;   
+    } 
 
     return null; 
   }
@@ -5629,7 +5708,7 @@ public Statement cfunctioncallUpdateForm(String fname,
       Expression arg1 = (Expression) args.get(1);
       arg1.setType(new Type("String", null)); 
       return new AssignStatement(arg0, arg1);  
-    } // and side-effect 
+    }  
     else if ("strncpy".equals(fname) && args.size() == 3)
     { Expression arg0 = (Expression) args.get(0);
       Expression arg1 = (Expression) args.get(1);
@@ -5642,7 +5721,7 @@ else if ("strncpy".equals(fname) && args.size() == 3)
         BasicExpression.newFunctionBasicExpression("subrange", arg1, pars);  
       fbe.setType(new Type("String", null));
       return new AssignStatement(arg0, fbe); 
-    } // and side-effect 
+    }  
     else if (("memcpy".equals(fname) || 
               "memmove".equals(fname)) && args.size() == 3)
     { // for i : 0..argn-1 
@@ -6950,6 +7029,13 @@ else if ("strncmp".equals(fname) && args.size() == 3)
       res.setType(new Type("int", null)); 
       return res; 
     }
+    else if ("strtok".equals(fname) && args.size() == 2)
+    { Expression tokenexpr = 
+         BasicExpression.newVariableBasicExpression(
+                        "_tok_token");   
+      tokenexpr.setType(new Type("String", null));
+      return tokenexpr; 
+    } 
     else if ("memcmp".equals(fname) && args.size() == 3) 
     { // arg1.subrange(1,n)->compareTo(arg2.subrange(1,n))
       Expression arg1 = (Expression) args.get(0);

ASTTerm.java

@@ -1291,6 +1291,33 @@ public static boolean sameNonSymbolArity(ASTTerm[] xs, ASTTerm[] ys)
       return false; 
     }
 
+    public static boolean lowerNonSymbolArity(ASTTerm[] xs, ASTTerm[] ys)
+    { // Is number of non-symbols in ys[i].terms <= 
+      // number of non-symbols in xs[i].terms? 
+
+      if (ys.length > 1 && xs.length == ys.length)
+      { for (int i = 0; i < xs.length; i++)
+        { ASTTerm xx = xs[i]; 
+          ASTTerm yvect = ys[i]; 
+
+          if (xx == null || yvect == null)
+          { return false; } 
+
+          int n = xx.nonSymbolArity();
+          System.out.println(">***> Non-symbol arity of " + xx + " = " + n); 
+ 
+          int m = yvect.nonSymbolArity(); 
+          System.out.println(">***> Non-symbol arity of " + yvect + " = " + m); 
+
+          if (n < m) 
+          { return false; } 
+        } 
+        return true; 
+      } 
+      return false; 
+    }
+
+
 /* 
     public static boolean embeddedTrees(ASTTerm[] xs, ASTTerm[] ys, ModelSpecification mod)
     { // Is each ys[i] = (tag xs[i]' ..terms..) for same tag? 
@@ -1686,6 +1713,39 @@ public static Vector entityMatchingsFromASTs(Vector sasts,
 
     Vector ems = new Vector(); 
 
+    for (int i = 0; i < sasts.size() && i < tasts.size(); i++) 
+    { ASTTerm s = (ASTTerm) sasts.get(i); 
+      ASTTerm t = (ASTTerm) tasts.get(i); 
+      
+      int n = s.arity(); 
+      int m = t.arity(); 
+
+      if (n > 0 && m > 0) 
+      { String sentname = s.getTag() + "_" + n; 
+        Entity sent = 
+          (Entity) ModelElement.lookupByName(sentname,es); 
+        String tentname = t.getTag() + "$T_" + m; 
+        Entity tent = 
+          (Entity) ModelElement.lookupByName(tentname,es); 
+        if (sent != null && tent != null) 
+        { EntityMatching em = 
+            new EntityMatching(sent,tent); 
+          if (ems.contains(em)) { }
+          else 
+          { ems.add(em); }  
+        } 
+      } 
+    } 
+    return ems; 
+  } 
+
+  public static Vector deepEntityMatchingsFromASTs(Vector sasts, 
+                         Vector tasts, Vector es)
+  { // For corresponding s, t create entity matching
+    // s.tag_s.arity |--> t.tag$T_t.arity. 
+
+    Vector ems = new Vector(); 
+
     for (int i = 0; i < sasts.size() && i < tasts.size(); i++) 
     { ASTTerm s = (ASTTerm) sasts.get(i); 
       ASTTerm t = (ASTTerm) tasts.get(i); 
@@ -1722,6 +1782,47 @@ public static void modelSpecificationFromASTs(Vector sasts,
     // t_inst.ast = t
     // s_inst |-> t_inst 
 
+    for (int i = 0; i < sasts.size() && i < tasts.size(); i++) 
+    { ASTTerm s = (ASTTerm) sasts.get(i); 
+      ASTTerm t = (ASTTerm) tasts.get(i); 
+      
+      int n = s.arity(); 
+      int m = t.arity(); 
+
+      if (n > 0 && m > 0) 
+      { String sentname = s.getTag() + "_" + n; 
+        String tentname = t.getTag() + "$T_" + m; 
+        String sinst = sentname.toLowerCase() + "_" + i; 
+        String tinst = tentname.toLowerCase() + "_" + i; 
+        Entity sent = 
+          (Entity) ModelElement.lookupByName(sentname,es); 
+        ObjectSpecification sobj = 
+          new ObjectSpecification(sinst,sentname); 
+        sobj.setEntity(sent);
+        sobj.setValue("ast", s); 
+        Entity tent = 
+          (Entity) ModelElement.lookupByName(tentname,es); 
+        ObjectSpecification tobj = 
+          new ObjectSpecification(tinst,tentname); 
+        tobj.setEntity(tent);
+        tobj.setValue("ast", t); 
+        mod.addObject(sobj); 
+        mod.addObject(tobj); 
+        mod.addCorrespondence(sobj,tobj); 
+      } 
+    } 
+  } 
+
+  public static void deepModelSpecificationFromASTs(Vector sasts, 
+                         Vector tasts, Vector es, 
+                         ModelSpecification mod)
+  { // For corresponding s, t create instances
+    // s_inst : s.tag_s.arity 
+    // s_inst.ast = s
+    // t_inst : t.tag$T_t.arity
+    // t_inst.ast = t
+    // s_inst |-> t_inst 
+
     for (int i = 0; i < sasts.size() && i < tasts.size(); i++) 
     { ASTTerm s = (ASTTerm) sasts.get(i); 
       ASTTerm t = (ASTTerm) tasts.get(i); 

AttributeMatching.java

@@ -153,7 +153,7 @@ public String toCSTL(String category, Expression cond,
     { String rulelhs = ((BasicExpression) srcvalue).toCSTL();
       BasicExpression rbe = (BasicExpression) trgvalue; 
 
-      System.out.println(">>> Mapping: " + this + " " + rbe.isFunctionApplication()); 
+      // System.out.println(">>> Mapping: " + this + " " + rbe.isFunctionApplication()); 
 
       if (rbe.isFunctionApplication())
       { String func = rbe.getAppliedFunction(); 
@@ -166,8 +166,9 @@ public String toCSTL(String category, Expression cond,
       } // It is simply _1 |-->_1`func
 
       String rulerhs = ((BasicExpression) trgvalue).toLiteralCSTL();
-      CGRule rle = new CGRule(rulelhs, rulerhs); 
-      if (cond != null) 
+      CGRule rle = new CGRule(rulelhs, rulerhs);
+      Vector vars = rle.getVariables();  
+      if (cond != null && vars.size() > 0) 
       { CGCondition cc = new CGCondition(cond); 
         rle.addCondition(cc); 
       } 

EntityMatching.java

@@ -4462,6 +4462,9 @@ public void checkModelConditions(ModelSpecification mod, ModelMatching mm, Vecto
     // checks that the condition of rule is valid, or if
     // no condition, creates a valid condition. 
 
+    if (realsrc == null || realtrg == null)
+	{ return; }
+	
     String srcname = realsrc.getName(); 
     String trgname = realtrg.getName(); 
 

KM3Editor.java

@@ -14,7 +14,7 @@
 import javax.swing.text.*;
 import javax.swing.event.*;
 
-/* K. Lano 2010-2021
+/* K. Lano 2010-2022
    
   Adapted from Oracle example of JTextPane
 
@@ -102,7 +102,7 @@ public KM3Editor(UCDArea parent, Vector ents, Vector ucs)
         JScrollPane scrollPane = new JScrollPane(textPane);
         scrollPane.setPreferredSize(new Dimension(100, 300));
 
-        messageArea = new JTextArea(10, 50);
+        messageArea = new JTextArea(20, 35);
         messageArea.setEditable(false);
         JScrollPane scrollPaneForLog = new JScrollPane(messageArea);
 

ModelMatching.java

@@ -153,6 +153,8 @@ public String toString()
     return res; 
   }  
 
+
+
   public String toCSTL(CGSpec cg)
   { String res = "\n"; 
     /* for (int i = 0; i < helpers.size(); i++) 
@@ -167,9 +169,16 @@ public String toCSTL(CGSpec cg)
       usedFunctions.addAll(em.usesCSTLfunctions()); 
     } 
 
+	
+    for (int i = 0; i < typematches.size(); i++) 
+    { TypeMatching tm = (TypeMatching) typematches.get(i);
+      if (usedFunctions.contains(tm.getName())) 
+      { usedFunctions.addAll(tm.usesCSTLfunctions()); } 
+    } // *only* include them if used in some rule. 
+
     System.out.println(">>> Used functions are: " + 
                        usedFunctions); 
-	
+
     for (int i = 0; i < typematches.size(); i++) 
     { TypeMatching tm = (TypeMatching) typematches.get(i);
       if (usedFunctions.contains(tm.getName()))