Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   [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.debug;
 
A TreeAdaptor proxy that fires debugging events to a DebugEventListener delegate and uses the TreeAdaptor delegate to do the actual work. All AST events are triggered by this adaptor; no code gen changes are needed in generated rules. Debugging events are triggered *after* invoking tree adaptor routines. Trees created with actions in rewrite actions like "-> ^(ADD {foo} {bar})" cannot be tracked as they might not use the adaptor to create foo, bar. The debug listener has to deal with tree node IDs for which it did not see a createNode event. A single <unknown> node is sufficient even if it represents a whole tree.
 
 public class DebugTreeAdaptor implements TreeAdaptor {
 	protected DebugEventListener dbg;
 	protected TreeAdaptor adaptor;
 
 	public DebugTreeAdaptor(DebugEventListener dbgTreeAdaptor adaptor) {
 		this. = dbg;
 		this. = adaptor;
 	}
 
 	public Object create(Token payload) {
 		if ( payload.getTokenIndex() < 0 ) {
 			// could be token conjured up during error recovery
 			return create(payload.getType(), payload.getText());
 		}
 		Object node = .create(payload);
 		.createNode(nodepayload);
 		return node;
 	}
 
 	public Object errorNode(TokenStream inputToken startToken stop,
 	{
 		Object node = .errorNode(inputstartstope);
 		if ( node!=null ) {
 			.errorNode(node);
 		}
 		return node;
 	}
 
 	public Object dupTree(Object tree) {
 		Object t = .dupTree(tree);
 		// walk the tree and emit create and add child events
 		// to simulate what dupTree has done. dupTree does not call this debug
 		// adapter so I must simulate.
 		return t;
 	}

^(A B C): emit create A, create B, add child, ..
 
 	protected void simulateTreeConstruction(Object t) {
 		int n = .getChildCount(t);
 		for (int i=0; i<ni++) {
 			Object child = .getChild(ti);
 			.addChild(tchild);
 		}
 	}
 
 	public Object dupNode(Object treeNode) {
 		Object d = .dupNode(treeNode);
 		return d;
	}
	public Object nil() {
		Object node = .nil();
		.nilNode(node);
		return node;
	}
	public boolean isNil(Object tree) {
		return .isNil(tree);
	}
	public void addChild(Object tObject child) {
		if ( t==null || child==null ) {
			return;
		}
		.addChild(t,child);
		.addChild(tchild);
	}
	public Object becomeRoot(Object newRootObject oldRoot) {
		Object n = .becomeRoot(newRootoldRoot);
		.becomeRoot(newRootoldRoot);
		return n;
	}
	public Object rulePostProcessing(Object root) {
	}
	public void addChild(Object tToken child) {
		Object n = this.create(child);
		this.addChild(tn);
	}
	public Object becomeRoot(Token newRootObject oldRoot) {
		Object n = this.create(newRoot);
		.becomeRoot(noldRoot);
		.becomeRoot(newRootoldRoot);
		return n;
	}
	public Object create(int tokenTypeToken fromToken) {
		Object node = .create(tokenTypefromToken);
		return node;
	}
	public Object create(int tokenTypeToken fromTokenString text) {
		Object node = .create(tokenTypefromTokentext);
		return node;
	}
	public Object create(int tokenTypeString text) {
		Object node = .create(tokenTypetext);
		return node;
	}
	public int getType(Object t) {
		return .getType(t);
	}
	public void setType(Object tint type) {
		.setType(ttype);
	}
	public String getText(Object t) {
		return .getText(t);
	}
	public void setText(Object tString text) {
		.setText(ttext);
	}
	public Token getToken(Object t) {
		return .getToken(t);
	}
	public void setTokenBoundaries(Object tToken startTokenToken stopToken) {
		.setTokenBoundaries(tstartTokenstopToken);
		if ( t!=null && startToken!=null && stopToken!=null ) {
				tstartToken.getTokenIndex(),
				stopToken.getTokenIndex());
		}
	}
	public int getTokenStartIndex(Object t) {
	}
	public int getTokenStopIndex(Object t) {
	}
	public Object getChild(Object tint i) {
		return .getChild(ti);
	}
	public void setChild(Object tint iObject child) {
		.setChild(tichild);
	}
	public Object deleteChild(Object tint i) {
		return deleteChild(ti);
	}
	public int getChildCount(Object t) {
	}
	public int getUniqueID(Object node) {
		return .getUniqueID(node);
	}
	public Object getParent(Object t) {
		return .getParent(t);
	}
	public int getChildIndex(Object t) {
	}
	public void setParent(Object tObject parent) {
		.setParent(tparent);
	}
	public void setChildIndex(Object tint index) {
	}
	public void replaceChildren(Object parentint startChildIndexint stopChildIndexObject t) {
		.replaceChildren(parentstartChildIndexstopChildIndext);
	}
	// support
		return ;
	}
	public void setDebugListener(DebugEventListener dbg) {
		this. = dbg;
	}
		return ;
	}
New to GrepCode? Check out our FAQ X