changes.

[IRC.git] / Robust / src / Analysis / SSJava / BuildLattice.java

diff --git a/Robust/src/Analysis/SSJava/BuildLattice.java b/Robust/src/Analysis/SSJava/BuildLattice.java
index fdf3d89d05d4448227300979d38aaf4f405c225f..b306a4fc00cf9abbd8d1cd1ccf8970fd5d41a302 100644 (file)
--- a/Robust/src/Analysis/SSJava/BuildLattice.java
+++ b/Robust/src/Analysis/SSJava/BuildLattice.java
@@ -160,11 +160,11 @@ public class BuildLattice {
 
     Map<TripleItem, String> mapIntermediateLoc = new HashMap<TripleItem, String>();
 
-    System.out.println("*insert=" + desc);
-    System.out.println("***nodeSet=" + nodeSet);
+    // System.out.println("*insert=" + desc);
+    // System.out.println("***nodeSet=" + nodeSet);
     for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
       HNode node = (HNode) iterator.next();
-      System.out.println("node=" + node);
+      // System.out.println("node=" + node);
 
       if (node.isSkeleton() && (!visited.contains(node))) {
         visited.add(node);
@@ -259,7 +259,7 @@ public class BuildLattice {
       HNode sharedNode = (HNode) iterator.next();
       TripleItem item = mapSharedNodeToTripleItem.get(sharedNode);
       String nonSharedLocName = mapIntermediateLoc.get(item);
-      System.out.println("sharedNode=" + sharedNode + "    locName=" + nonSharedLocName);
+      // System.out.println("sharedNode=" + sharedNode + "    locName=" + nonSharedLocName);
 
       String newLocName;
       if (locSummary.getHNodeNameSetByLatticeLoationName(nonSharedLocName) != null
@@ -272,8 +272,8 @@ public class BuildLattice {
         Set<String> belowElementSet = new HashSet<String>();
         belowElementSet.addAll(lattice.get(nonSharedLocName));
 
-        System.out.println("nonSharedLocName=" + nonSharedLocName + "   belowElementSet="
-            + belowElementSet + "  newLocName=" + newLocName);
+        // System.out.println("nonSharedLocName=" + nonSharedLocName + "   belowElementSet="
+        // + belowElementSet + "  newLocName=" + newLocName);
 
         lattice.insertNewLocationBetween(nonSharedLocName, belowElementSet, newLocName);
       } else {
@@ -315,7 +315,7 @@ public class BuildLattice {
       Set<HNode> visited, Map<TripleItem, String> mapIntermediateLoc, LocationSummary locSummary,
       HNode cnode) {
 
-    System.out.println("expandCombinationNode=" + cnode);
+    // System.out.println("expandCombinationNode=" + cnode);
     // expand the combination node 'outNode'
     // here we need to expand the corresponding combination location in the lattice
     HNode combinationNodeInSCGraph = getCombinationNodeInSCGraph(desc, cnode);
@@ -343,7 +343,7 @@ public class BuildLattice {
 
     // follows the straight line up to another skeleton/combination node
     if (endCombNodeSet.size() > 0) {
-      System.out.println("---endCombNodeSet=" + endCombNodeSet);
+      // System.out.println("---endCombNodeSet=" + endCombNodeSet);
       endCombNodeSet =
           removeTransitivelyReachToNode(desc, combinationNodeInSCGraph, endCombNodeSet);
 
@@ -392,8 +392,9 @@ public class BuildLattice {
   private HNode getDirectlyReachableSCNodeFromEndNode(HierarchyGraph scGraph, HNode startNode,
       Set<HNode> endNodeSet) {
 
-    System.out.println("getDirectlyReachableSCNodeFromEndNode start=" + startNode + " endNodeSet="
-        + endNodeSet);
+    // System.out.println("getDirectlyReachableSCNodeFromEndNode start=" + startNode +
+    // " endNodeSet="
+    // + endNodeSet);
     Set<HNode> newStartNodeSet = new HashSet<HNode>();
 
     for (Iterator iterator = endNodeSet.iterator(); iterator.hasNext();) {
@@ -408,7 +409,7 @@ public class BuildLattice {
       }
     }
 
-    System.out.println("newStartNodeSet=" + newStartNodeSet);
+    // System.out.println("newStartNodeSet=" + newStartNodeSet);
 
     if (newStartNodeSet.size() == 0) {
       newStartNodeSet.add(startNode);
@@ -438,14 +439,14 @@ public class BuildLattice {
 
   private HNode getDirectlyReachableNodeFromStartNodeReachToEndNode(HierarchyGraph scGraph,
       HNode startNode, HNode endNode) {
-    System.out.println("getDirectlyReachableNodeFromStartNodeReachToEndNode start=" + startNode
-        + " end=" + endNode);
+    // System.out.println("getDirectlyReachableNodeFromStartNodeReachToEndNode start=" + startNode
+    // + " end=" + endNode);
     Set<HNode> connected = new HashSet<HNode>();
     recurDirectlyReachableNodeFromStartNodeReachToEndNode(scGraph, startNode, endNode, connected);
     if (connected.size() == 0) {
       connected.add(endNode);
     }
-    System.out.println("connected=" + connected);
+    // System.out.println("connected=" + connected);
 
     return connected.iterator().next();
   }
@@ -514,20 +515,27 @@ public class BuildLattice {
       locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName);
     }
 
-    System.out.println("-TripleItem=" + item);
-    System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
-        + " locName=" + locName);
+    // System.out.println("-TripleItem=" + item);
+    // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
+    // + " locName=" + locName);
 
     Set<HNode> outSet = graph.getOutgoingNodeSet(curNode);
     for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) {
       HNode outNode = (HNode) iterator2.next();
-      if (!outNode.isSkeleton() && !outNode.isCombinationNode() && !visited.contains(outNode)) {
-        visited.add(outNode);
-        recurDFSNormalNode(desc, lattice, startNode, endNodeSet, visited, mapIntermediateLoc,
-            idx + 1, locSummary, outNode);
-      } else if (!outNode.isSkeleton() && outNode.isCombinationNode() && !visited.contains(outNode)) {
-        expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode);
+
+      Set<HNode> inNodeSetToOutNode = graph.getIncomingNodeSet(outNode);
+
+      if (visited.containsAll(inNodeSetToOutNode)) {
+        if (!outNode.isSkeleton() && !outNode.isCombinationNode() && !visited.contains(outNode)) {
+          visited.add(outNode);
+          recurDFSNormalNode(desc, lattice, startNode, endNodeSet, visited, mapIntermediateLoc,
+              idx + 1, locSummary, outNode);
+        } else if (!outNode.isSkeleton() && outNode.isCombinationNode()
+            && !visited.contains(outNode)) {
+          expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode);
+        }
       }
+
     }
 
   }
@@ -584,9 +592,9 @@ public class BuildLattice {
       locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName);
     }
 
-    System.out.println("-TripleItem=" + item);
-    System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
-        + " locName=" + locName);
+    // System.out.println("-TripleItem=" + item);
+    // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
+    // + " locName=" + locName);
 
     Set<HNode> outSet = graph.getOutgoingNodeSet(curNode);
     for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) {
@@ -595,19 +603,25 @@ public class BuildLattice {
       // System.out.println("---cur combinationNodeInSCGraph=" + combinationNodeInSCGraph);
       // System.out.println("---outNode combinationNodeInSCGraph="
       // + getCombinationNodeInSCGraph(desc, outNode));
-      if (!outNode.isSkeleton() && !visited.contains(outNode)) {
-        if (outNode.isCombinationNode()) {
-          // check whether the next combination node is different from the current node
-          if (combinationNodeInSCGraph.equals(getCombinationNodeInSCGraph(desc, outNode))) {
-            visited.add(outNode);
-            recurDFS(desc, lattice, combinationNodeInSCGraph, endNodeSet, visited,
-                mapIntermediateLoc, idx + 1, locSummary, outNode);
-          } else {
-            expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode);
+
+      Set<HNode> inNodeSetToOutNode = graph.getIncomingNodeSet(outNode);
+
+      if (visited.containsAll(inNodeSetToOutNode)) {
+        if (!outNode.isSkeleton() && !visited.contains(outNode)) {
+          if (outNode.isCombinationNode()) {
+            // check whether the next combination node is different from the current node
+            if (combinationNodeInSCGraph.equals(getCombinationNodeInSCGraph(desc, outNode))) {
+              visited.add(outNode);
+              recurDFS(desc, lattice, combinationNodeInSCGraph, endNodeSet, visited,
+                  mapIntermediateLoc, idx + 1, locSummary, outNode);
+            } else {
+              expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode);
+            }
           }
-        }
 
+        }
       }
+
     }
 
   }