Completed VB6 abstraction tools

Author: kevinlano

BasicExpression.java

@@ -845,7 +845,19 @@ public static void updateVariableType(Expression lhs, Expression rhs)
   { if (lhs instanceof BasicExpression)
     { BasicExpression be = (BasicExpression) lhs; 
       if (be.variable != null)
-      { Type elemType = rhs.getElementType();
+      { Type vType = rhs.getType();
+
+        System.out.println(">>> RHS type: " + vType); 
+ 
+        Type oldVType = be.variable.getType(); 
+
+        System.out.println(">>> old type: " + oldVType); 
+
+        be.variable.setType( 
+          Type.refineType(oldVType, vType));
+        System.out.println(">> From " + lhs + " := " + rhs + " deduced type " + be.variable.getType() + " for " + be.data);
+
+        Type elemType = rhs.getElementType();
 
         System.out.println(">>> RHS element type: " + elemType); 
 

BehaviouralFeature.java

@@ -408,6 +408,13 @@ public Object clone()
     return res; 
   } // and copy the use case, readfr, etc? 
 
+  public BehaviouralFeature interfaceOperation()
+  { BehaviouralFeature res = (BehaviouralFeature) clone(); 
+    res.activity = null; 
+    res.setAbstract(true); 
+    return res; 
+  } 
+
   public BehaviouralFeature addContainerReference(
                                BasicExpression ref, 
                                String var, Vector excl)
@@ -2522,6 +2529,13 @@ public static boolean isUpdateN(ModelElement mm)
     return false; 
   } 
 
+  public void setAbstract(boolean ab)
+  { if (ab) 
+    { addStereotype("abstract"); } 
+    else 
+    { removeStereotype("abstract"); } 
+  } 
+
   public boolean isAbstract()
   { return hasStereotype("abstract"); } 
 
@@ -3428,7 +3442,7 @@ else if (useCase != null)
 
     out.println("*** Number of parameters of operation " + nme + " = " + pars); 
     if (pars > 10) 
-    { System.err.println("*** Bad smell (EPL): too many parameters (" + pars + ") for " + nme); 
+    { System.err.println("!!! Bad smell (EPL): too many parameters (" + pars + ") for " + nme); 
       System.err.println(">>> Recommend refactoring by introducing value object for parameters or splitting operation into parts"); 
     }  
 
@@ -3446,18 +3460,27 @@ else if (useCase != null)
 
     if (activity != null)
     { cyc = activity.cyclomaticComplexity(); 
-      complexity = complexity + cyc; 
       out.println("*** Activity cyclomatic complexity = " + cyc); 
+      int acomp = activity.syntacticComplexity(); 
+      out.println("*** Activity syntactic complexity = " + acomp); 
+      if (acomp > 100) 
+      { System.err.println("!!! Bad smell (EOS): too high activity complexity (" + acomp + ") for " + nme); 
+        System.err.println(">>> Recommend refactoring by functional decomposition"); 
+      }  
+      else if (acomp > 50) 
+      { System.err.println("*** Warning: high activity complexity (" + acomp + ") for " + nme); }  
+      complexity = complexity + acomp; 
     }
 
     out.println("*** Total complexity of operation " + nme + " = " + complexity); 
     out.println(); 
     if (cyc > 10) 
-    { System.err.println("*** Bad smell (CC): high cyclomatic complexity (" + cyc + ") for " + nme);
+    { System.err.println("!!! Bad smell (CC): high cyclomatic complexity (" + cyc + ") for " + nme);
       System.err.println(">>> Recommend refactoring by functional decomposition"); 
     }  
+
     if (complexity > 100) 
-    { System.err.println("*** Bad smell (EHS): too high complexity (" + complexity + ") for " + nme); 
+    { System.err.println("!!! Bad smell (EHS): too high complexity (" + complexity + ") for " + nme); 
       System.err.println(">>> Recommend refactoring by functional decomposition"); 
     }  
     else if (complexity > 50) 
@@ -3496,7 +3519,7 @@ else if (useCase != null)
 
     System.out.println("*** Number of parameters of operation " + nme + " = " + pars); 
     if (pars > 10) 
-    { System.err.println("*** Bad smell (EPL): too many parameters (" + pars + ") for " + nme); }  
+    { System.err.println("!!! Bad smell (EPL): too many parameters (" + pars + ") for " + nme); }  
 
     int complexity = 0; 
     int cyc = 0; 
@@ -3519,9 +3542,9 @@ else if (useCase != null)
     System.out.println("*** Total complexity of operation " + nme + " = " + complexity); 
     System.out.println(); 
     if (cyc > 10) 
-    { System.err.println("*** Bad smell (CC): high cyclomatic complexity (" + cyc + ") for " + nme); }  
+    { System.err.println("!!! Bad smell (CC): high cyclomatic complexity (" + cyc + ") for " + nme); }  
     if (complexity > 100) 
-    { System.err.println("*** Bad smell (EHS): too high complexity (" + complexity + ") for " + nme); }  
+    { System.err.println("!!! Bad smell (EHS): too high complexity (" + complexity + ") for " + nme); }  
 
     return cyc; 
   } 
@@ -3552,7 +3575,9 @@ else if (useCase != null)
     { pre.findClones(clones,null, nme); } 
     if (post != null) 
     { post.findClones(clones,null, nme); } 
-  } // and activity
+    if (activity != null) 
+    { activity.findClones(clones, null, nme); } 
+  } 
 
   public void generateJava(PrintWriter out)
   { out.print(toString()); } 

BinaryExpression.java

@@ -4475,7 +4475,8 @@ else if (operator.equals("->restrict"))
     else if (operator.equals("->including") || 
              operator.equals("->prepend") || 
              operator.equals("->append"))
-    { Type newleftET = Type.refineType(etleft,right.getType()); 
+    { Type newleftET = 
+                Type.refineType(etleft,right.getType()); 
       System.out.println(">> Deduced element type of " + this + " = " + newleftET); 
       elementType = newleftET; 
       if (type == null)
@@ -4651,7 +4652,7 @@ private void tcMathOps(Type tleft, Type tright,
       else 
       { type = Expression.deduceType(operator,left,right); 
 
-        System.err.println("Warning!: arguments must be numeric in: " + this + ". Deduced type: " + type); 
+        System.err.println("!Warning!: arguments must be numeric in: " + this + " Deduced type: " + type); 
         if (type == null) 
         { JOptionPane.showMessageDialog(null, "Arguments not numeric in: " + this, 
                                             "Type error", JOptionPane.ERROR_MESSAGE);
@@ -4665,14 +4666,14 @@ else if (tlname.equals("long") || trname.equals("long"))
       else if (trname.equals("int") && trname.equals("int"))
       { type = new Type("int",null); }
       else 
-      { System.err.println("TYPE ERROR: invalid types " + tlname + " " + trname + " in: " + this);
+      { System.err.println("!! TYPE ERROR: invalid types " + tlname + " " + trname + " in: " + this);
         type = new Type("int", null);
       }
     } 
     else 
     { type = Expression.deduceType(operator,left,right); 
 
-      System.err.println("TYPE ERROR: invalid types " + tleft + " " + tright + " in: " + this + ". Deduced type " + type);
+      System.err.println("!! TYPE ERROR: invalid types " + tleft + " " + tright + " in: " + this + ". Deduced type " + type);
       JOptionPane.showMessageDialog(null, "Missing types in: " + this, 
                                           "Type error", JOptionPane.ERROR_MESSAGE);
       if (tleft != null)
@@ -4699,14 +4700,19 @@ private void tcLogical(Type tleft, Type tright,
       if (tlname.equals("boolean") && trname.equals("boolean"))
       {  }
       else
-      { System.err.println("Warning: invalid types in: " + this);
+      { System.err.println("! Warning: invalid types " + tlname + " " + trname + " in: " + this);
         JOptionPane.showMessageDialog(null, "Arguments must be booleans: " + this, 
                                             "Type error", JOptionPane.ERROR_MESSAGE); 
+        if ("int".equals(tlname) && "int".equals(trname))
+        { // bitwise operator
+          System.err.println("!! Bitwise operator expected here !!"); 
+          type = new Type("int", null); 
+        } 
       }
       type = new Type("boolean",null);
     } 
     else 
-    { System.err.println("TYPE ERROR: invalid types in: " + this);
+    { System.err.println("!! TYPE ERROR: invalid types in: " + this);
       JOptionPane.showMessageDialog(null, "Missing types in: " + this, 
                                           "Type error", JOptionPane.ERROR_MESSAGE);
     }
@@ -18172,8 +18178,16 @@ public Expression featureAdding2(String var, Vector remainder)
   public int syntacticComplexity() 
   { int res = left.syntacticComplexity();
     res = res + right.syntacticComplexity(); 
-    if (operator.equals("#") || operator.equals("#1") || operator.equals("#LC") || operator.equals("!") ||
-        operator.equals("|") || operator.equals("|R") || operator.equals("|C"))
+    if (operator.equals("#") || operator.equals("#1") || 
+        operator.equals("#LC") || operator.equals("!") ||
+        operator.equals("|") || operator.equals("|R") || 
+        operator.equals("|C") ||
+        operator.equals("|A") ||
+        operator.equals("|intersectAll") || 
+        operator.equals("|unionAll") ||
+        operator.equals("|selectMinimals") || 
+        operator.equals("|selectMaximals")
+       )
     { return res; }  
 
     if (operator.equals("->iterate"))
@@ -18189,9 +18203,11 @@ public int syntacticComplexity()
   } 
 
   public int cyclomaticComplexity() 
-  { if (operator.equals("#") || operator.equals("#1") || operator.equals("#LC") || operator.equals("!"))
+  { if (operator.equals("#") || operator.equals("#1") || 
+        operator.equals("#LC") || operator.equals("!"))
     { return right.cyclomaticComplexity(); } 
-    else if (operator.equals("&") || operator.equals("or") || operator.equals("=>"))
+    else if (operator.equals("&") || 
+             operator.equals("or") || operator.equals("=>"))
     { return left.cyclomaticComplexity() + right.cyclomaticComplexity(); }  
 
     if (operator.equals("->iterate"))

CGCondition.java

@@ -125,6 +125,31 @@ public void applyAction(Vector vars, Vector eargs, Vector reps, CGSpec cgs, Vect
     for (int x = 0; x < reps.size() && x < vars.size(); x++)
     { String var = (String) vars.get(x);
       String arg1 = (String) reps.get(x); 
+
+      String svarx = var; 
+      String smffeat = null; 
+      Vector stereomfs = CGRule.metafeatures(stereo); 
+      if (stereomfs.size() > 0)
+      { 
+        // If stereo has a metafeature: _i`mf
+        // evaluate _i`mf in cgs and set stereo to result 
+
+        String smf = (String) stereomfs.get(0); 
+        int smfindex = smf.indexOf("`"); 
+        svarx = smf.substring(0,smfindex); 
+        smffeat = smf.substring(smfindex+1,smf.length()); 
+        if (smffeat != null && var.equals(svarx)) 
+        { int indv = vars.indexOf(svarx);
+ 
+          if (indv >= 0 && eargs.get(indv) instanceof ASTTerm)
+          {  
+            ASTTerm earg = (ASTTerm) eargs.get(indv); 
+            stereo = CGRule.applyMetafeature(
+                             smffeat,earg,cgs,entities); 
+          }
+        } 
+      } 
+
       stereo = stereo.replace(var,arg1);
     }
 
@@ -677,6 +702,8 @@ public boolean conditionSatisfied(ASTTerm a, Vector entities, CGSpec cgs)
       String repl = CGRule.applyMetafeature(
                              mffeat,a,cgs,entities); 
 
+      System.out.println(">>> Test LHS = " + repl + " RHS = " + stereotype); 
+
       if (repl != null && repl.equals(stereotype))
       { return positive; } 
       else 
@@ -685,6 +712,11 @@ public boolean conditionSatisfied(ASTTerm a, Vector entities, CGSpec cgs)
 
     // Also the stereotype could have one. 
 
+    // if ("integer".equalsIgnoreCase(stereotype))
+    // { if (a.isInteger()) 
+    //   { return positive; } 
+    // } 
+
     if (a instanceof ASTCompositeTerm)
     { ASTCompositeTerm ac = (ASTCompositeTerm) a; 
 

CGRule.java

@@ -531,6 +531,11 @@ public static String applyMetafeature(String mffeat,
           return repl;
         } 
       }
+
+      if (term instanceof ASTSymbolTerm)
+      { ASTSymbolTerm st = (ASTSymbolTerm) term;
+        return "" + st.symbol.charAt(0);  
+      } 
 
       String replx = term.cg(cgs); 
       return replx;              
@@ -549,6 +554,10 @@ public static String applyMetafeature(String mffeat,
           return repl;
         } 
       } 
+      if (term instanceof ASTSymbolTerm)
+      { ASTSymbolTerm st = (ASTSymbolTerm) term;
+        return "" + st.symbol.charAt(1);  
+      } 
     }   
 
       if ("third".equals(mffeat) || 
@@ -564,6 +573,11 @@ public static String applyMetafeature(String mffeat,
             return repl;
           } 
         }    
+        if (term instanceof ASTSymbolTerm)
+        { ASTSymbolTerm st = (ASTSymbolTerm) term;
+          return "" + st.symbol.charAt(2);  
+        } 
+
       }   
 
       if ("fourth".equals(mffeat) || 
@@ -579,6 +593,11 @@ public static String applyMetafeature(String mffeat,
             return repl;
           } 
         } 
+        if (term instanceof ASTSymbolTerm)
+        { ASTSymbolTerm st = (ASTSymbolTerm) term;
+          return "" + st.symbol.charAt(3);  
+        } 
+
       }   
 
       if ("fifth".equals(mffeat) || 
@@ -594,17 +613,28 @@ public static String applyMetafeature(String mffeat,
             return repl; 
           } 
         } 
+        if (term instanceof ASTSymbolTerm)
+        { ASTSymbolTerm st = (ASTSymbolTerm) term;
+          return "" + st.symbol.charAt(4);  
+        } 
+
       }   
 
       if ("last".equals(mffeat))
-      { // get first subterm of obj
+      { // get last subterm of obj
         if (term instanceof ASTCompositeTerm)
         { ASTCompositeTerm ct = (ASTCompositeTerm) term; 
           int tsize = ct.terms.size(); 
           ASTTerm ct1 = (ASTTerm) ct.terms.get(tsize-1); 
           String repl = ct1.cg(cgs); 
           return repl; 
         } 
+        if (term instanceof ASTSymbolTerm)
+        { ASTSymbolTerm st = (ASTSymbolTerm) term;
+          int ssize = st.symbol.length();
+          return "" + st.symbol.charAt(ssize-1);  
+        } 
+
       }   
 
       if ("tail".equals(mffeat))