changes.

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

diff --git a/Robust/src/Analysis/SSJava/HierarchyGraph.java b/Robust/src/Analysis/SSJava/HierarchyGraph.java
index d1ee9fb27098254ca2cfd51be1bf606d54b236f2..d51e6107d41705113b6d3f0bc682f153e30c8e12 100644 (file)
--- a/Robust/src/Analysis/SSJava/HierarchyGraph.java
+++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java
@@ -141,18 +141,21 @@ public class HierarchyGraph {
     if (possibleCycleSet.size() > 0) {
 
       if (possibleCycleSet.size() == 1) {
+        System.out.println("possibleCycleSet=" + possibleCycleSet + "  from src=" + srcHNode
+            + " dstHNode=" + dstHNode);
         if (dstHNode.isSharedNode()) {
           // it has already been assigned shared node.
         } else {
           dstHNode.setSharedNode(true);
+          System.out.println("$$$setShared=" + dstHNode);
         }
         return;
       }
 
+      System.out.println("--- CYCLIC VALUE FLOW: " + srcHNode + " -> " + dstHNode);
       HNode newMergeNode = mergeNodes(possibleCycleSet, false);
       newMergeNode.setSharedNode(true);
-      System.out.println("### INTRODUCE A NEW MERGE NODE: " + newMergeNode);
-      System.out.println("### CYCLIC VALUE FLOW: " + srcHNode + " -> " + dstHNode + "\n");
+
     } else {
       getIncomingNodeSet(dstHNode).add(srcHNode);
       getOutgoingNodeSet(srcHNode).add(dstHNode);
@@ -191,6 +194,10 @@ public class HierarchyGraph {
         newNode.setSkeleton(true);
       }
 
+      if (d.equals(LocationInference.TOPDESC)) {
+        newNode.setSkeleton(true);
+      }
+
       String symbol = d.getSymbol();
       if (symbol.startsWith(LocationInference.PCLOC) || symbol.startsWith(LocationInference.RLOC)) {
         newNode.setSkeleton(true);
@@ -394,7 +401,7 @@ public class HierarchyGraph {
   private void addEdgeWithNoCycleCheck(HNode srcHNode, HNode dstHNode) {
     getIncomingNodeSet(dstHNode).add(srcHNode);
     getOutgoingNodeSet(srcHNode).add(dstHNode);
-    System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode);
+    // System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode);
   }
 
   private HNode mergeNodes(Set<HNode> set, boolean onlyCombinationNodes) {
@@ -424,16 +431,22 @@ public class HierarchyGraph {
 
     // if the input set contains a skeleton node, need to set a new merge node as skeleton also
     boolean hasSkeleton = false;
+    boolean hasShared = false;
     for (Iterator iterator = set.iterator(); iterator.hasNext();) {
       HNode inNode = (HNode) iterator.next();
       if (inNode.isSkeleton()) {
         hasSkeleton = true;
-        break;
+      }
+      if (inNode.isSharedNode()) {
+        hasShared = true;
       }
     }
-    System.out.println("--Set merging node=" + newMergeNode + " as a skeleton=" + set
-        + " hasSkeleton=" + hasSkeleton + " CUR DESC=" + desc);
+    // System.out.println("-----Set merging node=" + newMergeNode + " as a skeleton=" + set
+    // + " hasSkeleton=" + hasSkeleton + " CUR DESC=" + desc);
     newMergeNode.setSkeleton(hasSkeleton);
+    newMergeNode.setSharedNode(hasShared);
+
+    System.out.println("-----MERGING NODE=" + set + " new node=" + newMergeNode);
 
     for (Iterator iterator = set.iterator(); iterator.hasNext();) {
       HNode node = (HNode) iterator.next();
@@ -477,14 +490,14 @@ public class HierarchyGraph {
       HNode mergedNode = (HNode) iterator.next();
       addMapHNodeToCurrentHNode(mergedNode, newMergeNode);
     }
-    System.out.println("###mergedSkeletonNode=" + mergedSkeletonNode);
-    System.out.println("###MERGING NODE=" + set + " new node=" + newMergeNode);
 
     for (Iterator iterator = set.iterator(); iterator.hasNext();) {
       HNode hNode = (HNode) iterator.next();
       System.out.println("old=" + hNode + "----->newNode=" + getCurrentHNode(hNode));
     }
 
+    System.out.println();
+
     return newMergeNode;
   }
 
@@ -492,8 +505,8 @@ public class HierarchyGraph {
     if (curNode.isMergeNode()) {
       Set<HNode> mergingSet = getMergingSet(curNode);
       mergingSet.add(curNode);
-      System.out.println("addMapHNodeToCurrentHNode curNode=" + curNode + " meringSet="
-          + mergingSet);
+      System.out.println("-------addMapHNodeToCurrentHNode curNode=" + curNode + " meringSet="
+          + mergingSet + " newNode=" + newNode);
       for (Iterator iterator = mergingSet.iterator(); iterator.hasNext();) {
         HNode mergingNode = (HNode) iterator.next();
         mapHNodeToCurrentHNode.put(mergingNode, newNode);
@@ -764,9 +777,9 @@ public class HierarchyGraph {
     Set<Set<HNode>> keySet = simpleHierarchyGraph.getCombineNodeSet();
     for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
       Set<HNode> combineSet = (Set<HNode>) iterator.next();
-      System.out.println("--combineSet=" + combineSet);
+      // System.out.println("--combineSet=" + combineSet);
       HNode combinationNode = getCombinationNode(combineSet);
-      System.out.println("--combinationNode=" + combinationNode);
+      // System.out.println("--combinationNode=" + combinationNode);
       // add an edge from a skeleton node to a combination node
       for (Iterator iterator2 = combineSet.iterator(); iterator2.hasNext();) {
         HNode inSkeletonNode = (HNode) iterator2.next();
@@ -837,10 +850,10 @@ public class HierarchyGraph {
     Set<HNode> visited = new HashSet<HNode>();
     recurSkeletonReachTo(node, reachToSet, visited);
 
+    // obsolete!
     // if a node reaches to one of elements in the reachToSet, we do not need to keep it
     // because the node is not directly connected to the combination node
-
-    removeRedundantReachToNodes(reachToSet);
+    // removeRedundantReachToNodes(reachToSet);
 
     return reachToSet;
   }
@@ -954,6 +967,7 @@ public class HierarchyGraph {
       HNode node = (HNode) iterator.next();
       if (!node.isSkeleton()) {
         Set<HNode> reachToSet = getSkeleteNodeSetReachTo(node);
+        System.out.println("$node=" + node + "   reachToNodeSet=" + reachToSet);
         if (reachToSet.size() > 1) {
           // if (countSkeletonNodes(reachToSet) > 1) {
           System.out.println("-node=" + node + "  reachToSet=" + reachToSet);
@@ -1061,7 +1075,7 @@ public class HierarchyGraph {
 
   public void assignUniqueIndexToNode() {
     int idx = 1;
-    System.out.println("nodeSet=" + nodeSet);
+    // System.out.println("nodeSet=" + nodeSet);
     for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
       HNode node = (HNode) iterator.next();
       mapHNodeToUniqueIndex.put(node, idx);
@@ -1091,17 +1105,17 @@ public class HierarchyGraph {
       basis.addAll(BASISTOPELEMENT);
 
       Set<HNode> reachableNodeSet = getReachableNodeSetFrom(node);
-      System.out.println("node=" + node + "    reachableNodeSet=" + reachableNodeSet);
-      System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node));
+      // System.out.println("node=" + node + "    reachableNodeSet=" + reachableNodeSet);
+      // System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node));
       // if a node is reachable from the current node
       // need to remove the index of the reachable node from the basis
 
       basis.remove(getHNodeIndex(node));
       for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) {
         HNode reachableNode = (HNode) iterator2.next();
-        System.out.println("reachableNode=" + reachableNode);
-        System.out.println("getHNodeIndex(reachableNode))="
-            + mapHNodeToUniqueIndex.get(reachableNode));
+        // System.out.println("reachableNode=" + reachableNode);
+        // System.out.println("getHNodeIndex(reachableNode))="
+        // + mapHNodeToUniqueIndex.get(reachableNode));
         int idx = getHNodeIndex(reachableNode);
         basis.remove(idx);
       }