From 53f2a67b9d00cf3eaa7a55e23da5707011ec1f8c Mon Sep 17 00:00:00 2001 From: Tom Wieczorek Date: Sun, 10 Jul 2016 15:54:23 +0200 Subject: [PATCH 1/4] Add an iterative version of the ParseTreeWalker --- .../tree/IterativeParseTreeWalker.java | 151 ++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java b/runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java new file mode 100644 index 000000000..8a230511e --- /dev/null +++ b/runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java @@ -0,0 +1,151 @@ +/* + * [The "BSD license"] + * Copyright (c) 2012 Terence Parr + * Copyright (c) 2012 Sam Harwell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.antlr.v4.runtime.tree; + +/** + * An iterative (read: non-recursive) pre-order and post-order tree walker that + * doesn't use the thread stack but it's own heap-based stack using linked data + * structures. Makes it possible to process deeply nested parse trees. + */ +public class IterativeParseTreeWalker extends ParseTreeWalker { + public static final ParseTreeWalker DEFAULT = new IterativeParseTreeWalker(); + + @Override + public void walk(final ParseTreeListener listener, final ParseTree t) { + for (WalkerNode currentNode = createNode(null, t, 0); currentNode != null;) { + currentNode.enter(listener); // Pre order visit + + // Move down to first child + WalkerNode nextNode = currentNode.getFirstChild(); + if (nextNode != null) { + currentNode = nextNode; + continue; + } + + // No child nodes, so walk tree + while (currentNode != null) { + currentNode.exit(listener); // Post order visit + + // Move to sibling if possible + nextNode = currentNode.getNextSibling(); + if (nextNode != null) { + currentNode = nextNode; + break; + } + + // Move up + currentNode = currentNode.getParentNode(); + } + } + } + + protected WalkerNode createNode(final WalkerNode parent, final ParseTree self, final int pos) { + if (self instanceof ErrorNode) { + return new ErrorWalkerNode(parent, (ErrorNode) self, pos); + } else if (self instanceof TerminalNode) { + return new TerminalWalkerNode(parent, (TerminalNode) self, pos); + } else { + return new RuleWalkerNode(parent, (RuleNode) self, pos); + } + } + + protected abstract class WalkerNode { + private final WalkerNode parent; + protected final N self; + private final int pos; + + protected WalkerNode(final WalkerNode parent, final N self, final int pos) { + this.parent = parent; + this.self = self; + this.pos = pos; + } + + public WalkerNode getFirstChild() { + return self.getChildCount() > 0 ? createChildNode(0) : null; + } + + public WalkerNode getNextSibling() { + return parent != null && parent.self.getChildCount() > pos + 1 ? parent.createChildNode(pos + 1) : null; + } + + public WalkerNode getParentNode() { + return parent; + } + + public abstract void enter(ParseTreeListener listener); + + public void exit(final ParseTreeListener listener) { + // defaults to do nothing + } + + protected WalkerNode createChildNode(final int pos) { + return createNode(this, self.getChild(pos), pos); + } + } + + protected class RuleWalkerNode extends WalkerNode { + public RuleWalkerNode(final WalkerNode parent, final RuleNode self, final int pos) { + super(parent, self, pos); + } + + @Override + public void enter(final ParseTreeListener listener) { + enterRule(listener, self); + } + + @Override + public void exit(final ParseTreeListener listener) { + exitRule(listener, self); + } + } + + protected class ErrorWalkerNode extends WalkerNode { + public ErrorWalkerNode(final WalkerNode parent, final ErrorNode self, final int pos) { + super(parent, self, pos); + } + + @Override + public void enter(final ParseTreeListener listener) { + listener.visitErrorNode(self); + } + } + + protected class TerminalWalkerNode extends WalkerNode { + public TerminalWalkerNode(final WalkerNode parent, final TerminalNode self, final int pos) { + super(parent, self, pos); + } + + @Override + public void enter(final ParseTreeListener listener) { + listener.visitTerminal(self); + } + } +} From 7ca7acd084cfd156316d1063920efededcf9cce5 Mon Sep 17 00:00:00 2001 From: Tom Wieczorek Date: Wed, 20 Jul 2016 09:17:50 +0200 Subject: [PATCH 2/4] Use two queues instead of a custom linked memory structure --- .../tree/IterativeParseTreeWalker.java | 156 ++++++------------ 1 file changed, 54 insertions(+), 102 deletions(-) diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java b/runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java index 8a230511e..ebdf70998 100644 --- a/runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java +++ b/runtime/Java/src/org/antlr/v4/runtime/tree/IterativeParseTreeWalker.java @@ -30,122 +30,74 @@ package org.antlr.v4.runtime.tree; +import java.util.ArrayDeque; +import java.util.Deque; + +import org.antlr.v4.runtime.misc.IntegerStack; + /** * An iterative (read: non-recursive) pre-order and post-order tree walker that - * doesn't use the thread stack but it's own heap-based stack using linked data - * structures. Makes it possible to process deeply nested parse trees. + * doesn't use the thread stack but heap-based stacks. Makes it possible to + * process deeply nested parse trees. */ public class IterativeParseTreeWalker extends ParseTreeWalker { - public static final ParseTreeWalker DEFAULT = new IterativeParseTreeWalker(); - @Override - public void walk(final ParseTreeListener listener, final ParseTree t) { - for (WalkerNode currentNode = createNode(null, t, 0); currentNode != null;) { - currentNode.enter(listener); // Pre order visit + @Override + public void walk(ParseTreeListener listener, ParseTree t) { - // Move down to first child - WalkerNode nextNode = currentNode.getFirstChild(); - if (nextNode != null) { - currentNode = nextNode; - continue; - } + final Deque nodeStack = new ArrayDeque(); + final IntegerStack indexStack = new IntegerStack(); - // No child nodes, so walk tree - while (currentNode != null) { - currentNode.exit(listener); // Post order visit + ParseTree currentNode = t; + int currentIndex = 0; - // Move to sibling if possible - nextNode = currentNode.getNextSibling(); - if (nextNode != null) { - currentNode = nextNode; - break; - } + while (currentNode != null) { - // Move up - currentNode = currentNode.getParentNode(); - } - } - } + // pre-order visit + if (currentNode instanceof ErrorNode) { + listener.visitErrorNode((ErrorNode) currentNode); + } else if (currentNode instanceof TerminalNode) { + listener.visitTerminal((TerminalNode) currentNode); + } else { + final RuleNode r = (RuleNode) currentNode; + enterRule(listener, r); + } - protected WalkerNode createNode(final WalkerNode parent, final ParseTree self, final int pos) { - if (self instanceof ErrorNode) { - return new ErrorWalkerNode(parent, (ErrorNode) self, pos); - } else if (self instanceof TerminalNode) { - return new TerminalWalkerNode(parent, (TerminalNode) self, pos); - } else { - return new RuleWalkerNode(parent, (RuleNode) self, pos); - } - } + // Move down to first child, if exists + if (currentNode.getChildCount() > 0) { + nodeStack.push(currentNode); + indexStack.push(currentIndex); + currentIndex = 0; + currentNode = currentNode.getChild(0); + continue; + } - protected abstract class WalkerNode { - private final WalkerNode parent; - protected final N self; - private final int pos; + // No child nodes, so walk tree + do { - protected WalkerNode(final WalkerNode parent, final N self, final int pos) { - this.parent = parent; - this.self = self; - this.pos = pos; - } + // post-order visit + if (currentNode instanceof RuleNode) { + exitRule(listener, (RuleNode) currentNode); + } - public WalkerNode getFirstChild() { - return self.getChildCount() > 0 ? createChildNode(0) : null; - } + // No parent, so no siblings + if (nodeStack.isEmpty()) { + currentNode = null; + currentIndex = 0; + break; + } - public WalkerNode getNextSibling() { - return parent != null && parent.self.getChildCount() > pos + 1 ? parent.createChildNode(pos + 1) : null; - } + // Move to next sibling if possible + currentNode = nodeStack.peek().getChild(++currentIndex); + if (currentNode != null) { + break; + } - public WalkerNode getParentNode() { - return parent; - } + // No next, sibling, so move up + currentNode = nodeStack.pop(); + currentIndex = indexStack.pop(); - public abstract void enter(ParseTreeListener listener); - - public void exit(final ParseTreeListener listener) { - // defaults to do nothing - } - - protected WalkerNode createChildNode(final int pos) { - return createNode(this, self.getChild(pos), pos); - } - } - - protected class RuleWalkerNode extends WalkerNode { - public RuleWalkerNode(final WalkerNode parent, final RuleNode self, final int pos) { - super(parent, self, pos); - } - - @Override - public void enter(final ParseTreeListener listener) { - enterRule(listener, self); - } - - @Override - public void exit(final ParseTreeListener listener) { - exitRule(listener, self); - } - } - - protected class ErrorWalkerNode extends WalkerNode { - public ErrorWalkerNode(final WalkerNode parent, final ErrorNode self, final int pos) { - super(parent, self, pos); - } - - @Override - public void enter(final ParseTreeListener listener) { - listener.visitErrorNode(self); - } - } - - protected class TerminalWalkerNode extends WalkerNode { - public TerminalWalkerNode(final WalkerNode parent, final TerminalNode self, final int pos) { - super(parent, self, pos); - } - - @Override - public void enter(final ParseTreeListener listener) { - listener.visitTerminal(self); - } - } + } while (currentNode != null); + } + } } From ea316158047e08854f24ab4a87f04e1f8b5b9105 Mon Sep 17 00:00:00 2001 From: Tom Wieczorek Date: Wed, 20 Jul 2016 09:18:08 +0200 Subject: [PATCH 3/4] Use the iterative version of the ParseTreeWalker as default implementation --- runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeWalker.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeWalker.java b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeWalker.java index 1065204b4..e860327f8 100644 --- a/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeWalker.java +++ b/runtime/Java/src/org/antlr/v4/runtime/tree/ParseTreeWalker.java @@ -34,7 +34,7 @@ import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.RuleContext; public class ParseTreeWalker { - public static final ParseTreeWalker DEFAULT = new ParseTreeWalker(); + public static final ParseTreeWalker DEFAULT = new IterativeParseTreeWalker(); public void walk(ParseTreeListener listener, ParseTree t) { if ( t instanceof ErrorNode) { From cc59a699d4469d00be83370f3ee2b5b2700de60c Mon Sep 17 00:00:00 2001 From: Tom Wieczorek Date: Fri, 25 Nov 2016 12:16:48 +0100 Subject: [PATCH 4/4] Add myself to the list of contributors using the date of my first commit. --- contributors.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/contributors.txt b/contributors.txt index 687eeaf20..ab6403d32 100644 --- a/contributors.txt +++ b/contributors.txt @@ -92,3 +92,4 @@ YYYY/MM/DD, github id, Full name, email 2016/03/27, beardlybread, Bradley Steinbacher, bradley.j.steinbacher@gmail.com 2016/03/29, msteiger, Martin Steiger, antlr@martin-steiger.de 2016/03/28, gagern, Martin von Gagern, gagern@ma.tum.de +2016/07/10, twz123, Tom Wieczorek, tom.wieczorek@zalando.de