correct
[repair.git] / Repair / RepairCompiler / MCC / IR / NaiveGenerator.java
index bc4e6d47047f61c8fb0e478e734cc00e067fc8ed..505217e4b9f8cff674e316c82c71df32df7f485d 100755 (executable)
@@ -8,14 +8,14 @@ public class NaiveGenerator {
 
     State state;
     java.io.PrintWriter output = null;
-            
+
     public NaiveGenerator(State state) {
         this.state = state;
     }
 
     public void generate(java.io.OutputStream output) {
-        this.output = new java.io.PrintWriter(output, true); 
-        
+        this.output = new java.io.PrintWriter(output, true);
+
         generate_tokentable();
         generate_hashtables();
         generate_rules();
@@ -26,16 +26,16 @@ public class NaiveGenerator {
 
     private void generate_tokentable() {
 
-        CodeWriter cr = new StandardCodeWriter(output);        
-        Iterator tokens = TokenLiteralExpr.tokens.keySet().iterator();        
+        CodeWriter cr = new StandardCodeWriter(output);
+        Iterator tokens = TokenLiteralExpr.tokens.keySet().iterator();
 
         cr.outputline("");
-        cr.outputline("// Token values");
+        cr.outputline("/* Token values*/");
         cr.outputline("");
 
         while (tokens.hasNext()) {
             Object token = tokens.next();
-            cr.outputline("// " + token.toString() + " = " + TokenLiteralExpr.tokens.get(token).toString());            
+            cr.outputline("/* " + token.toString() + " = " + TokenLiteralExpr.tokens.get(token).toString()+"*/");
         }
 
         cr.outputline("");
@@ -45,48 +45,48 @@ public class NaiveGenerator {
     private void generate_hashtables() {
 
         CodeWriter cr = new StandardCodeWriter(output);
-        cr.outputline("int __Success = 1;\n");       
-        cr.outputline("// creating hashtables ");
-        
+        cr.outputline("int __Success = 1;\n");
+        cr.outputline("/* creating hashtables */");
+
         /* build all the hashtables */
         Hashtable hashtables = new Hashtable();
 
         /* build sets */
         Iterator sets = state.stSets.descriptors();
-        
+
         /* first pass create all the hash tables */
         while (sets.hasNext()) {
             SetDescriptor set = (SetDescriptor) sets.next();
             cr.outputline("SimpleHash* " + set.getSafeSymbol() + "_hash = new SimpleHash();");
-        } 
-        
+        }
+
         /* second pass build relationships between hashtables */
         sets = state.stSets.descriptors();
-        
+
         while (sets.hasNext()) {
             SetDescriptor set = (SetDescriptor) sets.next();
             Iterator subsets = set.subsets();
-            
+
             while (subsets.hasNext()) {
-                SetDescriptor subset = (SetDescriptor) subsets.next();                
+                SetDescriptor subset = (SetDescriptor) subsets.next();
                 cr.outputline(subset.getSafeSymbol() + "_hash->addParent(" + set.getSafeSymbol() + "_hash);");
             }
-        } 
+        }
 
         /* build relations */
         Iterator relations = state.stRelations.descriptors();
-        
+
         /* first pass create all the hash tables */
         while (relations.hasNext()) {
             RelationDescriptor relation = (RelationDescriptor) relations.next();
-            
+
             if (relation.testUsage(RelationDescriptor.IMAGE)) {
                 cr.outputline("SimpleHash* " + relation.getSafeSymbol() + "_hash = new SimpleHash();");
             }
 
             if (relation.testUsage(RelationDescriptor.INVIMAGE)) {
                 cr.outputline("SimpleHash* " + relation.getSafeSymbol() + "_hashinv = new SimpleHash();");
-            } 
+            }
         }
 
         cr.outputline("");
@@ -106,44 +106,47 @@ public class NaiveGenerator {
                     return g2.getFinishingTime() - g1.getFinishingTime();
                 }
             });
-        
-        topologicalsort.addAll(state.rulenodes.values());        
+
+        topologicalsort.addAll(state.rulenodes.values());
 
         /* build all the rules */
         Iterator rules = topologicalsort.iterator();
-                
+
         while (rules.hasNext()) {
 
             GraphNode rulenode = (GraphNode) rules.next();
-            Rule rule = (Rule) rulenode.getOwner();            
+            Rule rule = (Rule) rulenode.getOwner();
+
+            if (!state.vRules.contains(rule)) {
+                // this is no longer a top-level rule
+                continue;
+            }
 
             {
 
-                final SymbolTable st = rule.getSymbolTable();                
-                CodeWriter cr = new StandardCodeWriter(output) {
-                        public SymbolTable getSymbolTable() { return st; }
-                    };
-                
-                cr.outputline("// build " + rule.getLabel());
+                CodeWriter cr = new StandardCodeWriter(output);
+                cr.pushSymbolTable(rule.getSymbolTable());
+
+                cr.outputline("/* build " + rule.getLabel()+"*/");
                 cr.startblock();
 
                 ListIterator quantifiers = rule.quantifiers();
 
                 while (quantifiers.hasNext()) {
-                    Quantifier quantifier = (Quantifier) quantifiers.next();                   
+                    Quantifier quantifier = (Quantifier) quantifiers.next();
                     quantifier.generate_open(cr);
-                }            
-                        
+                }
+
                 /* pretty print! */
-                cr.output("//");
+                cr.output("/*");
                 rule.getGuardExpr().prettyPrint(cr);
-                cr.outputline("");
+                cr.outputline("*/");
 
                 /* now we have to generate the guard test */
-        
+
                 VarDescriptor guardval = VarDescriptor.makeNew();
                 rule.getGuardExpr().generate(cr, guardval);
-                
+
                 cr.outputline("if (" + guardval.getSafeSymbol() + ")");
                 cr.startblock();
 
@@ -151,6 +154,9 @@ public class NaiveGenerator {
                 rule.getInclusion().generate(cr);
                 cr.endblock();
 
+                // close startblocks generated by DotExpr memory checks
+                //DotExpr.generate_memory_endblocks(cr);
+
                 while (quantifiers.hasPrevious()) {
                     Quantifier quantifier = (Quantifier) quantifiers.previous();
                     cr.endblock();
@@ -166,9 +172,9 @@ public class NaiveGenerator {
     private void generate_implicit_checks() {
 
         /* do post checks */
-         
+
         CodeWriter cr = new StandardCodeWriter(output);
-           
+
         // #TBD#: these should be implicit checks added to the set of constraints
         //output.println("check multiplicity");
     }
@@ -180,44 +186,43 @@ public class NaiveGenerator {
 
         for (int i = 0; i < constraints.size(); i++) {
 
-            Constraint constraint = (Constraint) constraints.elementAt(i); 
+            Constraint constraint = (Constraint) constraints.elementAt(i);
 
             {
 
-                final SymbolTable st = constraint.getSymbolTable();
-                
-                CodeWriter cr = new StandardCodeWriter(output) {
-                        public SymbolTable getSymbolTable() { return st; }
-                    };
-                
-                cr.outputline("// checking " + constraint.getLabel());
+                CodeWriter cr = new StandardCodeWriter(output);
+                cr.pushSymbolTable(constraint.getSymbolTable());
+
+                cr.outputline("/* checking " + constraint.getLabel()+"*/");
                 cr.startblock();
 
                 ListIterator quantifiers = constraint.quantifiers();
 
                 while (quantifiers.hasNext()) {
-                    Quantifier quantifier = (Quantifier) quantifiers.next();                   
+                    Quantifier quantifier = (Quantifier) quantifiers.next();
                     quantifier.generate_open(cr);
-                }            
+                }
 
                 cr.outputline("int maybe = 0;");
-                        
+
                 /* now we have to generate the guard test */
-        
+
                 VarDescriptor constraintboolean = VarDescriptor.makeNew("constraintboolean");
                 constraint.getLogicStatement().generate(cr, constraintboolean);
-                
+
                 cr.outputline("if (maybe)");
                 cr.startblock();
                 cr.outputline("__Success = 0;");
-                cr.outputline("printf(\"maybe fail " + (i+1) + ". \");");
+                cr.outputline("printf(\"maybe fail " + constraint.getNum() + ". \");");
+                cr.outputline("exit(1);");
                 cr.endblock();
 
                 cr.outputline("else if (!" + constraintboolean.getSafeSymbol() + ")");
                 cr.startblock();
 
                 cr.outputline("__Success = 0;");
-                cr.outputline("printf(\"fail " + (i+1) + ". \");");
+                cr.outputline("printf(\"fail " + constraint.getNum() + ". \");");
+                cr.outputline("exit(1);");
                 cr.endblock();
 
                 while (quantifiers.hasPrevious()) {
@@ -229,13 +234,10 @@ public class NaiveGenerator {
                 cr.outputline("");
                 cr.outputline("");
             }
-            
+
         }
 
-        output.println("if (__Success) { printf(\"all tests passed\"); }");
-    }    
+        output.println("/*if (__Success) { printf(\"all tests passed\"); }*/");
+    }
 
 }
-
-
-