return mapParamDescToIdx;
}
- public FlowNode createIntermediateNode() {
+ public FlowNode createIntermediateNode(MethodDescriptor md) {
+
NTuple<Descriptor> tuple = new NTuple<Descriptor>();
Descriptor interDesc = new InterDescriptor(LocationInference.INTERLOC + interseed);
tuple.add(interDesc);
interseed++;
- FlowNode newNode = new FlowNode(tuple);
+ NTuple<Location> locTuple = new NTuple<Location>();
+ Location interLoc = new Location(md, interDesc);
+ locTuple.add(interLoc);
+
+ FlowNode newNode = new FlowNode(locTuple);
newNode.setIntermediate(true);
mapDescTupleToInferNode.put(tuple, newNode);
public FlowNode createNewFlowNode(NTuple<Descriptor> tuple) {
+ NTuple<Location> locTuple = translateToLocationTuple(tuple);
if (!mapDescTupleToInferNode.containsKey(tuple)) {
- FlowNode node = new FlowNode(tuple);
+
+ FlowNode node = new FlowNode(locTuple);
mapDescTupleToInferNode.put(tuple, node);
// nodeSet.add(node);
for (Iterator iterator = outEdgeSet.iterator(); iterator.hasNext();) {
FlowEdge edge = (FlowEdge) iterator.next();
- if (fn.getDescTuple().equals(edge.getInitTuple())) {
+ if (fn.getLocTuple().equals(edge.getInitTuple())) {
FlowNode dstNode = getFlowNode(edge.getEndTuple());
NTuple<Location> dstTuple = getLocationTuple(dstNode);
return getLocationTuple(getFlowNode(descTuple));
}
+ public NTuple<Location> translateToLocationTuple(NTuple<Descriptor> descTuple) {
+
+ NTuple<Location> locTuple = new NTuple<Location>();
+ ClassDescriptor cd = null;
+
+ Descriptor localDesc = descTuple.get(0);
+
+ if (localDesc instanceof InterDescriptor) {
+ Location interLoc = new Location(md, localDesc);
+ locTuple.add(interLoc);
+ } else if (localDesc.getSymbol().equals(LocationInference.TOPLOC)) {
+ Location topLoc = new Location(md, Location.TOP);
+ topLoc.setLocDescriptor(LocationInference.TOPDESC);
+ locTuple.add(topLoc);
+ } else if (localDesc.getSymbol().equals(LocationInference.GLOBALLOC)) {
+ Location globalLoc = new Location(md, LocationInference.GLOBALLOC);
+ globalLoc.setLocDescriptor(LocationInference.GLOBALDESC);
+ locTuple.add(globalLoc);
+ } else {
+ // normal case
+ for (int i = 0; i < descTuple.size(); i++) {
+ Descriptor curDesc = descTuple.get(i);
+ Location loc;
+ if (i == 0) {
+ loc = new Location(md, curDesc.getSymbol());
+ loc.setLocDescriptor(curDesc);
+ cd = ((VarDescriptor) curDesc).getType().getClassDesc();
+ } else {
+ loc = new Location(cd, curDesc.getSymbol());
+ loc.setLocDescriptor(curDesc);
+
+ if (curDesc instanceof FieldDescriptor) {
+ cd = ((FieldDescriptor) curDesc).getType().getClassDesc();
+ } else {
+ cd = ((LocationDescriptor) curDesc).getEnclosingClassDesc();
+ }
+
+ }
+ locTuple.add(loc);
+ }
+ }
+
+ return locTuple;
+ }
+
public NTuple<Location> getLocationTuple(FlowNode fn) {
if (!mapFlowNodeToLocTuple.containsKey(fn)) {
FlowNode u = flowEdge.getSrc();
FlowNode v = flowEdge.getDst();
- if (u.getDescTuple().equals(flowEdge.getInitTuple())
- && v.getDescTuple().equals(flowEdge.getEndTuple())) {
+ if (u.getLocTuple().equals(flowEdge.getInitTuple())
+ && v.getLocTuple().equals(flowEdge.getEndTuple())) {
// only draw an edge of the actual value flow
if (!addedEdgeSet.contains(flowEdge)) {
while (iter.hasNext()) {
FlowNode node = iter.next();
- if (node.getDescTuple().size() == 1) {
+ if (node.getLocTuple().size() == 1) {
// here, we just care about the local variable
if (node.getFieldNodeSet().size() > 0) {
drawSubgraph(node, bw, addedEdgeSet);
public class FlowNode {
// descriptor tuple is a unique identifier of the flow node
- private NTuple<Descriptor> descTuple;
+ private NTuple<Location> locTuple;
// if the infer node represents the base type of field access,
// this set contains fields of the base type
return fieldNodeSet;
}
- public FlowNode(NTuple<Descriptor> tuple) {
+ public FlowNode(NTuple<Location> tuple) {
this.isSkeleton = false;
this.isIntermediate = false;
- NTuple<Descriptor> base = null;
- Descriptor desc = null;
+ NTuple<Location> base = null;
+ Location loc = null;
if (tuple.size() > 1) {
base = tuple.subList(0, tuple.size() - 1);
- desc = tuple.get(tuple.size() - 1);
+ loc = tuple.get(tuple.size() - 1);
} else {
base = tuple;
}
fieldNodeSet = new HashSet<FlowNode>();
- descTuple = new NTuple<Descriptor>();
+ locTuple = new NTuple<Location>();
if (base != null) {
- descTuple.addAll(base);
+ locTuple.addAll(base);
}
- if (desc != null) {
- descTuple.add(desc);
+ if (loc != null) {
+ locTuple.add(loc);
}
}
fieldNodeSet.add(node);
}
- public NTuple<Descriptor> getDescTuple() {
- return descTuple;
- }
-
- public Descriptor getOwnDescriptor() {
- return descTuple.get(descTuple.size() - 1);
+ public NTuple<Location> getLocTuple() {
+ return locTuple;
}
public boolean isReturn() {
this.isReturn = isReturn;
}
- public boolean isPrimitiveType() {
- Descriptor desc = descTuple.get(descTuple.size() - 1);
- if (desc instanceof VarDescriptor) {
- return ((VarDescriptor) desc).getType().isPrimitive();
- } else if (desc instanceof FieldDescriptor) {
- return ((FieldDescriptor) desc).getType().isPrimitive();
- }
- return false;
- }
-
public String toString() {
String rtr = "[FlowNode]:";
if (isSkeleton()) {
rtr += "SKELETON:";
}
- rtr += ":" + descTuple;
+ rtr += ":" + locTuple;
return rtr;
}
-
public int hashCode() {
- return 7 + descTuple.hashCode();
+ return 7 + locTuple.hashCode();
}
public boolean equals(Object obj) {
if (obj instanceof FlowNode) {
FlowNode in = (FlowNode) obj;
- if (descTuple.equals(in.getDescTuple())) {
+ if (locTuple.equals(in.getLocTuple())) {
return true;
}
}
public String getID() {
String id = "";
- for (int i = 0; i < descTuple.size(); i++) {
- id += descTuple.get(i).getSymbol();
+ for (int i = 0; i < locTuple.size(); i++) {
+ id += locTuple.get(i).getSymbol();
}
return id;
}
public String getPrettyID() {
String id = "<";
String property = "";
- for (int i = 0; i < descTuple.size(); i++) {
+ for (int i = 0; i < locTuple.size(); i++) {
if (i != 0) {
id += ",";
}
- id += descTuple.get(i).getSymbol();
+ id += locTuple.get(i).getSymbol();
}
id += ">";
return isDeclarationNode;
}
+ public NTuple<Location> getCurrentLocTuple() {
+ if (compLoc == null) {
+ return locTuple;
+ }
+ NTuple<Location> curLocTuple = new NTuple<Location>();
+ for (int i = 0; i < compLoc.getSize(); i++) {
+ Location locElement = compLoc.get(i);
+ curLocTuple.add(locElement);
+ }
+ return curLocTuple;
+ }
+
public NTuple<Descriptor> getCurrentDescTuple() {
if (compLoc == null) {
- return descTuple;
+ return getDescTuple();
}
NTuple<Descriptor> curDescTuple = new NTuple<Descriptor>();
this.isSkeleton = isSkeleton;
}
+ public NTuple<Descriptor> getDescTuple() {
+ NTuple<Descriptor> descTuple = new NTuple<Descriptor>();
+ for (int i = 0; i < locTuple.size(); i++) {
+ descTuple.add(locTuple.get(i).getLocDescriptor());
+ }
+ return descTuple;
+ }
+
}
}
}
+
+ // DEBUG: write a global flow graph
+ MethodDescriptor mdContainingSSJavaLoop = ssjava.getMethodContainingSSJavaLoop();
+ FlowGraph globalFlowGraph = getSubGlobalFlowGraph(mdContainingSSJavaLoop);
+ // System.out.println("GLOBAL NODE SET=" + globalFlowGraph.getNodeSet());
+ assignCompositeLocation(globalFlowGraph);
+ try {
+ globalFlowGraph.writeGraph("_GLOBAL");
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
// _debug_printGraph();
}
+ private void assignCompositeLocation(FlowGraph globalFlowGraph) {
+ Set<FlowNode> nodeSet = globalFlowGraph.getNodeSet();
+
+ for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
+ FlowNode flowNode = (FlowNode) iterator.next();
+ Set<FlowNode> inNodeSet = globalFlowGraph.getIncomingFlowNodeSet(flowNode);
+ Set<FlowNode> reachableNodeSet = globalFlowGraph.getReachFlowNodeSetFrom(flowNode);
+
+ // System.out.println("flowNode=" + flowNode + " incoming=" + inNodeSet);
+ // System.out.println("reachableNodeSet=" + reachableNodeSet);
+
+ Map<NTuple<Location>, Set<NTuple<Descriptor>>> mapPrefixToIncomingLocTupleSet =
+ new HashMap<NTuple<Location>, Set<NTuple<Descriptor>>>();
+
+ List<NTuple<Descriptor>> prefixList = new ArrayList<NTuple<Descriptor>>();
+
+ for (Iterator iterator2 = inNodeSet.iterator(); iterator2.hasNext();) {
+ FlowNode inNode = (FlowNode) iterator2.next();
+
+ NTuple<Descriptor> inNodeTuple = inNode.getCurrentDescTuple();
+
+ // CompositeLocation inNodeInferredLoc =
+ // generateInferredCompositeLocation(methodInfo, inNodeTuple);
+ // NTuple<Location> inNodeInferredLocTuple = inNodeInferredLoc.getTuple();
+
+ for (int i = 1; i < inNodeTuple.size(); i++) {
+ NTuple<Descriptor> prefix = inNodeTuple.subList(0, i);
+ if (!prefixList.contains(prefix)) {
+ prefixList.add(prefix);
+ }
+ }
+ }
+
+ Collections.sort(prefixList, new Comparator<NTuple<Descriptor>>() {
+ public int compare(NTuple<Descriptor> arg0, NTuple<Descriptor> arg1) {
+ int s0 = arg0.size();
+ int s1 = arg1.size();
+ if (s0 > s1) {
+ return -1;
+ } else if (s0 == s1) {
+ return 0;
+ } else {
+ return 1;
+ }
+ }
+ });
+
+ // find out reachable nodes that have the longest common prefix
+ for (int i = 0; i < prefixList.size(); i++) {
+ NTuple<Descriptor> curPrefix = prefixList.get(i);
+ Set<NTuple<Descriptor>> reachableCommonPrefixSet = new HashSet<NTuple<Descriptor>>();
+
+ for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) {
+ FlowNode reachableNode = (FlowNode) iterator2.next();
+ NTuple<Descriptor> reachLocTuple = reachableNode.getCurrentDescTuple();
+ if (reachLocTuple.startsWith(curPrefix)) {
+ reachableCommonPrefixSet.add(reachLocTuple);
+ }
+ }
+
+ if (!reachableCommonPrefixSet.isEmpty()) {
+ // found reachable nodes that start with the prefix curPrefix
+ // need to assign a composite location
+ // System.out.println("-prefixList=" + prefixList);
+ // System.out.println("-reachableCommonPrefixSet=" + reachableCommonPrefixSet);
+ // System.out.println("-curPrefix=" + curPrefix);
+
+ // first, check if there are more than one the set of locations that has
+ // the same length of the longest reachable prefix, no way to assign
+ // a composite location to the input local var
+ prefixSanityCheck(prefixList, i, globalFlowGraph, reachableNodeSet);
+
+ MethodDescriptor topMethodDesc = globalFlowGraph.getMethodDescriptor();
+ CompositeLocation newCompLoc = generateCompositeLocation(curPrefix, topMethodDesc);
+
+ System.out.println("SET COMPOSITE LOCATION=" + newCompLoc + " to " + flowNode);
+ flowNode.setCompositeLocation(newCompLoc);
+ }
+ }
+
+ }
+
+ }
+
+ private CompositeLocation generateCompositeLocation(NTuple<Descriptor> curPrefix,
+ MethodDescriptor md) {
+ CompositeLocation newCompLoc = new CompositeLocation();
+
+ Descriptor enclosingDesc = md;
+ for (int i = 0; i < curPrefix.size(); i++) {
+ Descriptor curDesc = curPrefix.get(i);
+ Location loc = new Location(enclosingDesc, curDesc.getSymbol());
+ newCompLoc.addLocation(loc);
+ if (i == 0) {
+ VarDescriptor varDesc = (VarDescriptor) curDesc;
+ enclosingDesc = varDesc.getType().getClassDesc();
+ } else {
+ FieldDescriptor fieldDesc = (FieldDescriptor) curDesc;
+ enclosingDesc = fieldDesc.getType().getClassDesc();
+ }
+ }
+
+ LocationDescriptor newLocDescriptor = generateNewLocationDescriptor();
+ newLocDescriptor.setEnclosingClassDesc((ClassDescriptor) enclosingDesc);
+
+ Location newLoc = new Location(enclosingDesc, newLocDescriptor.getSymbol());
+ newLoc.setLocDescriptor(newLocDescriptor);
+ newCompLoc.addLocation(newLoc);
+
+ return newCompLoc;
+ }
+
+ private void prefixSanityCheck(List<NTuple<Descriptor>> prefixList, int curIdx,
+ FlowGraph globalFlowGraph, Set<FlowNode> reachableNodeSet) {
+
+ NTuple<Descriptor> curPrefix = prefixList.get(curIdx);
+
+ for (int i = curIdx + 1; i < prefixList.size(); i++) {
+ NTuple<Descriptor> prefixTuple = prefixList.get(i);
+
+ if (curPrefix.startsWith(prefixTuple)) {
+ continue;
+ }
+
+ for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) {
+ FlowNode reachableNode = (FlowNode) iterator2.next();
+ NTuple<Descriptor> reachLocTuple = reachableNode.getCurrentDescTuple();
+ if (reachLocTuple.startsWith(prefixTuple)) {
+ throw new Error(
+ "Failed to generate a composite location because there is more than one prefix which is reach to the current node.");
+ }
+ }
+ }
+
+ }
+
private void addValueFlowsFromCalleeSubGlobalFlowGraph(MethodDescriptor mdCaller,
FlowGraph subGlobalFlowGraph) {
return callerTuple;
}
- private NTuple<Descriptor> traslateToCalleeParamTupleToCallerArgTuple(
- NTuple<Descriptor> calleeInitTuple, NTuple<Descriptor> callerSrcTuple) {
-
- NTuple<Descriptor> callerInitTuple = new NTuple<Descriptor>();
-
- for (int i = 0; i < callerSrcTuple.size(); i++) {
- callerInitTuple.add(callerSrcTuple.get(i));
- }
-
- for (int i = 1; i < calleeInitTuple.size(); i++) {
- callerInitTuple.add(calleeInitTuple.get(i));
- }
-
- return callerInitTuple;
- }
-
private NTuple<Descriptor> translateToCaller(NTuple<Descriptor> dstDescTuple,
NTuple<Descriptor> baseTuple) {
NTuple<Descriptor> callerDescTuple = new NTuple<Descriptor>();
for (int paramIdx = 0; paramIdx < flowGraph.getNumParameters(); paramIdx++) {
FlowNode flowNode = flowGraph.getParamFlowNode(paramIdx);
- NTuple<Descriptor> descTuple = flowNode.getDescTuple();
+ NTuple<Location> locTuple = flowNode.getLocTuple();
CompositeLocation assignedCompLoc = flowNode.getCompositeLocation();
CompositeLocation inferredCompLoc;
if (assignedCompLoc != null) {
inferredCompLoc = translateCompositeLocation(assignedCompLoc);
} else {
- Descriptor locDesc = descTuple.get(0);
- Location loc = new Location(md, locDesc.getSymbol());
- loc.setLocDescriptor(locDesc);
+ Location loc = locTuple.get(0);
inferredCompLoc = new CompositeLocation(loc);
}
System.out.println("-paramIdx=" + paramIdx + " infer=" + inferredCompLoc);
Set<FlowNode> nodeSet = fg.getNodeSet();
for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
FlowNode flowNode = (FlowNode) iterator.next();
- if (flowNode.getDescTuple().get(0).equals(md.getThis())) {
+ if (flowNode.getLocTuple().get(0).equals(md.getThis())) {
return true;
}
}
CompositeLocation inferSrcLoc;
CompositeLocation inferDstLoc = methodInfo.getInferLocation(dstDesc);
- if (srcNode.getDescTuple().size() > 1) {
+ if (srcNode.getLocTuple().size() > 1) {
// field access
inferSrcLoc = new CompositeLocation();
inferSrcLoc = methodInfo.getInferLocation(srcDesc);
}
- if (dstNode.getDescTuple().size() > 1) {
+ if (dstNode.getLocTuple().size() > 1) {
// field access
inferDstLoc = new CompositeLocation();
// first, check if there are more than one the set of locations that has
// the same length of the longest reachable prefix, no way to assign
// a composite location to the input local var
- prefixSanityCheck(prefixList, i, flowGraph, reachableNodeSet);
+ // prefixSanityCheck(prefixList, i, flowGraph, reachableNodeSet);
Set<NTuple<Location>> incomingCommonPrefixSet =
mapPrefixToIncomingLocTupleSet.get(curPrefix);
methodInfo.removeMaplocalVarToLocSet(srcLocalVar);
// add the field/var descriptor to the set of the location symbol
- int lastIdx = srcNode.getDescTuple().size() - 1;
+ int lastIdx = srcNode.getLocTuple().size() - 1;
Descriptor lastFlowNodeDesc = srcNode.getDescTuple().get(lastIdx);
NTuple<Location> srcNodelocTuple = flowGraph.getLocationTuple(srcNode);
Descriptor enclosinglastLastFlowNodeDesc = srcNodelocTuple.get(lastIdx).getDescriptor();
methodInfo.removeMaplocalVarToLocSet(localVarDesc);
// add the field/var descriptor to the set of the location symbol
- int lastIdx = flowNode.getDescTuple().size() - 1;
+ int lastIdx = flowNode.getLocTuple().size() - 1;
Descriptor lastFlowNodeDesc = flowNode.getDescTuple().get(lastIdx);
Descriptor enclosinglastLastFlowNodeDesc = flowNodelocTuple.get(lastIdx).getDescriptor();
}
- private void prefixSanityCheck(List<NTuple<Location>> prefixList, int curIdx,
- FlowGraph flowGraph, Set<FlowNode> reachableNodeSet) {
-
- NTuple<Location> curPrefix = prefixList.get(curIdx);
-
- for (int i = curIdx + 1; i < prefixList.size(); i++) {
- NTuple<Location> prefixTuple = prefixList.get(i);
-
- if (curPrefix.startsWith(prefixTuple)) {
- continue;
- }
-
- for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) {
- FlowNode reachableNode = (FlowNode) iterator2.next();
- NTuple<Location> reachLocTuple = flowGraph.getLocationTuple(reachableNode);
- if (reachLocTuple.startsWith(prefixTuple)) {
- // TODO
- throw new Error("Failed to generate a composite location");
- }
- }
- }
- }
-
public boolean isPrimitiveLocalVariable(FlowNode node) {
VarDescriptor varDesc = (VarDescriptor) node.getDescTuple().get(0);
return varDesc.getType().isPrimitive();
private void extractRelationFromFieldFlows(ClassDescriptor cd, FlowNode srcNode,
FlowNode dstNode, int idx) throws CyclicFlowException {
- if (srcNode.getDescTuple().get(idx).equals(dstNode.getDescTuple().get(idx))
- && srcNode.getDescTuple().size() > (idx + 1) && dstNode.getDescTuple().size() > (idx + 1)) {
+ if (srcNode.getLocTuple().get(idx).equals(dstNode.getLocTuple().get(idx))
+ && srcNode.getLocTuple().size() > (idx + 1) && dstNode.getLocTuple().size() > (idx + 1)) {
// value flow between fields: we don't need to add a binary relation
// for this case
if (newImplicitTupleSet.size() > 1) {
// need to create an intermediate node for the GLB of conditional locations & implicit flows
- NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+ NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple();
for (Iterator<NTuple<Descriptor>> idxIter = newImplicitTupleSet.iterator(); idxIter.hasNext();) {
NTuple<Descriptor> tuple = idxIter.next();
addFlowGraphEdge(md, tuple, interTuple);
currentFlowTupleSet.addTupleSet(implicitFlowTupleSet);
if (currentFlowTupleSet.size() > 1) {
- FlowNode meetNode = fg.createIntermediateNode();
+ FlowNode meetNode = fg.createIntermediateNode(md);
for (Iterator iterator = currentFlowTupleSet.iterator(); iterator.hasNext();) {
NTuple<Descriptor> currentFlowTuple = (NTuple<Descriptor>) iterator.next();
fg.addValueFlowEdge(currentFlowTuple, meetNode.getDescTuple());
if (newImplicitTupleSet.size() > 1) {
// need to create an intermediate node for the GLB of conditional locations & implicit flows
- NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+ NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple();
for (Iterator<NTuple<Descriptor>> idxIter = newImplicitTupleSet.iterator(); idxIter
.hasNext();) {
NTuple<Descriptor> tuple = idxIter.next();
implicitFlowTupleSet, false);
// ///////////
- NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+ NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple();
for (Iterator<NTuple<Descriptor>> idxIter = condTupleNode.iterator(); idxIter.hasNext();) {
NTuple<Descriptor> tuple = idxIter.next();
if (newImplicitTupleSet.size() > 1) {
// need to create an intermediate node for the GLB of conditional locations & implicit flows
- NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+ NTuple<Descriptor> interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple();
for (Iterator<NTuple<Descriptor>> idxIter = newImplicitTupleSet.iterator(); idxIter.hasNext();) {
NTuple<Descriptor> tuple = idxIter.next();
addFlowGraphEdge(md, tuple, interTuple);
// creates edges from RHS to LHS
NTuple<Descriptor> interTuple = null;
if (nodeSetRHS.size() > 1) {
- interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+ interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple();
}
for (Iterator<NTuple<Descriptor>> iter = nodeSetRHS.iterator(); iter.hasNext();) {
NTuple<Descriptor> argTuple = new NTuple<Descriptor>();
if (argTupleSet.size() > 1) {
NTuple<Descriptor> interTuple =
- getFlowGraph(md).createIntermediateNode().getDescTuple();
+ getFlowGraph(md).createIntermediateNode(md).getDescTuple();
for (Iterator<NTuple<Descriptor>> idxIter = argTupleSet.iterator(); idxIter.hasNext();) {
NTuple<Descriptor> tuple = idxIter.next();
addFlowGraphEdge(md, tuple, interTuple);
// creates edges from RHS to LHS
NTuple<Descriptor> interTuple = null;
if (nodeSetRHS.size() > 1) {
- interTuple = getFlowGraph(md).createIntermediateNode().getDescTuple();
+ interTuple = getFlowGraph(md).createIntermediateNode(md).getDescTuple();
}
for (Iterator<NTuple<Descriptor>> iter = nodeSetRHS.iterator(); iter.hasNext();) {