COBOL invariants and refactoring

Author: kevinlano

ASTCompositeTerm.java

@@ -40328,7 +40328,7 @@ public Vector cobolDataDefinitions(java.util.Map context, Vector invs)
       int levelNumber = 0; 
       String fieldName = ""; 
 
-      if ("77".equals(level)) 
+      if ("77".equals(level) || "66".equals(level)) 
       { context.put("container", null); 
         return res; 
       } 
@@ -40407,7 +40407,7 @@ public Vector cobolDataDefinitions(java.util.Map context, Vector invs)
             String progname = 
                (String) context.get("programName"); 
 
-            if (multiplicity >= 1 && contMult == 1)
+            if (multiplicity == 1 && contMult == 1)
             { // fieldName = owner.subrange(startPos,endPos)
 
               JOptionPane.showMessageDialog(null, progname + ":: " + fieldName + 
@@ -40428,8 +40428,42 @@ public Vector cobolDataDefinitions(java.util.Map context, Vector invs)
               BasicExpression substr = 
                 BasicExpression.newFunctionBasicExpression(
                   "subrange", owner, spars); 
+              Expression convertedExpr = 
+                Type.typeConversionFromString(
+                                          substr,typ); 
               BinaryExpression inv = 
-                new BinaryExpression("=", attr, substr);
+                new BinaryExpression("=", attr, 
+                                     convertedExpr);
+              Constraint cons = 
+                Constraint.getConstraint(inv); 
+              cons.ownerName = progname;  
+              invs.add(cons);
+            } 
+            else if (multiplicity > 1 && contMult == 1)
+            { // fieldName = owner.subrange(startPos,endPos)
+              int fwdth = wdth/multiplicity; 
+              JOptionPane.showMessageDialog(null, progname + ":: " + fieldName + 
+                 "[i] = " + ownername + 
+                 ".subrange(" + startPos + " + (i-1)*" + fwdth + ",  i*" + fwdth + ")", 
+                          "", 
+                          JOptionPane.INFORMATION_MESSAGE);
+              BasicExpression owner = 
+                BasicExpression.newAttributeBasicExpression(
+                                   ownername, stringType);  
+              BasicExpression attr = 
+                BasicExpression.newAttributeBasicExpression(
+                                   fieldName, 
+                                   typ);
+              Vector spars = new Vector(); 
+              spars.add(new BasicExpression(startPos)); 
+              spars.add(new BasicExpression(endPos));  
+              BasicExpression substr = 
+                BasicExpression.newFunctionBasicExpression(
+                  "subrange", owner, spars); 
+              BinaryExpression inv = 
+                new BinaryExpression("=", 
+                   new UnaryExpression("->sum", attr), 
+                                       substr);
               Constraint cons = 
                 Constraint.getConstraint(inv); 
               cons.ownerName = progname;  
@@ -40469,8 +40503,26 @@ else if (multiplicity == 1 & contMult > 1)
               BasicExpression substr = 
                 BasicExpression.newFunctionBasicExpression(
                   "subrange", owner, spars); 
+              Expression convertedExpr = 
+                Type.typeConversionFromString(
+                                          substr,typ); 
               BinaryExpression inv = 
-                new BinaryExpression("=", attr, substr);
+                new BinaryExpression("=", attr, 
+                                     convertedExpr);
+              Vector ipars = new Vector(); 
+              ipars.add(new BasicExpression(1)); 
+              ipars.add(
+                new BasicExpression(contMult)); 
+
+              BasicExpression dmn = 
+                 BasicExpression.newFunctionBasicExpression(
+                     "subrange", "Integer", ipars);
+              BinaryExpression indmn = 
+                  new BinaryExpression(":", indx, dmn);       
+      
+              inv = 
+                new BinaryExpression("!", indmn, inv);
+
               Constraint cons = 
                 Constraint.getConstraint(inv); 
               cons.ownerName = progname;  

AgileUMLApp.java

@@ -86,7 +86,7 @@ public void init()
       SimpleAttributeSet[] attrs = initAttributes(4);
 
       try {
-            doc.insertString(0, "class Person { String name; int age; }", attrs[1]);
+            doc.insertString(0, "struct Person { char* name; int age; };\n\n struct Person* pp = malloc(sizeof(struct Person));\n", attrs[1]);
           }
           catch (BadLocationException ble) {
             System.err.println("!! Couldn't insert code text.");
@@ -185,6 +185,10 @@ protected JMenu createTranslationMenu()
         // checkAction.setMnemonic(KeyEvent.VK_K);
       menu.add(toCSAction); 
 
+      javax.swing.Action toCPPAction = new Translate2CPPAction(); 
+        // checkAction.setMnemonic(KeyEvent.VK_K);
+      menu.add(toCPPAction); 
+
       return menu; 
    } 
 
@@ -608,4 +612,27 @@ public void actionPerformed(ActionEvent e)
       messageArea.setText(res);
     } 
   }
+
+  class Translate2CPPAction extends javax.swing.AbstractAction
+  { public Translate2CPPAction()
+    { super("Translate to C++"); }
+
+    public void actionPerformed(ActionEvent e)
+    { StringWriter sw = new StringWriter(); 
+      PrintWriter out = new PrintWriter(sw);   
+      
+      StringWriter sw1 = new StringWriter(); 
+      PrintWriter out1 = new PrintWriter(sw1);   
+      
+      for (int i = 0; i < entities.size(); i++) 
+      { Entity ent = (Entity) entities.get(i);
+        if (ent.isExternal() || ent.isComponent()) 
+        { continue; }  
+        ent.generateCPP(entities,types,out,out1);     
+      } 
+      String res = sw.toString(); 
+      String res1 = sw1.toString(); 
+      messageArea.setText(res + "\n\n" + res1);
+    } 
+  }
 }

BasicExpression.java

@@ -4326,7 +4326,7 @@ else if (t.getName().equals(objectRef + ""))
         arrayType = type;  
         adjustTypeForArrayIndex(att); 
 
-        System.out.println("**>> Adjusted type of " + this + " is " + type + "(" + elementType + ")");  
+        // System.out.println("**>> Adjusted type of " + this + " is " + type + "(" + elementType + ")");  
 
         elementType = Type.correctElementType(type,elementType,types,entities); 
         att.setElementType(elementType); 

BehaviouralFeature.java

@@ -10008,6 +10008,153 @@ private static Type getElementType(BinaryExpression be)
   }
 
   // Check completeness: if post updates v but not w when w data depends on v
+
+  public Statement selfCalls2Loops(Statement act)
+  { // if there are simple calls to itself, replace by 
+    // continue/break in a loop. 
+
+    // ... ; self.nme() ; *** 
+    // is  while true do (...)
+
+    // ... ; if E then self.nme() else skip ; ***
+    // is   while true do (... ; if E then continue else 
+    //                     skip) ; ***
+
+    Statement oldact = act; 
+    if (oldact == null) 
+    { oldact = activity; } 
+    if (oldact == null) 
+    { return act; } 
+
+    String nme = getName(); 
+
+    Vector contexts = new Vector(); 
+    Vector remainders = new Vector(); 
+
+    Vector opcalls = Statement.getOperationCallsContexts(
+                              nme,oldact,contexts,remainders); 
+
+    System.out.println(opcalls); 
+    System.out.println(contexts); 
+    System.out.println(remainders); 
+
+    int selfcalls = 0; 
+    Vector branches = new Vector(); 
+    Vector rems = new Vector(); 
+
+    for (int i = 0; i < opcalls.size(); i++) 
+    { InvocationStatement opcall = (InvocationStatement) opcalls.get(i); 
+      Vector cntx = (Vector) contexts.get(i); 
+      Vector rem = (Vector) remainders.get(i); 
+      Expression expr = opcall.getCallExp();  
+
+      if (("self." + nme + "()").equals(expr + ""))
+      { selfcalls++; 
+        branches.add(cntx); 
+        rems.add(rem); 
+        // System.out.println(cntx);
+      } 
+    } 
+
+    System.out.println(">>> There are " + selfcalls + " calls of self." + nme + "() in " + oldact); 
+    System.out.println(">>> Branches to calls: " + branches); 
+    System.out.println(">>> Remainders: " + rems); 
+
+    if (selfcalls <= 0) 
+    { return act; } 
+
+    if (selfcalls == 1) 
+    { // simple case. The call is the last item in 
+      // branches[0]. Either a direct call or conditional.
+
+      SequenceStatement loopBody = new SequenceStatement(); 
+
+      Vector branch = (Vector) branches.get(0); 
+      int blen = branch.size(); 
+      for (int i = 0; i < blen - 1; i++) 
+      { Statement sx = (Statement) branch.get(i); 
+        loopBody.addStatement(sx); 
+      } 
+
+      Vector remainder = (Vector) rems.get(0); 
+      Object selfcall = branch.get(blen-1); 
+
+      if (selfcall instanceof Statement)      
+      { 
+        WhileStatement ws = new WhileStatement(
+                                 new BasicExpression(true),
+                                 loopBody); 
+
+        System.out.println(">>> Restructured code: " + ws); 
+        System.out.println(); 
+
+        return ws;
+      } 
+      else if (selfcall instanceof Vector)
+      { // conditional cases
+        Vector selfcallv = (Vector) selfcall; 
+        if (selfcallv.size() == 4 && 
+            "if".equals(selfcallv.get(0) + ""))      
+        { Expression tst = (Expression) selfcallv.get(1);
+          Vector sts = (Vector) selfcallv.get(2); 
+          Statement cde = 
+            Statement.replaceSelfCallByContinue(nme,sts);
+          Statement elsePart = (Statement) selfcallv.get(3); 
+  
+          Statement newelse = 
+            SequenceStatement.combineSequenceStatements(
+                            elsePart,new BreakStatement()); 
+          ConditionalStatement cs = 
+            new ConditionalStatement(tst,
+                cde, 
+                newelse); 
+          loopBody.addStatement(cs); 
+
+          WhileStatement ws = new WhileStatement(
+                                 new BasicExpression(true),
+                                 loopBody); 
+          SequenceStatement res = new SequenceStatement(); 
+          res.addStatement(ws); 
+          res.addStatements(remainder); 
+
+          System.out.println(">>> Restructured code: " + res); 
+          System.out.println(); 
+
+          return res;
+        } 
+        else if (selfcallv.size() == 4 && 
+                 "else".equals(selfcallv.get(0) + ""))      
+        { Expression tst = (Expression) selfcallv.get(1);
+          Statement ifpart = (Statement) selfcallv.get(2); 
+
+          Vector sts = (Vector) selfcallv.get(3); 
+          Statement cde = 
+            Statement.replaceSelfCallByContinue(nme,sts);  
+          Statement newif = 
+            SequenceStatement.combineSequenceStatements(
+                            ifpart,new BreakStatement()); 
+          ConditionalStatement cs = 
+            new ConditionalStatement(tst, 
+                newif, cde); 
+          loopBody.addStatement(cs);
+ 
+          WhileStatement ws = new WhileStatement(
+                                 new BasicExpression(true),
+                                 loopBody); 
+          SequenceStatement res = new SequenceStatement(); 
+          res.addStatement(ws); 
+          res.addStatements(remainder); 
+
+          System.out.println(">>> Restructured code: " + res); 
+          System.out.println(); 
+
+          return res;
+        } 
+      } 
+    } 
+
+    return act;  
+  } 
 }
 
 

Compiler2.java

@@ -5595,6 +5595,11 @@ public static String isKeywordOrPart(String st, String[] mess)
       { mess[0] = "Use case extension, eg., extendedBy errorCase;"; 
         return "extendedBy"; 
       }
+
+      if ("execute".startsWith(st))
+      { mess[0] = "Execute expression as statement. Eg., execute (x->display())"; 
+        return "execute"; 
+      }
     }