Updated Java8 code generator

Author: kevinlano

Attribute.java

@@ -317,8 +317,9 @@ public boolean typeCheck(Vector types, Vector entities)
       initialExpression.typeCheck(types,entities,cntx,env); 
       if (type == null) 
       { type = initialExpression.type; 
-        elementType = initialExpression.elementType; 
+        elementType = initialExpression.elementType;  
       } 
+      System.out.println(">> Type of " + initialExpression + " is " + type + "(" + elementType + ")");
     } 
 
     if (type == null) 
@@ -329,10 +330,14 @@ public boolean typeCheck(Vector types, Vector entities)
     String tname = type + ""; 
     Type t = Type.getTypeFor(tname, types, entities); 
     if (t == null) 
-    { type = new Type("OclAny", null); 
+    { System.err.println("!! Warning: null type for attribute " + name); 
+      type = new Type("OclAny", null); 
       return true; 
     } 
     type = t; 
+    if (initialExpression != null && 
+        initialExpression.type == null) 
+    { initialExpression.type = type; } 
     return true; 
   } 
 
@@ -2021,17 +2026,36 @@ public String initialiserJava7()
     { return "this." + nme + " = " + nme + "x;"; }
     if (isFinal()) { return ""; }
 
+    
+    
+
     if (initialExpression != null) 
-    { java.util.Map env = new java.util.HashMap();
+    { System.out.println(">> Initialiser of " + this + " is " + 
+          initialExpression + " " + initialExpression.type); 
+      if ("Set{}".equals(initialExpression + ""))
+      { initialExpression.setElementType(elementType); } 
+      else if ("Sequence{}".equals(initialExpression + ""))
+      { initialExpression.setElementType(elementType); } 
+      else if ("Map{}".equals(initialExpression + ""))
+      { initialExpression.setType(type); 
+        initialExpression.setElementType(type.elementType); 
+      } 
+    
+      java.util.Map env = new java.util.HashMap();
       if (entity != null) 
       { env.put(entity.getName(), "this"); } 
       return "this." + nme + " = " + initialExpression.queryFormJava7(env,true) + ";"; 
     } 
 
 
     // if (initialValue != null && !initialValue.equals(""))
-    // { return "this." + nme + " = " + initialValue + ";"; } 
+    // { return "this." + nme + " = " + initialValue + ";"; }
+ 
     String def = type.getDefaultJava7();
+
+    System.out.println(">> Initialiser of " + this + " is " + 
+                       def); 
+
     if (def == null) { return ""; }
     return "this." + nme + " = " + def + ";";
   } 

Compiler2.java

@@ -1223,6 +1223,7 @@ else if (t2 == null)
           } 
         }
       } 
+
       if (tt == null) 
       { System.err.println("!!ERROR!!: Invalid map/function type, it must have 2 type arguments: " + showLexicals(st,en)); 
         return null; 
@@ -3084,14 +3085,15 @@ public Expression parse_basic_expression(int bc, int pstart, int pend, Vector en
 
     if (pstart < pend && "]".equals(lexicals.get(pend) + "") && 
         "[".equals(lexicals.get(pstart+1) + ""))
-    { String ss = lexicals.elementAt(pstart).toString(); 
+    { // iden[indexes]
+
+      String ss = lexicals.elementAt(pstart).toString(); 
       BasicExpression ee = new BasicExpression(ss,0); 
       Expression op = ee.checkIfSetExpression(); 
       // Expression op = parse_basic_expression(bc,pstart,pstart); 
       Expression arg = parse_additive_expression(bc,pstart+2,pend-1,entities,types); 
       if (arg == null) 
-      { // System.err.println("ERROR: Invalid array argument: " + showLexicals(pstart+2,pend-1));
-        Vector args = parse_array_index_sequence(bc,pstart+2,pend-1,entities,types);  
+      { Vector args = parse_array_index_sequence(bc,pstart+2,pend-1,entities,types);  
         if (args != null) 
         { Expression opx = defineArrayIndex(op,args,entities,types); 
           System.out.println(">>> Array index sequence: " + args + " for " + opx); 
@@ -3108,19 +3110,30 @@ else if (op != null && op instanceof BasicExpression) // must be
     }       
 
     if (pstart < pend && "]".equals(lexicals.get(pend-1) + "") && 
-        "[".equals(lexicals.get(pstart+1) + ""))  // be[arrind].be2
-    { String tail = lexicals.get(pend) + ""; 
+        "[".equals(lexicals.get(pstart+1) + "") &&
+        (lexicals.get(pend) + "").charAt(0) == '.')  
+    { // be[inds].f
+
+      String tail = lexicals.get(pend) + ""; 
       if (tail.charAt(0) == '.')
       { tail = tail.substring(1,tail.length()); } 
+
       Expression op = parse_basic_expression(bc,pstart,pstart,entities,types); 
       Expression arg = parse_additive_expression(bc,pstart+2,pend-2,entities,types); 
       if (arg == null) 
       { // System.err.println("ERROR: Invalid array argument: " + showLexicals(pstart+2,pend-2)); 
+        /* Vector args = parse_array_index_sequence(bc,pstart+2,pend-2,entities,types);  
+        if (args != null) 
+        { Expression opx = defineArrayIndex(op,args,entities,types); 
+          System.out.println(">>> Array index sequence: " + args + " for " + opx); 
+          return opx; 
+        } */ 
       } 
       else if (op != null && op instanceof BasicExpression) // must be
       { BasicExpression beop = (BasicExpression) op;  
         beop.setArrayIndex(arg); 
-        BasicExpression te = // new BasicExpression(ss,0);   // (ss) surely?
+        BasicExpression te = 
+          // new BasicExpression(ss,0);   // (ss) surely?
                        new BasicExpression(tail,0); 
         Expression ef = te.checkIfSetExpression(); 
         if (ef != null && (ef instanceof BasicExpression)) 
@@ -3176,8 +3189,8 @@ else if (op != null && op instanceof BasicExpression) // must be
           if (ve != null)
           { BasicExpression beop = (BasicExpression) op;
             String tail = strs.substring(1,strs.length()); 
-			BasicExpression rees = new BasicExpression(tail, 0); 
-			rees.setObjectRef(beop);  
+            BasicExpression rees = new BasicExpression(tail, 0); 
+            rees.setObjectRef(beop);  
             rees.setIsEvent();
             rees.setParameters(ve);
             System.out.println("*** Parsed extended call expression " + rees);
@@ -3188,37 +3201,52 @@ else if (op != null && op instanceof BasicExpression) // must be
     }
   }
 
-  /*  if (pstart < pend &&  
-        "[".equals(lexicals.get(pstart+1) + ""))  // be[arrind].something
-    { for (int k = pstart + 2; k < pend; k++) 
-      { String kstring = lexicals.get(k) + ""; 
-        if ("]".equals(kstring))
-        { Expression op = parse_basic_expression(bc,pstart,pstart); 
-          Expression arg = parse_factor_expression(bc,pstart+2,k-1); 
+  if (pstart < pend &&  
+      "[".equals(lexicals.get(pstart+1) + "") && 
+      "]".equals(lexicals.get(pend-1) + "") && 
+      (lexicals.get(pend) + "").charAt(0) == '.') 
+    { // iden[ ... ].f  valid basic expression before .f
+
+      Expression op = parse_basic_expression(
+                      bc,pstart,pend-1,entities,types); 
+      String tail = lexicals.get(pend) + ""; 
+      if (tail.charAt(0) == '.')
+      { tail = tail.substring(1,tail.length()); } 
+    
+      if (op instanceof BasicExpression) // must be
+      { BasicExpression beop = (BasicExpression) op;  
+        BasicExpression rees = new BasicExpression(tail, 0); 
+        rees.setObjectRef(beop);  
+        System.out.println(">>> Parsed array 2 expression: " + rees);
+        return rees;  
+      }
+      // return null; 
+    }       
+
+  if (pstart + 1 < pend &&  
+      "]".equals(lexicals.get(pend) + "")) 
+    { // be [ ind ]  valid basic expression be
+
+      for (int k = pend-1; k >= pstart; k--)
+      { String lex = lexicals.get(k) + ""; 
+        if ("[".equals(lex))
+        { Expression op = parse_basic_expression(
+                       bc,pstart,k-1,entities,types); 
 
-          String tail = lexicals.get(k+1) + ""; 
-          if (tail.charAt(0) == '.')
-          { tail = tail.substring(1,tail.length()); } 
           if (op instanceof BasicExpression) // must be
           { BasicExpression beop = (BasicExpression) op;  
-            beop.setArrayIndex(arg); 
-            Expression te = parse_basic_expression(bc,k+1,pend); 
-            if (te != null)
-            { if (te instanceof BasicExpression)
-              { BasicExpression bte = (BasicExpression) te; 
-                bte.setData(tail);  
-                bte.setObjectRef(beop); 
-                System.out.println("Parsed array 2 expression: " + bte);
-                return bte;  
-              }
-              else 
-              { return null; } 
-            }        
-          } 
-        }
-      } 
-      return null; 
-    }   */     
+            Expression arg = parse_additive_expression(
+                         bc,k+1,pend-1,entities,types); 
+            if (arg != null && beop.arrayIndex == null)
+            { beop.setArrayIndex(arg); 
+              System.out.println(">>> Parsed array 3 expression: " + beop);
+              return beop;
+            } 
+          }
+        }  
+      }
+      // return null; 
+    }       
 
     if (pstart + 2 < pend)
     { for (int i = pstart + 1; i < pend; i++)
@@ -5043,10 +5071,6 @@ public static String isKeywordOrPart(String st, String[] mess)
       return "then"; 
     }
 
-    if ("else".startsWith(st)) 
-    { mess[0] = "else part of if-expression or if-statement"; 
-      return "else"; 
-    }
 
     if ("while".startsWith(st)) 
     { mess[0] = "Unbounded loop statement: while expr do statement\nCan only be used in an activity"; 
@@ -5136,6 +5160,13 @@ public static String isKeywordOrPart(String st, String[] mess)
       return "assert"; 
     }
 
+    if (st.length() > 2)
+    { if ("else".startsWith(st)) 
+      { mess[0] = "else part of if-expression or if-statement"; 
+        return "else"; 
+      }
+    } 
+
     if (st.length() > 3) 
     { if ("reference".startsWith(st)) 
       { mess[0] = "reference declaration, eg: reference name : Type;\nType is a class type or collection (of class element type)"; 
@@ -5235,6 +5266,18 @@ public static String isKeywordOrPart(String st, String[] mess)
         return "arg->reverse()"; 
       }
 
+      if ("->restrict".startsWith(st))
+      { mess[0] = "arg->restrict(keys) operator on maps.\n" + 
+          "Returns submap of arg: elements with key in keys"; 
+        return "arg->restrict(keys)"; 
+      }
+
+      if ("->antirestrict".startsWith(st))
+      { mess[0] = "arg->antirestrict(keys) operator on maps.\n" + 
+          "Returns submap of arg: elements with key not in keys"; 
+        return "arg->antirestrict(keys)"; 
+      }
+
       if ("->first".startsWith(st))
       { mess[0] = "arg->first() operator on non-empty strings, sequences\n" + 
           "Returns  arg->at(1)"; 
@@ -9724,7 +9767,7 @@ public static void main(String[] args)
     // Type xx = c.parseType(0,c.lexicals.size()-1,exs, new Vector()); 
 
     // c.nospacelexicalanalysis("arr[x][y]"); 
-    c.nospacelexicalanalysis("(OclFile.newOclFile(\"(text)\")).setReadOnly()");
+    c.nospacelexicalanalysis("Worksheets[Y].Range[X].Value");
     // c.nospacelexicalanalysis("(OclFile.newOclFile_Read(OclFile.newOclFile(s))).readObject()"); 
 
     // c.nospacelexicalanalysis("(MyString).subrange((MyString)->indexOf((MyString)->trim()))"); 

Entity.java

@@ -1455,27 +1455,37 @@ public void removeOperations(String nme)
   } 
 
   public void typeCheckAttributes(Vector types, Vector entities)
-  { for (int i = 0; i < attributes.size(); i++) 
+  { Vector localtypes = new Vector(); 
+    localtypes.addAll(types); 
+    localtypes.addAll(typeParameters); 
+    for (int i = 0; i < attributes.size(); i++) 
     { Attribute att = (Attribute) attributes.get(i); 
-      att.typeCheck(types,entities); 
+      // System.out.println(">> Type-checking " + att + " with " + localtypes + " " + entities); 
+      att.typeCheck(localtypes,entities); 
     } 
   } 
 
   public void typeCheckOps(Vector types, Vector entities)
-  { for (int i = 0; i < operations.size(); i++) 
+  { Vector localtypes = new Vector(); 
+    localtypes.addAll(types); 
+    localtypes.addAll(typeParameters); 
+    for (int i = 0; i < operations.size(); i++) 
     { BehaviouralFeature bf = (BehaviouralFeature) operations.get(i); 
-      bf.typeCheck(types,entities); 
+      bf.typeCheck(localtypes,entities); 
     } 
   } 
 
   public void typeCheckInvariants(Vector types, Vector entities)
   { Vector contexts = new Vector(); 
     contexts.add(this); 
     Vector vars = new Vector(); 
+    Vector localtypes = new Vector(); 
+    localtypes.addAll(types); 
+    localtypes.addAll(typeParameters); 
 
     for (int i = 0; i < invariants.size(); i++) 
     { Constraint inv = (Constraint) invariants.get(i); 
-      inv.typeCheck(types,entities,contexts,vars);
+      inv.typeCheck(localtypes,entities,contexts,vars);
     } 
   } 
 

Type.java

@@ -2878,7 +2878,12 @@ public String getDefaultJava7()
         { return "new ArrayList()"; } 
       } 
       if (nme.equals("Map"))
-      { if (elementType != null) 
+      { if (keyType != null && elementType != null) 
+        { String kt = keyType.typeWrapperJava7(); 
+          String et = elementType.typeWrapperJava7(); 
+          return "new HashMap<" + kt + "," + et + ">()"; 
+        } 
+        else if (elementType != null) 
         { return "new HashMap<String," + elementType.typeWrapperJava7() + ">()"; } 
         else 
         { return "new HashMap()"; }
@@ -3636,6 +3641,8 @@ public String getJava7()
     if (nme.equals("Map"))
     { if (keyType != null && elementType != null) 
       { return "HashMap<" + keyType.typeWrapperJava7() + ", " + elementType.typeWrapperJava7() + ">"; } 
+      else if (elementType != null) 
+      { return "HashMap<String, " + elementType.typeWrapperJava7() + ">"; } 
       else 
       { return "HashMap"; } 
 
@@ -3646,6 +3653,8 @@ public String getJava7()
     if (nme.equals("Function"))
     { if (keyType != null && elementType != null) 
       { return "Evaluation<" + keyType.typeWrapperJava7() + ", " + elementType.typeWrapperJava7() + ">"; } 
+      else if (elementType != null) 
+      { return "Evaluation<String, " + elementType.typeWrapperJava7() + ">"; } 
       else 
       { return "Evaluation<String,Object>"; } 
     }