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;
 
 
 import java.io.*;
 
 public class RemoteDebugEventSocketListener implements Runnable {
 	static final int MAX_EVENT_ELEMENTS = 8;
 	int port;
 	Socket channel = null;
Version of ANTLR (dictates events)
 
 	public String version;
Track the last token index we saw during a consume. If same, then set a flag that we have a problem.
 
 	int previousTokenIndex = -1;
 	boolean tokenIndexesInvalid = false;
 
 	private static final String TAG = "ANTLR:DEBUG:RemoteDebugEventSocketListener";
 
 	public static class ProxyToken implements Token {
 		int index;
 		int type;
 		int channel;
 		int line;
 		int charPos;
 		public ProxyToken(int index) { this. = index; }		
 		public ProxyToken(int indexint typeint channel,
 						  int lineint charPosString text)
 		{
 			this. = index;
 			this. = type;
 			this. = channel;
 			this. = line;
 			this. = charPos;
 			this. = text;
 		}
 		public String getText() {
 			return ;
 		}
 		public void setText(String text) {
 			this. = text;
 		}
 		public int getType() {
 			return ;
 		}
 		public void setType(int ttype) {
 			this. = ttype;
 		}
 		public int getLine() {
 			return ;
 		}
 		public void setLine(int line) {
 			this. = line;
 		}
 		public int getCharPositionInLine() {
 			return ;
 		}
		public void setCharPositionInLine(int pos) {
			this. = pos;
		}
		public int getChannel() {
			return ;
		}
		public void setChannel(int channel) {
			this. = channel;
		}
		public int getTokenIndex() {
			return ;
		}
		public void setTokenIndex(int index) {
			this. = index;
		}
			return null;
		}
		public void setInputStream(CharStream input) {
		}
		public String toString() {
			String channelStr = "";
				channelStr=",channel="+;
			}
			return "["+getText()+"/<"++">"+channelStr+","++":"+getCharPositionInLine()+",@"++"]";
		}
	}
	public static class ProxyTree extends BaseTree {
		public int ID;
		public int type;
		public int line = 0;
		public int charPos = -1;
		public int tokenIndex = -1;
		public String text;
		public ProxyTree(int IDint typeint lineint charPosint tokenIndexString text) {
			this. = ID;
			this. = type;
			this. = line;
			this. = charPos;
			this. = tokenIndex;
			this. = text;
		}
		public ProxyTree(int ID) { this. = ID; }
		public int getTokenStartIndex() { return ; }
		public void setTokenStartIndex(int index) {	}
		public int getTokenStopIndex() { return 0; }
		public void setTokenStopIndex(int index) { }
		public Tree dupNode() {	return null; }
		public int getType() { return ; }
		public String getText() { return ; }
		public String toString() {
			return "fix this";
		}
	}
										  String machine,
										  int portthrows IOException
	{
		this. = listener;
		this. = machine;
		this. = port;
        if( !openConnection() ) {
            throw new ConnectException();
        }
	}
	protected void eventHandler() {
		try {
			while ( !=null ) {
				ack();
			}
		}
		catch (Exception e) {
			//System.err.println(e);
			//e.printStackTrace(System.err);
			android.util.Log.e(, android.util.Log.getStackTraceString(e));
		}
		finally {
            closeConnection();
		}
	}
    protected boolean openConnection() {
        boolean success = false;
        try {
             = new Socket();
            .setTcpNoDelay(true);
			OutputStreamWriter osw = new OutputStreamWriter(os"UTF8");
			 = new PrintWriter(new BufferedWriter(osw));
			InputStreamReader isr = new InputStreamReader(is"UTF8");
			 = new BufferedReader(isr);
            success = true;
        } catch(Exception e) {
            //System.err.println(e);
	    android.util.Log.e(, android.util.Log.getStackTraceString(e));
        }
        return success;
    }
    protected void closeConnection() {
        try {
            .close();  = null;
            .close();  = null;
            .close(); =null;
        }
        catch (Exception e) {
            //System.err.println(e);
            //e.printStackTrace(System.err);
	    android.util.Log.e(, android.util.Log.getStackTraceString(e));
        }
        finally {
            if ( !=null ) {
                try {.close();} catch (IOException ioe) {
                    //System.err.println(ioe);
		    android.util.Log.e(, android.util.Log.getStackTraceString(ioe));
                }
            }
            if ( !=null ) {
                .close();
            }
            if ( !=null ) {
                try {.close();} catch (IOException ioe) {
                    //System.err.println(ioe);
		    android.util.Log.e(, android.util.Log.getStackTraceString(ioe));
                }
            }
        }
    }
	protected void handshake() throws IOException {
		String antlrLine = .readLine();
		String[] antlrElements = getEventElements(antlrLine);
		 = antlrElements[1];
		String grammarLine = .readLine();
		String[] grammarElements = getEventElements(grammarLine);
		 = grammarElements[1];
		ack();
		.commence(); // inform listener after handshake
	}
	protected void ack() {
        .println("ack");
	}
	protected void dispatch(String line) {
        //System.out.println("event: "+line);
        String[] elements = getEventElements(line);
		if ( elements==null || elements[0]==null ) {
			//System.err.println("unknown debug event: "+line);
			android.util.Log.e("unknown debug event: "+line);
			return;
		}
		if ( elements[0].equals("enterRule") ) {
			.enterRule(elements[1], elements[2]);
		}
		else if ( elements[0].equals("exitRule") ) {
			.exitRule(elements[1], elements[2]);
		}
		else if ( elements[0].equals("enterAlt") ) {
			.enterAlt(Integer.parseInt(elements[1]));
		}
		else if ( elements[0].equals("enterSubRule") ) {
			.enterSubRule(Integer.parseInt(elements[1]));
		}
		else if ( elements[0].equals("exitSubRule") ) {
			.exitSubRule(Integer.parseInt(elements[1]));
		}
		else if ( elements[0].equals("enterDecision") ) {
			.enterDecision(Integer.parseInt(elements[1]), elements[2].equals("true"));
		}
		else if ( elements[0].equals("exitDecision") ) {
			.exitDecision(Integer.parseInt(elements[1]));
		}
		else if ( elements[0].equals("location") ) {
			.location(Integer.parseInt(elements[1]),
							  Integer.parseInt(elements[2]));
		}
		else if ( elements[0].equals("consumeToken") ) {
			ProxyToken t = deserializeToken(elements, 1);
			if ( t.getTokenIndex() ==  ) {
			}
		}
		else if ( elements[0].equals("consumeHiddenToken") ) {
			ProxyToken t = deserializeToken(elements, 1);
			if ( t.getTokenIndex() ==  ) {
			}
		}
		else if ( elements[0].equals("LT") ) {
			Token t = deserializeToken(elements, 2);
			.LT(Integer.parseInt(elements[1]), t);
		}
		else if ( elements[0].equals("mark") ) {
			.mark(Integer.parseInt(elements[1]));
		}
		else if ( elements[0].equals("rewind") ) {
			if ( elements[1]!=null ) {
				.rewind(Integer.parseInt(elements[1]));
			}
			else {
			}
		}
		else if ( elements[0].equals("beginBacktrack") ) {
			.beginBacktrack(Integer.parseInt(elements[1]));
		}
		else if ( elements[0].equals("endBacktrack") ) {
			int level = Integer.parseInt(elements[1]);
			int successI = Integer.parseInt(elements[2]);
		}
		else if ( elements[0].equals("exception") ) {
			String excName = elements[1];
			String indexS = elements[2];
			String lineS = elements[3];
			String posS = elements[4];
			Class excClass = null;
			try {
				excClass = Class.forName(excName);
				e.index = Integer.parseInt(indexS);
				e.line = Integer.parseInt(lineS);
				e.charPositionInLine = Integer.parseInt(posS);
			}
			catch (ClassNotFoundException cnfe) {
				//System.err.println("can't find class "+cnfe);
				android.util.Log.e("can't find class "+cnfe);
				//cnfe.printStackTrace(System.err);
				android.util.Log.e(, android.util.Log.getStackTraceString(cnfe));
			}
			catch (InstantiationException ie) {
				//System.err.println("can't instantiate class "+ie);
				//ie.printStackTrace(System.err);
				android.util.Log.e(, android.util.Log.getStackTraceString(ie));
			}
			catch (IllegalAccessException iae) {
				//System.err.println("can't access class "+iae);
				//iae.printStackTrace(System.err);
				android.util.Log.e(, android.util.Log.getStackTraceString(iae));
			}
		}
		else if ( elements[0].equals("beginResync") ) {
		}
		else if ( elements[0].equals("endResync") ) {
		}
		else if ( elements[0].equals("terminate") ) {
		}
		else if ( elements[0].equals("semanticPredicate") ) {
			Boolean result = Boolean.valueOf(elements[1]);
			String predicateText = elements[2];
			predicateText = unEscapeNewlines(predicateText);
									   predicateText);
		}
		else if ( elements[0].equals("consumeNode") ) {
			ProxyTree node = deserializeNode(elements, 1);
		}
		else if ( elements[0].equals("LN") ) {
			int i = Integer.parseInt(elements[1]);
			ProxyTree node = deserializeNode(elements, 2);
			.LT(inode);
		}
		else if ( elements[0].equals("createNodeFromTokenElements") ) {
			int ID = Integer.parseInt(elements[1]);
			int type = Integer.parseInt(elements[2]);
			String text = elements[3];
			text = unEscapeNewlines(text);
			ProxyTree node = new ProxyTree(IDtype, -1, -1, -1, text);
		}
		else if ( elements[0].equals("createNode") ) {
			int ID = Integer.parseInt(elements[1]);
			int tokenIndex = Integer.parseInt(elements[2]);
			// create dummy node/token filled with ID, tokenIndex
			ProxyTree node = new ProxyTree(ID);
			ProxyToken token = new ProxyToken(tokenIndex);
			.createNode(nodetoken);
		}
		else if ( elements[0].equals("nilNode") ) {
			int ID = Integer.parseInt(elements[1]);
			ProxyTree node = new ProxyTree(ID);
		}
		else if ( elements[0].equals("errorNode") ) {
			// TODO: do we need a special tree here?
			int ID = Integer.parseInt(elements[1]);
			int type = Integer.parseInt(elements[2]);
			String text = elements[3];
			text = unEscapeNewlines(text);
			ProxyTree node = new ProxyTree(IDtype, -1, -1, -1, text);
		}
		else if ( elements[0].equals("becomeRoot") ) {
			int newRootID = Integer.parseInt(elements[1]);
			int oldRootID = Integer.parseInt(elements[2]);
			ProxyTree newRoot = new ProxyTree(newRootID);
			ProxyTree oldRoot = new ProxyTree(oldRootID);
			.becomeRoot(newRootoldRoot);
		}
		else if ( elements[0].equals("addChild") ) {
			int rootID = Integer.parseInt(elements[1]);
			int childID = Integer.parseInt(elements[2]);
			ProxyTree root = new ProxyTree(rootID);
			ProxyTree child = new ProxyTree(childID);
			.addChild(rootchild);
		}
		else if ( elements[0].equals("setTokenBoundaries") ) {
			int ID = Integer.parseInt(elements[1]);
			ProxyTree node = new ProxyTree(ID);
				node,
				Integer.parseInt(elements[2]),
				Integer.parseInt(elements[3]));
		}
		else {
			//System.err.println("unknown debug event: "+line);
			android.util.Log.e("unknown debug event: "+line);
		}
	}
	protected ProxyTree deserializeNode(String[] elementsint offset) {
		int ID = Integer.parseInt(elements[offset+0]);
		int type = Integer.parseInt(elements[offset+1]);
		int tokenLine = Integer.parseInt(elements[offset+2]);
		int charPositionInLine = Integer.parseInt(elements[offset+3]);
		int tokenIndex = Integer.parseInt(elements[offset+4]);
		String text = elements[offset+5];
		text = unEscapeNewlines(text);
		return new ProxyTree(IDtypetokenLinecharPositionInLinetokenIndextext);
	}
	protected ProxyToken deserializeToken(String[] elements,
										  int offset)
	{
		String indexS = elements[offset+0];
		String typeS = elements[offset+1];
		String channelS = elements[offset+2];
		String lineS = elements[offset+3];
		String posS = elements[offset+4];
		String text = elements[offset+5];
		text = unEscapeNewlines(text);
		int index = Integer.parseInt(indexS);
			new ProxyToken(index,
						   Integer.parseInt(typeS),
						   Integer.parseInt(channelS),
						   Integer.parseInt(lineS),
						   Integer.parseInt(posS),
						   text);
		return t;
	}

Create a thread to listen to the remote running recognizer
	public void start() {
		Thread t = new Thread(this);
		t.start();
	}
	public void run() {
	}
	// M i s c
	public String[] getEventElements(String event) {
		if ( event==null ) {
			return null;
		}
		String[] elements = new String[];
		String str = null// a string element if present (must be last)
		try {
			int firstQuoteIndex = event.indexOf('"');
			if ( firstQuoteIndex>=0 ) {
				// treat specially; has a string argument like "a comment\n
				// Note that the string is terminated by \n not end quote.
				// Easier to parse that way.
				String eventWithoutString = event.substring(0,firstQuoteIndex);
				str = event.substring(firstQuoteIndex+1,event.length());
				event = eventWithoutString;
			}
			StringTokenizer st = new StringTokenizer(event"\t"false);
			int i = 0;
			while ( st.hasMoreTokens() ) {
				if ( i>= ) {
					// ErrorManager.internalError("event has more than "+MAX_EVENT_ELEMENTS+" args: "+event);
					return elements;
				}
				elements[i] = st.nextToken();
				i++;
			}
			if ( str!=null ) {
				elements[i] = str;
			}
		}
		catch (Exception e) {
			//e.printStackTrace(System.err);
			android.util.Log.e(, android.util.Log.getStackTraceString(e));
		}
		return elements;
	}
	protected String unEscapeNewlines(String txt) {
		// this unescape is slow but easy to understand
		txt = txt.replaceAll("%0A","\n");  // unescape \n
		txt = txt.replaceAll("%0D","\r");  // unescape \r
		txt = txt.replaceAll("%25","%");   // undo escaped escape chars
		return txt;
	}
	public boolean tokenIndexesAreInvalid() {
		return false;
		//return tokenIndexesInvalid;
	}
New to GrepCode? Check out our FAQ X