changes.

diff --git a/Robust/src/Analysis/SSJava/BuildLattice.java b/Robust/src/Analysis/SSJava/BuildLattice.java
index a08e01663764020bc2d4e77340bb61186a636f97..22e514d45720ffa28f64accd8455d795ebc1783d 100644 (file)
--- a/Robust/src/Analysis/SSJava/BuildLattice.java
+++ b/Robust/src/Analysis/SSJava/BuildLattice.java
@@ -211,7 +211,6 @@ public class BuildLattice {
                 endCombNodeSet.add(bottomNode);
               }
 
-
               recurDFSNormalNode(desc, lattice, startNode, endCombNodeSet, visited,
                   mapIntermediateLoc, 1, locSummary, outNode);
             }
@@ -225,27 +224,31 @@ public class BuildLattice {
         System.out.println("n=" + node);
 
         // an intermediate node 'node' may be located between "TOP" location and a skeleton node
-        int sizeIncomingNode = simpleGraph.getIncomingNodeSet(node).size();
-
-        if (sizeIncomingNode == 0) {
+        if (simpleGraph.getIncomingNodeSet(node).size() == 0) {
           // this node will be directly connected to the TOP location
           // start adding the following nodes from this node
 
-          Set<HNode> endNodeSetFromSimpleGraph =
-              simpleGraph.getDirectlyReachableSkeletonCombinationNodeFrom(node, null);
+          // Set<HNode> endNodeSetFromSimpleGraph =
+          // simpleGraph.getDirectlyReachableSkeletonCombinationNodeFrom(node, null);
+
+          Set<HNode> endNodeSet = simpleGraph.getReachableSCNodeSet(node);
 
-          Set<HNode> endCombNodeSet = new HashSet<HNode>();
-          for (Iterator iterator3 = endNodeSetFromSimpleGraph.iterator(); iterator3.hasNext();) {
+          Set<HNode> endCombNormalNodeSet = new HashSet<HNode>();
+          for (Iterator iterator3 = endNodeSet.iterator(); iterator3.hasNext();) {
             HNode endNode = (HNode) iterator3.next();
-            endCombNodeSet.add(getCombinationNodeInSCGraph(desc, endNode));
+            if (endNode.isSkeleton() || endNode.isCombinationNode()) {
+              endCombNormalNodeSet.add(getCombinationNodeInSCGraph(desc, endNode));
+            } else {
+              endCombNormalNodeSet.addAll(simpleGraph.getSCNodeReachToSet(endNode));
+            }
           }
 
           HNode startNode = topNode;
           visited.add(startNode);
-          if (endCombNodeSet.size() > 0) {
+          if (endCombNormalNodeSet.size() > 0) {
             // follows the straight line up to another skeleton/combination node
             // endCombNodeSet = removeTransitivelyReachToNode(desc, node, endCombNodeSet);
-            recurDFSNormalNode(desc, lattice, startNode, endCombNodeSet, visited,
+            recurDFSNormalNode(desc, lattice, startNode, endCombNormalNodeSet, visited,
                 mapIntermediateLoc, 1, locSummary, node);
           }
 
@@ -293,7 +296,6 @@ public class BuildLattice {
       endCombNodeSet =
           removeTransitivelyReachToNode(desc, combinationNodeInSCGraph, endCombNodeSet);
 
-
       recurDFS(desc, lattice, combinationNodeInSCGraph, endCombNodeSet, visited,
           mapIntermediateLoc, 1, locSummary, cnode);
     } else {
@@ -433,9 +435,14 @@ public class BuildLattice {
       Set<String> belowSet = new HashSet<String>();
       for (Iterator iterator = endNodeSet.iterator(); iterator.hasNext();) {
         HNode endNode = (HNode) iterator.next();
-        belowSet.add(endNode.getName());
+        String locName;
+        if (locSummary.getMapHNodeNameToLocationName().containsKey(endNode.getName())) {
+          locName = locSummary.getLocationName(endNode.getName());
+        } else {
+          locName = endNode.getName();
+        }
+        belowSet.add(locName);
       }
-
       lattice.insertNewLocationBetween(above, belowSet, newLocName);
 
       mapIntermediateLoc.put(item, newLocName);

diff --git a/Robust/src/Analysis/SSJava/HierarchyGraph.java b/Robust/src/Analysis/SSJava/HierarchyGraph.java
index ef07ac89b5bb15acdaa250e664cbfc69189d0f1b..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() {
@@ -568,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>();