calabash-android 0.5.2 → 0.5.3

data/test-server/instrumentation-backend/src/org/antlr/runtime/debug/DebugEventListener.java

@@ -1,323 +0,0 @@
-/*
- [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;
-
-import org.antlr.runtime.RecognitionException;
-import org.antlr.runtime.Token;
-
-/** All debugging events that a recognizer can trigger.
- *
- *  I did not create a separate AST debugging interface as it would create
- *  lots of extra classes and DebugParser has a dbg var defined, which makes
- *  it hard to change to ASTDebugEventListener.  I looked hard at this issue
- *  and it is easier to understand as one monolithic event interface for all
- *  possible events.  Hopefully, adding ST debugging stuff won't be bad.  Leave
- *  for future. 4/26/2006.
- */
-public interface DebugEventListener {
-	/** Moved to version 2 for v3.1: added grammar name to enter/exit Rule */
-	public static final String PROTOCOL_VERSION = "2";
-	
-	/** serialized version of true */
-	public static final int TRUE = 1;
-	public static final int FALSE = 0;
-
-	/** The parser has just entered a rule.  No decision has been made about
-	 *  which alt is predicted.  This is fired AFTER init actions have been
-	 *  executed.  Attributes are defined and available etc...
-	 *  The grammarFileName allows composite grammars to jump around among
-	 *  multiple grammar files.
-	 */
-	public void enterRule(String grammarFileName, String ruleName);
-
-	/** Because rules can have lots of alternatives, it is very useful to
-	 *  know which alt you are entering.  This is 1..n for n alts.
-	 */
-	public void enterAlt(int alt);
-
-	/** This is the last thing executed before leaving a rule.  It is
-	 *  executed even if an exception is thrown.  This is triggered after
-	 *  error reporting and recovery have occurred (unless the exception is
-	 *  not caught in this rule).  This implies an "exitAlt" event.
-	 *  The grammarFileName allows composite grammars to jump around among
-	 *  multiple grammar files.
-	 */
-	public void exitRule(String grammarFileName, String ruleName);
-
-	/** Track entry into any (...) subrule other EBNF construct */
-	public void enterSubRule(int decisionNumber);
-
-	public void exitSubRule(int decisionNumber);
-
-	/** Every decision, fixed k or arbitrary, has an enter/exit event
-	 *  so that a GUI can easily track what LT/consume events are
-	 *  associated with prediction.  You will see a single enter/exit
-	 *  subrule but multiple enter/exit decision events, one for each
-	 *  loop iteration.
-	 */
-	public void enterDecision(int decisionNumber, boolean couldBacktrack);
-
-	public void exitDecision(int decisionNumber);
-
-	/** An input token was consumed; matched by any kind of element.
-	 *  Trigger after the token was matched by things like match(), matchAny().
-	 */
-	public void consumeToken(Token t);
-
-	/** An off-channel input token was consumed.
-	 *  Trigger after the token was matched by things like match(), matchAny().
-	 *  (unless of course the hidden token is first stuff in the input stream).
-	 */
-	public void consumeHiddenToken(Token t);
-
-	/** Somebody (anybody) looked ahead.  Note that this actually gets
-	 *  triggered by both LA and LT calls.  The debugger will want to know
-	 *  which Token object was examined.  Like consumeToken, this indicates
-	 *  what token was seen at that depth.  A remote debugger cannot look
-	 *  ahead into a file it doesn't have so LT events must pass the token
-	 *  even if the info is redundant.
-	 */
-	public void LT(int i, Token t);
-
-	/** The parser is going to look arbitrarily ahead; mark this location,
-	 *  the token stream's marker is sent in case you need it.
-	 */
-	public void mark(int marker);
-
-	/** After an arbitrairly long lookahead as with a cyclic DFA (or with
-	 *  any backtrack), this informs the debugger that stream should be
-	 *  rewound to the position associated with marker.
-	 */
-	public void rewind(int marker);
-
-	/** Rewind to the input position of the last marker.
-	 *  Used currently only after a cyclic DFA and just
-	 *  before starting a sem/syn predicate to get the
-	 *  input position back to the start of the decision.
-	 *  Do not "pop" the marker off the state.  mark(i)
-	 *  and rewind(i) should balance still.
-	 */
-	public void rewind();
-
-	public void beginBacktrack(int level);
-
-	public void endBacktrack(int level, boolean successful);
-
-	/** To watch a parser move through the grammar, the parser needs to
-	 *  inform the debugger what line/charPos it is passing in the grammar.
-	 *  For now, this does not know how to switch from one grammar to the
-	 *  other and back for island grammars etc...
-	 *
-	 *  This should also allow breakpoints because the debugger can stop
-	 *  the parser whenever it hits this line/pos.
-	 */
-	public void location(int line, int pos);
-
-	/** A recognition exception occurred such as NoViableAltException.  I made
-	 *  this a generic event so that I can alter the exception hierachy later
-	 *  without having to alter all the debug objects.
-	 *
-	 *  Upon error, the stack of enter rule/subrule must be properly unwound.
-	 *  If no viable alt occurs it is within an enter/exit decision, which
-	 *  also must be rewound.  Even the rewind for each mark must be unwount.
-	 *  In the Java target this is pretty easy using try/finally, if a bit
-	 *  ugly in the generated code.  The rewind is generated in DFA.predict()
-	 *  actually so no code needs to be generated for that.  For languages
-	 *  w/o this "finally" feature (C++?), the target implementor will have
-	 *  to build an event stack or something.
-	 *
-	 *  Across a socket for remote debugging, only the RecognitionException
-	 *  data fields are transmitted.  The token object or whatever that
-	 *  caused the problem was the last object referenced by LT.  The
-	 *  immediately preceding LT event should hold the unexpected Token or
-	 *  char.
-	 *
-	 *  Here is a sample event trace for grammar:
-	 *
-	 *  b : C ({;}A|B) // {;} is there to prevent A|B becoming a set
-     *    | D
-     *    ;
-     *
-	 *  The sequence for this rule (with no viable alt in the subrule) for
-	 *  input 'c c' (there are 3 tokens) is:
-	 *
-	 *		commence
-	 *		LT(1)
-	 *		enterRule b
-	 *		location 7 1
-	 *		enter decision 3
-	 *		LT(1)
-	 *		exit decision 3
-	 *		enterAlt1
-	 *		location 7 5
-	 *		LT(1)
-	 *		consumeToken [c/<4>,1:0]
-	 *		location 7 7
-	 *		enterSubRule 2
-	 *		enter decision 2
-	 *		LT(1)
-	 *		LT(1)
-	 *		recognitionException NoViableAltException 2 1 2
-	 *		exit decision 2
-	 *		exitSubRule 2
-	 *		beginResync
-	 *		LT(1)
-	 *		consumeToken [c/<4>,1:1]
-	 *		LT(1)
-	 *		endResync
-	 *		LT(-1)
-	 *		exitRule b
-	 *		terminate
-	 */
-	public void recognitionException(RecognitionException e);
-
-	/** Indicates the recognizer is about to consume tokens to resynchronize
-	 *  the parser.  Any consume events from here until the recovered event
-	 *  are not part of the parse--they are dead tokens.
-	 */
-	public void beginResync();
-
-	/** Indicates that the recognizer has finished consuming tokens in order
-	 *  to resychronize.  There may be multiple beginResync/endResync pairs
-	 *  before the recognizer comes out of errorRecovery mode (in which
-	 *  multiple errors are suppressed).  This will be useful
-	 *  in a gui where you want to probably grey out tokens that are consumed
-	 *  but not matched to anything in grammar.  Anything between
-	 *  a beginResync/endResync pair was tossed out by the parser.
-	 */
-	public void endResync();
-
-	/** A semantic predicate was evaluate with this result and action text */
-	public void semanticPredicate(boolean result, String predicate);
-
-	/** Announce that parsing has begun.  Not technically useful except for
-	 *  sending events over a socket.  A GUI for example will launch a thread
-	 *  to connect and communicate with a remote parser.  The thread will want
-	 *  to notify the GUI when a connection is made.  ANTLR parsers
-	 *  trigger this upon entry to the first rule (the ruleLevel is used to
-	 *  figure this out).
-	 */
-	public void commence();
-
-	/** Parsing is over; successfully or not.  Mostly useful for telling
-	 *  remote debugging listeners that it's time to quit.  When the rule
-	 *  invocation level goes to zero at the end of a rule, we are done
-	 *  parsing.
-	 */
-	public void terminate();
-
-
-	// T r e e  P a r s i n g
-
-	/** Input for a tree parser is an AST, but we know nothing for sure
-	 *  about a node except its type and text (obtained from the adaptor).
-	 *  This is the analog of the consumeToken method.  Again, the ID is
-	 *  the hashCode usually of the node so it only works if hashCode is
-	 *  not implemented.  If the type is UP or DOWN, then
-	 *  the ID is not really meaningful as it's fixed--there is
-	 *  just one UP node and one DOWN navigation node.
-	 * @param t
-	 */
-	public void consumeNode(Object t);
-
-	/** The tree parser lookedahead.  If the type is UP or DOWN,
-	 *  then the ID is not really meaningful as it's fixed--there is
-	 *  just one UP node and one DOWN navigation node.
-	 */
-	public void LT(int i, Object t);
-
-
-	// A S T  E v e n t s
-
-	/** A nil was created (even nil nodes have a unique ID...
-	 *  they are not "null" per se).  As of 4/28/2006, this
-	 *  seems to be uniquely triggered when starting a new subtree
-	 *  such as when entering a subrule in automatic mode and when
-	 *  building a tree in rewrite mode.
-     *
- 	 *  If you are receiving this event over a socket via
-	 *  RemoteDebugEventSocketListener then only t.ID is set.
-	 */
-	public void nilNode(Object t);
-
-	/** Upon syntax error, recognizers bracket the error with an error node
-	 *  if they are building ASTs.
-	 * @param t
-	 */
-	public void errorNode(Object t);
-
-	/** Announce a new node built from token elements such as type etc...
-	 * 
-	 *  If you are receiving this event over a socket via
-	 *  RemoteDebugEventSocketListener then only t.ID, type, text are
-	 *  set.
-	 */
-	public void createNode(Object t);
-
-	/** Announce a new node built from an existing token.
-	 *
-	 *  If you are receiving this event over a socket via
-	 *  RemoteDebugEventSocketListener then only node.ID and token.tokenIndex
-	 *  are set.
-	 */
-	public void createNode(Object node, Token token);
-
-	/** Make a node the new root of an existing root.  See
-	 *
-	 *  Note: the newRootID parameter is possibly different
-	 *  than the TreeAdaptor.becomeRoot() newRoot parameter.
-	 *  In our case, it will always be the result of calling
-	 *  TreeAdaptor.becomeRoot() and not root_n or whatever.
-	 *
-	 *  The listener should assume that this event occurs
-	 *  only when the current subrule (or rule) subtree is
-	 *  being reset to newRootID.
-	 * 
-	 *  If you are receiving this event over a socket via
-	 *  RemoteDebugEventSocketListener then only IDs are set.
-	 *
-	 *  @see org.antlr.runtime.tree.TreeAdaptor.becomeRoot()
-	 */
-	public void becomeRoot(Object newRoot, Object oldRoot);
-
-	/** Make childID a child of rootID.
-	 *
-	 *  If you are receiving this event over a socket via
-	 *  RemoteDebugEventSocketListener then only IDs are set.
-	 * 
-	 *  @see org.antlr.runtime.tree.TreeAdaptor.addChild()
-	 */
-	public void addChild(Object root, Object child);
-
-	/** Set the token start/stop token index for a subtree root or node.
-	 *
-	 *  If you are receiving this event over a socket via
-	 *  RemoteDebugEventSocketListener then only t.ID is set.
-	 */
-	public void setTokenBoundaries(Object t, int tokenStartIndex, int tokenStopIndex);
-}

data/test-server/instrumentation-backend/src/org/antlr/runtime/debug/DebugEventRepeater.java

@@ -1,88 +0,0 @@
-/*
- [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;
-
-import org.antlr.runtime.Token;
-import org.antlr.runtime.RecognitionException;
-
-/** A simple event repeater (proxy) that delegates all functionality to the
- *  listener sent into the ctor.  Useful if you want to listen in on a few
- *  debug events w/o interrupting the debugger.  Just subclass the repeater
- *  and override the methods you want to listen in on.  Remember to call
- *  the method in this class so the event will continue on to the original
- *  recipient.
- *
- *  @see DebugEventHub
- */
-public class DebugEventRepeater implements DebugEventListener {
-	protected DebugEventListener listener;
-
-	public DebugEventRepeater(DebugEventListener listener) {
-		this.listener = listener;
-	}
-	
-	public void enterRule(String grammarFileName, String ruleName) { listener.enterRule(grammarFileName, ruleName); }
-	public void exitRule(String grammarFileName, String ruleName) { listener.exitRule(grammarFileName, ruleName); }
-	public void enterAlt(int alt) { listener.enterAlt(alt); }
-	public void enterSubRule(int decisionNumber) { listener.enterSubRule(decisionNumber); }
-	public void exitSubRule(int decisionNumber) { listener.exitSubRule(decisionNumber); }
-	public void enterDecision(int decisionNumber, boolean couldBacktrack) { listener.enterDecision(decisionNumber, couldBacktrack); }
-	public void exitDecision(int decisionNumber) { listener.exitDecision(decisionNumber); }
-	public void location(int line, int pos) { listener.location(line, pos); }
-	public void consumeToken(Token token) { listener.consumeToken(token); }
-	public void consumeHiddenToken(Token token) { listener.consumeHiddenToken(token); }
-	public void LT(int i, Token t) { listener.LT(i, t); }
-	public void mark(int i) { listener.mark(i); }
-	public void rewind(int i) { listener.rewind(i); }
-	public void rewind() { listener.rewind(); }
-	public void beginBacktrack(int level) { listener.beginBacktrack(level); }
-	public void endBacktrack(int level, boolean successful) { listener.endBacktrack(level, successful); }
-	public void recognitionException(RecognitionException e) { listener.recognitionException(e); }
-	public void beginResync() { listener.beginResync(); }
-	public void endResync() { listener.endResync(); }
-	public void semanticPredicate(boolean result, String predicate) { listener.semanticPredicate(result, predicate); }
-	public void commence() { listener.commence(); }
-	public void terminate() { listener.terminate(); }
-
-	// Tree parsing stuff
-
-	public void consumeNode(Object t) { listener.consumeNode(t); }
-	public void LT(int i, Object t) { listener.LT(i, t); }
-
-	// AST Stuff
-
-	public void nilNode(Object t) { listener.nilNode(t); }
-	public void errorNode(Object t) { listener.errorNode(t); }
-	public void createNode(Object t) { listener.createNode(t); }
-	public void createNode(Object node, Token token) { listener.createNode(node, token); }
-	public void becomeRoot(Object newRoot, Object oldRoot) { listener.becomeRoot(newRoot, oldRoot); }
-	public void addChild(Object root, Object child) { listener.addChild(root, child); }
-	public void setTokenBoundaries(Object t, int tokenStartIndex, int tokenStopIndex) {
-		listener.setTokenBoundaries(t, tokenStartIndex, tokenStopIndex);
-	}
-}

data/test-server/instrumentation-backend/src/org/antlr/runtime/debug/DebugEventSocketProxy.java

@@ -1,358 +0,0 @@
-/*
- [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;
-
-import org.antlr.runtime.RecognitionException;
-import org.antlr.runtime.Token;
-import org.antlr.runtime.BaseRecognizer;
-import org.antlr.runtime.tree.TreeAdaptor;
-
-import java.io.*;
-import java.net.ServerSocket;
-import java.net.Socket;
-
-/** A proxy debug event listener that forwards events over a socket to
- *  a debugger (or any other listener) using a simple text-based protocol;
- *  one event per line.  ANTLRWorks listens on server socket with a
- *  RemoteDebugEventSocketListener instance.  These two objects must therefore
- *  be kept in sync.  New events must be handled on both sides of socket.
- */
-public class DebugEventSocketProxy extends BlankDebugEventListener {
-	public static final int DEFAULT_DEBUGGER_PORT = 49100; // was 49153
-	protected int port = DEFAULT_DEBUGGER_PORT;
-	protected ServerSocket serverSocket;
-	protected Socket socket;
-	protected String grammarFileName;
-	protected PrintWriter out;
-	protected BufferedReader in;
-
-	private static final String TAG = "ANTLR:DEBUG:DebugEventSocketProxy";
-
-	/** Who am i debugging? */
-	protected BaseRecognizer recognizer;
-
-	/** Almost certainly the recognizer will have adaptor set, but
-	 *  we don't know how to cast it (Parser or TreeParser) to get
-	 *  the adaptor field.  Must be set with a constructor. :(
-	 */
-	protected TreeAdaptor adaptor;
-
-	public DebugEventSocketProxy(BaseRecognizer recognizer, TreeAdaptor adaptor) {
-		this(recognizer, DEFAULT_DEBUGGER_PORT, adaptor);
-	}
-
-	public DebugEventSocketProxy(BaseRecognizer recognizer, int port, TreeAdaptor adaptor) {
-		this.grammarFileName = recognizer.getGrammarFileName();
-		this.adaptor = adaptor;
-		this.port = port;
-	}
-
-	public void handshake() throws IOException {
-		if ( serverSocket==null ) {
-			serverSocket = new ServerSocket(port);
-			socket = serverSocket.accept();
-			socket.setTcpNoDelay(true);
-			OutputStream os = socket.getOutputStream();
-			OutputStreamWriter osw = new OutputStreamWriter(os, "UTF8");
-			out = new PrintWriter(new BufferedWriter(osw));
-			InputStream is = socket.getInputStream();
-			InputStreamReader isr = new InputStreamReader(is, "UTF8");
-			in = new BufferedReader(isr);
-			out.println("ANTLR "+ DebugEventListener.PROTOCOL_VERSION);
-			out.println("grammar \""+ grammarFileName);
-			out.flush();
-			ack();
-		}
-	}
-
-	public void commence() {
-		// don't bother sending event; listener will trigger upon connection
-	}
-
-	public void terminate() {
-		transmit("terminate");
-		out.close();
-		try {
-			socket.close();
-		}
-		catch (IOException ioe) {
-			//ioe.printStackTrace(System.err);
-			android.util.Log.e(TAG, android.util.Log.getStackTraceString(ioe));
-		}
-	}
-
-	protected void ack() {
-		try {
-			in.readLine();
-		}
-		catch (IOException ioe) {
-			ioe.printStackTrace(System.err);
-			android.util.Log.e(TAG, android.util.Log.getStackTraceString(ioe));
-		}
-	}
-
-	protected void transmit(String event) {
-		out.println(event);
-		out.flush();
-		ack();
-	}
-
-	public void enterRule(String grammarFileName, String ruleName) {
-		transmit("enterRule\t"+grammarFileName+"\t"+ruleName);
-	}
-
-	public void enterAlt(int alt) {
-		transmit("enterAlt\t"+alt);
-	}
-
-	public void exitRule(String grammarFileName, String ruleName) {
-		transmit("exitRule\t"+grammarFileName+"\t"+ruleName);
-	}
-
-	public void enterSubRule(int decisionNumber) {
-		transmit("enterSubRule\t"+decisionNumber);
-	}
-
-	public void exitSubRule(int decisionNumber) {
-		transmit("exitSubRule\t"+decisionNumber);
-	}
-
-	public void enterDecision(int decisionNumber, boolean couldBacktrack) {
-		transmit("enterDecision\t"+decisionNumber+"\t"+couldBacktrack);
-	}
-
-	public void exitDecision(int decisionNumber) {
-		transmit("exitDecision\t"+decisionNumber);
-	}
-
-	public void consumeToken(Token t) {
-		String buf = serializeToken(t);
-		transmit("consumeToken\t"+buf);
-	}
-
-	public void consumeHiddenToken(Token t) {
-		String buf = serializeToken(t);
-		transmit("consumeHiddenToken\t"+buf);
-	}
-
-	public void LT(int i, Token t) {
-        if(t != null)
-            transmit("LT\t"+i+"\t"+serializeToken(t));
-	}
-
-	public void mark(int i) {
-		transmit("mark\t"+i);
-	}
-
-	public void rewind(int i) {
-		transmit("rewind\t"+i);
-	}
-
-	public void rewind() {
-		transmit("rewind");
-	}
-
-	public void beginBacktrack(int level) {
-		transmit("beginBacktrack\t"+level);
-	}
-
-	public void endBacktrack(int level, boolean successful) {
-		transmit("endBacktrack\t"+level+"\t"+(successful?TRUE:FALSE));
-	}
-
-	public void location(int line, int pos) {
-		transmit("location\t"+line+"\t"+pos);
-	}
-
-	public void recognitionException(RecognitionException e) {
-		StringBuffer buf = new StringBuffer(50);
-		buf.append("exception\t");
-		buf.append(e.getClass().getName());
-		// dump only the data common to all exceptions for now
-		buf.append("\t");
-		buf.append(e.index);
-		buf.append("\t");
-		buf.append(e.line);
-		buf.append("\t");
-		buf.append(e.charPositionInLine);
-		transmit(buf.toString());
-	}
-
-	public void beginResync() {
-		transmit("beginResync");
-	}
-
-	public void endResync() {
-		transmit("endResync");
-	}
-
-	public void semanticPredicate(boolean result, String predicate) {
-		StringBuffer buf = new StringBuffer(50);
-		buf.append("semanticPredicate\t");
-		buf.append(result);
-		serializeText(buf, predicate);
-		transmit(buf.toString());
-	}
-
-	// A S T  P a r s i n g  E v e n t s
-
-	public void consumeNode(Object t) {
-		StringBuffer buf = new StringBuffer(50);
-		buf.append("consumeNode");
-		serializeNode(buf, t);
-		transmit(buf.toString());
-	}
-
-	public void LT(int i, Object t) {
-		int ID = adaptor.getUniqueID(t);
-		String text = adaptor.getText(t);
-		int type = adaptor.getType(t);
-		StringBuffer buf = new StringBuffer(50);
-		buf.append("LN\t"); // lookahead node; distinguish from LT in protocol
-		buf.append(i);
-		serializeNode(buf, t);
-		transmit(buf.toString());
-	}
-
-	protected void serializeNode(StringBuffer buf, Object t) {
-		int ID = adaptor.getUniqueID(t);
-		String text = adaptor.getText(t);
-		int type = adaptor.getType(t);
-		buf.append("\t");
-		buf.append(ID);
-		buf.append("\t");
-		buf.append(type);
-		Token token = adaptor.getToken(t);
-		int line = -1;
-		int pos = -1;
-		if ( token!=null ) {
-			line = token.getLine();
-			pos = token.getCharPositionInLine();
-		}
-		buf.append("\t");
-		buf.append(line);
-		buf.append("\t");
-		buf.append(pos);
-		int tokenIndex = adaptor.getTokenStartIndex(t);
-		buf.append("\t");
-		buf.append(tokenIndex);
-		serializeText(buf, text);
-	}
-
-
-	// A S T  E v e n t s
-
-	public void nilNode(Object t) {
-		int ID = adaptor.getUniqueID(t);
-		transmit("nilNode\t"+ID);
-	}
-
-	public void errorNode(Object t) {
-		int ID = adaptor.getUniqueID(t);
-		String text = t.toString();
-		StringBuffer buf = new StringBuffer(50);
-		buf.append("errorNode\t");
-		buf.append(ID);
-		buf.append("\t");
-		buf.append(Token.INVALID_TOKEN_TYPE);
-		serializeText(buf, text);
-		transmit(buf.toString());
-	}
-
-	public void createNode(Object t) {
-		int ID = adaptor.getUniqueID(t);
-		String text = adaptor.getText(t);
-		int type = adaptor.getType(t);
-		StringBuffer buf = new StringBuffer(50);
-		buf.append("createNodeFromTokenElements\t");
-		buf.append(ID);
-		buf.append("\t");
-		buf.append(type);
-		serializeText(buf, text);
-		transmit(buf.toString());
-	}
-
-	public void createNode(Object node, Token token) {
-		int ID = adaptor.getUniqueID(node);
-		int tokenIndex = token.getTokenIndex();
-		transmit("createNode\t"+ID+"\t"+tokenIndex);
-	}
-
-	public void becomeRoot(Object newRoot, Object oldRoot) {
-		int newRootID = adaptor.getUniqueID(newRoot);
-		int oldRootID = adaptor.getUniqueID(oldRoot);
-		transmit("becomeRoot\t"+newRootID+"\t"+oldRootID);
-	}
-
-	public void addChild(Object root, Object child) {
-		int rootID = adaptor.getUniqueID(root);
-		int childID = adaptor.getUniqueID(child);
-		transmit("addChild\t"+rootID+"\t"+childID);
-	}
-
-	public void setTokenBoundaries(Object t, int tokenStartIndex, int tokenStopIndex) {
-		int ID = adaptor.getUniqueID(t);
-		transmit("setTokenBoundaries\t"+ID+"\t"+tokenStartIndex+"\t"+tokenStopIndex);
-	}
-
-
-    // support
-
-    public void setTreeAdaptor(TreeAdaptor adaptor) { this.adaptor = adaptor; }
-    public TreeAdaptor getTreeAdaptor() { return adaptor; }
-
-    protected String serializeToken(Token t) {
-        StringBuffer buf = new StringBuffer(50);
-        buf.append(t.getTokenIndex()); buf.append('\t');
-        buf.append(t.getType()); buf.append('\t');
-        buf.append(t.getChannel()); buf.append('\t');
-        buf.append(t.getLine()); buf.append('\t');
-		buf.append(t.getCharPositionInLine());
-		serializeText(buf, t.getText());
-		return buf.toString();
-	}
-
-	protected void serializeText(StringBuffer buf, String text) {
-		buf.append("\t\"");
-		if ( text==null ) {
-			text = "";
-		}
-		// escape \n and \r all text for token appears to exist on one line
-		// this escape is slow but easy to understand
-		text = escapeNewlines(text);
-		buf.append(text);
-	}
-
-	protected String escapeNewlines(String txt) {
-		txt = txt.replaceAll("%","%25");   // escape all escape char ;)
-		txt = txt.replaceAll("\n","%0A");  // escape \n
-		txt = txt.replaceAll("\r","%0D");  // escape \r
-		return txt;
-	}
-}
-