X-Git-Url: http://plrg.eecs.uci.edu/git/?p=repair.git;a=blobdiff_plain;f=Repair%2FRepairCompiler%2FMCC%2FIR%2FConstraintDependence.java;fp=Repair%2FRepairCompiler%2FMCC%2FIR%2FConstraintDependence.java;h=7ae89cb7143fc41e9b47a875ecae9da2eec0c7bc;hp=49d4cb97ab78e675dad361513f0f7d9bca42c7c9;hb=7f5349f8ce0cad85a83e9485b3d083296f9f7737;hpb=1ac19ae1b06036f6883e3a5f91b8a85ecab9ab72

diff --git a/Repair/RepairCompiler/MCC/IR/ConstraintDependence.java b/Repair/RepairCompiler/MCC/IR/ConstraintDependence.java
index 49d4cb9..7ae89cb 100755
--- a/Repair/RepairCompiler/MCC/IR/ConstraintDependence.java
+++ b/Repair/RepairCompiler/MCC/IR/ConstraintDependence.java
@@ -18,10 +18,29 @@ public class ConstraintDependence {
 	constonode=new Hashtable();
 	nodetonode=new Hashtable();
 	constructnodes();
-	constructconjunctionnodes();
-	constructconjunctionedges();
     }
     
+    public Set computeOrdering() {
+	HashSet allnodes=new HashSet();
+	allnodes.addAll(constnodes);
+	allnodes.addAll(nodes);
+	boolean acyclic=GraphNode.DFS.depthFirstSearch(allnodes);
+	if (!acyclic) {
+	    throw new Error("Cylic dependency between constraints.");
+	}
+	TreeSet topologicalsort = new TreeSet(new Comparator() {
+                public boolean equals(Object obj) { return false; }
+                public int compare(Object o1, Object o2) {
+                    GraphNode g1 = (GraphNode) o1;
+                    GraphNode g2 = (GraphNode) o2;
+                    return g1.getFinishingTime() - g2.getFinishingTime();
+                }
+            });
+	
+        topologicalsort.addAll(constnodes);
+	return topologicalsort;
+    }
+
     public void addNode(GraphNode gn) {
 	GraphNode gn2=new GraphNode(gn.getLabel(),gn.getTextLabel(),gn);
 	nodes.add(gn2);
@@ -29,6 +48,9 @@ public class ConstraintDependence {
     }
 
     public void associateWithConstraint(GraphNode gn, Constraint c) {
+	if (!nodetonode.containsKey(gn)) {
+	    addNode(gn);
+	}
 	GraphNode ggn=(GraphNode)nodetonode.get(gn);
 	GraphNode gc=(GraphNode)constonode.get(c);
 	GraphNode.Edge e=new GraphNode.Edge("associated",ggn);
@@ -36,12 +58,49 @@ public class ConstraintDependence {
     }
 
     public void requiresConstraint(GraphNode gn, Constraint c) {
+	if (!nodetonode.containsKey(gn)) {
+	    addNode(gn);
+	}
 	GraphNode ggn=(GraphNode)nodetonode.get(gn);
 	GraphNode gc=(GraphNode)constonode.get(c);
 	GraphNode.Edge e=new GraphNode.Edge("requires",gc);
 	ggn.addEdge(e);
     }
 
+    public void traversedependences(Termination termination) {
+	constructconjunctionnodes(termination);
+	constructconjunctionedges(termination);
+	Set removedset=termination.removedset;
+
+	for(int i=0;i<state.vConstraints.size();i++) {
+	    Constraint c=(Constraint)state.vConstraints.get(i);
+	    Set conjset=(Set)termination.conjunctionmap.get(c);
+	    HashSet exploredset=new HashSet();
+
+	    for(Iterator it=conjset.iterator();it.hasNext();) {
+		GraphNode gn=(GraphNode)it.next();
+		recursedependence(c,termination,exploredset,gn);
+	    }
+	}
+    }
+
+    void recursedependence(Constraint c,Termination termination, HashSet exploredset, GraphNode gn) {
+	Set removedset=termination.removedset;
+	Set conjunctionset=termination.conjunctions;
+
+	if (removedset.contains(gn))
+	    return;
+	exploredset.add(gn);
+	associateWithConstraint(gn,c);
+	for(Iterator it=gn.edges();it.hasNext();) {
+	    GraphNode.Edge e=(GraphNode.Edge) it.next();
+	    GraphNode gn2=e.getTarget();
+	    if (!(exploredset.contains(gn2)||
+		  conjunctionset.contains(gn2)))
+		recursedependence(c,termination,exploredset,gn2);
+	}
+    }
+
     /** Constructs a node for each Constraint */
     private void constructnodes() {
 	for(int i=0;i<state.vConstraints.size();i++) {
@@ -52,26 +111,33 @@ public class ConstraintDependence {
   	}
     }
     
-    private void constructconjunctionnodes() {
-	for(Iterator it=termination.conjunctions.iterator();it.hasNext();) {
-	    GraphNode conjnode=(GraphNode)it.next();
-	    TermNode tn=(TermNode)conjnode.getOwner();
-	    Conjunction conj=tn.getConjunction();
-	    addNode(conjnode);
-	}
+    private void constructconjunctionnodes(Termination termination) {
+	/*for(Iterator it=termination.conjunctions.iterator();it.hasNext();) {
+	  GraphNode conjnode=(GraphNode)it.next();
+	  TermNode tn=(TermNode)conjnode.getOwner();
+	  Conjunction conj=tn.getConjunction();
+	  addNode(conjnode);
+	  }*/
+	Set removedset=termination.removedset;
+
 	for(int i=0;i<state.vConstraints.size();i++) {
 	    Constraint c=(Constraint)state.vConstraints.get(i);
 	    Set conjset=(Set)termination.conjunctionmap.get(c);
 	    for(Iterator it=conjset.iterator();it.hasNext();) {
 		GraphNode gn=(GraphNode)it.next();
-		associateWithConstraint(gn,c);
+		if (!removedset.contains(gn))
+		    associateWithConstraint(gn,c);
 	    }
 	}
     }
 
-    private void constructconjunctionedges() {
+    private void constructconjunctionedges(Termination termination) {
+	Set removedset=termination.removedset;
 	for(Iterator it=termination.conjunctions.iterator();it.hasNext();) {
 	    GraphNode conjnode=(GraphNode)it.next();
+	    if (removedset.contains(conjnode))
+		continue;
+	    
 	    TermNode tn=(TermNode)conjnode.getOwner();
 	    Conjunction conj=tn.getConjunction();
 	    for(int i=0;i<conj.size();i++) {