Improved energyflaw analysis

Author: kevinlano

BasicExpression.java

@@ -19262,6 +19262,17 @@ else if (pars.size() == 1)
       } 
     } 
 
+    if ("excludingAt".equals(data) &&
+        arrayIndex == null && 
+        pars != null)
+    { if (pars.size() == 1)
+      { Expression res = 
+          Expression.simplifyExcludingAt(objR, 
+                             (Expression) pars.get(0)); 
+        return res;
+      } 
+    } 
+
     if ("insertAt".equals(data) &&
         arrayIndex == null && 
         pars != null)
@@ -19286,7 +19297,30 @@ else if (pars.size() == 1)
       } 
     } 
 
-    // excludingSubrange, setSubrange, + regex ops
+    if ("excludingSubrange".equals(data) &&
+        arrayIndex == null && 
+        pars != null)
+    { if (pars.size() == 2)
+      { Expression res = 
+          Expression.simplifyExcludingSubrange(objR, 
+                             (Expression) pars.get(0), 
+                             (Expression) pars.get(1)); 
+        return res;
+      } 
+    } 
+
+    if ("setSubrange".equals(data) &&
+        arrayIndex == null && 
+        pars != null)
+    { if (pars.size() == 3)
+      { Expression res = 
+          Expression.simplifySetSubrange(objR, 
+                             (Expression) pars.get(0), 
+                             (Expression) pars.get(1), 
+                             (Expression) pars.get(2)); 
+        return res;
+      } 
+    } 
 
     BasicExpression res = (BasicExpression) clone(); 
     res.objectRef = objR; 
@@ -19417,6 +19451,7 @@ public java.util.Map collectionOperatorUses(int level,
         data.equals("insertInto") ||
         data.equals("subrange") ||
         data.equals("setAt") ||
+        data.equals("excludingAt") ||
         data.equals("excludingSubrange") ||
         data.equals("setSubrange"))
     { Vector opers = (Vector) res.get(level); 
@@ -19483,6 +19518,14 @@ public java.util.Map collectionOperatorUses(int level,
                             Map uses, Vector messages)
   { //  level |-> [x.setAt(i,y), etc]
 
+    if (parameters != null) 
+    { for (int i = 0; i < parameters.size(); i++) 
+      { Expression par = (Expression) parameters.get(i); 
+        par.collectionOperatorUses(level, res, vars, 
+                                   uses, messages); 
+      } 
+    } 
+
     /* JOptionPane.showInputDialog("Collection uses of " + this + " " + level + " " + objectRef + " " + parameters);  */ 
 
     if (objectRef != null || parameters != null ||
@@ -19491,11 +19534,7 @@ public java.util.Map collectionOperatorUses(int level,
       Vector vuses = variablesUsedIn(vars);
       int syncom = syntacticComplexity(); 
 
-      /* JOptionPane.showInputDialog("Complexity of " + this + 
-          " = " + syncom + " uses = " + vuses + 
-          " level: " + level + " sideeffect: " + sideeffect); */ 
-
-      if (syncom >= TestParameters.energyCloneSizeLimit &&
+      if (syncom > TestParameters.energyCloneSizeLimit &&
           level > 1 && vuses.size() == 0 && !sideeffect)
       { messages.add("!!! Warning (LCE): The expression " + this + " may be independent of the iterator variables " + vars + "\n" + 
           "!!!  Use Extract local variable to optimise.");
@@ -19506,12 +19545,24 @@ public java.util.Map collectionOperatorUses(int level,
         int oescount = (int) uses.get("LCE"); 
         uses.set("LCE", oescount+1);
       }
+      else if (syncom > 1 && 
+          level > 1 && vuses.size() == 0 && !sideeffect)
+      { messages.add("! Warning (OEW): The expression " + this + " may be independent of the iterator variables " + vars + "\n" + 
+          "!  Use Extract local variable to optimise.");
+        refactorELV = true;  
+        int yScore = (int) uses.get("yellow"); 
+        uses.set("yellow", yScore+1); 
+        messages.add(""); 
+        int oewcount = (int) uses.get("OEW"); 
+        uses.set("OEW", oewcount+1);
+      }
     } // Any non-trivial basic expression
 
     if (data.equals("insertAt") || 
         data.equals("insertInto") ||
         data.equals("subrange") ||
         data.equals("setAt") ||
+        data.equals("excludingAt") ||
         data.equals("excludingSubrange") ||
         data.equals("setSubrange"))
     { Vector opers = (Vector) res.get(level); 

BehaviouralFeature.java

@@ -5043,8 +5043,64 @@ public void collectionOperatorUses(int level,
     } 
 
     if (activity != null) 
-    { activity.collectionOperatorUses(level, res, vars, 
-                                      flaws, messages); 
+    { java.util.Map localres = new java.util.HashMap(); 
+
+      activity.collectionOperatorUses(level, localres, vars, 
+                                      flaws, messages);
+      
+      java.util.Set keys = localres.keySet(); 
+      for (Object k : keys)
+      { java.util.Set linearOpCollections = 
+                            new java.util.HashSet(); 
+
+        Vector opers = (Vector) localres.get(k); 
+        for (int i = 0; i < opers.size(); i++) 
+        { Expression oper = (Expression) opers.get(i);
+ 
+          if (oper instanceof UnaryExpression) 
+          { UnaryExpression ue = (UnaryExpression) oper; 
+            Expression arg = ue.getArgument(); 
+            if (arg instanceof BasicExpression && 
+                Expression.linearOperators.contains(
+                                   ue.getOperator()))
+            { arg.setBrackets(false); 
+              if (linearOpCollections.contains("" + arg))
+              { messages.add("! (OEW): multiple linear iterations over collection " + 
+                  arg + " in " + this + 
+                  ": Can be optimised using a single iteration.\n");
+                int rScore = (int) flaws.get("yellow"); 
+                flaws.set("yellow", rScore+1);  
+                int lcecount = (int) flaws.get("OEW"); 
+                flaws.set("OEW", lcecount+1); 
+              }
+
+              linearOpCollections.add("" + arg);  
+            }
+          } 
+
+          if (oper instanceof BinaryExpression) 
+          { BinaryExpression be = (BinaryExpression) oper; 
+            Expression arg = be.getLeft(); 
+            if (arg instanceof BasicExpression && 
+                Expression.linearOperators.contains(
+                                   be.getOperator())) 
+            { arg.setBrackets(false); 
+              if (linearOpCollections.contains("" + arg))
+              { messages.add("! (OEW): multiple linear iterations over collection " + arg + " in " + this + 
+                   ": Can be optimised using a single iteration.\n"); 
+                int rScore = (int) flaws.get("yellow"); 
+                flaws.set("yellow", rScore+1);  
+                int lcecount = (int) flaws.get("OEW"); 
+                flaws.set("OEW", lcecount+1);
+              } 
+           
+              linearOpCollections.add("" + arg);
+            } 
+          } 
+        } 
+      } 
+
+      res.putAll(localres);  
     } 
 
   } // and activity

BinaryExpression.java

@@ -22515,6 +22515,11 @@ public Expression simplifyOCL()
       return Expression.simplifyIntersection(lexpr,rexpr); 
     } 
 
+    if ("->excludingAt".equals(operator))
+    { // merge the literal sets/sequences/maps
+      return Expression.simplifyExcludingAt(lexpr,rexpr); 
+    } 
+
     int synLeft = lexpr.syntacticComplexity();
     int synRight = rexpr.syntacticComplexity();
 
@@ -24038,21 +24043,37 @@ public java.util.Map collectionOperatorUses(int level,
                                       Vector messages)
   { //  level |-> [x.setAt(i,y), etc]
 
+    int syncomp = syntacticComplexity(); 
     boolean sideeffect = isSideEffecting(); 
     Vector vuses = variablesUsedIn(vars);
 
-    if (level > 1 && vuses.size() == 0 && !sideeffect)
+    if (level > 1 && 
+        syncomp > TestParameters.energyCloneSizeLimit && 
+        vuses.size() == 0 && !sideeffect)
     { messages.add("!!! (LCE) flaw: The expression " + this + " may be independent of the iterator variables " + vars + "\n" + 
         "!!! Use Extract local variable to optimise."); 
       messages.add(""); 
-      System.err.println(); 
+      // System.err.println(); 
       refactorELV = true;
       int rScore = (int) uses.get("red"); 
       uses.set("red", rScore+1);  
       int lcecount = (int) uses.get("LCE"); 
       uses.set("LCE", lcecount+1); 
       return res; 
     }
+    else if (level > 1 && 
+        syncomp > 1 && 
+        vuses.size() == 0 && !sideeffect)
+    { messages.add("! (OEW) warning: The expression " + this + " may be independent of the iterator variables " + vars + "\n" + 
+        "! Use Extract local variable to optimise."); 
+      messages.add(""); 
+      // System.err.println(); 
+      refactorELV = true;
+      int rScore = (int) uses.get("yellow"); 
+      uses.set("yellow", rScore+1);  
+      int lcecount = (int) uses.get("OEW"); 
+      uses.set("OEW", lcecount+1); 
+    }
 
     if (operator.equals("->including") ||
         operator.equals("->prepend") ||