001: package org.antlr.runtime.debug;
002:
003: import org.antlr.runtime.Token;
004: import org.antlr.runtime.tree.TreeAdaptor;
005:
006: /** A TreeAdaptor proxy that fires debugging events to a DebugEventListener
007: * delegate and uses the TreeAdaptor delegate to do the actual work. All
008: * AST events are triggered by this adaptor; no code gen changes are needed
009: * in generated rules. Debugging events are triggered *after* invoking
010: * tree adaptor routines.
011: *
012: * Trees created with actions in rewrite actions like "-> ^(ADD {foo} {bar})"
013: * cannot be tracked as they might not use the adaptor to create foo, bar.
014: * The debug listener has to deal with tree node IDs for which it did
015: * not see a createNode event. A single <unknown> node is sufficient even
016: * if it represents a whole tree.
017: */
018: public class DebugTreeAdaptor implements TreeAdaptor {
019: protected DebugEventListener dbg;
020: protected TreeAdaptor adaptor;
021:
022: public DebugTreeAdaptor(DebugEventListener dbg, TreeAdaptor adaptor) {
023: this .dbg = dbg;
024: this .adaptor = adaptor;
025: }
026:
027: public Object create(Token payload) {
028: Object node = adaptor.create(payload);
029: dbg.createNode(node, payload);
030: return node;
031: }
032:
033: public Object dupTree(Object tree) {
034: // TODO: do these need to be sent to dbg?
035: return adaptor.dupTree(tree);
036: }
037:
038: public Object dupNode(Object treeNode) {
039: // TODO: do these need to be sent to dbg?
040: return adaptor.dupNode(treeNode);
041: }
042:
043: public Object nil() {
044: Object node = adaptor.nil();
045: dbg.nilNode(node);
046: return node;
047: }
048:
049: public boolean isNil(Object tree) {
050: return adaptor.isNil(tree);
051: }
052:
053: public void addChild(Object t, Object child) {
054: if (t == null || child == null) {
055: return;
056: }
057: adaptor.addChild(t, child);
058: dbg.addChild(t, child);
059: }
060:
061: public Object becomeRoot(Object newRoot, Object oldRoot) {
062: Object n = adaptor.becomeRoot(newRoot, oldRoot);
063: dbg.becomeRoot(newRoot, oldRoot);
064: return n;
065: }
066:
067: public Object rulePostProcessing(Object root) {
068: return adaptor.rulePostProcessing(root);
069: }
070:
071: public void addChild(Object t, Token child) {
072: Object n = this .create(child);
073: this .addChild(t, n);
074: }
075:
076: public Object becomeRoot(Token newRoot, Object oldRoot) {
077: Object n = this .create(newRoot);
078: adaptor.becomeRoot(n, oldRoot);
079: dbg.becomeRoot(newRoot, oldRoot);
080: return n;
081: }
082:
083: public Object create(int tokenType, Token fromToken) {
084: Object node = adaptor.create(tokenType, fromToken);
085: dbg.createNode(node);
086: return node;
087: }
088:
089: public Object create(int tokenType, Token fromToken, String text) {
090: Object node = adaptor.create(tokenType, fromToken, text);
091: dbg.createNode(node);
092: return node;
093: }
094:
095: public Object create(int tokenType, String text) {
096: Object node = adaptor.create(tokenType, text);
097: dbg.createNode(node);
098: return node;
099: }
100:
101: public int getType(Object t) {
102: return adaptor.getType(t);
103: }
104:
105: public void setType(Object t, int type) {
106: adaptor.setType(t, type);
107: }
108:
109: public String getText(Object t) {
110: return adaptor.getText(t);
111: }
112:
113: public void setText(Object t, String text) {
114: adaptor.setText(t, text);
115: }
116:
117: public Token getToken(Object t) {
118: return adaptor.getToken(t);
119: }
120:
121: public void setTokenBoundaries(Object t, Token startToken,
122: Token stopToken) {
123: adaptor.setTokenBoundaries(t, startToken, stopToken);
124: if (t != null && startToken != null && stopToken != null) {
125: dbg.setTokenBoundaries(t, startToken.getTokenIndex(),
126: stopToken.getTokenIndex());
127: }
128: }
129:
130: public int getTokenStartIndex(Object t) {
131: return adaptor.getTokenStartIndex(t);
132: }
133:
134: public int getTokenStopIndex(Object t) {
135: return adaptor.getTokenStopIndex(t);
136: }
137:
138: public Object getChild(Object t, int i) {
139: return adaptor.getChild(t, i);
140: }
141:
142: public int getChildCount(Object t) {
143: return adaptor.getChildCount(t);
144: }
145:
146: public int getUniqueID(Object node) {
147: return adaptor.getUniqueID(node);
148: }
149:
150: // support
151:
152: public DebugEventListener getDebugEventListener() {
153: return dbg;
154: }
155:
156: public void setDebugEventListener(DebugEventListener dbg) {
157: this .dbg = dbg;
158: }
159:
160: public TreeAdaptor getTreeAdaptor() {
161: return adaptor;
162: }
163: }
|