Changes to allow unique names

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

diff --git a/Repair/RepairCompiler/MCC/IR/RepairGenerator.java b/Repair/RepairCompiler/MCC/IR/RepairGenerator.java
index bba7b78055d77b9aa88dc76d077d9cf57d55cb51..80400dc0a84e4bf56aa941dd58904ebc07b96faf 100755 (executable)
--- a/Repair/RepairCompiler/MCC/IR/RepairGenerator.java
+++ b/Repair/RepairCompiler/MCC/IR/RepairGenerator.java
@@ -7,10 +7,11 @@ import MCC.Compiler;
 
 public class RepairGenerator {
     State state;
-    java.io.PrintWriter outputrepair = null;
-    java.io.PrintWriter outputaux = null;
-    java.io.PrintWriter outputhead = null;
-    String name="foo";
+    PrintWrapper outputrepair = null;
+    PrintWrapper outputaux = null;
+    PrintWrapper outputhead = null;
+    public static String name="foo";
+    public static String postfix="";
     String headername;
     static VarDescriptor oldmodel=null;
     static VarDescriptor newmodel=null;
@@ -57,7 +58,6 @@ public class RepairGenerator {
        }
     }
 
-
     private void name_updates() {
        int count=0;
        for(Iterator it=termination.updatenodes.iterator();it.hasNext();) {
@@ -67,22 +67,36 @@ public class RepairGenerator {
            if (togenerate.contains(gn))
            for (int i=0;i<mun.numUpdates();i++) {
                UpdateNode un=mun.getUpdate(i);
-               String name="update"+String.valueOf(count++);
+               String name="update"+RepairGenerator.name+String.valueOf(count++);
                updatenames.put(un,name);
            }
        }
     }
 
     public void generate(OutputStream outputrepair, OutputStream outputaux,OutputStream outputhead, String st) {
-        this.outputrepair = new java.io.PrintWriter(outputrepair, true);
-        this.outputaux = new java.io.PrintWriter(outputaux, true);
-        this.outputhead = new java.io.PrintWriter(outputhead, true);
+        this.outputrepair = new PrintWrapper(new java.io.PrintWriter(outputrepair, true));
+        this.outputaux = new PrintWrapper(new java.io.PrintWriter(outputaux, true));
+        this.outputhead = new PrintWrapper(new java.io.PrintWriter(outputhead, true));
+
         headername=st;
        name_updates();
        generatetypechecks(true);
         generate_tokentable();
+       RelationDescriptor.prefix = "thisvar->";
+       SetDescriptor.prefix = "thisvar->";
+
         generate_hashtables();
        generate_stateobject();
+
+
+       /* Rewrite globals */
+        CodeWriter craux = new StandardCodeWriter(this.outputaux);
+       for (Iterator it=this.state.stGlobals.descriptors();it.hasNext();) {
+           VarDescriptor vd=(VarDescriptor)it.next();
+           craux.outputline("#define "+vd.getSafeSymbol()+" thisvar->"+vd.getSafeSymbol());
+       }
+
+
        generate_call();
        generate_start();
         generate_rules();
@@ -92,9 +106,9 @@ public class RepairGenerator {
         generate_checks();
         generate_teardown();
        CodeWriter crhead = new StandardCodeWriter(this.outputhead);
-       CodeWriter craux = new StandardCodeWriter(this.outputaux);
-       crhead.outputline("};");
-       craux.outputline("}");
+       craux = new StandardCodeWriter(this.outputaux);
+       craux.emptyBuffer();
+       craux.endblock();
 
        if (Compiler.GENERATEDEBUGHOOKS) {
            crhead.outputline("void debughook();");
@@ -129,6 +143,7 @@ public class RepairGenerator {
 
        for (Iterator it=this.state.stGlobals.descriptors();it.hasNext();) {
            VarDescriptor vd=(VarDescriptor)it.next();
+            craux.outputline("#undef "+vd.getSafeSymbol());
            craux.outputline("#define "+vd.getSafeSymbol()+" "+ststate+"->"+vd.getSafeSymbol());
        }
 
@@ -145,14 +160,16 @@ public class RepairGenerator {
                switch(mun.op) {
                case MultUpdateNode.ADD:
                    if (isrelation) {
-                       crhead.outputline("void "+methodname+"("+name+"_state * " +ststate+","+name+" * "+stmodel+", RepairHash * "+strepairtable+", int "+stleft+", int "+stright+");");
-                       craux.outputline("void "+methodname+"("+name+"_state * "+ ststate+","+name+" * "+stmodel+", RepairHash * "+strepairtable+", int "+stleft+", int "+stright+")");
+                       crhead.outputline("void "+methodname+"(struct "+name+"_state * " +ststate+",struct "+name+" * "+stmodel+", struct RepairHash * "+strepairtable+", int "+stleft+", int "+stright+");");
+                       craux.outputline("void "+methodname+"(struct "+name+"_state * "+ ststate+", struct "+name+" * "+stmodel+", struct RepairHash * "+strepairtable+", int "+stleft+", int "+stright+")");
                    } else {
-                       crhead.outputline("void "+methodname+"("+name+"_state * "+ ststate+","+name+" * "+stmodel+", RepairHash * "+strepairtable+", int "+stleft+");");
-                       craux.outputline("void "+methodname+"("+name+"_state * "+ststate+","+name+" * "+stmodel+", RepairHash * "+strepairtable+", int "+stleft+")");
+                       crhead.outputline("void "+methodname+"(struct "+name+"_state * "+ ststate+", struct "+name+" * "+stmodel+", struct RepairHash * "+strepairtable+", int "+stleft+");");
+                       craux.outputline("void "+methodname+"(struct "+name+"_state * "+ststate+", struct "+name+" * "+stmodel+", struct RepairHash * "+strepairtable+", int "+stleft+")");
                    }
                    craux.startblock();
-                   craux.outputline("int maybe=0;");
+                   craux.startBuffer();
+                   craux.addDeclaration("int","maybe");
+                   craux.outputline("maybe=0;");
                    if (Compiler.GENERATEINSTRUMENT)
                        craux.outputline("updatecount++;");
 
@@ -162,11 +179,12 @@ public class RepairGenerator {
                     };
                    un.generate(cr, false, false, stleft,stright, null,this);
                    craux.outputline("if (maybe) printf(\"REALLY BAD\");");
+                   craux.emptyBuffer();
                    craux.endblock();
                    break;
                case MultUpdateNode.REMOVE: {
                    Rule r=un.getRule();
-                   String methodcall="void "+methodname+"("+name+"_state * "+ststate+","+name+" * "+stmodel+", RepairHash * "+strepairtable;
+                   String methodcall="void "+methodname+"(struct "+name+"_state * "+ststate+", struct "+name+" * "+stmodel+", struct RepairHash * "+strepairtable;
                    for(int j=0;j<r.numQuantifiers();j++) {
                        Quantifier q=r.getQuantifier(j);
                        if (q instanceof SetQuantifier) {
@@ -186,7 +204,9 @@ public class RepairGenerator {
                    crhead.outputline(methodcall+";");
                    craux.outputline(methodcall);
                    craux.startblock();
-                   craux.outputline("int maybe=0;");
+                   craux.startBuffer();
+                   craux.addDeclaration("int","maybe");
+                   craux.outputline("maybe=0;");
                    if (Compiler.GENERATEINSTRUMENT)
                        craux.outputline("updatecount++;");
                    final SymbolTable st2 = un.getRule().getSymbolTable();
@@ -195,12 +215,13 @@ public class RepairGenerator {
                     };
                    un.generate(cr2, true, false, null,null, null,this);
                    craux.outputline("if (maybe) printf(\"REALLY BAD\");");
+                   craux.emptyBuffer();
                    craux.endblock();
                }
                    break;
                case MultUpdateNode.MODIFY: {
                    Rule r=un.getRule();
-                   String methodcall="void "+methodname+"("+name+"_state * "+ststate+","+name+" * "+stmodel+", RepairHash * "+strepairtable;
+                   String methodcall="void "+methodname+"(struct "+name+"_state * "+ststate+", struct "+name+" * "+stmodel+", struct RepairHash * "+strepairtable;
                    for(int j=0;j<r.numQuantifiers();j++) {
                        Quantifier q=r.getQuantifier(j);
                        if (q instanceof SetQuantifier) {
@@ -221,6 +242,7 @@ public class RepairGenerator {
                    crhead.outputline(methodcall+";");
                    craux.outputline(methodcall);
                    craux.startblock();
+                   craux.startBuffer();
                    craux.outputline("int maybe=0;");
                    if (Compiler.GENERATEINSTRUMENT)
                        craux.outputline("updatecount++;");
@@ -230,6 +252,7 @@ public class RepairGenerator {
                     };
                    un.generate(cr2, false, true, stleft, stright, stnew, this);
                    craux.outputline("if (maybe) printf(\"REALLY BAD\");");
+                   craux.emptyBuffer();
                    craux.endblock();
                }
                    break;
@@ -244,20 +267,21 @@ public class RepairGenerator {
     private void generate_call() {
         CodeWriter cr = new StandardCodeWriter(outputrepair);
        VarDescriptor vdstate=VarDescriptor.makeNew("repairstate");
-       cr.outputline(name+"_state * "+vdstate.getSafeSymbol()+"=new "+name+"_state();");
+       cr.addDeclaration("struct "+ name+"_state *", vdstate.getSafeSymbol());
+       cr.outputline(vdstate.getSafeSymbol()+"=allocate"+name+"_state();");
        Iterator globals=state.stGlobals.descriptors();
        while (globals.hasNext()) {
            VarDescriptor vd=(VarDescriptor) globals.next();
            cr.outputline(vdstate.getSafeSymbol()+"->"+vd.getSafeSymbol()+"=("+vd.getType().getGenerateType().getSafeSymbol()+")"+vd.getSafeSymbol()+";");
        }
        /* Insert repair here */
-       cr.outputline(vdstate.getSafeSymbol()+"->doanalysis();");
+       cr.outputline("doanalysis"+postfix+"("+vdstate.getSafeSymbol()+");");
        globals=state.stGlobals.descriptors();
        while (globals.hasNext()) {
            VarDescriptor vd=(VarDescriptor) globals.next();
            cr.outputline("*(("+vd.getType().getGenerateType().getSafeSymbol()+"*) &"+vd.getSafeSymbol()+")="+vdstate.getSafeSymbol()+"->"+vd.getSafeSymbol()+";");
        }
-       cr.outputline("delete "+vdstate.getSafeSymbol()+";");
+       cr.outputline("free"+name+"_state("+vdstate.getSafeSymbol()+");");
     }
 
     private void generate_tokentable() {
@@ -265,12 +289,12 @@ public class RepairGenerator {
         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("");
@@ -279,15 +303,28 @@ public class RepairGenerator {
 
     private void generate_stateobject() {
         CodeWriter crhead = new StandardCodeWriter(outputhead);
-       crhead.outputline("class "+name+"_state {");
-       crhead.outputline("public:");
+        CodeWriter craux = new StandardCodeWriter(outputaux);
+       crhead.outputline("struct "+name+"_state {");
        Iterator globals=state.stGlobals.descriptors();
        while (globals.hasNext()) {
            VarDescriptor vd=(VarDescriptor) globals.next();
            crhead.outputline(vd.getType().getGenerateType().getSafeSymbol()+" "+vd.getSafeSymbol()+";");
        }
-       crhead.outputline("void computesizes(int *,int **);");
-       crhead.outputline("void recomputesizes();");
+        crhead.outputline("};");
+       crhead.outputline("struct "+name+"_state * allocate"+name+"_state();");
+       craux.outputline("struct "+name+"_state * allocate"+name+"_state()");
+       craux.startblock();
+       craux.outputline("return (struct "+name+"_state *) malloc(sizeof(struct "+name+"_state));");
+       craux.endblock();
+
+       crhead.outputline("void free"+name+"_state(struct "+name+"_state *);");
+       craux.outputline("void free"+name+"_state(struct "+name+"_state * thisvar)");
+       craux.startblock();
+       craux.outputline("free(thisvar);");
+       craux.endblock();
+
+       crhead.outputline("void "+name+"_statecomputesizes(struct "+name+"_state * ,int *,int **);");
+       crhead.outputline("void "+name+"_staterecomputesizes(struct "+name+"_state *);");
     }
 
     private void generate_computesizes() {
@@ -302,8 +339,11 @@ public class RepairGenerator {
                public SymbolTable getSymbolTable() { return st; }
            };
 
-       cr.outputline("void "+name+"_state::computesizes(int *sizearray,int **numele) {");
-       cr.outputline("int maybe=0;");
+       cr.outputline("void "+name+"_statecomputesizes(struct "+name+"_state * thisvar,int *sizearray,int **numele)");
+       cr.startblock();
+       cr.startBuffer();
+       cr.addDeclaration("int","maybe");
+       cr.outputline("maybe=0;");
        for(int i=0;i<max;i++) {
            TypeDescriptor td=tdarray[i];
            Expr size=td.getSizeExpr();
@@ -328,7 +368,8 @@ public class RepairGenerator {
            }
        }
        cr.outputline("if (maybe) printf(\"BAD ERROR\");");
-       cr.outputline("}");
+       cr.emptyBuffer();
+       cr.endblock();
     }
 
     private void generate_recomputesizes() {
@@ -342,8 +383,11 @@ public class RepairGenerator {
        CodeWriter cr = new StandardCodeWriter(outputaux) {
                public SymbolTable getSymbolTable() { return st; }
            };
-       cr.outputline("void "+name+"_state::recomputesizes() {");
-       cr.outputline("int maybe=0;");
+       cr.outputline("void "+name+"_staterecomputesizes(struct "+name+"_state * thisvar)");
+       cr.startblock();
+       cr.startBuffer();
+       cr.addDeclaration("int","maybe");
+       cr.outputline("maybe=0;");
        for(int i=0;i<max;i++) {
            TypeDescriptor td=tdarray[i];
            Expr size=td.getSizeExpr();
@@ -366,7 +410,8 @@ public class RepairGenerator {
            }
        }
        cr.outputline("if (maybe) printf(\"BAD ERROR\");");
-       cr.outputline("}");
+       cr.emptyBuffer();
+       cr.endblock();
     }
 
 
@@ -376,15 +421,12 @@ public class RepairGenerator {
        crhead.outputline("#ifndef "+name+"_h");
        crhead.outputline("#define "+name+"_h");
         crhead.outputline("#include \"SimpleHash.h\"");
-       crhead.outputline("extern \"C\" {");
         crhead.outputline("#include \"instrument.h\"");
-       crhead.outputline("}");
         crhead.outputline("#include <stdio.h>");
         crhead.outputline("#include <stdlib.h>");
-       crhead.outputline("class "+name+" {");
-       crhead.outputline("public:");
-       crhead.outputline(name+"();");
-       crhead.outputline("~"+name+"();");
+       crhead.outputline("struct "+name+" * allocate"+name+"();");
+       crhead.outputline("void free"+name+"(struct "+name+" *);");
+       crhead.outputline("struct "+name+" {");
         craux.outputline("#include \""+headername+"\"");
         craux.outputline("#include \"size.h\"");
        if (Compiler.TIME) {
@@ -406,17 +448,20 @@ public class RepairGenerator {
                }
            }
        }
-        craux.outputline(name+"::"+name+"() {");
-        craux.outputline("// creating hashtables ");
+        craux.outputline("struct "+ name+"* allocate"+name+"()");
+       craux.startblock();
+        craux.outputline("/* creating hashtables */");
 
         /* build sets */
         Iterator sets = state.stSets.descriptors();
+        craux.addDeclaration("struct "+name+"*", "thisvar");
+        craux.outputline("thisvar=(struct "+name+"*) malloc(sizeof(struct "+name+"));");
 
         /* first pass create all the hash tables */
         while (sets.hasNext()) {
             SetDescriptor set = (SetDescriptor) sets.next();
-           crhead.outputline("SimpleHash* " + set.getSafeSymbol() + "_hash;");
-            craux.outputline(set.getSafeSymbol() + "_hash = new SimpleHash();");
+           crhead.outputline("struct SimpleHash* " + set.getJustSafeSymbol() + "_hash;");
+            craux.outputline(set.getSafeSymbol() + "_hash = noargallocateSimpleHash();");
         }
 
         /* second pass build relationships between hashtables */
@@ -428,7 +473,7 @@ public class RepairGenerator {
 
             while (subsets.hasNext()) {
                 SetDescriptor subset = (SetDescriptor) subsets.next();
-                craux.outputline(subset.getSafeSymbol() + "_hash->addParent(" + set.getSafeSymbol() + "_hash);");
+                craux.outputline("SimpleHashaddParent("+subset.getSafeSymbol() +"_hash ,"+ set.getSafeSymbol() + "_hash);");
             }
         }
 
@@ -440,20 +485,21 @@ public class RepairGenerator {
             RelationDescriptor relation = (RelationDescriptor) relations.next();
 
             if (relation.testUsage(RelationDescriptor.IMAGE)) {
-                crhead.outputline("SimpleHash* " + relation.getSafeSymbol() + "_hash;");
-                craux.outputline(relation.getSafeSymbol() + "_hash = new SimpleHash();");
+                crhead.outputline("struct SimpleHash* " + relation.getJustSafeSymbol() + "_hash;");
+                craux.outputline(relation.getSafeSymbol() + "_hash = noargallocateSimpleHash();");
             }
 
             if (relation.testUsage(RelationDescriptor.INVIMAGE)) {
-                crhead.outputline("SimpleHash* " + relation.getSafeSymbol() + "_hashinv;");
-                craux.outputline(relation.getSafeSymbol() + "_hashinv = new SimpleHash();");
+                crhead.outputline("struct SimpleHash* " + relation.getJustSafeSymbol() + "_hashinv;");
+                craux.outputline(relation.getSafeSymbol() + "_hashinv = noargallocateSimpleHash();");
             }
         }
-
-        craux.outputline("}");
+        craux.outputline("return thisvar;");
+        craux.endblock();
         crhead.outputline("};");
-        craux.outputline(name+"::~"+name+"() {");
-        craux.outputline("// deleting hashtables");
+        craux.outputline("void free"+name+"(struct "+ name +"* thisvar)");
+       craux.startblock();
+        craux.outputline("/* deleting hashtables */");
 
         /* build destructor */
         sets = state.stSets.descriptors();
@@ -461,7 +507,7 @@ public class RepairGenerator {
         /* first pass create all the hash tables */
         while (sets.hasNext()) {
             SetDescriptor set = (SetDescriptor) sets.next();
-            craux.outputline("delete "+set.getSafeSymbol() + "_hash;");
+            craux.outputline("freeSimpleHash("+set.getSafeSymbol() + "_hash);");
         }
 
         /* destroy relations */
@@ -472,14 +518,15 @@ public class RepairGenerator {
             RelationDescriptor relation = (RelationDescriptor) relations.next();
 
             if (relation.testUsage(RelationDescriptor.IMAGE)) {
-                craux.outputline("delete "+relation.getSafeSymbol() + "_hash;");
+                craux.outputline("freeSimpleHash("+relation.getSafeSymbol() + "_hash);");
             }
 
             if (relation.testUsage(RelationDescriptor.INVIMAGE)) {
-                craux.outputline("delete " + relation.getSafeSymbol() + "_hashinv;");
+                craux.outputline("freeSimpleHash(" + relation.getSafeSymbol() + "_hashinv);");
             }
         }
-        craux.outputline("}");
+        craux.outputline("free(thisvar);");
+        craux.endblock();
     }
 
     private void generate_start() {
@@ -497,31 +544,37 @@ public class RepairGenerator {
            craux.outputline("int abstractcount;");
        }
 
-       crhead.outputline("void doanalysis();");
-       craux.outputline("void "+name +"_state::doanalysis()");
+       crhead.outputline("void doanalysis"+postfix+"(struct "+name+"_state *);");
+       craux.outputline("void doanalysis"+postfix+"(struct "+name+"_state * thisvar)");
        craux.startblock();
+       craux.outputline("int highmark;"); /* This declaration is special...need it to be first */
+       craux.startBuffer();
+
        if (Compiler.TIME) {
            craux.outputline("struct timeval _begin_time,_end_time;");
            craux.outputline("gettimeofday(&_begin_time,NULL);");
        }
-
        if (Compiler.GENERATEINSTRUMENT) {
            craux.outputline("updatecount=0;");
            craux.outputline("rebuildcount=0;");
            craux.outputline("abstractcount=0;");
        }
-       craux.outputline("int highmark;");
+
+
+       craux.addDeclaration("struct "+name+ " * ",oldmodel.getSafeSymbol());
+       craux.outputline(oldmodel.getSafeSymbol()+"=0;");
+        craux.addDeclaration("struct WorkList * ",worklist.getSafeSymbol());
+        craux.outputline(worklist.getSafeSymbol()+" = allocateWorkList();");
+       craux.addDeclaration("struct RepairHash * ",repairtable.getSafeSymbol());
+       craux.outputline(repairtable.getSafeSymbol()+"=0;");
        craux.outputline("initializestack(&highmark);");
-       craux.outputline("typeobject *typeobject1=gettypeobject();");
-       craux.outputline("typeobject1->computesizes(this);");
-       craux.outputline("recomputesizes();");
-       craux.outputline(name+ " * "+oldmodel.getSafeSymbol()+"=0;");
-        craux.outputline("WorkList * "+worklist.getSafeSymbol()+" = new WorkList();");
-       craux.outputline("RepairHash * "+repairtable.getSafeSymbol()+"=0;");
+       craux.outputline("computesizes(thisvar);");
+       craux.outputline(name+"_staterecomputesizes(thisvar);");
        craux.outputline("while (1)");
        craux.startblock();
-       craux.outputline(name+ " * "+newmodel.getSafeSymbol()+"=new "+name+"();");
-       craux.outputline(worklist.getSafeSymbol()+"->reset();");
+       craux.addDeclaration("struct "+name+ " * ",newmodel.getSafeSymbol());
+       craux.outputline(newmodel.getSafeSymbol()+"=allocate"+name+"();");
+       craux.outputline("WorkListreset("+worklist.getSafeSymbol()+");");
        if (Compiler.GENERATEINSTRUMENT)
            craux.outputline("rebuildcount++;");
     }
@@ -550,7 +603,7 @@ public class RepairGenerator {
                public SymbolTable getSymbolTable() { return st; }
            };
 
-       cr.outputline("// printing sets!");
+       cr.outputline("/* printing sets!*/");
        cr.outputline("printf(\"\\n\\nPRINTING SETS AND RELATIONS\\n\");");
 
         Iterator setiterator = state.stSets.descriptors();
@@ -563,13 +616,14 @@ public class RepairGenerator {
            String setname = sd.getSafeSymbol();
 
            cr.startblock();
-           cr.outputline("// printing set " + setname);
-           cr.outputline("printf(\"\\nPrinting set " + sd.getSymbol() + " - %d elements \\n\", " + setname + "_hash->count());");
-           cr.outputline("SimpleIterator __setiterator;");
-           cr.outputline("" + setname + "_hash->iterator(__setiterator);");
-           cr.outputline("while (__setiterator.hasNext())");
+           cr.outputline("/* printing set " + setname+"*/");
+           cr.outputline("printf(\"\\nPrinting set " + sd.getSymbol() + " - %d elements \\n\", SimpleHashcountset("+setname+"_hash));");
+           cr.addDeclaration("struct SimpleIterator","__setiterator");
+           cr.outputline("SimpleHashiterator("+setname+"_hash,&__setiterator);");
+           cr.outputline("while (hasNext(&__setiterator))");
            cr.startblock();
-           cr.outputline("int __setval = (int) __setiterator.next();");
+           cr.addDeclaration("int","__setval");
+           cr.outputline("__setval = (int) next(&__setiterator);");
 
            TypeDescriptor td = sd.getType();
            if (td instanceof StructureTypeDescriptor) {
@@ -585,6 +639,51 @@ public class RepairGenerator {
            cr.endblock();
        }
 
+        Iterator reliterator = state.stRelations.descriptors();
+       while (reliterator.hasNext()) {
+           RelationDescriptor rd = (RelationDescriptor) reliterator.next();
+
+
+           String relname = rd.getSafeSymbol();
+            if (rd.testUsage(RelationDescriptor.IMAGE)) {
+                cr.startblock();
+                cr.outputline("/* printing relation " + relname+"*/");
+                cr.outputline("printf(\"\\nPrinting relation " + rd.getSymbol() + " - %d elements \\n\", SimpleHashcountset("+relname+"_hash));");
+                cr.addDeclaration("struct SimpleIterator","__reliterator");
+                cr.outputline("SimpleHashiterator("+relname+"_hash,&__reliterator);");
+                cr.outputline("while (hasNext(&__reliterator))");
+                cr.startblock();
+                cr.addDeclaration("int","__relval");
+                cr.addDeclaration("int","__relval2");
+                cr.outputline("__relval2 = (int) key(&__reliterator);");
+                cr.outputline("__relval = (int) next(&__reliterator);");
+
+                cr.outputline("printf(\"<%ld,%ld> \", __relval2,__relval);");
+
+                cr.endblock();
+                cr.endblock();
+            } else if (rd.testUsage(RelationDescriptor.INVIMAGE)) {
+                cr.startblock();
+                cr.outputline("/* printing inv relation " + relname+"*/");
+                cr.outputline("printf(\"\\nPrinting relation using inv" + rd.getSymbol() + " - %d elements \\n\", SimpleHashcountset("+relname+"_hash));");
+                cr.addDeclaration("struct SimpleIterator","__reliterator");
+                cr.outputline("SimpleHashiterator("+relname+"_hashinv,&__reliterator);");
+                cr.outputline("while (hasNext(&__reliterator))");
+                cr.startblock();
+                cr.addDeclaration("int","__relval");
+                cr.addDeclaration("int","__relval2");
+                cr.outputline("__relval2 = (int) key(&__reliterator);");
+                cr.outputline("__relval = (int) next(&__reliterator);");
+
+
+                cr.outputline("printf(\"<%ld,%ld> \", __relval,__relval2);");
+
+                cr.endblock();
+                cr.endblock();
+            }
+
+       }
+
        cr.outputline("printf(\"\\n\\n------------------- END PRINTING\\n\");");
     }
 
@@ -612,9 +711,10 @@ public class RepairGenerator {
                        InvariantValue ivalue=new InvariantValue();
                        cr.setInvariantValue(ivalue);
 
-                       cr.outputline("// build " +escape(rule.toString()));
+                       cr.outputline("/* build " +escape(rule.toString())+"*/");
                        cr.startblock();
-                       cr.outputline("int maybe=0;");
+                       cr.addDeclaration("int","maybe");
+                       cr.outputline("maybe=0;");
 
                        Expr ruleexpr=rule.getGuardExpr();
                        HashSet invariantvars=new HashSet();
@@ -639,16 +739,19 @@ public class RepairGenerator {
                            }
                        }
 
+                        int openparencount=0;
                        for(Iterator invit=invariants.iterator();invit.hasNext();) {
                            Expr invexpr=(Expr)invit.next();
                            VarDescriptor tmpvd=VarDescriptor.makeNew("tmpvar");
                            VarDescriptor maybevd=VarDescriptor.makeNew("maybevar");
                            invexpr.generate(cr,tmpvd);
-                           cr.outputline("int "+maybevd.getSafeSymbol()+"=maybe;");
+                           cr.addDeclaration("int ",maybevd.getSafeSymbol());
+                           cr.outputline(maybevd.getSafeSymbol()+"=maybe;");
                            cr.outputline("maybe=0;");
                            ivalue.assignPair(invexpr,tmpvd,maybevd);
+                            openparencount++;
+                            cr.startblock();
                        }
-
                        quantifiers = rule.quantifiers();
                        while (quantifiers.hasNext()) {
                            Quantifier quantifier = (Quantifier) quantifiers.next();
@@ -656,9 +759,9 @@ public class RepairGenerator {
                        }
 
                        /* 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();
@@ -675,6 +778,8 @@ public class RepairGenerator {
                            cr.endblock();
                        }
                        cr.endblock();
+                        while((openparencount--)>0)
+                            cr.endblock();
                        cr.outputline("");
                        cr.outputline("");
                    }
@@ -685,13 +790,14 @@ public class RepairGenerator {
                for(Iterator initialworklist=ruleset.iterator();initialworklist.hasNext();) {
                    /** Construct initial worklist set */
                    Rule rule=(Rule)initialworklist.next();
-                   cr2.outputline(worklist.getSafeSymbol()+"->add("+rule.getNum()+",-1,0,0);");
+                   cr2.outputline("WorkListadd("+worklist.getSafeSymbol()+","+rule.getNum()+",-1,0,0);");
                }
 
-               cr2.outputline("while ("+worklist.getSafeSymbol()+"->hasMoreElements())");
+               cr2.outputline("while (WorkListhasMoreElements("+worklist.getSafeSymbol()+"))");
                cr2.startblock();
                VarDescriptor idvar=VarDescriptor.makeNew("id");
-               cr2.outputline("int "+idvar.getSafeSymbol()+"="+worklist.getSafeSymbol()+"->getid();");
+               cr2.addDeclaration("int ",idvar.getSafeSymbol());
+               cr2.outputline(idvar.getSafeSymbol()+"=WorkListgetid("+worklist.getSafeSymbol()+");");
 
                String elseladder = "if";
 
@@ -710,14 +816,18 @@ public class RepairGenerator {
                        cr.indent();
                        cr.outputline(elseladder + " ("+idvar.getSafeSymbol()+" == " + dispatchid + ")");
                        cr.startblock();
-                       cr.outputline("int maybe=0;");
+                       cr.addDeclaration("int","maybe");
+                       cr.outputline("maybe=0;");
                        VarDescriptor typevar=VarDescriptor.makeNew("type");
                        VarDescriptor leftvar=VarDescriptor.makeNew("left");
                        VarDescriptor rightvar=VarDescriptor.makeNew("right");
-                       cr.outputline("int "+typevar.getSafeSymbol()+"="+worklist.getSafeSymbol()+"->gettype();");
-                       cr.outputline("int "+leftvar.getSafeSymbol()+"="+worklist.getSafeSymbol()+"->getlvalue();");
-                       cr.outputline("int "+rightvar.getSafeSymbol()+"="+worklist.getSafeSymbol()+"->getrvalue();");
-                       cr.outputline("// build " +escape(rule.toString()));
+                       cr.addDeclaration("int",typevar.getSafeSymbol());
+                       cr.outputline(typevar.getSafeSymbol()+"= WorkListgettype("+worklist.getSafeSymbol()+");");
+                       cr.addDeclaration("int",leftvar.getSafeSymbol());
+                       cr.outputline(leftvar.getSafeSymbol()+"= WorkListgetlvalue("+worklist.getSafeSymbol()+");");
+                       cr.addDeclaration("int",rightvar.getSafeSymbol());
+                       cr.outputline(rightvar.getSafeSymbol()+"= WorkListgetrvalue("+worklist.getSafeSymbol()+");");
+                       cr.outputline("/* build " +escape(rule.toString())+"*/");
 
 
                        for (int j=0;j<rule.numQuantifiers();j++) {
@@ -726,10 +836,10 @@ public class RepairGenerator {
                        }
 
                        /* pretty print! */
-                       cr.output("//");
+                       cr.output("/*");
 
                        rule.getGuardExpr().prettyPrint(cr);
-                       cr.outputline("");
+                       cr.outputline("*/");
 
                        /* now we have to generate the guard test */
 
@@ -762,7 +872,7 @@ public class RepairGenerator {
                cr2.outputline("exit(1);");
                cr2.endblock();
                // end block created for worklist
-               cr2.outputline(worklist.getSafeSymbol()+"->pop();");
+               cr2.outputline("WorkListpop("+worklist.getSafeSymbol()+");");
                cr2.endblock();
            }
        }
@@ -799,7 +909,7 @@ public class RepairGenerator {
                CodeWriter cr = new StandardCodeWriter(outputaux);
                cr.pushSymbolTable(constraint.getSymbolTable());
 
-               cr.outputline("// checking " + escape(constraint.toString()));
+               cr.outputline("/* checking " + escape(constraint.toString())+"*/");
                 cr.startblock();
 
                 ListIterator quantifiers = constraint.quantifiers();
@@ -809,7 +919,8 @@ public class RepairGenerator {
                     quantifier.generate_open(cr);
                 }
 
-                cr.outputline("int maybe = 0;");
+                cr.addDeclaration("int","maybe");
+                cr.outputline("maybe = 0;");
 
                 /* now we have to generate the guard test */
 
@@ -830,9 +941,10 @@ public class RepairGenerator {
                if (Compiler.REPAIR) {
                /* Do repairs */
                /* Build new repair table */
+
                cr.outputline("if ("+repairtable.getSafeSymbol()+")");
-               cr.outputline("delete "+repairtable.getSafeSymbol()+";");
-                cr.outputline(repairtable.getSafeSymbol()+"=new RepairHash();");
+               cr.outputline("freeRepairHash("+repairtable.getSafeSymbol()+");");
+                cr.outputline(repairtable.getSafeSymbol()+"=noargallocateRepairHash();");
 
                if (Compiler.GENERATEDEBUGHOOKS)
                    cr.outputline("debughook();");
@@ -843,10 +955,11 @@ public class RepairGenerator {
                dnfconst.addAll((Set)termination.conjunctionmap.get(constraint));
 
                if (dnfconst.size()<=1) {
-                   cr.outputline("int "+mincostindex.getSafeSymbol()+"=0;");
+                   cr.addDeclaration("int",mincostindex.getSafeSymbol());
+                   cr.outputline(mincostindex.getSafeSymbol()+"=0;");
                }
                if (dnfconst.size()>1) {
-                   cr.outputline("int "+mincostindex.getSafeSymbol()+";");
+                   cr.addDeclaration("int",mincostindex.getSafeSymbol());
                    boolean first=true;
                    for(int j=0;j<dnfconst.size();j++) {
                        GraphNode gn=(GraphNode)dnfconst.get(j);
@@ -865,9 +978,10 @@ public class RepairGenerator {
                            boolean negate=dpred.isNegated();
                            VarDescriptor predvalue=VarDescriptor.makeNew("Predicatevalue");
                            p.generate(cr,predvalue);
-                           if (k==0)
-                               cr.outputline("int "+costvar.getSafeSymbol()+"=0;");
-
+                           if (k==0) {
+                               cr.addDeclaration("int",costvar.getSafeSymbol());
+                               cr.outputline(costvar.getSafeSymbol()+"=0;");
+                           }
                            if (negate)
                                cr.outputline("if (maybe||"+predvalue.getSafeSymbol()+")");
                            else
@@ -886,7 +1000,8 @@ public class RepairGenerator {
                        first=false;
                    }
                }
-               cr.outputline("switch("+mincostindex.getSafeSymbol()+") {");
+               cr.outputline("switch("+mincostindex.getSafeSymbol()+")");
+               cr.startblock();
                for(int j=0;j<dnfconst.size();j++) {
                    GraphNode gn=(GraphNode)dnfconst.get(j);
                    Conjunction conj=((TermNode)gn.getOwner()).getConjunction();
@@ -922,10 +1037,10 @@ public class RepairGenerator {
                    cr.endblock();
                    cr.outputline("break;");
                }
-               cr.outputline("}");
+               cr.endblock();
 
                cr.outputline("if ("+oldmodel.getSafeSymbol()+")");
-               cr.outputline("delete "+oldmodel.getSafeSymbol()+";");
+               cr.outputline("free"+name+"("+oldmodel.getSafeSymbol()+");");
                cr.outputline(oldmodel.getSafeSymbol()+"="+newmodel.getSafeSymbol()+";");
                cr.outputline("goto rebuild;");  /* Rebuild model and all */
                }
@@ -943,11 +1058,11 @@ public class RepairGenerator {
        CodeWriter cr = new StandardCodeWriter(outputaux);
        cr.startblock();
        cr.outputline("if ("+repairtable.getSafeSymbol()+")");
-       cr.outputline("delete "+repairtable.getSafeSymbol()+";");
+       cr.outputline("freeRepairHash("+repairtable.getSafeSymbol()+");");
        cr.outputline("if ("+oldmodel.getSafeSymbol()+")");
-       cr.outputline("delete "+oldmodel.getSafeSymbol()+";");
-       cr.outputline("delete "+newmodel.getSafeSymbol()+";");
-       cr.outputline("delete "+worklist.getSafeSymbol()+";");
+       cr.outputline("free"+name+"("+oldmodel.getSafeSymbol()+");");
+       cr.outputline("free"+name+"("+newmodel.getSafeSymbol()+");");
+       cr.outputline("freeWorkList("+worklist.getSafeSymbol()+");");
        cr.outputline("resettypemap();");
        cr.outputline("break;");
        cr.endblock();
@@ -1044,19 +1159,20 @@ public class RepairGenerator {
            System.out.println("Warning:  need to have individual remove operations for"+dpred.name());
            needremoveloop=false;
        }
-       if (needremoveloop)
-           cr.outputline("while (1) {");
-
+       if (needremoveloop) {
+           cr.outputline("while (1)");
+           cr.startblock();
+       }
        if (!inverted) {
            ((RelationExpr)expr.getLeftExpr()).getExpr().generate(cr,leftside);
            expr.getRightExpr().generate(cr,newvalue);
-           cr.outputline(rd.getRange().getType().getGenerateType().getSafeSymbol()+" "+rightside.getSafeSymbol()+";");
-           cr.outputline(rd.getSafeSymbol()+"_hash->get("+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+");");
+           cr.addDeclaration(rd.getRange().getType().getGenerateType().getSafeSymbol(),rightside.getSafeSymbol());
+           cr.outputline("SimpleHashget("+rd.getSafeSymbol()+"_hash,"+leftside.getSafeSymbol()+", &"+rightside.getSafeSymbol()+");");
        } else {
            ((RelationExpr)expr.getLeftExpr()).getExpr().generate(cr,rightside);
            expr.getRightExpr().generate(cr,newvalue);
            cr.outputline(rd.getDomain().getType().getGenerateType().getSafeSymbol()+" "+leftside.getSafeSymbol()+";");
-           cr.outputline(rd.getSafeSymbol()+"_hashinv->get("+rightside.getSafeSymbol()+","+leftside.getSafeSymbol()+");");
+           cr.outputline("SimpleHashget("+rd.getSafeSymbol()+"_hashinv,"+rightside.getSafeSymbol()+", &"+leftside.getSafeSymbol()+");");
        }
 
        opcode=Opcode.translateOpcode(negated,opcode);
@@ -1078,17 +1194,19 @@ public class RepairGenerator {
        }
        /* Do abstract repairs */
        if (usageimage) {
-           cr.outputline(rd.getSafeSymbol()+"_hash->remove("+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+");");
+           cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hash, "+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+");");
        }
        if (usageinvimage) {
-           cr.outputline(rd.getSafeSymbol()+"_hashinv->remove("+rightside.getSafeSymbol()+","+leftside.getSafeSymbol()+");");
+           cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hashinv, "+rightside.getSafeSymbol()+","+leftside.getSafeSymbol()+");");
        }
 
        if (needremoveloop) {
            if (!inverted) {
-               cr.outputline("if ("+rd.getSafeSymbol()+"_hash->contains("+leftside.getSafeSymbol()+")) {");
+               cr.outputline("if (SimpleHashcontainskey("+rd.getSafeSymbol()+"_hash, "+leftside.getSafeSymbol()+"))");
+               cr.startblock();
            } else {
-               cr.outputline("if ("+rd.getSafeSymbol()+"_hashinv->contains("+rightside.getSafeSymbol()+")) {");
+               cr.outputline("if (SimpleHashcontainskey("+rd.getSafeSymbol()+"_hashinv, "+rightside.getSafeSymbol()+"))");
+               cr.startblock();
            }
            for(int i=0;i<state.vRules.size();i++) {
                Rule r=(Rule)state.vRules.get(i);
@@ -1098,27 +1216,27 @@ public class RepairGenerator {
                        if (un.getRule()==r) {
                                /* Update for rule r */
                            String name=(String)updatenames.get(un);
-                           cr.outputline(repairtable.getSafeSymbol()+"->addrelation("+rd.getNum()+","+r.getNum()+","+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+",(int) &"+name+");");
+                           cr.outputline("RepairHashaddrelation("+repairtable.getSafeSymbol()+","+rd.getNum()+","+r.getNum()+","+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+",(int) &"+name+");");
                        }
                    }
                }
            }
            cr.outputline("continue;");
-           cr.outputline("}");
+           cr.endblock();
        }
 
        if (usageimage) {
            if (!inverted) {
-               cr.outputline(rd.getSafeSymbol()+"_hash->add("+leftside.getSafeSymbol()+","+newvalue.getSafeSymbol()+");");
+               cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hash,"+leftside.getSafeSymbol()+","+newvalue.getSafeSymbol()+");");
            } else {
-               cr.outputline(rd.getSafeSymbol()+"_hash->add("+newvalue.getSafeSymbol()+","+rightside.getSafeSymbol()+");");
+               cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hash, "+newvalue.getSafeSymbol()+","+rightside.getSafeSymbol()+");");
            }
        }
        if (usageinvimage) {
            if (!inverted) {
-               cr.outputline(rd.getSafeSymbol()+"_hashinv->add("+newvalue.getSafeSymbol()+","+leftside.getSafeSymbol()+");");
+               cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hashinv, "+newvalue.getSafeSymbol()+","+leftside.getSafeSymbol()+");");
            } else {
-               cr.outputline(rd.getSafeSymbol()+"_hashinv->add("+rightside.getSafeSymbol()+","+newvalue.getSafeSymbol()+");");
+               cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hashinv,"+rightside.getSafeSymbol()+","+newvalue.getSafeSymbol()+");");
            }
        }
        /* Do concrete repairs */
@@ -1131,7 +1249,7 @@ public class RepairGenerator {
                        if (un.getRule()==r) {
                            /* Update for rule r */
                            String name=(String)updatenames.get(un);
-                           cr.outputline(repairtable.getSafeSymbol()+"->addrelation("+rd.getNum()+","+r.getNum()+","+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+",(int) &"+name+","+newvalue.getSafeSymbol()+");");
+                           cr.outputline("RepairHashaddrelation2("+repairtable.getSafeSymbol()+","+rd.getNum()+","+r.getNum()+","+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+",(int) &"+name+","+newvalue.getSafeSymbol()+");");
                        }
                    }
                }
@@ -1147,7 +1265,7 @@ public class RepairGenerator {
                            if (un.getRule()==r) {
                                /* Update for rule r */
                                String name=(String)updatenames.get(un);
-                               cr.outputline(repairtable.getSafeSymbol()+"->addrelation("+rd.getNum()+","+r.getNum()+","+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+",(int) &"+name+");");
+                               cr.outputline("RepairHashaddrelation("+repairtable.getSafeSymbol()+","+rd.getNum()+","+r.getNum()+","+leftside.getSafeSymbol()+","+rightside.getSafeSymbol()+",(int) &"+name+");");
                            }
                        }
                    }
@@ -1156,14 +1274,14 @@ public class RepairGenerator {
            UpdateNode un=munadd.getUpdate(0);
            String name=(String)updatenames.get(un);
            if (!inverted) {
-               cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+leftside.getSafeSymbol()+","+newvalue.getSafeSymbol()+");");
+               cr.outputline(name+"(thisvar,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+leftside.getSafeSymbol()+","+newvalue.getSafeSymbol()+");");
            } else {
-               cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+newvalue.getSafeSymbol()+","+rightside.getSafeSymbol()+");");
+               cr.outputline(name+"(thisvar,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+newvalue.getSafeSymbol()+","+rightside.getSafeSymbol()+");");
            }
        }
        if (needremoveloop) {
            cr.outputline("break;");
-           cr.outputline("}");
+           cr.endblock();
        }
     }
 
@@ -1187,7 +1305,7 @@ public class RepairGenerator {
        VarDescriptor sizevar=VarDescriptor.makeNew("size");
        ((OpExpr)expr).left.generate(cr, sizevar);
        VarDescriptor change=VarDescriptor.makeNew("change");
-       cr.outputline("int "+change.getSafeSymbol()+";");
+       cr.addDeclaration("int",change.getSafeSymbol());
        boolean generateadd=false;
        boolean generateremove=false;
        if (opcode==Opcode.GT) {
@@ -1236,15 +1354,16 @@ public class RepairGenerator {
            if (d instanceof RelationDescriptor) {
                if (ep.inverted()) {
                    ((ImageSetExpr)((SizeofExpr)expr.left).setexpr).generate_leftside(cr,rightvar);
-                   cr.outputline("int "+leftvar.getSafeSymbol()+";");
-                   cr.outputline(d.getSafeSymbol()+"_hashinv->get((int)"+rightvar.getSafeSymbol()+","+leftvar.getSafeSymbol()+");");
+                   cr.addDeclaration("int",leftvar.getSafeSymbol());
+                   cr.outputline("SimpleHashget("+d.getSafeSymbol()+"_hashinv,(int)"+rightvar.getSafeSymbol()+", &"+leftvar.getSafeSymbol()+");");
                } else {
                    ((ImageSetExpr)((SizeofExpr)expr.left).setexpr).generate_leftside(cr,leftvar);
-                   cr.outputline("int "+rightvar.getSafeSymbol()+"=0;");
-                   cr.outputline(d.getSafeSymbol()+"_hash->get((int)"+leftvar.getSafeSymbol()+","+rightvar.getSafeSymbol()+");");
+                   cr.addDeclaration("int",rightvar.getSafeSymbol());
+                   cr.outputline("SimpleHashget("+d.getSafeSymbol()+"_hash ,(int)"+leftvar.getSafeSymbol()+", &"+rightvar.getSafeSymbol()+");");
                }
            } else {
-               cr.outputline("int "+leftvar.getSafeSymbol()+"="+d.getSafeSymbol()+"_hash->firstkey();");
+               cr.addDeclaration("int",leftvar.getSafeSymbol());
+               cr.outputline(leftvar.getSafeSymbol()+"= SimpleHashfirstkey("+d.getSafeSymbol()+"_hash);");
            }
            /* Generate abstract remove instruction */
            if (d instanceof RelationDescriptor) {
@@ -1252,11 +1371,11 @@ public class RepairGenerator {
                boolean usageimage=rd.testUsage(RelationDescriptor.IMAGE);
                boolean usageinvimage=rd.testUsage(RelationDescriptor.INVIMAGE);
                if (usageimage)
-                   cr.outputline(rd.getSafeSymbol() + "_hash->remove((int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
+                   cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hash, (int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
                if (usageinvimage)
-                   cr.outputline(rd.getSafeSymbol() + "_hashinv->remove((int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+                   cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hashinv ,(int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
            } else {
-               cr.outputline(d.getSafeSymbol() + "_hash->remove((int)" + leftvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+               cr.outputline("SimpleHashremove("+d.getSafeSymbol()+"_hash, (int)" + leftvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
            }
            /* Generate concrete remove instruction */
            for(int i=0;i<state.vRules.size();i++) {
@@ -1268,9 +1387,9 @@ public class RepairGenerator {
                                /* Update for rule rule r */
                            String name=(String)updatenames.get(un);
                            if (d instanceof RelationDescriptor) {
-                               cr.outputline(repairtable.getSafeSymbol()+"->addrelation("+d.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+","+rightvar.getSafeSymbol()+",(int) &"+name+");");
+                               cr.outputline("RepairHashaddrelation("+repairtable.getSafeSymbol()+","+d.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+","+rightvar.getSafeSymbol()+",(int) &"+name+");");
                            } else {
-                               cr.outputline(repairtable.getSafeSymbol()+"->addset("+d.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+",(int) &"+name+");");
+                               cr.outputline("RepairHashaddset("+repairtable.getSafeSymbol()+","+d.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+",(int) &"+name+");");
                            }
                        }
                    }
@@ -1298,17 +1417,17 @@ public class RepairGenerator {
                    /* Set Source */
                    SetDescriptor sd=termination.sources.relgetSourceSet(rd,!ep.inverted());
                    VarDescriptor iterator=VarDescriptor.makeNew("iterator");
-                   cr.outputline(sd.getType().getGenerateType().getSafeSymbol() +" "+newobject.getSafeSymbol()+";");
-                   cr.outputline("SimpleIterator "+iterator.getSafeSymbol()+";");
-                   cr.outputline("for("+sd.getSafeSymbol()+"_hash->iterator("+ iterator.getSafeSymbol() +");"+iterator.getSafeSymbol()+".hasNext();)");
+                   cr.addDeclaration(sd.getType().getGenerateType().getSafeSymbol(),newobject.getSafeSymbol());
+                   cr.addDeclaration("struct SimpleIterator",iterator.getSafeSymbol());
+                   cr.outputline("for(SimpleHashiterator("+sd.getSafeSymbol()+"_hash , &"+ iterator.getSafeSymbol() +"); hasNext(&"+iterator.getSafeSymbol()+");)");
                    cr.startblock();
                    if (ep.inverted()) {
-                       cr.outputline("if (!"+rd.getSafeSymbol()+"_hashinv->contains("+iterator.getSafeSymbol()+".key(),"+otherside.getSafeSymbol()+"))");
+                       cr.outputline("if (!SimpleHashcontainskeydata("+rd.getSafeSymbol()+"_hashinv,"+iterator.getSafeSymbol()+".key(),"+otherside.getSafeSymbol()+"))");
                    } else {
-                       cr.outputline("if (!"+rd.getSafeSymbol()+"_hash->contains("+otherside.getSafeSymbol()+","+iterator.getSafeSymbol()+".key()))");
+                       cr.outputline("if (!SimpleHashcontainskeydata("+rd.getSafeSymbol()+"_hash, "+otherside.getSafeSymbol()+","+iterator.getSafeSymbol()+".key()))");
                    }
-                   cr.outputline(newobject.getSafeSymbol()+"="+iterator.getSafeSymbol()+".key();");
-                   cr.outputline(iterator.getSafeSymbol()+".next();");
+                   cr.outputline(newobject.getSafeSymbol()+"=key(&"+iterator.getSafeSymbol()+");");
+                   cr.outputline("next(&"+iterator.getSafeSymbol()+");");
                    cr.endblock();
                } else if (termination.sources.relallocSource(rd,!ep.inverted())) {
                    /* Allocation Source*/
@@ -1318,23 +1437,23 @@ public class RepairGenerator {
                    boolean usageimage=rd.testUsage(RelationDescriptor.IMAGE);
                    boolean usageinvimage=rd.testUsage(RelationDescriptor.INVIMAGE);
                    if (usageimage)
-                       cr.outputline(rd.getSafeSymbol()+"_hash->add("+newobject.getSafeSymbol()+","+otherside.getSafeSymbol()+");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hash, "+newobject.getSafeSymbol()+","+otherside.getSafeSymbol()+");");
                    if (usageinvimage)
-                       cr.outputline(rd.getSafeSymbol()+"_hashinv->add("+otherside.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hashinv, "+otherside.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
 
                    UpdateNode un=munadd.getUpdate(0);
                    String name=(String)updatenames.get(un);
-                   cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+newobject.getSafeSymbol()+","+otherside.getSafeSymbol()+");");
+                   cr.outputline(name+"(thisvar,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+newobject.getSafeSymbol()+","+otherside.getSafeSymbol()+");");
                } else {
                    boolean usageimage=rd.testUsage(RelationDescriptor.IMAGE);
                    boolean usageinvimage=rd.testUsage(RelationDescriptor.INVIMAGE);
                    if (usageimage)
-                       cr.outputline(rd.getSafeSymbol()+"_hash->add("+otherside.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hash, "+otherside.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
                    if (usageinvimage)
-                       cr.outputline(rd.getSafeSymbol()+"_hashinv->add("+newobject.getSafeSymbol()+","+otherside.getSafeSymbol()+");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hashinv, "+newobject.getSafeSymbol()+","+otherside.getSafeSymbol()+");");
                    UpdateNode un=munadd.getUpdate(0);
                    String name=(String)updatenames.get(un);
-                   cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+otherside.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
+                   cr.outputline(name+"(thisvar, "+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+otherside.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
                }
            } else {
                SetDescriptor sd=(SetDescriptor)d;
@@ -1343,22 +1462,22 @@ public class RepairGenerator {
                    /* Set Source */
                    SetDescriptor sourcesd=termination.sources.getSourceSet(sd);
                    VarDescriptor iterator=VarDescriptor.makeNew("iterator");
-                   cr.outputline(sourcesd.getType().getGenerateType().getSafeSymbol() +" "+newobject.getSafeSymbol()+";");
-                   cr.outputline("SimpleIterator "+iterator.getSafeSymbol()+";");
-                   cr.outputline("for("+sourcesd.getSafeSymbol()+"_hash->iterator("+iterator.getSafeSymbol()+");"+iterator.getSafeSymbol()+".hasNext();)");
+                   cr.addDeclaration(sourcesd.getType().getGenerateType().getSafeSymbol(), newobject.getSafeSymbol());
+                   cr.addDeclaration("struct SimpleIterator",iterator.getSafeSymbol());
+                   cr.outputline("for(SimpleHashiterator("+sourcesd.getSafeSymbol()+"_hash, &"+iterator.getSafeSymbol()+"); hasNext(&"+iterator.getSafeSymbol()+");)");
                    cr.startblock();
-                   cr.outputline("if (!"+sd.getSafeSymbol()+"_hash->contains("+iterator.getSafeSymbol()+".key()))");
-                   cr.outputline(newobject.getSafeSymbol()+"="+iterator.getSafeSymbol()+".key();");
-                   cr.outputline(iterator.getSafeSymbol()+".next();");
+                   cr.outputline("if (!SimpleHashcontainskey("+sd.getSafeSymbol()+"_hash, key(&"+iterator.getSafeSymbol()+")))");
+                   cr.outputline(newobject.getSafeSymbol()+"=key(&"+iterator.getSafeSymbol()+");");
+                   cr.outputline("next(&"+iterator.getSafeSymbol()+");");
                    cr.endblock();
                } else if (termination.sources.allocSource(sd)) {
                    /* Allocation Source*/
                    termination.sources.generateSourceAlloc(cr,newobject,sd);
                } else throw new Error("No source for adding to Set");
-               cr.outputline(sd.getSafeSymbol()+"_hash->add("+newobject.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
+               cr.outputline("SimpleHashadd("+sd.getSafeSymbol()+"_hash, "+newobject.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
                UpdateNode un=munadd.getUpdate(0);
                String name=(String)updatenames.get(un);
-               cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
+               cr.outputline(name+"(thisvar,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+newobject.getSafeSymbol()+");");
            }
            cr.endblock();
        }
@@ -1381,14 +1500,14 @@ public class RepairGenerator {
                boolean usageinvimage=rd.testUsage(RelationDescriptor.INVIMAGE);
                if (inverse) {
                    if (usageimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hash->remove((int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hash, (int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
                    if (usageinvimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hashinv->remove((int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hashinv, (int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
                } else {
                    if (usageimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hash->remove((int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hash ,(int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
                    if (usageinvimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hashinv->remove((int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashremove("+rd.getSafeSymbol()+"_hashinv, (int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
                }
                for(int i=0;i<state.vRules.size();i++) {
                    Rule r=(Rule)state.vRules.get(i);
@@ -1399,9 +1518,9 @@ public class RepairGenerator {
                                /* Update for rule rule r */
                                String name=(String)updatenames.get(un);
                                if (inverse) {
-                                   cr.outputline(repairtable.getSafeSymbol()+"->addrelation("+rd.getNum()+","+r.getNum()+","+rightvar.getSafeSymbol()+","+leftvar.getSafeSymbol()+",(int) &"+name+");");
+                                   cr.outputline("RepairHashaddrelation("+repairtable.getSafeSymbol()+","+rd.getNum()+","+r.getNum()+","+rightvar.getSafeSymbol()+","+leftvar.getSafeSymbol()+",(int) &"+name+");");
                                } else {
-                                   cr.outputline(repairtable.getSafeSymbol()+"->addrelation("+rd.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+","+rightvar.getSafeSymbol()+",(int) &"+name+");");
+                                   cr.outputline("RepairHashaddrelation("+repairtable.getSafeSymbol()+","+rd.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+","+rightvar.getSafeSymbol()+",(int) &"+name+");");
                                }
                            }
                        }
@@ -1409,7 +1528,7 @@ public class RepairGenerator {
                }
            } else {
                SetDescriptor sd=ip.setexpr.sd;
-               cr.outputline(sd.getSafeSymbol() + "_hash->remove((int)" + leftvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+               cr.outputline("SimpleHashremove("+sd.getSafeSymbol()+"_hash, (int)" + leftvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
 
                for(int i=0;i<state.vRules.size();i++) {
                    Rule r=(Rule)state.vRules.get(i);
@@ -1419,7 +1538,7 @@ public class RepairGenerator {
                            if (un.getRule()==r) {
                                /* Update for rule rule r */
                                String name=(String)updatenames.get(un);
-                               cr.outputline(repairtable.getSafeSymbol()+"->addset("+sd.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+",(int) &"+name+");");
+                               cr.outputline("RepairHashaddset("+repairtable.getSafeSymbol()+","+sd.getNum()+","+r.getNum()+","+leftvar.getSafeSymbol()+",(int) &"+name+");");
                            }
                        }
                    }
@@ -1436,30 +1555,30 @@ public class RepairGenerator {
                boolean usageinvimage=rd.testUsage(RelationDescriptor.INVIMAGE);
                if (inverse) {
                    if (usageimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hash->add((int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hash, (int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
                    if (usageinvimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hashinv->add((int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hashinv, (int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
                } else {
                    if (usageimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hash->add((int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hash, (int)" + leftvar.getSafeSymbol() + ", (int)" + rightvar.getSafeSymbol() + ");");
                    if (usageinvimage)
-                       cr.outputline(rd.getSafeSymbol() + "_hashinv->add((int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+                       cr.outputline("SimpleHashadd("+rd.getSafeSymbol()+"_hashinv, (int)" + rightvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
                }
                UpdateNode un=mun.getUpdate(0);
                String name=(String)updatenames.get(un);
                if (inverse) {
-                   cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+rightvar.getSafeSymbol()+","+leftvar.getSafeSymbol()+");");
+                   cr.outputline(name+"(thisvar,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+rightvar.getSafeSymbol()+","+leftvar.getSafeSymbol()+");");
                } else {
-                   cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+leftvar.getSafeSymbol()+","+rightvar.getSafeSymbol()+");");
+                   cr.outputline(name+"(thisvar,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+leftvar.getSafeSymbol()+","+rightvar.getSafeSymbol()+");");
                }
            } else {
                SetDescriptor sd=ip.setexpr.sd;
-               cr.outputline(sd.getSafeSymbol() + "_hash->add((int)" + leftvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
+               cr.outputline("SimpleHashadd("+sd.getSafeSymbol()+"_hash, (int)" + leftvar.getSafeSymbol() + ", (int)" + leftvar.getSafeSymbol() + ");");
 
                UpdateNode un=mun.getUpdate(0);
                /* Update for rule rule r */
                String name=(String)updatenames.get(un);
-               cr.outputline(name+"(this,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+leftvar.getSafeSymbol()+");");
+               cr.outputline(name+"(thisvar,"+newmodel.getSafeSymbol()+","+repairtable.getSafeSymbol()+","+leftvar.getSafeSymbol()+");");
            }
        }
     }
@@ -1526,24 +1645,25 @@ public class RepairGenerator {
        if (!(usageinvimage||usageimage)) /* not used at all*/
            return;
 
-        cr.outputline("// RELATION DISPATCH ");
+        cr.outputline("/* RELATION DISPATCH */");
        if (Compiler.REPAIR) {
            cr.outputline("if ("+oldmodel.getSafeSymbol()+"&&");
            if (usageimage)
-               cr.outputline("!"+oldmodel.getSafeSymbol() +"->"+rd.getJustSafeSymbol()+"_hash->contains("+leftvar+","+rightvar+"))");
+               cr.outputline("!SimpleHashcontainskeydata("+oldmodel.getSafeSymbol()+"->"+rd.getJustSafeSymbol() + "_hash, "+leftvar+","+rightvar+"))");
            else
-               cr.outputline("!"+oldmodel.getSafeSymbol() +"->"+rd.getJustSafeSymbol()+"_hashinv->contains("+rightvar+","+leftvar+"))");
+               cr.outputline("!SimpleHashcontainskeydata("+oldmodel.getSafeSymbol() +"->"+rd.getJustSafeSymbol()+"_hashinv, "+rightvar+","+leftvar+"))");
 
            cr.startblock(); {
                /* Adding new item */
                /* Perform safety checks */
                cr.outputline("if ("+repairtable.getSafeSymbol()+"&&");
-               cr.outputline(repairtable.getSafeSymbol()+"->containsrelation("+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+"))");
+               cr.outputline("RepairHashcontainsrelation("+repairtable.getSafeSymbol()+","+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+"))");
                cr.startblock(); {
                    /* Have update to call into */
                    VarDescriptor mdfyptr=VarDescriptor.makeNew("modifyptr");
                    VarDescriptor ismdfyptr=VarDescriptor.makeNew("ismodifyptr");
-                   cr.outputline("int "+ismdfyptr.getSafeSymbol()+"="+repairtable.getSafeSymbol()+"->ismodify("+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+");");
+                   cr.addDeclaration("int ",ismdfyptr.getSafeSymbol());
+                   cr.outputline(ismdfyptr.getSafeSymbol()+"=RepairHashismodify("+repairtable.getSafeSymbol()+","+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+");");
 
 
 
@@ -1555,10 +1675,10 @@ public class RepairGenerator {
                        else
                            parttype=parttype+", int";
                    }
-                   VarDescriptor funptr=VarDescriptor.makeNew("updateptr");
+
                    VarDescriptor tmpptr=VarDescriptor.makeNew("tempupdateptr");
 
-                   String methodcall="("+funptr.getSafeSymbol()+") (this,"+oldmodel.getSafeSymbol()+","+repairtable.getSafeSymbol();
+                   String methodcall="(thisvar,"+oldmodel.getSafeSymbol()+","+repairtable.getSafeSymbol();
                    for(int i=0;i<currentrule.numQuantifiers();i++) {
                        Quantifier q=currentrule.getQuantifier(i);
                        if (q instanceof SetQuantifier) {
@@ -1576,24 +1696,32 @@ public class RepairGenerator {
 
 
 
-                   cr.outputline("void *"+tmpptr.getSafeSymbol()+"=");
-                   cr.outputline("(void *) "+repairtable.getSafeSymbol()+"->getrelation("+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+");");
+                   cr.addDeclaration("void *",tmpptr.getSafeSymbol());
+                   cr.outputline(tmpptr.getSafeSymbol()+"=");
+                   cr.outputline("(void *) RepairHashgetrelation("+repairtable.getSafeSymbol()+","+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+");");
                    cr.outputline("if ("+ismdfyptr.getSafeSymbol()+")");
                    {
+                       VarDescriptor funptr=VarDescriptor.makeNew("updateptr");
+                       String methodcallprefix="("+funptr.getSafeSymbol()+") ";
                        cr.startblock();
-                       cr.outputline("int "+mdfyptr.getSafeSymbol()+"="+repairtable.getSafeSymbol()+"->getrelation2("+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+");");
-                       cr.outputline("void (*"+funptr.getSafeSymbol()+") ("+name+"_state *,"+name+"*,RepairHash *"+parttype+",int,int,int)="+"(void (*) ("+name+"_state *,"+name+"*,RepairHash *"+parttype+",int,int,int)) "+tmpptr.getSafeSymbol()+";");
-                       cr.outputline(methodcall+","+leftvar+", "+rightvar+", "+mdfyptr.getSafeSymbol() +");");
+                       cr.addDeclaration("int",mdfyptr.getSafeSymbol());
+                       cr.outputline(mdfyptr.getSafeSymbol()+"=RepairHashgetrelation2("+repairtable.getSafeSymbol()+","+rd.getNum()+","+currentrule.getNum()+","+leftvar+","+rightvar+");");
+                       cr.addDeclaration("void (*"+funptr.getSafeSymbol()+") (struct "+name+"_state *, struct "+name+"*, struct RepairHash *"+parttype+",int,int,int);");
+                       cr.outputline(funptr.getSafeSymbol()+"="+"(void (*) (struct "+name+"_state *, struct "+name+"*, struct RepairHash *"+parttype+",int,int,int)) "+tmpptr.getSafeSymbol()+";");
+                       cr.outputline(methodcallprefix+methodcall+","+leftvar+", "+rightvar+", "+mdfyptr.getSafeSymbol() +");");
                        cr.endblock();
                    }
                    cr.outputline("else ");
                    {
+                       VarDescriptor funptr=VarDescriptor.makeNew("updateptr");
+                       String methodcallprefix="("+funptr.getSafeSymbol()+") ";
                        cr.startblock();
-                       cr.outputline("void (*"+funptr.getSafeSymbol()+") ("+name+"_state *,"+name+"*,RepairHash *"+parttype+")="+"(void (*) ("+name+"_state *,"+name+"*,RepairHash *"+parttype+")) "+tmpptr.getSafeSymbol()+";");
-                       cr.outputline(methodcall+");");
+                       cr.addDeclaration("void (*"+funptr.getSafeSymbol()+") (struct "+name+"_state *, struct "+name+"*,struct RepairHash *"+parttype+");");
+                       cr.outputline(funptr.getSafeSymbol()+"="+"(void (*) (struct "+name+"_state *,struct "+name+"*,struct RepairHash *"+parttype+")) "+tmpptr.getSafeSymbol()+";");
+                       cr.outputline(methodcallprefix+methodcall+");");
                        cr.endblock();
                    }
-                   cr.outputline("delete "+newmodel.getSafeSymbol()+";");
+                   cr.outputline("free"+name+"("+newmodel.getSafeSymbol()+");");
                    cr.outputline("goto rebuild;");
                }
                cr.endblock();
@@ -1603,7 +1731,7 @@ public class RepairGenerator {
                    UpdateNode un=find_compensation(currentrule);
                    String name=(String)updatenames.get(un);
                    usedupdates.add(un); /* Mark as used */
-                   String methodcall=name+"(this,"+oldmodel.getSafeSymbol()+","+repairtable.getSafeSymbol();
+                   String methodcall=name+"(thisvar,"+oldmodel.getSafeSymbol()+","+repairtable.getSafeSymbol();
                    for(int i=0;i<currentrule.numQuantifiers();i++) {
                        Quantifier q=currentrule.getQuantifier(i);
                        if (q instanceof SetQuantifier) {
@@ -1620,7 +1748,7 @@ public class RepairGenerator {
                    }
                    methodcall+=");";
                    cr.outputline(methodcall);
-                   cr.outputline("delete "+newmodel.getSafeSymbol()+";");
+                   cr.outputline("free"+name+"("+newmodel.getSafeSymbol()+");");
                    cr.outputline("goto rebuild;");
                }
            }
@@ -1628,7 +1756,9 @@ public class RepairGenerator {
        }
 
         String addeditem = (VarDescriptor.makeNew("addeditem")).getSafeSymbol();
-       cr.outputline("int " + addeditem + "=0;");
+        cr.startblock();
+       cr.addDeclaration("int" , addeditem);
+       cr.outputline(addeditem + "=0;");
 
        String ifstring="if (!maybe";
        if (rd.getDomain().getType() instanceof StructureTypeDescriptor)  {
@@ -1643,12 +1773,12 @@ public class RepairGenerator {
 
        if (rd.testUsage(RelationDescriptor.IMAGE)) {
            cr.outputline(ifstring);
-           cr.outputline(addeditem + " = " + rd.getSafeSymbol() + "_hash->add((int)" + leftvar + ", (int)" + rightvar+ ");");
+           cr.outputline(addeditem + " = SimpleHashadd("+rd.getSafeSymbol()+"_hash, (int)" + leftvar + ", (int)" + rightvar+ ");");
        }
 
        if (rd.testUsage(RelationDescriptor.INVIMAGE)) {
            cr.outputline(ifstring);
-           cr.outputline(addeditem + " = " + rd.getSafeSymbol() + "_hashinv->add((int)" + rightvar + ", (int)" + leftvar + ");");
+           cr.outputline(addeditem + " = SimpleHashadd("+rd.getSafeSymbol()+"_hashinv, (int)" + rightvar + ", (int)" + leftvar + ");");
        }
 
 
@@ -1662,7 +1792,8 @@ public class RepairGenerator {
        }
        dispatchrules.removeAll(toremove);
         if (dispatchrules.size() == 0) {
-            cr.outputline("// nothing to dispatch");
+            cr.outputline("/* nothing to dispatch */");
+            cr.endblock();
             return;
         }
 
@@ -1673,32 +1804,32 @@ public class RepairGenerator {
             Rule rule = (Rule) dispatchrules.elementAt(i);
            if (rule.getGuardExpr().getRequiredDescriptors().contains(rd)) {
                /* Guard depends on this relation, so we recomput everything */
-               cr.outputline(worklist.getSafeSymbol()+"->add("+rule.getNum()+",-1,0,0);");
+               cr.outputline("WorkListadd("+worklist.getSafeSymbol()+","+rule.getNum()+",-1,0,0);");
            } else {
                for (int j=0;j<rule.numQuantifiers();j++) {
                    Quantifier q=rule.getQuantifier(j);
                    if (q.getRequiredDescriptors().contains(rd)) {
                        /* Generate add */
-                       cr.outputline(worklist.getSafeSymbol()+"->add("+rule.getNum()+","+j+","+leftvar+","+rightvar+");");
+                       cr.outputline("WorkListadd("+worklist.getSafeSymbol()+","+rule.getNum()+","+j+","+leftvar+","+rightvar+");");
                    }
                }
            }
         }
-
+        cr.endblock();
        cr.endblock();
     }
 
 
     public void generate_dispatch(CodeWriter cr, SetDescriptor sd, String setvar) {
-       cr.outputline("// SET DISPATCH ");
+       cr.outputline("/* SET DISPATCH */");
        if (Compiler.REPAIR) {
            cr.outputline("if ("+oldmodel.getSafeSymbol()+"&&");
-           cr.outputline("!"+oldmodel.getSafeSymbol() +"->"+sd.getJustSafeSymbol()+"_hash->contains("+setvar+"))");
+           cr.outputline("!SimpleHashcontainskey("+oldmodel.getSafeSymbol() +"->"+sd.getJustSafeSymbol()+"_hash, "+setvar+"))");
            cr.startblock(); {
                /* Adding new item */
                /* See if there is an outstanding update in the repairtable */
                cr.outputline("if ("+repairtable.getSafeSymbol()+"&&");
-               cr.outputline(repairtable.getSafeSymbol()+"->containsset("+sd.getNum()+","+currentrule.getNum()+","+setvar+"))");
+               cr.outputline("RepairHashcontainsset("+repairtable.getSafeSymbol()+","+sd.getNum()+","+currentrule.getNum()+","+setvar+"))");
                cr.startblock(); {
                    /* Have update to call into */
                    VarDescriptor funptr=VarDescriptor.makeNew("updateptr");
@@ -1709,9 +1840,10 @@ public class RepairGenerator {
                        else
                            parttype=parttype+", int";
                    }
-                   cr.outputline("void (*"+funptr.getSafeSymbol()+") ("+name+"_state *,"+name+"*,RepairHash *"+parttype+")=");
-                   cr.outputline("(void (*) ("+name+"_state *,"+name+"*,RepairHash *"+parttype+")) "+repairtable.getSafeSymbol()+"->getset("+sd.getNum()+","+currentrule.getNum()+","+setvar+");");
-                   String methodcall="("+funptr.getSafeSymbol()+") (this,"+oldmodel.getSafeSymbol()+","+
+                   cr.addDeclaration("void (*"+funptr.getSafeSymbol()+") (struct "+name+"_state *,struct "+name+"*,struct RepairHash *"+parttype+");");
+                   cr.outputline(funptr.getSafeSymbol()+"=");
+                   cr.outputline("(void (*) (struct "+name+"_state *,struct "+name+"*,struct RepairHash *"+parttype+")) RepairHashgetset("+repairtable.getSafeSymbol()+","+sd.getNum()+","+currentrule.getNum()+","+setvar+");");
+                   String methodcall="("+funptr.getSafeSymbol()+") (thisvar,"+oldmodel.getSafeSymbol()+","+
                        repairtable.getSafeSymbol();
                    for(int i=0;i<currentrule.numQuantifiers();i++) {
                        Quantifier q=currentrule.getQuantifier(i);
@@ -1729,7 +1861,7 @@ public class RepairGenerator {
                    }
                    methodcall+=");";
                    cr.outputline(methodcall);
-                   cr.outputline("delete "+newmodel.getSafeSymbol()+";");
+                   cr.outputline("free"+name+"("+newmodel.getSafeSymbol()+");");
                    cr.outputline("goto rebuild;");
                }
                cr.endblock();
@@ -1746,7 +1878,7 @@ public class RepairGenerator {
                        String name=(String)updatenames.get(un);
                        usedupdates.add(un); /* Mark as used */
 
-                       String methodcall=name+"(this,"+oldmodel.getSafeSymbol()+","+
+                       String methodcall=name+"(thisvar,"+oldmodel.getSafeSymbol()+","+
                            repairtable.getSafeSymbol();
                        for(int j=0;j<currentrule.numQuantifiers();j++) {
                            Quantifier q=currentrule.getQuantifier(j);
@@ -1766,11 +1898,11 @@ public class RepairGenerator {
                        if (currentrule!=itrule) {
                            SetDescriptor sdrule=((SetInclusion)itrule.getInclusion()).getSet();
                            cr.outputline("if ("+oldmodel.getSafeSymbol()+"&&");
-                           cr.outputline("!"+oldmodel.getSafeSymbol() +"->"+sdrule.getJustSafeSymbol()+"_hash->contains("+setvar+"))");
+                           cr.outputline("!SimpleHashcontainskey("+ oldmodel.getSafeSymbol() +"->"+sdrule.getJustSafeSymbol() +"_hash,"+setvar+"))");
                            cr.startblock();
                        }
                        cr.outputline(methodcall);
-                       cr.outputline("delete "+newmodel.getSafeSymbol()+";");
+                       cr.outputline("free"+name+"("+newmodel.getSafeSymbol()+");");
                        cr.outputline("goto rebuild;");
                        cr.endblock();
                    }
@@ -1780,13 +1912,15 @@ public class RepairGenerator {
            }
        }
 
+        cr.startblock();
         String addeditem = (VarDescriptor.makeNew("addeditem")).getSafeSymbol();
-       cr.outputline("int " + addeditem + " = 0;");
+       cr.addDeclaration("int", addeditem);
+       cr.outputline(addeditem + " = 0;");
        if (sd.getType() instanceof StructureTypeDescriptor)  {
            cr.outputline("if (!maybe&&"+setvar+")");
        } else
            cr.outputline("if (!maybe)");
-       cr.outputline(addeditem + " = " + sd.getSafeSymbol() + "_hash->add((int)" + setvar +  ", (int)" + setvar + ");");
+       cr.outputline(addeditem + " = SimpleHashadd("+sd.getSafeSymbol()+"_hash, (int)" + setvar +  ", (int)" + setvar + ");");
        cr.startblock();
         Vector dispatchrules = getrulelist(sd);
 
@@ -1799,7 +1933,8 @@ public class RepairGenerator {
        dispatchrules.removeAll(toremove);
 
         if (dispatchrules.size() == 0) {
-            cr.outputline("// nothing to dispatch");
+            cr.outputline("/* nothing to dispatch */");
+           cr.endblock();
            cr.endblock();
             return;
         }
@@ -1810,18 +1945,19 @@ public class RepairGenerator {
             Rule rule = (Rule) dispatchrules.elementAt(i);
            if (SetDescriptor.expand(rule.getGuardExpr().getRequiredDescriptors()).contains(sd)) {
                /* Guard depends on this relation, so we recompute everything */
-               cr.outputline(worklist.getSafeSymbol()+"->add("+rule.getNum()+",-1,0,0);");
+               cr.outputline("WorkListadd("+worklist.getSafeSymbol()+","+rule.getNum()+",-1,0,0);");
            } else {
                for (int j=0;j<rule.numQuantifiers();j++) {
                    Quantifier q=rule.getQuantifier(j);
                    if (SetDescriptor.expand(q.getRequiredDescriptors()).contains(sd)) {
                        /* Generate add */
-                       cr.outputline(worklist.getSafeSymbol()+"->add("+rule.getNum()+","+j+","+setvar+",0);");
+                       cr.outputline("WorkListadd("+worklist.getSafeSymbol()+","+rule.getNum()+","+j+","+setvar+",0);");
                    }
                }
            }
        }
        cr.endblock();
        cr.endblock();
+       cr.endblock();
     }
 }