testautoa 0.4.0.pre16

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeParser.java

@@ -0,0 +1,169 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ 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.runtime.tree;
+
+import org.antlr.runtime.*;
+
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
+
+/** A parser for a stream of tree nodes.  "tree grammars" result in a subclass
+ *  of this.  All the error reporting and recovery is shared with Parser via
+ *  the BaseRecognizer superclass.
+*/
+public class TreeParser extends BaseRecognizer {
+	public static final int DOWN = Token.DOWN;
+	public static final int UP = Token.UP;
+
+    // precompiled regex used by inContext
+    static String dotdot = ".*[^.]\\.\\.[^.].*";
+    static String doubleEtc = ".*\\.\\.\\.\\s+\\.\\.\\..*";
+    static Pattern dotdotPattern = Pattern.compile(dotdot);
+    static Pattern doubleEtcPattern = Pattern.compile(doubleEtc);
+
+	protected TreeNodeStream input;
+
+	public TreeParser(TreeNodeStream input) {
+		super(); // highlight that we go to super to set state object
+		setTreeNodeStream(input);
+	}
+
+	public TreeParser(TreeNodeStream input, RecognizerSharedState state) {
+		super(state); // share the state object with another parser
+		setTreeNodeStream(input);
+    }
+
+	public void reset() {
+		super.reset(); // reset all recognizer state variables
+		if ( input!=null ) {
+			input.seek(0); // rewind the input
+		}
+	}
+
+	/** Set the input stream */
+	public void setTreeNodeStream(TreeNodeStream input) {
+		this.input = input;
+	}
+
+	public TreeNodeStream getTreeNodeStream() {
+		return input;
+	}
+
+	public String getSourceName() {
+		return input.getSourceName();
+	}
+
+	protected Object getCurrentInputSymbol(IntStream input) {
+		return ((TreeNodeStream)input).LT(1);
+	}
+
+	protected Object getMissingSymbol(IntStream input,
+									  RecognitionException e,
+									  int expectedTokenType,
+									  BitSet follow)
+	{
+		String tokenText =
+			"<missing "+getTokenNames()[expectedTokenType]+">";
+        TreeAdaptor adaptor = ((TreeNodeStream)e.input).getTreeAdaptor();
+        return adaptor.create(new CommonToken(expectedTokenType, tokenText));
+	}
+
+    /** Match '.' in tree parser has special meaning.  Skip node or
+	 *  entire tree if node has children.  If children, scan until
+	 *  corresponding UP node.
+	 */
+	public void matchAny(IntStream ignore) { // ignore stream, copy of input
+		state.errorRecovery = false;
+		state.failed = false;
+		Object look = input.LT(1);
+		if ( input.getTreeAdaptor().getChildCount(look)==0 ) {
+			input.consume(); // not subtree, consume 1 node and return
+			return;
+		}
+		// current node is a subtree, skip to corresponding UP.
+		// must count nesting level to get right UP
+		int level=0;
+		int tokenType = input.getTreeAdaptor().getType(look);
+		while ( tokenType!=Token.EOF && !(tokenType==UP && level==0) ) {
+			input.consume();
+			look = input.LT(1);
+			tokenType = input.getTreeAdaptor().getType(look);
+			if ( tokenType == DOWN ) {
+				level++;
+			}
+			else if ( tokenType == UP ) {
+				level--;
+			}
+		}
+		input.consume(); // consume UP
+	}
+
+    /** We have DOWN/UP nodes in the stream that have no line info; override.
+	 *  plus we want to alter the exception type.  Don't try to recover
+	 *  from tree parser errors inline...
+     */
+    protected Object recoverFromMismatchedToken(IntStream input,
+                                                int ttype,
+                                                BitSet follow)
+        throws RecognitionException
+    {
+        throw new MismatchedTreeNodeException(ttype, (TreeNodeStream)input);
+    }
+
+    /** Prefix error message with the grammar name because message is
+	 *  always intended for the programmer because the parser built
+	 *  the input tree not the user.
+	 */
+	public String getErrorHeader(RecognitionException e) {
+		return getGrammarFileName()+": node from "+
+			   (e.approximateLineInfo?"after ":"")+"line "+e.line+":"+e.charPositionInLine;
+	}
+
+	/** Tree parsers parse nodes they usually have a token object as
+	 *  payload. Set the exception token and do the default behavior.
+	 */
+	public String getErrorMessage(RecognitionException e, String[] tokenNames) {
+		if ( this instanceof TreeParser ) {
+			TreeAdaptor adaptor = ((TreeNodeStream)e.input).getTreeAdaptor();
+			e.token = adaptor.getToken(e.node);
+			if ( e.token==null ) { // could be an UP/DOWN node
+				e.token = new CommonToken(adaptor.getType(e.node),
+										  adaptor.getText(e.node));
+			}
+		}
+		return super.getErrorMessage(e, tokenNames);
+	}
+
+	public void traceIn(String ruleName, int ruleIndex)  {
+		super.traceIn(ruleName, ruleIndex, input.LT(1));
+	}
+
+	public void traceOut(String ruleName, int ruleIndex)  {
+		super.traceOut(ruleName, ruleIndex, input.LT(1));
+	}
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreePatternLexer.java

@@ -0,0 +1,135 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ 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.runtime.tree;
+
+public class TreePatternLexer {
+	public static final int EOF = -1;
+	public static final int BEGIN = 1;
+	public static final int END = 2;
+	public static final int ID = 3;
+	public static final int ARG = 4;
+	public static final int PERCENT = 5;
+	public static final int COLON = 6;
+	public static final int DOT = 7;
+
+	/** The tree pattern to lex like "(A B C)" */
+	protected String pattern;
+
+	/** Index into input string */
+	protected int p = -1;
+
+	/** Current char */
+	protected int c;
+
+	/** How long is the pattern in char? */
+	protected int n;
+
+	/** Set when token type is ID or ARG (name mimics Java's StreamTokenizer) */
+	public StringBuffer sval = new StringBuffer();
+
+	public boolean error = false;
+
+	public TreePatternLexer(String pattern) {
+		this.pattern = pattern;
+		this.n = pattern.length();
+		consume();
+	}
+
+	public int nextToken() {
+		sval.setLength(0); // reset, but reuse buffer
+		while ( c != EOF ) {
+			if ( c==' ' || c=='\n' || c=='\r' || c=='\t' ) {
+				consume();
+				continue;
+			}
+			if ( (c>='a' && c<='z') || (c>='A' && c<='Z') || c=='_' ) {
+				sval.append((char)c);
+				consume();
+				while ( (c>='a' && c<='z') || (c>='A' && c<='Z') ||
+						(c>='0' && c<='9') || c=='_' )
+				{
+					sval.append((char)c);
+					consume();
+				}
+				return ID;
+			}
+			if ( c=='(' ) {
+				consume();
+				return BEGIN;
+			}
+			if ( c==')' ) {
+				consume();
+				return END;
+			}
+			if ( c=='%' ) {
+				consume();
+				return PERCENT;
+			}
+			if ( c==':' ) {
+				consume();
+				return COLON;
+			}
+			if ( c=='.' ) {
+				consume();
+				return DOT;
+			}
+			if ( c=='[' ) { // grab [x] as a string, returning x
+				consume();
+				while ( c!=']' ) {
+					if ( c=='\\' ) {
+						consume();
+						if ( c!=']' ) {
+							sval.append('\\');
+						}
+						sval.append((char)c);
+					}
+					else {
+						sval.append((char)c);
+					}
+					consume();
+				}
+				consume();
+				return ARG;
+			}
+			consume();
+			error = true;
+			return EOF;
+		}
+		return EOF;
+	}
+
+	protected void consume() {
+		p++;
+		if ( p>=n ) {
+			c = EOF;
+		}
+		else {
+			c = pattern.charAt(p);
+		}
+	}
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreePatternParser.java

@@ -0,0 +1,154 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ 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.runtime.tree;
+
+import org.antlr.runtime.Token;
+import org.antlr.runtime.CommonToken;
+
+public class TreePatternParser {
+	protected TreePatternLexer tokenizer;
+	protected int ttype;
+	protected TreeWizard wizard;
+	protected TreeAdaptor adaptor;
+
+	public TreePatternParser(TreePatternLexer tokenizer, TreeWizard wizard, TreeAdaptor adaptor) {
+		this.tokenizer = tokenizer;
+		this.wizard = wizard;
+		this.adaptor = adaptor;
+		ttype = tokenizer.nextToken(); // kickstart
+	}
+
+	public Object pattern() {
+		if ( ttype==TreePatternLexer.BEGIN ) {
+			return parseTree();
+		}
+		else if ( ttype==TreePatternLexer.ID ) {
+			Object node = parseNode();
+			if ( ttype==TreePatternLexer.EOF ) {
+				return node;
+			}
+			return null; // extra junk on end
+		}
+		return null;
+	}
+
+	public Object parseTree() {
+		if ( ttype != TreePatternLexer.BEGIN ) {
+			throw new RuntimeException("no BEGIN");
+		}
+		ttype = tokenizer.nextToken();
+		Object root = parseNode();
+		if ( root==null ) {
+			return null;
+		}
+		while ( ttype==TreePatternLexer.BEGIN ||
+				ttype==TreePatternLexer.ID ||
+				ttype==TreePatternLexer.PERCENT ||
+				ttype==TreePatternLexer.DOT )
+		{
+			if ( ttype==TreePatternLexer.BEGIN ) {
+				Object subtree = parseTree();
+				adaptor.addChild(root, subtree);
+			}
+			else {
+				Object child = parseNode();
+				if ( child==null ) {
+					return null;
+				}
+				adaptor.addChild(root, child);
+			}
+		}
+		if ( ttype != TreePatternLexer.END ) {
+			throw new RuntimeException("no END");
+		}
+		ttype = tokenizer.nextToken();
+		return root;
+	}
+
+	public Object parseNode() {
+		// "%label:" prefix
+		String label = null;
+		if ( ttype == TreePatternLexer.PERCENT ) {
+			ttype = tokenizer.nextToken();
+			if ( ttype != TreePatternLexer.ID ) {
+				return null;
+			}
+			label = tokenizer.sval.toString();
+			ttype = tokenizer.nextToken();
+			if ( ttype != TreePatternLexer.COLON ) {
+				return null;
+			}
+			ttype = tokenizer.nextToken(); // move to ID following colon
+		}
+
+		// Wildcard?
+		if ( ttype == TreePatternLexer.DOT ) {
+			ttype = tokenizer.nextToken();
+			Token wildcardPayload = new CommonToken(0, ".");
+			TreeWizard.TreePattern node =
+				new TreeWizard.WildcardTreePattern(wildcardPayload);
+			if ( label!=null ) {
+				node.label = label;
+			}
+			return node;
+		}
+
+		// "ID" or "ID[arg]"
+		if ( ttype != TreePatternLexer.ID ) {
+			return null;
+		}
+		String tokenName = tokenizer.sval.toString();
+		ttype = tokenizer.nextToken();
+		if ( tokenName.equals("nil") ) {
+			return adaptor.nil();
+		}
+		String text = tokenName;
+		// check for arg
+		String arg = null;
+		if ( ttype == TreePatternLexer.ARG ) {
+			arg = tokenizer.sval.toString();
+			text = arg;
+			ttype = tokenizer.nextToken();
+		}
+		
+		// create node
+		int treeNodeType = wizard.getTokenType(tokenName);
+		if ( treeNodeType==Token.INVALID_TOKEN_TYPE ) {
+			return null;
+		}
+		Object node;
+		node = adaptor.create(treeNodeType, text);
+		if ( label!=null && node.getClass()==TreeWizard.TreePattern.class ) {
+			((TreeWizard.TreePattern)node).label = label;
+		}
+		if ( arg!=null && node.getClass()==TreeWizard.TreePattern.class ) {
+			((TreeWizard.TreePattern)node).hasTextArg = true;
+		}
+		return node;
+	}
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeRewriter.java

@@ -0,0 +1,124 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ 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.runtime.tree;
+
+import org.antlr.runtime.RecognizerSharedState;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.TokenStream;
+
+public class TreeRewriter extends TreeParser {
+
+    private static final String TAG = "ANTLR:TREE:TreeRewriter";
+
+    public interface fptr {
+        public Object rule() throws RecognitionException;
+    }
+
+    protected boolean showTransformations = false;
+
+    protected TokenStream originalTokenStream;
+    protected TreeAdaptor originalAdaptor;
+    
+    public TreeRewriter(TreeNodeStream input) {
+        this(input, new RecognizerSharedState());
+    }
+    public TreeRewriter(TreeNodeStream input, RecognizerSharedState state) {
+        super(input, state);
+        originalAdaptor = input.getTreeAdaptor();
+        originalTokenStream = input.getTokenStream();        
+    }
+
+    public Object applyOnce(Object t, fptr whichRule) {
+        if ( t==null ) return null;
+        try {
+            // share TreeParser object but not parsing-related state
+            state = new RecognizerSharedState();
+            input = new CommonTreeNodeStream(originalAdaptor, t);
+            ((CommonTreeNodeStream)input).setTokenStream(originalTokenStream);
+            setBacktrackingLevel(1);
+            TreeRuleReturnScope r = (TreeRuleReturnScope)whichRule.rule();
+            setBacktrackingLevel(0);
+            if ( failed() ) return t;
+            if ( showTransformations &&
+                 r!=null && !t.equals(r.getTree()) && r.getTree()!=null )
+            {
+                reportTransformation(t, r.getTree());
+            }
+            if ( r!=null && r.getTree()!=null ) return r.getTree();
+            else return t;
+        }
+        catch (RecognitionException e) { ; }
+        return t;
+    }
+
+    public Object applyRepeatedly(Object t, fptr whichRule) {
+        boolean treeChanged = true;
+        while ( treeChanged ) {
+            Object u = applyOnce(t, whichRule);
+            treeChanged = !t.equals(u);
+            t = u;
+        }
+        return t;
+    }
+
+    public Object downup(Object t) { return downup(t, false); }
+
+    public Object downup(Object t, boolean showTransformations) {
+        this.showTransformations = showTransformations;
+        TreeVisitor v = new TreeVisitor(new CommonTreeAdaptor());
+        TreeVisitorAction actions = new TreeVisitorAction() {
+            public Object pre(Object t)  { return applyOnce(t, topdown_fptr); }
+            public Object post(Object t) { return applyRepeatedly(t, bottomup_ftpr); }
+        };
+        t = v.visit(t, actions);
+        return t;
+    }
+
+    /** Override this if you need transformation tracing to go somewhere
+     *  other than stdout or if you're not using Tree-derived trees.
+     */
+    public void reportTransformation(Object oldTree, Object newTree) {
+        //System.out.println(((Tree)oldTree).toStringTree()+" -> "+
+                           //((Tree)newTree).toStringTree());
+	android.util.Log.i(TAG, ((Tree)oldTree).toStringTree()+" -> "+((Tree)newTree).toStringTree());
+    }
+
+    fptr topdown_fptr = new fptr() {
+        public Object rule() throws RecognitionException { return topdown(); }
+    };
+    
+    fptr bottomup_ftpr = new fptr() {
+        public Object rule() throws RecognitionException { return bottomup(); }
+    };
+
+    // methods the downup strategy uses to do the up and down rules.
+    // to override, just define tree grammar rule topdown and turn on
+    // filter=true.
+    public Object topdown() throws RecognitionException { return null; }
+    public Object bottomup() throws RecognitionException { return null; }
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeRuleReturnScope.java

@@ -0,0 +1,41 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ 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.runtime.tree;
+
+import org.antlr.runtime.RuleReturnScope;
+
+/** This is identical to the ParserRuleReturnScope except that
+ *  the start property is a tree nodes not Token object
+ *  when you are parsing trees.  To be generic the tree node types
+ *  have to be Object.
+ */
+public class TreeRuleReturnScope extends RuleReturnScope {
+	/** First node or root node of tree matched for this rule. */
+	public Object start;
+	public Object getStart() { return start; }	
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/tree/TreeVisitor.java

@@ -0,0 +1,69 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ 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.runtime.tree;
+
+/** Do a depth first walk of a tree, applying pre() and post() actions
+ *  as we discover and finish nodes.
+ */
+public class TreeVisitor {
+    protected TreeAdaptor adaptor;
+    
+    public TreeVisitor(TreeAdaptor adaptor) {
+        this.adaptor = adaptor;
+    }
+    public TreeVisitor() { this(new CommonTreeAdaptor()); }
+    
+    /** Visit every node in tree t and trigger an action for each node
+     *  before/after having visited all of its children.
+     *  Execute both actions even if t has no children.
+     *  If a child visit yields a new child, it can update its
+     *  parent's child list or just return the new child.  The
+     *  child update code works even if the child visit alters its parent
+     *  and returns the new tree.
+     *
+     *  Return result of applying post action to this node.
+     */
+    public Object visit(Object t, TreeVisitorAction action) {
+        // System.out.println("visit "+((Tree)t).toStringTree());
+        boolean isNil = adaptor.isNil(t);
+        if ( action!=null && !isNil ) {
+            t = action.pre(t); // if rewritten, walk children of new t
+        }
+        for (int i=0; i<adaptor.getChildCount(t); i++) {
+            Object child = adaptor.getChild(t, i);
+            Object visitResult = visit(child, action);
+            Object childAfterVisit = adaptor.getChild(t, i);
+            if ( visitResult !=  childAfterVisit ) { // result & child differ?
+                adaptor.setChild(t, i, visitResult);
+            }
+        }
+        if ( action!=null && !isNil ) t = action.post(t);
+        return t;
+    }
+}