import IR.Descriptor;
import IR.FieldDescriptor;
+import IR.VarDescriptor;
public class HierarchyGraph {
Map<Set<HNode>, HNode> mapCombineNodeSetToCombinationNode;
Map<Set<HNode>, Set<HNode>> mapCombineNodeSetToOutgoingNodeSet;
- Map<HNode, String> mapHNodeToLocationName;
-
Set<HNode> nodeSet;
public static int seed = 0;
mapHNodeToUniqueIndex = new HashMap<HNode, Integer>();
mapHNodeToBasis = new HashMap<HNode, Set<Integer>>();
- mapHNodeToLocationName = new HashMap<HNode, String>();
mapMergeNodetoMergingSet = new HashMap<HNode, Set<HNode>>();
mapHNodeToCurrentHNode = new HashMap<HNode, HNode>();
this.desc = desc;
}
- public void addMapHNodeToLocationName(HNode node, String locName) {
- mapHNodeToLocationName.put(node, locName);
- }
-
- public String getLocationName(HNode node) {
- return mapHNodeToLocationName.get(node);
- }
-
public String getName() {
return name;
}
continue;
}
+ if (!isEligibleForMerging(node1, node2)) {
+ continue;
+ }
+
if (!node1.equals(node2)) {
Set<HNode> incomingNodeSet2 = getIncomingNodeSet(node2);
return false;
}
+ 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,
+ // all descriptors of node1 & node2 should have a primitive type
+
+ Set<Descriptor> descSet = new HashSet<Descriptor>();
+ descSet.addAll(getDescSetOfNode(node1));
+ descSet.addAll(getDescSetOfNode(node2));
+
+ for (Iterator iterator = descSet.iterator(); iterator.hasNext();) {
+ Descriptor desc = (Descriptor) iterator.next();
+ if (!isPrimitive(desc)) {
+ return false;
+ }
+ }
+ System.out.println("******** true");
+ return true;
+ }
+ return false;
+ }
+
+ private boolean isPrimitive(Descriptor desc) {
+
+ if (desc instanceof FieldDescriptor) {
+ return ((FieldDescriptor) desc).getType().isPrimitive();
+ } else if (desc instanceof VarDescriptor) {
+ return ((VarDescriptor) desc).getType().isPrimitive();
+ } else if (desc instanceof InterDescriptor) {
+ return true;
+ }
+
+ return false;
+ }
+
private void addEdgeWithNoCycleCheck(HNode srcHNode, HNode dstHNode) {
getIncomingNodeSet(dstHNode).add(srcHNode);
getOutgoingNodeSet(srcHNode).add(dstHNode);
HNode mergedNode = (HNode) iterator.next();
addMapHNodeToCurrentHNode(mergedNode, newMergeNode);
}
-
+ System.out.println("\n###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));
+ }
+
return newMergeNode;
}
private void addMapHNodeToCurrentHNode(HNode curNode, HNode newNode) {
if (curNode.isMergeNode()) {
Set<HNode> mergingSet = getMergingSet(curNode);
+ mergingSet.add(curNode);
+ System.out.println("addMapHNodeToCurrentHNode curNode=" + curNode + " meringSet="
+ + mergingSet);
for (Iterator iterator = mergingSet.iterator(); iterator.hasNext();) {
HNode mergingNode = (HNode) iterator.next();
mapHNodeToCurrentHNode.put(mergingNode, newNode);
for (Iterator iterator = mergedNode.iterator(); iterator.hasNext();) {
HNode node = (HNode) iterator.next();
if (node.isMergeNode()) {
+ mergingSet.add(node);
mergingSet.addAll(getMergingSet(node));
} else {
mergingSet.add(node);
return mergingSet;
}
- private Set<Descriptor> getDescSetOfNode(HNode node) {
+ public Set<Descriptor> getDescSetOfNode(HNode node) {
if (!mapHNodeToDescSet.containsKey(node)) {
mapHNodeToDescSet.put(node, new HashSet<Descriptor>());
}
HNode outNode = getCombinationNode(combineNode);
addEdgeWithNoCycleCheck(combinationNode, outNode);
} else if (curNode.isSkeleton()) {
- // HNode dstNode = getHNode(curNode.getDescriptor());
+ // HNode dstNode2 = getHNode(curNode.getDescriptor());
HNode dstNode = getCurrentHNode(curNode);
+ // System.out.println("-----curNode=" + curNode + "------->" + dstNode + " dstNode2="
+ // + dstNode2);
addEdgeWithNoCycleCheck(combinationNode, dstNode);
}
}
public void assignUniqueIndexToNode() {
int idx = 1;
+ System.out.println("nodeSet=" + nodeSet);
for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
HNode node = (HNode) iterator.next();
mapHNodeToUniqueIndex.put(node, idx);
Set<HNode> reachableNodeSet = getReachableNodeSetFrom(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
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));
int idx = getHNodeIndex(reachableNode);
basis.remove(idx);
}