Examples with NodeVisitor com.oracle.truffle.api.nodes.NodeVisitor used on opensource projects

Example 6 with NodeVisitor

use of com.oracle.truffle.api.nodes.NodeVisitor in project graal by oracle.

the class SLLexicalScope method findChildrenBlock.

private static SLBlockNode findChildrenBlock(Node node) {
    SLBlockNode[] blockPtr = new SLBlockNode[1];
    node.accept(new NodeVisitor() {

        @Override
        public boolean visit(Node n) {
            if (n instanceof SLBlockNode) {
                blockPtr[0] = (SLBlockNode) n;
                return false;
            } else {
                return true;
            }
        }
    });
    return blockPtr[0];
}

Example 7 with NodeVisitor

use of com.oracle.truffle.api.nodes.NodeVisitor in project graal by oracle.

the class SLLexicalScope method collectVars.

private Map<String, FrameSlot> collectVars(Node varsBlock, Node currentNode) {
    // Variables are slot-based.
    // To collect declared variables, traverse the block's AST and find slots associated
    // with SLWriteLocalVariableNode. The traversal stops when we hit the current node.
    Map<String, FrameSlot> slots = new LinkedHashMap<>(4);
    NodeUtil.forEachChild(varsBlock, new NodeVisitor() {

        @Override
        public boolean visit(Node node) {
            if (node == currentNode) {
                return false;
            }
            // Do not enter any nested blocks.
            if (!(node instanceof SLBlockNode)) {
                boolean all = NodeUtil.forEachChild(node, this);
                if (!all) {
                    return false;
                }
            }
            // Write to a variable is a declaration unless it exists already in a parent scope.
            if (node instanceof SLWriteLocalVariableNode) {
                SLWriteLocalVariableNode wn = (SLWriteLocalVariableNode) node;
                String name = Objects.toString(wn.getSlot().getIdentifier());
                if (!hasParentVar(name)) {
                    slots.put(name, wn.getSlot());
                }
            }
            return true;
        }
    });
    return slots;
}

Example 8 with NodeVisitor

use of com.oracle.truffle.api.nodes.NodeVisitor in project graal by oracle.

the class DefaultNearestNodeSearch method findChildTaggedNode.

/**
 * Finds the nearest tagged {@link Node node}. See the algorithm description at
 * {@link InstrumentableNode#findNearestNodeAt(int, Set)}.
 */
private static Node findChildTaggedNode(Node node, int offset, Set<Class<? extends Tag>> tags, boolean haveOuterCandidate, boolean preferFirst) {
    Node[] highestLowerNode = new Node[] { null };
    Node[] highestLowerTaggedNode = new Node[] { null };
    Node[] lowestHigherNode = new Node[] { null };
    Node[] lowestHigherTaggedNode = new Node[] { null };
    final Node[] foundNode = new Node[] { null };
    NodeUtil.forEachChild(node, new NodeVisitor() {

        int highestLowerNodeIndex = 0;

        int highestLowerTaggedNodeIndex = 0;

        int lowestHigherNodeIndex = 0;

        int lowestHigherTaggedNodeIndex = 0;

        @Override
        public boolean visit(Node childNode) {
            Node ch = childNode;
            if (ch instanceof WrapperNode) {
                ch = ((WrapperNode) ch).getDelegateNode();
            }
            SourceSection ss;
            if (ch instanceof InstrumentableNode && ((InstrumentableNode) ch).isInstrumentable()) {
                ch = (Node) ((InstrumentableNode) ch).materializeInstrumentableNodes(tags);
                ss = ch.getSourceSection();
                if (ss == null) {
                    return true;
                }
            } else {
                // An unknown node, process its children on the same level.
                NodeUtil.forEachChild(ch, this);
                return foundNode[0] == null;
            }
            boolean isTagged = isTaggedWith((InstrumentableNode) ch, tags);
            int i1 = ss.getCharIndex();
            int i2 = getCharEndIndex(ss);
            if (isTagged && offset == i1) {
                // We're at it
                foundNode[0] = ch;
                return false;
            }
            if (i1 <= offset && offset <= i2) {
                // In an encapsulating source section
                Node taggedNode = findChildTaggedNode(ch, offset, tags, isTagged || haveOuterCandidate, preferFirst);
                if (taggedNode != null) {
                    foundNode[0] = taggedNode;
                    return false;
                }
                if (isTagged) {
                    // If nothing in and is tagged, return it
                    foundNode[0] = ch;
                    return false;
                }
            }
            if (offset < i1) {
                // We're after the offset
                if (lowestHigherNode[0] == null || lowestHigherNodeIndex > i1) {
                    lowestHigherNode[0] = ch;
                    lowestHigherNodeIndex = i1;
                }
                if (isTagged) {
                    if (lowestHigherTaggedNode[0] == null || lowestHigherTaggedNodeIndex > i1) {
                        lowestHigherTaggedNode[0] = ch;
                        lowestHigherTaggedNodeIndex = i1;
                    }
                }
            }
            if (i2 < offset) {
                // We're before the offset
                if (highestLowerNode[0] == null || (preferFirst ? i1 < highestLowerNodeIndex : highestLowerNodeIndex < i1)) {
                    highestLowerNode[0] = ch;
                    highestLowerNodeIndex = i1;
                }
                if (isTagged) {
                    if (highestLowerTaggedNode[0] == null || (preferFirst ? i1 < highestLowerTaggedNodeIndex : highestLowerTaggedNodeIndex < i1)) {
                        highestLowerTaggedNode[0] = ch;
                        highestLowerTaggedNodeIndex = i1;
                    }
                }
            }
            return true;
        }
    });
    if (foundNode[0] != null) {
        return foundNode[0];
    }
    Node primaryNode;
    Node primaryTaggedNode;
    Node secondaryNode;
    Node secondaryTaggedNode;
    if (preferFirst) {
        // Prefer node before the offset:
        primaryNode = highestLowerNode[0];
        primaryTaggedNode = highestLowerTaggedNode[0];
        secondaryNode = lowestHigherNode[0];
        secondaryTaggedNode = lowestHigherTaggedNode[0];
    } else {
        // Prefer node after the offset:
        primaryNode = lowestHigherNode[0];
        primaryTaggedNode = lowestHigherTaggedNode[0];
        secondaryNode = highestLowerNode[0];
        secondaryTaggedNode = highestLowerTaggedNode[0];
    }
    if (isTaggedWith(primaryNode, tags)) {
        return primaryNode;
    }
    if (isTaggedWith(secondaryNode, tags)) {
        return secondaryNode;
    }
    // Try to go in the preferred node:
    Node taggedNode = null;
    if (!haveOuterCandidate) {
        if (primaryNode != null) {
            taggedNode = findChildTaggedNode(primaryNode, offset, tags, haveOuterCandidate, true);
        }
    }
    if (taggedNode == null && primaryTaggedNode != null) {
        return primaryTaggedNode;
    }
    // Try to go in a node before:
    if (!haveOuterCandidate) {
        if (taggedNode == null && secondaryNode != null) {
            taggedNode = findChildTaggedNode(secondaryNode, offset, tags, haveOuterCandidate, true);
        }
    }
    if (taggedNode == null && secondaryTaggedNode != null) {
        return secondaryTaggedNode;
    }
    return taggedNode;
}

Example 9 with NodeVisitor

use of com.oracle.truffle.api.nodes.NodeVisitor in project graal by oracle.

the class TruffleInlining method getCallNodes.

private static List<OptimizedDirectCallNode> getCallNodes(OptimizedCallTarget target) {
    final List<OptimizedDirectCallNode> callNodes = new ArrayList<>();
    target.getRootNode().accept(new NodeVisitor() {

        @Override
        public boolean visit(Node node) {
            if (node instanceof OptimizedDirectCallNode) {
                callNodes.add((OptimizedDirectCallNode) node);
            }
            return true;
        }
    });
    return callNodes;
}

Example 10 with NodeVisitor

use of com.oracle.truffle.api.nodes.NodeVisitor in project graal by oracle.

the class NodeUtilTest method testAccept.

@Test
public void testAccept() {
    TestRootNode root = new TestRootNode();
    TestForEachNode testForEachNode = new TestForEachNode(1);
    root.child0 = testForEachNode;
    TestNode testNode1 = new TestNode();
    testForEachNode.firstChild = testNode1;
    TestNode testNode2 = new TestNode();
    testForEachNode.children[0] = testNode2;
    TestNode testNode3 = new TestNode();
    testForEachNode.lastChild = testNode3;
    root.adoptChildren();
    int[] count = new int[1];
    testForEachNode.accept(new NodeVisitor() {

        public boolean visit(Node node) {
            ((VisitableNode) node).visited++;
            count[0]++;
            return true;
        }
    });
    Assert.assertEquals(4, count[0]);
    Assert.assertEquals(1, testForEachNode.visited);
    Assert.assertEquals(1, testNode1.visited);
    Assert.assertEquals(1, testNode2.visited);
    Assert.assertEquals(1, testNode3.visited);
}