/** * Returns the type of a ControlFlowGraphNode * @param node The node * @return The type of the given node */ public static CFGNodeType getTypeOfCFGNode(Node node) { if (node == null) { return null; } node.accept(getter); return getter.type; }
/** * Inserts another node right before this node. * <p/> * The new node is added as a successor of all predecessors of this node and this node is set as the successor of the new * node. * * @param newNode The node that should be inserted. */ public void insertBefore(SequentialNode newNode) { newNode.setSuccessor(this); Set<Node> predecessors = new HashSet<Node>(getPredecessors()); for (Node predecessor : predecessors) { predecessor.replaceSuccessor(this, newNode); } predecessors.clear(); // previous predecessors are no predecessors anymore addPredecessor(newNode); } }
/** * Removes the given node from the control flow graph. The graph will be traversed in order to find the node to be * removed. Once the desired node is found, its predecessors are rewired to have the old node's successor as direct * successors. * * @param node node to be removed */ public void removeNode(SequentialNode node) { Node successor = node.getSuccessor(); successor.removePredecessor(node); Set<Node> predecessors = new HashSet<Node>(node.getPredecessors()); for (Node predecessor : predecessors) { successor.addPredecessor(predecessor); predecessor.replaceSuccessor(node, successor); } }
@Override public void replaceSuccessor(Node oldSuccessor, Node newSuccessor) { if (successor == oldSuccessor) { successor = null; oldSuccessor.removePredecessor(this); newSuccessor.removePredecessor(oldSuccessor); newSuccessor.addPredecessor(this); successor = newSuccessor; } }
private void addPredecessorEdges(Node node) { // Add edges back to predecessors for (Node predecessor : node.getPredecessors()) { addBackwardsEdge(node, predecessor); } }
@Override public void replaceSuccessor(Node oldSuccessor, Node newSuccessor) { if (oldSuccessor == body) { newSuccessor.removePredecessor(oldSuccessor); newSuccessor.addPredecessor(this); body = (SequentialNode) newSuccessor; } else { super.replaceSuccessor(oldSuccessor, newSuccessor); } }
@Override public void visit(Macro node) { // ignore body of macro node.getSuccessor().accept(this); }
/** * Inserts a node after this sequential node and its successor. This method will rewire the nodes to keep the graph * consistent. It will do the following: * <ol> * <li>Remove the connection between this node and its successor.</li> * <li>Add a bi-directional connection between this node and the new node.</li> * <li>Add a bi-directional connection between the new node and this nodes old successor.</li> * </ol> * * @param newNode The new node that should be inserted in the control flow after this one. */ public void insertAfter(SequentialNode newNode) { Node oldSuccessor = successor; successor = newNode; newNode.addPredecessor(this); if (oldSuccessor != null) { newNode.successor = oldSuccessor; oldSuccessor.removePredecessor(this); oldSuccessor.addPredecessor(newNode); } }
/** * {@inheritDoc} * * This empty implementation visits the successor node by default. */ @Override public void visit(BreakNode node) { node.getSuccessor().accept(this); }
@Override public void replaceSuccessor(Node oldSuccessor, Node newSuccessor) { if (oldSuccessor == positive) { newSuccessor.removePredecessor(oldSuccessor); newSuccessor.addPredecessor(this); // cast is safe since branch of if-then-else cannot be the end node setPositive((SequentialNode) newSuccessor); } else if (oldSuccessor == negative) { newSuccessor.removePredecessor(oldSuccessor); newSuccessor.addPredecessor(this); // cast is safe since branch of if-then-else cannot be the end node setNegative((SequentialNode) newSuccessor); } else { super.replaceSuccessor(oldSuccessor, newSuccessor); } }
/** * {@inheritDoc} * * This empty implementation visits the successor node by default. */ @Override public void visit(Macro node) { node.getSuccessor().accept(this); }
@Override public void visit(StartNode node) { code.append("\\begin{align*}\n"); node.getSuccessor().accept(this); }
@Override public void visit(BreakNode breakNode) { code.append("\\text{break}\\\\"); breakNode.getSuccessor().accept(this); }
/** * {@inheritDoc} * * This empty implementation visits the successor node by default. */ @Override public void visit(AssignmentNode node) { node.getSuccessor().accept(this); }
/** * {@inheritDoc} * * This empty implementation visits the successor node by default. */ @Override public void visit(StoreResultNode node) { node.getSuccessor().accept(this); }
@Override public void visit(StoreResultNode node) { System.out.println("MyStoreResultVisit"); node.getSuccessor().accept(this); // TODO Auto-generated method stub }
@Override public void visit(StartNode node) { // just do nothing, because only MulitvectorComponent is important node.getSuccessor().accept(this); }
@Override public void visit(Macro node) { // ignore body of macro node.getSuccessor().accept(this); }
@Override public void visit(ColorNode node) { node.getSuccessor().accept(this); } }
@Override public void visit(ExpressionStatement node) { nodeList.addLast(node); node.getSuccessor().accept(this); }