Added ->selectElements for Python np

Author: kevinlano

ATLFileFilter.class

@@ -897,6 +897,30 @@ else if (objectRef != null)
     return res; 
   }
 
+  public Expression transformPythonSelectExpressions()
+  { BasicExpression res = (BasicExpression) clone();
+    if (arrayIndex != null) 
+    { res.arrayIndex = 
+        arrayIndex.transformPythonSelectExpressions(); 
+    }
+
+    if (parameters != null) 
+    { res.parameters = new Vector(); 
+      for (int i = 0; i < parameters.size(); i++) 
+      { if (parameters.get(i) instanceof Expression)
+	    { Expression par = (Expression) parameters.get(i); 
+          Expression pclone = 
+             par.transformPythonSelectExpressions(); 
+          res.parameters.add(pclone); 
+        }
+        else 
+        { res.parameters.add(parameters.get(i)); }
+      } 
+    } 
+
+    return res; 
+  }
+
   public boolean containsSubexpression(Expression expr) 
   { if (arrayIndex != null) 
     { if (arrayIndex.containsSubexpression(expr))

BasicExpression.class

@@ -291,6 +291,33 @@ public Expression determinate()
     // return new BasicExpression("false",0);
   }
 
+  public Expression transformPythonSelectExpressions()
+  { 
+  //   s->selectRows(P) is transformed to 
+  //   s->select( $x | P[$x/s] ) 
+  //   s->restrict(P) for Sequence s is transformed to 
+  //   s->select( _x | P[_x/s] )
+  //   but actually nested.
+
+     if ("->restrict".equals(operator) && left.isSequence())
+     { String fvar = left + ""; 
+       Expression avar = 
+         BasicExpression.newVariableBasicExpression("$x"); 
+       Expression newright = 
+         right.substituteEq(fvar, avar); 
+       Expression newleft =
+         new BinaryExpression(":", avar, left); 
+       return new BinaryExpression("|", 
+                                   newleft, newright); 
+     } 
+ 
+     BinaryExpression res = (BinaryExpression) clone(); 
+     res.left = left.transformPythonSelectExpressions(); 
+     res.right = right.transformPythonSelectExpressions(); 
+     return res; 
+  } 
+
+
   public Expression firstConjunct()
   { if ("&".equals(operator))
     { return left.firstConjunct(); } 
@@ -3677,7 +3704,7 @@ public int typeCheck(Vector sms)
     else if (operator.equals("&") || operator.equals("or"))
     { return typeCheckAnd(sms); }
     else 
-    { System.out.println("Unexpected operator: " + operator);
+    { System.out.println("!! ERROR: Unexpected operator: " + operator);
       modality = ERROR; 
       return ERROR; 
     }
@@ -3731,6 +3758,16 @@ public boolean typeInference(final Vector types,
       return true; 
     }
 
+    if ("->restrict".equals(operator) && left.isSequence())
+    { JOptionPane.showInputDialog("Converting Python expression " + this); 
+      BinaryExpression pyexpr = 
+        (BinaryExpression) transformPythonSelectExpressions();
+      operator = pyexpr.operator; 
+      left = pyexpr.left; 
+      right = pyexpr.right;
+      return true;   
+    } 
+
     if (operator.equals("->exists") || 
         operator.equals("->exists1") ||
         "->existsLC".equals(operator) || 
@@ -5122,6 +5159,16 @@ public boolean typeCheck(final Vector types,
       return true; 
     }
 
+    if ("->restrict".equals(operator) && left.isSequence())
+    { BinaryExpression pyexpr = 
+        (BinaryExpression) transformPythonSelectExpressions();
+      JOptionPane.showInputDialog("Converting Python expression " + this + " to " + pyexpr); 
+      operator = pyexpr.operator; 
+      left = pyexpr.left; 
+      right = pyexpr.right;  
+      return true; 
+    } 
+
     if (operator.equals("->iterate") && 
         iteratorVariable != null && 
         accumulator != null)

BasicExpression.java

@@ -713,20 +713,20 @@ public void nospacelexicalanalysis(String str)
     { char c = str.charAt(i); 
       if (in == INUNKNOWN) 
       { if (isSymbolCharacter(c))
-        { sb = new StringBuffer();     // start new buffer for the symbol
+        { sb = new StringBuffer();  // new buffer for symbol
           lexicals.addElement(sb);  
           in = INSYMBOL; 
           sb.append(c); 
           previous = c; 
         }
         else if (isBasicExpCharacter(c))
-        { sb = new StringBuffer();     // start new buffer for the expression
+        { sb = new StringBuffer();  // new buffer for expression
           lexicals.addElement(sb);  
           in = INBASICEXP; 
           sb.append(c); 
         }           
         else if (isStringDelimiter(c))
-        { sb = new StringBuffer();     // start new buffer for the string
+        { sb = new StringBuffer();  // new buffer for the string
           lexicals.addElement(sb);  
           in = INSTRING; 
           sb.append('"'); 
@@ -742,18 +742,19 @@ else if (c == ' ' || c == '\n' || c == '\t' || c == '\r')
             in = INBASICEXP; 
           } 
           else
-          { System.err.println("Unrecognised literal: " + c); } 
+          { System.err.println("!! Unrecognised UML/OCL token: " + c); } 
         }
       } 
       else if (in == INBASICEXP)
-      { if (isBasicExpCharacter(c) || c == '"')  // Why allow " in a basic exp???
-        { sb.append(c); }              // carry on adding to current basic exp
+      { if (isBasicExpCharacter(c) || 
+            c == '"')           // Why allow " in a basic exp???
+        { sb.append(c); }       // carry on adding to current basic exp
         else if (c == '_') 
         { // System.out.println("Metavariable symbol: " + c); 
           sb.append(c); 
         } 
         else if (isSymbolCharacter(c))
-        { sb = new StringBuffer();     // start new buffer for the symbol
+        { sb = new StringBuffer();     // new buffer for symbol
           lexicals.addElement(sb);  
           in = INSYMBOL; 
           sb.append(c); 
@@ -765,27 +766,27 @@ else if (c == ' ' || c == '\n' || c == '\t' || c == '\r')
         { sb = new StringBuffer();     // unrecognised lexical
           lexicals.addElement(sb);  
           in = INUNKNOWN; 
-          System.err.println("Unrecognised literal in expression: " + c); 
+          System.err.println("!! Unrecognised token in expression: " + c); 
           sb.append(c); 
         }
       }
       else if (in == INSYMBOL)
       { if (isStringDelimiter(c))
-        { sb = new StringBuffer();     // start new buffer for the string
+        { sb = new StringBuffer();  // new buffer for the string
           lexicals.addElement(sb);  
           in = INSTRING; 
           sb.append('"'); 
         }
         else if (c == '(' || c == ')')
-        { sb = new StringBuffer();     // start new buffer for the new symbol
+        { sb = new StringBuffer();  // new buffer for new symbol
           lexicals.addElement(sb);  
           in = INSYMBOL; 
           previous = c; 
           sb.append(c); 
         }
         else if (c == '_') 
         { // System.out.println("Metavariable symbol: " + c); 
-          sb = new StringBuffer();     // start new buffer for the string
+          sb = new StringBuffer();  // new buffer for the string
           lexicals.addElement(sb);  
           in = INBASICEXP; 
           sb.append(c); 
@@ -1091,6 +1092,50 @@ else if (c == ' ' || c == '\n' ||
     }
   }
 
+  public void filterLexicals()
+  { // removes invalid sequences such as ; ; and ; )
+
+    Vector newlexicals = new Vector(); 
+    boolean previousSemi = false; // last token was ';'
+    StringBuffer semi = new StringBuffer(); 
+    semi.append(";"); 
+
+    for (int i = 0; i < lexicals.size(); i++) 
+    { StringBuffer sb = (StringBuffer) lexicals.get(i); 
+      String ss = sb + ""; 
+      if (";".equals(ss))
+      { if (previousSemi) { } // skip the token
+        else 
+        { previousSemi = true; } 
+      } 
+      else if (")".equals(ss))
+      { if (previousSemi) 
+        { previousSemi = false; 
+          newlexicals.add(sb); 
+        } 
+        else 
+        { newlexicals.add(sb); } 
+      } 
+      else if ("else".equals(ss))
+      { if (previousSemi) 
+        { previousSemi = false; 
+          newlexicals.add(sb); 
+        } 
+        else 
+        { newlexicals.add(sb); } 
+      } 
+      else if (previousSemi)
+      { newlexicals.add(semi); 
+        previousSemi = false; 
+        newlexicals.add(sb); 
+      } 
+      else 
+      { newlexicals.add(sb); } 
+    } 
+
+    lexicals = newlexicals; 
+  }
+
   public void nospacelexicalanalysisAST(String str) 
   { int in = INUNKNOWN; 
     char previous = ' '; 
@@ -2771,6 +2816,13 @@ public BinaryExpression parse_implies_expression(int bcount, int pstart,
     } 
   }
 
+
+  public void showLexicals()
+  { int sze = lexicals.size(); 
+    String lexs = showLexicals(0,sze-1); 
+    System.out.println(lexs); 
+  } 
+
   public String showLexicals(int st, int en)
   { String res = ""; 
     for (int i = st; i <= en; i++) 
@@ -3408,10 +3460,19 @@ else if (i + 3 <= pend) // && "(".equals(lexicals.get(i+2) + "") &&
         { // System.out.println(">> Trying to parse at " + ss2); 
           Expression ee1 = parse_expression(bc+1,i+3,pend-1,entities,types); 
           if (ee1 == null) { continue; } 
-          Expression ee2 = parse_factor_expression(bc,pstart,i-1,entities,types); 
+
+          Expression ee2 = 
+            parse_factor_expression(bc,pstart,i-1,
+                                    entities,types); 
+
           if (ee2 == null) { continue; }
+
           if ("selectRows".equals(ss2))
-          { // convert it
+          { // convert it to 
+            // MathLib.dataTableFromRows(
+            //   MathLib.rowsOfDataTable(ee2)->select(
+            //     $row | ee1[$row/ee2] ) )
+            
             BasicExpression realarg = 
               BasicExpression.newStaticCallBasicExpression(
                  "rowsOfDataTable", "MathLib", ee2);
@@ -3429,8 +3490,32 @@ else if (i + 3 <= pend) // && "(".equals(lexicals.get(i+2) + "") &&
                  "dataTableFromRows", "MathLib", be); 
             return res; 
           }  
+
+          if ("selectElements".equals(ss2))
+          { // convert it to 
+            // MatrixLib.selectElements(ee2, 
+            //    lambda $x : double in ee1[$x/ee2])
+            
+            BasicExpression svar =
+              BasicExpression.newVariableBasicExpression("$x");
+            svar.isEvent = false;  
+            Type dtype = new Type("double", null); 
+            Expression subee1 = 
+                ee1.substituteEq("" + ee2, svar);  
+            Expression func = 
+              UnaryExpression.newLambdaUnaryExpression(
+                       "$x", dtype, subee1); 
+            Vector pars = new Vector(); 
+            pars.add(ee2); 
+            pars.add(func); 
+            BasicExpression res = 
+              BasicExpression.newStaticCallBasicExpression(
+                 "selectElements", "MatrixLib", pars); 
+            return res; 
+          }  
 
-          BinaryExpression be = new BinaryExpression(ss+ss2,ee2,ee1); 
+          BinaryExpression be = 
+            new BinaryExpression(ss+ss2,ee2,ee1); 
           // System.out.println(">>> Parsed binary -> expression: " + be); 
           return be; 
         } 
@@ -3648,7 +3733,8 @@ public Expression parse_basic_expression(int bc,
       // return null; 
     }       
 
-    if (pstart < pend && "]".equals(lexicals.get(pend) + "") && 
+    if (pstart < pend && 
+        "]".equals(lexicals.get(pend) + "") && 
         "[".equals(lexicals.get(pstart+1) + ""))
     { // iden[indexes]
 
@@ -11257,7 +11343,7 @@ public NLPSentence parseRoot(int st, int en)
 	{ String tag = "" + lexicals.get(st+1); 
 	  NLPSentence sent = parseSentence(st+2,en-1); 
 	  if (sent == null) 
-	  { System.err.println("!! Not a sentence: " + showLexicals(st+2,en-1)); 
+	  { System.err.println("!! Error: Not a sentence: " + showLexicals(st+2,en-1)); 
 	    return null; 
        }
        return sent; 
@@ -11299,10 +11385,36 @@ public static void main(String[] args)
 
     // c.nospacelexicalanalysis("Map{ \"Name\" |-> Sequence{\"Braund, Mr. Owen Harris\"}->union(Sequence{\"Allen, Mr. William Henry\"}->union(Sequence{ \"Bonnell, Miss. Elizabeth\" })) }->union(Map{ \"Age\" |-> Sequence{22}->union(Sequence{35}->union(Sequence{ 58 })) }->union(Map{ \"Sex\" |-> Sequence{\"male\"}->union(Sequence{\"male\"}->union(Sequence{ \"female\" })) }->union(Map{ \"Fare\" |-> Sequence{102.0}->union(Sequence{99.0}->union(Sequence{ 250.0 })) }) ) )"); 
 
-     c.nospacelexicalanalysis("table->selectRows(table->at(p) > v)");  
-    Expression zz = c.parseExpression(); 
+  
+
+ c.nospacelexicalanalysis("table->restrict(table > v)");  
+ BinaryExpression zz = (BinaryExpression) c.parseExpression(); 
+
+ Expression zleft = zz.getLeft(); 
+ zleft.setType(new Type("Sequence", null)); 
+
+ System.out.println(zz);
+
+ Expression yy = zz.transformPythonSelectExpressions(); 
+
+ System.out.println(yy);
+ 
+ /* 
+    c.nospacelexicalanalysis("execute (OclFile[\"system.in\"]).println(x)"); 
 
-    System.out.println(zz); 
+    Statement stat = c.parseStatement(); 
+
+    System.out.println(stat); 
+
+    c.showLexicals(); */ 
+
+    // c.filterLexicals(); 
+
+    // c.showLexicals(); 
+
+    // stat = c.parseStatement(); 
+
+    // System.out.println(stat); 
 
     /* zz.typeCheck(new Vector(), new Vector(), new Vector(), new Vector()); 
 

BinaryExpression.class

@@ -54,6 +54,13 @@ public Expression getElse()
   public Vector getParameters() 
   { return new Vector(); } 
 
+  public Expression transformPythonSelectExpressions()
+  { Expression tqf = test.transformPythonSelectExpressions();
+    Expression lqf = ifExp.transformPythonSelectExpressions();
+    Expression rqf = elseExp.transformPythonSelectExpressions();
+    return new ConditionalExpression(tqf, lqf, rqf); 
+  } 
+
   public String queryForm(java.util.Map env, boolean local)
   { String tqf = test.queryForm(env, local);
     String lqf = ifExp.queryForm(env, local);