Fixed some errors in the Repair Generator code.

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

diff --git a/Repair/RepairCompiler/MCC/IR/AbstractRepair.java b/Repair/RepairCompiler/MCC/IR/AbstractRepair.java
index 01cba236543a73499a3da1f91976c8fb07443209..153677fff76fc516d2cd6521596c08f27cd85ecf 100755 (executable)
--- a/Repair/RepairCompiler/MCC/IR/AbstractRepair.java
+++ b/Repair/RepairCompiler/MCC/IR/AbstractRepair.java
@@ -1,4 +1,5 @@
 package MCC.IR;
+import MCC.State;
 
 class AbstractRepair {
     public final static int ADDTOSET=1;
@@ -10,6 +11,7 @@ class AbstractRepair {
     DNFPredicate torepair;
     int type;
     Descriptor descriptor;
+    Sources sources;
 
     public String type() {
        switch(type) {
@@ -27,7 +29,116 @@ class AbstractRepair {
            return "Unknown";
        }
     }
-    
+
+    public boolean isNewObject(boolean isdomain) {
+       if (getType()==ADDTOSET) {
+           return sources.allocSource((SetDescriptor)descriptor);
+       } else if (getType()==ADDTORELATION) {
+           RelationDescriptor rd=(RelationDescriptor)descriptor;
+           return sources.relallocSource(rd,isdomain);
+       } else throw new Error(type());
+    }
+
+    public SetDescriptor getDomainSet() {
+       if (torepair==null)
+           return null;
+       Predicate predicate=torepair.getPredicate();
+       if (!(predicate.getDescriptor() instanceof RelationDescriptor))
+           return null;
+
+       /* Have relation descriptor now */
+       if (predicate instanceof InclusionPredicate) {
+           InclusionPredicate ip=(InclusionPredicate)predicate;
+           if (ip.inverted())
+               return ip.expr.getSet();
+           else if (ip.setexpr instanceof ImageSetExpr) {
+               ImageSetExpr ise=(ImageSetExpr)ip.setexpr;
+               if (ise.isimageset)
+                   return ise.getImageSetExpr().getSet();
+               else
+                   return ise.getVar().getSet();
+           }
+       } else if (predicate instanceof ExprPredicate) {
+           ExprPredicate ep=(ExprPredicate)predicate;
+
+           if (ep.inverted()&&ep.getType()==ExprPredicate.SIZE)
+               return sources.relgetSourceSet((RelationDescriptor)predicate.getDescriptor(),true);
+           else if (ep.inverted()&&ep.getType()==ExprPredicate.COMPARISON)
+               return ((OpExpr)ep.expr).right.getSet();
+           else if (!ep.inverted()) {
+               switch(ep.getType()) {
+               case ExprPredicate.SIZE: 
+                   {
+                       SizeofExpr soe=((SizeofExpr)((OpExpr)ep.expr).left);
+                       ImageSetExpr ise=(ImageSetExpr)soe.setexpr;
+                       if (ise.isimageset)
+                           return ise.getImageSetExpr().getSet();
+                       else
+                           return ise.getVar().getSet();
+                   }
+               case ExprPredicate.COMPARISON:
+                   {
+                       RelationExpr re=((RelationExpr)((OpExpr)ep.expr).left);
+                       return re.expr.getSet();
+                   }
+               default:
+                   throw new Error("");
+               }
+           }
+       } else throw new Error("Unrecognized predicate");
+       return null;
+    }
+
+    public SetDescriptor getRangeSet() {
+       if (torepair==null)
+           return null;
+       Predicate predicate=torepair.getPredicate();
+       if (!(predicate.getDescriptor() instanceof RelationDescriptor))
+           return null;
+
+       /* Have relation descriptor now */
+       if (predicate instanceof InclusionPredicate) {
+           InclusionPredicate ip=(InclusionPredicate)predicate;
+           if (!ip.inverted())
+               return ip.expr.getSet();
+           else if (ip.setexpr instanceof ImageSetExpr) {
+               ImageSetExpr ise=(ImageSetExpr)ip.setexpr;
+               if (ise.isimageset)
+                   return ise.getImageSetExpr().getSet();
+               else
+                   return ise.getVar().getSet();
+           }
+       } else if (predicate instanceof ExprPredicate) {
+           ExprPredicate ep=(ExprPredicate)predicate;
+
+           if (!ep.inverted()&&ep.getType()==ExprPredicate.SIZE)
+               return sources.relgetSourceSet((RelationDescriptor)predicate.getDescriptor(),false);
+           else if (!ep.inverted()&&ep.getType()==ExprPredicate.COMPARISON)
+               return ((OpExpr)ep.expr).right.getSet();
+           else if (ep.inverted()) {
+               switch(ep.getType()) {
+               case ExprPredicate.SIZE: 
+                   {
+                       SizeofExpr soe=((SizeofExpr)((OpExpr)ep.expr).left);
+                       ImageSetExpr ise=(ImageSetExpr)soe.setexpr;
+                       if (ise.isimageset)
+                           return ise.getImageSetExpr().getSet();
+                       else
+                           return ise.getVar().getSet();
+                   }
+               case ExprPredicate.COMPARISON:
+                   {
+                       RelationExpr re=((RelationExpr)((OpExpr)ep.expr).left);
+                       return re.expr.getSet();
+                   }
+               default:
+                   throw new Error("");
+               }
+           }
+       } else throw new Error("Unrecognized predicate");
+       return null;
+    }
+
     public int getType() {
        return type;
     }
@@ -40,9 +151,21 @@ class AbstractRepair {
        return descriptor;
     }
 
-    public AbstractRepair(DNFPredicate dp,int typ, Descriptor d) {
+
+    /** Thie method tells whether the repair needs to remove objects *
+     *  from the relation, or whether the model definition rules make
+     *  the remove unnecessary.*/
+
+    public boolean needsRemoves(State state) {
+       assert type==MODIFYRELATION;
+       SetDescriptor sd=getPredicate().getPredicate().inverted()?getRangeSet():getDomainSet();
+       return !ConstraintDependence.rulesensurefunction(state,(RelationDescriptor)getDescriptor(), sd, getPredicate().getPredicate().inverted(), true);
+    }
+
+    public AbstractRepair(DNFPredicate dp,int typ, Descriptor d, Sources s) {
        torepair=dp;
        type=typ;
        descriptor=d;
+       sources=s;
     }
 }