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 6a12849f157d7dc43e8f082a3a71c8cf4104f98a..d1ee9fb27098254ca2cfd51be1bf606d54b236f2 100644 (file)
--- a/Robust/src/Analysis/SSJava/HierarchyGraph.java
+++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java
@@ -36,6 +36,8 @@ public class HierarchyGraph {
   Map<Set<HNode>, HNode> mapCombineNodeSetToCombinationNode;
   Map<Set<HNode>, Set<HNode>> mapCombineNodeSetToOutgoingNodeSet;
 
+  Map<HNode, Set<HNode>> mapNormalNodeToSCNodeReachToSet;
+
   Set<HNode> nodeSet;
 
   // for the lattice generation
@@ -63,6 +65,7 @@ public class HierarchyGraph {
 
     mapHNodeNameToCurrentHNode = new HashMap<String, HNode>();
 
+    mapNormalNodeToSCNodeReachToSet = new HashMap<HNode, Set<HNode>>();
   }
 
   public Descriptor getDesc() {
@@ -163,10 +166,16 @@ public class HierarchyGraph {
   }
 
   public void addEdge(Descriptor src, Descriptor dst) {
-    HNode srcHNode = getHNode(src);
-    HNode dstHNode = getHNode(dst);
 
-    addEdge(srcHNode, dstHNode);
+    if (src.equals(LocationInference.LITERALDESC)) {
+      // in this case, we do not need to add a source hnode
+      // just add a destination hnode
+      getHNode(dst);
+    } else {
+      HNode srcHNode = getHNode(src);
+      HNode dstHNode = getHNode(dst);
+      addEdge(srcHNode, dstHNode);
+    }
 
   }
 
@@ -177,9 +186,16 @@ public class HierarchyGraph {
   public HNode getHNode(Descriptor d) {
     if (!mapDescToHNode.containsKey(d)) {
       HNode newNode = new HNode(d);
+
       if (d instanceof FieldDescriptor) {
         newNode.setSkeleton(true);
       }
+
+      String symbol = d.getSymbol();
+      if (symbol.startsWith(LocationInference.PCLOC) || symbol.startsWith(LocationInference.RLOC)) {
+        newNode.setSkeleton(true);
+      }
+
       mappingDescriptorToHNode(d, newNode);
       nodeSet.add(newNode);
     }
@@ -355,8 +371,6 @@ public class HierarchyGraph {
 
   private boolean isEligibleForMerging(HNode node1, HNode node2) {
 
-    System.out.println("********isEligibleForMerging=" + node1 + " " + node2);
-
     if (node1.isSharedNode() || node2.isSharedNode()) {
 
       // if either of nodes is a shared node,
@@ -372,7 +386,6 @@ public class HierarchyGraph {
           return false;
         }
       }
-      System.out.println("******** true");
       return true;
     }
     return false;
@@ -558,6 +571,68 @@ public class HierarchyGraph {
 
   }
 
+  public Set<HNode> getReachableSCNodeSet(HNode startNode) {
+    // returns the set of hnodes which is reachable from the startNode and is either SC node or a
+    // node which is directly connected to the SC nodes
+    Set<HNode> reachable = new HashSet<HNode>();
+    Set<HNode> visited = new HashSet<HNode>();
+    visited.add(startNode);
+    recurReachableNodeSet(startNode, visited, reachable);
+    return reachable;
+  }
+
+  public Set<HNode> getSCNodeReachToSet(HNode node) {
+    if (!mapNormalNodeToSCNodeReachToSet.containsKey(node)) {
+      mapNormalNodeToSCNodeReachToSet.put(node, new HashSet<HNode>());
+    }
+    return mapNormalNodeToSCNodeReachToSet.get(node);
+  }
+
+  private void recurReachableNodeSet(HNode node, Set<HNode> visited, Set<HNode> reachable) {
+
+    Set<HNode> outSet = getOutgoingNodeSet(node);
+    for (Iterator iterator = outSet.iterator(); iterator.hasNext();) {
+      HNode out = (HNode) iterator.next();
+
+      if (!visited.contains(out)) {
+        visited.add(out);
+        Set<HNode> reachableFromSCNodeSet = reachableFromSCNode(out);
+        mapNormalNodeToSCNodeReachToSet.put(out, reachableFromSCNodeSet);
+        if (out.isSkeleton() || out.isCombinationNode() || reachableFromSCNodeSet.size() > 0) {
+          reachable.add(out);
+        } else {
+          visited.add(out);
+          recurReachableNodeSet(out, visited, reachable);
+        }
+
+      }
+
+    }
+
+  }
+
+  private Set<HNode> reachableFromSCNode(HNode node) {
+    Set<HNode> visited = new HashSet<HNode>();
+    visited.add(node);
+    Set<HNode> reachable = new HashSet<HNode>();
+    recurReachableFromSCNode(node, reachable, visited);
+    return reachable;
+  }
+
+  private void recurReachableFromSCNode(HNode node, Set<HNode> reachable, Set<HNode> visited) {
+    Set<HNode> inNodeSet = getIncomingNodeSet(node);
+    for (Iterator iterator = inNodeSet.iterator(); iterator.hasNext();) {
+      HNode inNode = (HNode) iterator.next();
+      if (inNode.isSkeleton() || inNode.isCombinationNode()) {
+        visited.add(inNode);
+        reachable.add(inNode);
+      } else if (!visited.contains(inNode)) {
+        visited.add(inNode);
+        recurReachableFromSCNode(inNode, reachable, visited);
+      }
+    }
+  }
+
   public Set<HNode> getDirectlyReachableSkeletonCombinationNodeFrom(HNode node,
       Set<HNode> combinationNodeSet) {
     Set<HNode> reachable = new HashSet<HNode>();