all fixed...

diff --git a/Robust/src/Analysis/SSJava/BuildLattice.java b/Robust/src/Analysis/SSJava/BuildLattice.java
index aa8ac139b1088a51b35ac453b6fabc87bfb9a3fd..e24965e35b5916b223b07eb0083d555bfbbcabd0 100644 (file)
--- a/Robust/src/Analysis/SSJava/BuildLattice.java
+++ b/Robust/src/Analysis/SSJava/BuildLattice.java
@@ -315,11 +315,15 @@ public class BuildLattice {
             // the current node is not a combination node
             // there is only one parent node which should be skeleton node.
 
-            System.out.println("   hierarchyGraph.getSkeleteNodeSetReachTo(" + hNode + ")="
-                + hierarchyGraph.getSkeleteNodeSetReachTo(hNode));
-            aboveSet.addAll(hierarchyGraph.getSkeleteNodeSetReachTo(hNode));
-            System.out.println("   aboveset of " + hNode + "=" + aboveSet);
-            // assert aboveSet.size() == 1;
+            // System.out.println("   hierarchyGraph.getSkeleteNodeSetReachTo(" + hNode + ")="
+            // + hierarchyGraph.getSkeleteNodeSetReachTo(hNode));
+
+            Set<HNode> reachToSet = hierarchyGraph.getSkeleteNodeSetReachTo(hNode);
+            for (Iterator iterator2 = reachToSet.iterator(); iterator2.hasNext();) {
+              HNode reachToNode = (HNode) iterator2.next();
+              aboveSet.add(scGraph.getCurrentHNode(reachToNode));
+            }
+
             SCNode = aboveSet.iterator().next();
           }
 
@@ -333,8 +337,8 @@ public class BuildLattice {
 
           trace = hierarchyGraph.computeDistance(hNode, endSet, combineSkeletonNodeSet);
 
-          System.out.println("   COUNT-RESULT::node=" + hNode + " above=" + endSet + " trace="
-              + trace + "   SCNode=" + SCNode);
+          System.out.println("   COUNT-RESULT::start=" + hNode + " end=" + endSet + " trace="
+              + trace);
         }
 
         // 3) convert the node m into a chain of nodes with the last node in the chain having m’s

diff --git a/Robust/src/Analysis/SSJava/HierarchyGraph.java b/Robust/src/Analysis/SSJava/HierarchyGraph.java
index 145cf8af0b9659dad6e8080db50de02621b48afb..3c598d4ed962b5d2c00f471fa136f8bd0e637da3 100644 (file)
--- a/Robust/src/Analysis/SSJava/HierarchyGraph.java
+++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java
@@ -811,11 +811,10 @@ 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);
       HNode combinationNode = getCombinationNode(combineSet);
-      System.out.println("--combinationNode=" + combinationNode + "   combineSet=" + combineSet);
-
-      System.out.println("--hierarchynodes="
+      System.out.println("\n@INSERT COMBINATION NODE FOR combineSet=" + combineSet
+          + "  --combinationNode=" + combinationNode);
+      System.out.println("      --hierarchynodes="
           + simpleHierarchyGraph.getCombinationNodeSetByCombineNodeSet(combineSet));
 
       Set<HNode> simpleHNodeSet =
@@ -843,6 +842,14 @@ public class HierarchyGraph {
         if (isFirstNodeOfChain) {
           simpleHierarchyGraph.addFirstNodeOfChain(combineSet, simpleHNode);
           System.out.println("IT IS THE FIRST NODE OF THE CHAIN:" + simpleHNode);
+          // System.out.println("--->INCOMING NODES=");
+          // Set<HNode> inNodeSet = simpleHierarchyGraph.getIncomingNodeSet(simpleHNode);
+          // for (Iterator iterator3 = inNodeSet.iterator(); iterator3.hasNext();) {
+          // HNode inNode = (HNode) iterator3.next();
+          // System.out.println("          inNode=" + inNode + "   combineSet="
+          // + simpleHierarchyGraph.getCombineSetByCombinationNode(inNode) + " SKELETON TO SET="
+          // + simpleHierarchyGraph.getSkeleteNodeSetReachTo(inNode));
+          // }
         }
       }
 
@@ -859,6 +866,7 @@ public class HierarchyGraph {
           srcNode = getHNode(inSkeletonNode.getDescriptor());
         }
         // System.out.println("--srcNode=" + srcNode);
+        System.out.println("     ADD EDGE SRC=" + srcNode + " -> " + combinationNode);
         addEdgeWithNoCycleCheck(srcNode, combinationNode);
       }
 
@@ -897,7 +905,8 @@ public class HierarchyGraph {
     // because the node is not directly connected to the combination node
     // removeRedundantReachToNodes(reachToSet);
 
-    return reachToSet;
+    return removeTransitivelyReachToSet(reachToSet);
+    // return reachToSet;
   }
 
   private void recurSkeletonReachTo(HNode node, Set<HNode> reachToSet, Set<HNode> visited) {
@@ -998,6 +1007,7 @@ public class HierarchyGraph {
       if (!node.isSkeleton()) {
         Set<HNode> reachToSet = getSkeleteNodeSetReachTo(node);
         // Set<HNode> tempSet = removeTransitivelyReachToSet(reachToSet);
+        // System.out.println("ALL REACH SET=" + reachToSet);
         // reachToSet = removeTransitivelyReachToSet(reachToSet);
 
         Set<HNode> curReachToSet = new HashSet<HNode>();
@@ -1006,7 +1016,7 @@ public class HierarchyGraph {
           curReachToSet.add(getCurrentHNode(reachSkeletonNode));
         }
 
-        System.out.println("-curReachToSet=" + curReachToSet + "  reachToSet=" + reachToSet);
+        // System.out.println("-curReachToSett=" + curReachToSet + "  reachToSet=" + reachToSet);
 
         reachToSet = curReachToSet;
         // System.out.println("$node=" + node + "   reachToNodeSet=" + reachToSet + " tempSet="
@@ -1413,7 +1423,8 @@ public class HierarchyGraph {
   }
 
   public Stack<String> computeDistance(HNode startNode, Set<HNode> endNodeSet, Set<HNode> combineSet) {
-    System.out.println("#####computeDistance startNode=" + startNode + " endNode=" + endNodeSet);
+    // System.out.println("#####computeDistanceance startNode=" + startNode + " endNode=" +
+    // endNodeSet);
     Stack<String> trace = new Stack<String>();
     return recur_computeDistance(startNode, endNodeSet, 0, combineSet, trace);
   }
@@ -1429,7 +1440,6 @@ public class HierarchyGraph {
       }
     }
 
-
     if (endNodeSet.contains(curNode)) {
       // it reaches to one of endNodeSet
       return trace;
@@ -1452,11 +1462,11 @@ public class HierarchyGraph {
         }
       }
 
-      System.out.println("    traverse more to" + inNode + "  before-trace=" + trace);
+      // System.out.println("    traverse more to" + inNode + "  before-trace=" + trace);
       Stack<String> newTrace = (Stack<String>) trace.clone();
       Stack<String> curTrace =
           recur_computeDistance(inNode, endNodeSet, count, combineSet, newTrace);
-      System.out.println("curTrace=" + curTrace);
+      // System.out.println("curTracerTrace=" + curTrace);
 
       if (curTrace != null && curTrace.size() > curMaxDistance) {
         curMaxTrace = curTrace;
@@ -1610,4 +1620,15 @@ public class HierarchyGraph {
     // HNode inNode = inNodeSet.iterator().next();
     return -1;
   }
+
+  public void removeIsolatedNodes() {
+    Set<HNode> toberemoved = new HashSet<HNode>();
+    for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
+      HNode node = (HNode) iterator.next();
+      if (getIncomingNodeSet(node).isEmpty() && getOutgoingNodeSet(node).isEmpty()) {
+        toberemoved.add(node);
+      }
+    }
+    nodeSet.removeAll(toberemoved);
+  }
 }

diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java
index 3adfeebea621970b1089b1511113eb256ff72b73..e951c1a970e7b0214c2f7649184dbc0207d76d2a 100644 (file)
--- a/Robust/src/Analysis/SSJava/LocationInference.java
+++ b/Robust/src/Analysis/SSJava/LocationInference.java
@@ -2634,6 +2634,7 @@ public class LocationInference {
     lattice.removeRedundantEdges();
 
     LocationInference.numLocationsSInfer += lattice.getKeySet().size();
+    System.out.println(desc + " numPaths=" + lattice.countPaths());
 
     if (desc instanceof ClassDescriptor) {
       // field lattice
@@ -2772,6 +2773,7 @@ public class LocationInference {
       HierarchyGraph simpleHierarchyGraph = getHierarchyGraph(desc).clone();
       simpleHierarchyGraph.setName(desc + "_SIMPLE");
       simpleHierarchyGraph.removeRedundantEdges();
+      // simpleHierarchyGraph.removeIsolatedNodes();
       mapDescriptorToSimpleHierarchyGraph.put(desc, simpleHierarchyGraph);
     }
   }
@@ -3202,6 +3204,7 @@ public class LocationInference {
         // if the srcNode is started with the global descriptor
         // need to set as a skeleton node
         if (!hasGlobalAccess && srcNode.getDescTuple().startsWith(GLOBALDESC)) {
+          System.out.println("SRCNODE=" + srcNode);
           hasGlobalAccess = true;
         }
 
@@ -3313,8 +3316,8 @@ public class LocationInference {
     // set hasGloabalAccess true in the method summary.
     if (hasGlobalAccess) {
       getMethodSummary(md).setHasGlobalAccess();
+      methodGraph.getHNode(GLOBALDESC).setSkeleton(true);
     }
-    methodGraph.getHNode(GLOBALDESC).setSkeleton(true);
 
     if (ssjava.getMethodContainingSSJavaLoop().equals(md)) {
       // if the current method contains the event loop

diff --git a/Robust/src/Analysis/SSJava/SSJavaLattice.java b/Robust/src/Analysis/SSJava/SSJavaLattice.java
index ae875777acf78d4982b2eebe9dd31353dad79a0d..406b72eca8c2671f0f1e326d4c72039819976848 100644 (file)
--- a/Robust/src/Analysis/SSJava/SSJavaLattice.java
+++ b/Robust/src/Analysis/SSJava/SSJavaLattice.java
@@ -336,8 +336,6 @@ public class SSJavaLattice<T> extends Lattice<T> {
     }
   }
 
- 
-
   public SSJavaLattice<T> clone() {
 
     SSJavaLattice<T> clone = new SSJavaLattice<T>(getTopItem(), getBottomItem());
@@ -346,4 +344,39 @@ public class SSJavaLattice<T> extends Lattice<T> {
     return clone;
   }
 
+  public int countPaths() {
+    T bottom = getBottomItem();
+
+    Map<T, Set<T>> map = getIncomingElementMap();
+    Map<T, Integer> countMap = new HashMap<T, Integer>();
+
+    Set<T> visited = new HashSet<T>();
+    visited.add(bottom);
+
+    countMap.put(bottom, new Integer(1));
+    recur_countPaths(bottom, map, countMap, visited);
+    if (countMap.containsKey(getTopItem())) {
+      return countMap.get(getTopItem());
+    }
+    return 0;
+  }
+
+  private void recur_countPaths(T cur, Map<T, Set<T>> map, Map<T, Integer> countMap, Set<T> visited) {
+    int curCount = countMap.get(cur).intValue();
+    Set<T> inSet = map.get(cur);
+
+    for (Iterator iterator = inSet.iterator(); iterator.hasNext();) {
+      T in = (T) iterator.next();
+      int inCount = 0;
+      if (countMap.containsKey(in)) {
+        inCount = countMap.get(in).intValue();
+      }
+      inCount += curCount;
+      countMap.put(in, inCount);
+      if (visited.containsAll(get(in))) {
+        visited.add(in);
+        recur_countPaths(in, map, countMap, visited);
+      }
+    }
+  }
 }