/*
* [The "BSD licence"]
* Copyright (c) 2005-2008 Terence Parr
* All rights reserved.
*
* Conversion to C#:
* Copyright (c) 2008-2009 Sam Harwell, Pixel Mine, Inc.
* 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.
*/
namespace Antlr.Runtime.Debug {
using ITreeAdaptor = Antlr.Runtime.Tree.ITreeAdaptor;
/** <summary>
* 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.
* </summary>
*
* <remarks>
* 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.
* </remarks>
*/
public class DebugTreeAdaptor : ITreeAdaptor {
protected IDebugEventListener dbg;
protected ITreeAdaptor adaptor;
public DebugTreeAdaptor(IDebugEventListener dbg, ITreeAdaptor adaptor) {
this.dbg = dbg;
this.adaptor = adaptor;
}
public virtual object Create(IToken payload) {
if (payload.TokenIndex < 0) {
// could be token conjured up during error recovery
return Create(payload.Type, payload.Text);
}
object node = adaptor.Create(payload);
dbg.CreateNode(node, payload);
return node;
}
public virtual object ErrorNode(ITokenStream input, IToken start, IToken stop,
RecognitionException e) {
object node = adaptor.ErrorNode(input, start, stop, e);
if (node != null) {
dbg.ErrorNode(node);
}
return node;
}
public virtual object DupTree(object tree) {
object t = adaptor.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.
SimulateTreeConstruction(t);
return t;
}
/** <summary>^(A B C): emit create A, create B, add child, ...</summary> */
protected virtual void SimulateTreeConstruction(object t) {
dbg.CreateNode(t);
int n = adaptor.GetChildCount(t);
for (int i = 0; i < n; i++) {
object child = adaptor.GetChild(t, i);
SimulateTreeConstruction(child);
dbg.AddChild(t, child);
}
}
public virtual object DupNode(object treeNode) {
object d = adaptor.DupNode(treeNode);
dbg.CreateNode(d);
return d;
}
public virtual object Nil() {
object node = adaptor.Nil();
dbg.NilNode(node);
return node;
}
public virtual bool IsNil(object tree) {
return adaptor.IsNil(tree);
}
public virtual void AddChild(object t, object child) {
if (t == null || child == null) {
return;
}
adaptor.AddChild(t, child);
dbg.AddChild(t, child);
}
public virtual object BecomeRoot(object newRoot, object oldRoot) {
object n = adaptor.BecomeRoot(newRoot, oldRoot);
dbg.BecomeRoot(newRoot, oldRoot);
return n;
}
public virtual object RulePostProcessing(object root) {
return adaptor.RulePostProcessing(root);
}
public virtual void AddChild(object t, IToken child) {
object n = this.Create(child);
this.AddChild(t, n);
}
public virtual object BecomeRoot(IToken newRoot, object oldRoot) {
object n = this.Create(newRoot);
adaptor.BecomeRoot(n, oldRoot);
dbg.BecomeRoot(newRoot, oldRoot);
return n;
}
public virtual object Create(int tokenType, IToken fromToken) {
object node = adaptor.Create(tokenType, fromToken);
dbg.CreateNode(node);
return node;
}
public virtual object Create(int tokenType, IToken fromToken, string text) {
object node = adaptor.Create(tokenType, fromToken, text);
dbg.CreateNode(node);
return node;
}
public virtual object Create(int tokenType, string text) {
object node = adaptor.Create(tokenType, text);
dbg.CreateNode(node);
return node;
}
public virtual int GetType(object t) {
return adaptor.GetType(t);
}
public virtual void SetType(object t, int type) {
adaptor.SetType(t, type);
}
public virtual string GetText(object t) {
return adaptor.GetText(t);
}
public virtual void SetText(object t, string text) {
adaptor.SetText(t, text);
}
public virtual IToken GetToken(object t) {
return adaptor.GetToken(t);
}
public virtual void SetTokenBoundaries(object t, IToken startToken, IToken stopToken) {
adaptor.SetTokenBoundaries(t, startToken, stopToken);
if (t != null && startToken != null && stopToken != null) {
dbg.SetTokenBoundaries(
t, startToken.TokenIndex,
stopToken.TokenIndex);
}
}
public virtual int GetTokenStartIndex(object t) {
return adaptor.GetTokenStartIndex(t);
}
public virtual int GetTokenStopIndex(object t) {
return adaptor.GetTokenStopIndex(t);
}
public virtual object GetChild(object t, int i) {
return adaptor.GetChild(t, i);
}
public virtual void SetChild(object t, int i, object child) {
adaptor.SetChild(t, i, child);
}
public virtual object DeleteChild(object t, int i) {
return DeleteChild(t, i);
}
public virtual int GetChildCount(object t) {
return adaptor.GetChildCount(t);
}
public virtual int GetUniqueID(object node) {
return adaptor.GetUniqueID(node);
}
public virtual object GetParent(object t) {
return adaptor.GetParent(t);
}
public virtual int GetChildIndex(object t) {
return adaptor.GetChildIndex(t);
}
public virtual void SetParent(object t, object parent) {
adaptor.SetParent(t, parent);
}
public virtual void SetChildIndex(object t, int index) {
adaptor.SetChildIndex(t, index);
}
public virtual void ReplaceChildren(object parent, int startChildIndex, int stopChildIndex, object t) {
adaptor.ReplaceChildren(parent, startChildIndex, stopChildIndex, t);
}
#region support
public virtual IDebugEventListener GetDebugListener() {
return dbg;
}
public virtual void SetDebugListener(IDebugEventListener dbg) {
this.dbg = dbg;
}
public virtual ITreeAdaptor GetTreeAdaptor() {
return adaptor;
}
#endregion
}
}