Checking in changes that:

[repair.git] / Repair / RepairCompiler / MCC / IR / NaiveGenerator.java

diff --git a/Repair/RepairCompiler/MCC/IR/NaiveGenerator.java b/Repair/RepairCompiler/MCC/IR/NaiveGenerator.java
index 08ed84d6325ddd44a83d3a90faed431f3d758cf5..505217e4b9f8cff674e316c82c71df32df7f485d 100755 (executable)
--- a/Repair/RepairCompiler/MCC/IR/NaiveGenerator.java
+++ b/Repair/RepairCompiler/MCC/IR/NaiveGenerator.java
@@ -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,16 +106,16 @@ 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
@@ -125,28 +125,28 @@ public class NaiveGenerator {
             {
 
                 CodeWriter cr = new StandardCodeWriter(output);
-                cr.pushSymbolTable(rule.getSymbolTable()); 
-                
-                cr.outputline("// build " + rule.getLabel());
+                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();
 
@@ -172,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");
     }
@@ -186,30 +186,30 @@ public class NaiveGenerator {
 
         for (int i = 0; i < constraints.size(); i++) {
 
-            Constraint constraint = (Constraint) constraints.elementAt(i); 
+            Constraint constraint = (Constraint) constraints.elementAt(i);
 
             {
 
                 CodeWriter cr = new StandardCodeWriter(output);
                 cr.pushSymbolTable(constraint.getSymbolTable());
-                
-                cr.outputline("// checking " + constraint.getLabel());
+
+                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;");
@@ -234,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\"); }*/");
+    }
 
 }
-
-
-