| /* |
| * [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 Antlr.Runtime.JavaExtensions; |
| |
| using Array = System.Array; |
| using BaseTree = Antlr.Runtime.Tree.BaseTree; |
| using Console = System.Console; |
| using Exception = System.Exception; |
| using IOException = System.IO.IOException; |
| using ITree = Antlr.Runtime.Tree.ITree; |
| using Math = System.Math; |
| using Socket = System.Net.Sockets.Socket; |
| using SocketException = System.Net.Sockets.SocketException; |
| using TextReader = System.IO.TextReader; |
| using TextWriter = System.IO.TextWriter; |
| |
| public class RemoteDebugEventSocketListener |
| { |
| const int MAX_EVENT_ELEMENTS = 8; |
| IDebugEventListener listener; |
| string machine; |
| int port; |
| Socket channel = null; |
| TextWriter @out; |
| TextReader @in; |
| string @event; |
| /** <summary>Version of ANTLR (dictates events)</summary> */ |
| public string version; |
| public string grammarFileName; |
| /** <summary> |
| * Track the last token index we saw during a consume. If same, then |
| * set a flag that we have a problem. |
| * </summary> |
| */ |
| int previousTokenIndex = -1; |
| bool tokenIndexesInvalid = false; |
| |
| public class ProxyToken : IToken |
| { |
| int index; |
| int type; |
| int channel; |
| int line; |
| int charPos; |
| string text; |
| public ProxyToken( int index ) |
| { |
| this.index = index; |
| } |
| public ProxyToken( int index, int type, int channel, |
| int line, int charPos, string text ) |
| { |
| this.index = index; |
| this.type = type; |
| this.channel = channel; |
| this.line = line; |
| this.charPos = charPos; |
| this.text = text; |
| } |
| |
| #region IToken Members |
| public string Text |
| { |
| get |
| { |
| return text; |
| } |
| set |
| { |
| text = value; |
| } |
| } |
| |
| public int Type |
| { |
| get |
| { |
| return type; |
| } |
| set |
| { |
| type = value; |
| } |
| } |
| |
| public int Line |
| { |
| get |
| { |
| return line; |
| } |
| set |
| { |
| line = value; |
| } |
| } |
| |
| public int CharPositionInLine |
| { |
| get |
| { |
| return charPos; |
| } |
| set |
| { |
| charPos = value; |
| } |
| } |
| |
| public int Channel |
| { |
| get |
| { |
| return channel; |
| } |
| set |
| { |
| channel = value; |
| } |
| } |
| |
| public int StartIndex |
| { |
| get |
| { |
| return -1; |
| } |
| set |
| { |
| } |
| } |
| |
| public int StopIndex |
| { |
| get |
| { |
| return -1; |
| } |
| set |
| { |
| } |
| } |
| |
| public int TokenIndex |
| { |
| get |
| { |
| return index; |
| } |
| set |
| { |
| index = value; |
| } |
| } |
| |
| public ICharStream InputStream |
| { |
| get |
| { |
| return null; |
| } |
| set |
| { |
| } |
| } |
| |
| #endregion |
| |
| public override string ToString() |
| { |
| string channelStr = ""; |
| if ( channel != TokenChannels.Default ) |
| { |
| channelStr = ",channel=" + channel; |
| } |
| return "[" + Text + "/<" + type + ">" + channelStr + "," + line + ":" + CharPositionInLine + ",@" + index + "]"; |
| } |
| } |
| |
| public class ProxyTree : BaseTree |
| { |
| public int ID; |
| int type; |
| int line = 0; |
| public int charPos = -1; |
| public int tokenIndex = -1; |
| string text; |
| |
| public ProxyTree( int ID, int type, int line, int charPos, int tokenIndex, string text ) |
| { |
| this.ID = ID; |
| this.type = type; |
| this.line = line; |
| this.charPos = charPos; |
| this.tokenIndex = tokenIndex; |
| this.text = text; |
| } |
| |
| public ProxyTree( int ID ) |
| { |
| this.ID = ID; |
| } |
| |
| #region Properties |
| public override string Text |
| { |
| get |
| { |
| return text; |
| } |
| set |
| { |
| } |
| } |
| public override int TokenStartIndex |
| { |
| get |
| { |
| return tokenIndex; |
| } |
| set |
| { |
| } |
| } |
| public override int TokenStopIndex |
| { |
| get |
| { |
| return 0; |
| } |
| set |
| { |
| } |
| } |
| public override int Type |
| { |
| get |
| { |
| return type; |
| } |
| set |
| { |
| } |
| } |
| #endregion |
| |
| public override ITree DupNode() |
| { |
| return null; |
| } |
| |
| public override string ToString() |
| { |
| return "fix this"; |
| } |
| } |
| |
| public RemoteDebugEventSocketListener( IDebugEventListener listener, |
| string machine, |
| int port ) |
| { |
| this.listener = listener; |
| this.machine = machine; |
| this.port = port; |
| |
| if ( !OpenConnection() ) |
| { |
| throw new SocketException(); |
| } |
| } |
| |
| protected virtual void EventHandler() |
| { |
| try |
| { |
| Handshake(); |
| @event = @in.ReadLine(); |
| while ( @event != null ) |
| { |
| Dispatch( @event ); |
| Ack(); |
| @event = @in.ReadLine(); |
| } |
| } |
| catch ( Exception e ) |
| { |
| Console.Error.WriteLine( e ); |
| ExceptionExtensions.PrintStackTrace( e, Console.Error ); |
| } |
| finally |
| { |
| CloseConnection(); |
| } |
| } |
| |
| protected virtual bool OpenConnection() |
| { |
| bool success = false; |
| try |
| { |
| throw new System.NotImplementedException(); |
| //channel = new Socket( machine, port ); |
| //channel.setTcpNoDelay( true ); |
| //OutputStream os = channel.getOutputStream(); |
| //OutputStreamWriter osw = new OutputStreamWriter( os, "UTF8" ); |
| //@out = new PrintWriter( new BufferedWriter( osw ) ); |
| //InputStream @is = channel.getInputStream(); |
| //InputStreamReader isr = new InputStreamReader( @is, "UTF8" ); |
| //@in = new BufferedReader( isr ); |
| //success = true; |
| } |
| catch ( Exception e ) |
| { |
| Console.Error.WriteLine( e ); |
| } |
| return success; |
| } |
| |
| protected virtual void CloseConnection() |
| { |
| try |
| { |
| @in.Close(); |
| @in = null; |
| @out.Close(); |
| @out = null; |
| channel.Close(); |
| channel = null; |
| } |
| catch ( Exception e ) |
| { |
| Console.Error.WriteLine( e ); |
| ExceptionExtensions.PrintStackTrace( e, Console.Error ); |
| } |
| finally |
| { |
| if ( @in != null ) |
| { |
| try |
| { |
| @in.Close(); |
| } |
| catch ( IOException ioe ) |
| { |
| Console.Error.WriteLine( ioe ); |
| } |
| } |
| if ( @out != null ) |
| { |
| @out.Close(); |
| } |
| if ( channel != null ) |
| { |
| try |
| { |
| channel.Close(); |
| } |
| catch ( IOException ioe ) |
| { |
| Console.Error.WriteLine( ioe ); |
| } |
| } |
| } |
| |
| } |
| |
| protected virtual void Handshake() |
| { |
| string antlrLine = @in.ReadLine(); |
| string[] antlrElements = GetEventElements( antlrLine ); |
| version = antlrElements[1]; |
| string grammarLine = @in.ReadLine(); |
| string[] grammarElements = GetEventElements( grammarLine ); |
| grammarFileName = grammarElements[1]; |
| Ack(); |
| listener.Commence(); // inform listener after handshake |
| } |
| |
| protected virtual void Ack() |
| { |
| @out.WriteLine( "ack" ); |
| @out.Flush(); |
| } |
| |
| protected virtual void Dispatch( string line ) |
| { |
| //JSystem.@out.println( "event: " + line ); |
| string[] elements = GetEventElements( line ); |
| if ( elements == null || elements[0] == null ) |
| { |
| Console.Error.WriteLine( "unknown debug event: " + line ); |
| return; |
| } |
| if ( elements[0].Equals( "enterRule" ) ) |
| { |
| listener.EnterRule( elements[1], elements[2] ); |
| } |
| else if ( elements[0].Equals( "exitRule" ) ) |
| { |
| listener.ExitRule( elements[1], elements[2] ); |
| } |
| else if ( elements[0].Equals( "enterAlt" ) ) |
| { |
| listener.EnterAlt( int.Parse( elements[1] ) ); |
| } |
| else if ( elements[0].Equals( "enterSubRule" ) ) |
| { |
| listener.EnterSubRule( int.Parse( elements[1] ) ); |
| } |
| else if ( elements[0].Equals( "exitSubRule" ) ) |
| { |
| listener.ExitSubRule( int.Parse( elements[1] ) ); |
| } |
| else if ( elements[0].Equals( "enterDecision" ) ) |
| { |
| listener.EnterDecision(int.Parse(elements[1]), elements[2].Equals("true")); |
| } |
| else if ( elements[0].Equals( "exitDecision" ) ) |
| { |
| listener.ExitDecision( int.Parse( elements[1] ) ); |
| } |
| else if ( elements[0].Equals( "location" ) ) |
| { |
| listener.Location( int.Parse( elements[1] ), |
| int.Parse( elements[2] ) ); |
| } |
| else if ( elements[0].Equals( "consumeToken" ) ) |
| { |
| ProxyToken t = DeserializeToken( elements, 1 ); |
| if ( t.TokenIndex == previousTokenIndex ) |
| { |
| tokenIndexesInvalid = true; |
| } |
| previousTokenIndex = t.TokenIndex; |
| listener.ConsumeToken( t ); |
| } |
| else if ( elements[0].Equals( "consumeHiddenToken" ) ) |
| { |
| ProxyToken t = DeserializeToken( elements, 1 ); |
| if ( t.TokenIndex == previousTokenIndex ) |
| { |
| tokenIndexesInvalid = true; |
| } |
| previousTokenIndex = t.TokenIndex; |
| listener.ConsumeHiddenToken( t ); |
| } |
| else if ( elements[0].Equals( "LT" ) ) |
| { |
| IToken t = DeserializeToken( elements, 2 ); |
| listener.LT( int.Parse( elements[1] ), t ); |
| } |
| else if ( elements[0].Equals( "mark" ) ) |
| { |
| listener.Mark( int.Parse( elements[1] ) ); |
| } |
| else if ( elements[0].Equals( "rewind" ) ) |
| { |
| if ( elements[1] != null ) |
| { |
| listener.Rewind( int.Parse( elements[1] ) ); |
| } |
| else |
| { |
| listener.Rewind(); |
| } |
| } |
| else if ( elements[0].Equals( "beginBacktrack" ) ) |
| { |
| listener.BeginBacktrack( int.Parse( elements[1] ) ); |
| } |
| else if ( elements[0].Equals( "endBacktrack" ) ) |
| { |
| int level = int.Parse( elements[1] ); |
| int successI = int.Parse( elements[2] ); |
| listener.EndBacktrack( level, successI == DebugEventListenerConstants.True ); |
| } |
| else if ( elements[0].Equals( "exception" ) ) |
| { |
| #if true |
| throw new System.NotImplementedException(); |
| #else |
| string excName = elements[1]; |
| string indexS = elements[2]; |
| string lineS = elements[3]; |
| string posS = elements[4]; |
| Class excClass = null; |
| try |
| { |
| excClass = Class.forName( excName ); |
| RecognitionException e = |
| (RecognitionException)excClass.newInstance(); |
| e.index = int.Parse( indexS ); |
| e.line = int.Parse( lineS ); |
| e.charPositionInLine = int.Parse( posS ); |
| listener.recognitionException( e ); |
| } |
| catch ( ClassNotFoundException cnfe ) |
| { |
| Console.Error.println( "can't find class " + cnfe ); |
| cnfe.printStackTrace( Console.Error ); |
| } |
| catch ( InstantiationException ie ) |
| { |
| Console.Error.println( "can't instantiate class " + ie ); |
| ie.printStackTrace( Console.Error ); |
| } |
| catch ( IllegalAccessException iae ) |
| { |
| Console.Error.println( "can't access class " + iae ); |
| iae.printStackTrace( Console.Error ); |
| } |
| #endif |
| } |
| else if ( elements[0].Equals( "beginResync" ) ) |
| { |
| listener.BeginResync(); |
| } |
| else if ( elements[0].Equals( "endResync" ) ) |
| { |
| listener.EndResync(); |
| } |
| else if ( elements[0].Equals( "terminate" ) ) |
| { |
| listener.Terminate(); |
| } |
| else if ( elements[0].Equals( "semanticPredicate" ) ) |
| { |
| bool result = bool.Parse( elements[1] ); |
| string predicateText = elements[2]; |
| predicateText = UnEscapeNewlines( predicateText ); |
| listener.SemanticPredicate( result, |
| predicateText ); |
| } |
| else if ( elements[0].Equals( "consumeNode" ) ) |
| { |
| ProxyTree node = DeserializeNode( elements, 1 ); |
| listener.ConsumeNode( node ); |
| } |
| else if ( elements[0].Equals( "LN" ) ) |
| { |
| int i = int.Parse( elements[1] ); |
| ProxyTree node = DeserializeNode( elements, 2 ); |
| listener.LT( i, node ); |
| } |
| else if ( elements[0].Equals( "createNodeFromTokenElements" ) ) |
| { |
| int ID = int.Parse( elements[1] ); |
| int type = int.Parse( elements[2] ); |
| string text = elements[3]; |
| text = UnEscapeNewlines( text ); |
| ProxyTree node = new ProxyTree( ID, type, -1, -1, -1, text ); |
| listener.CreateNode( node ); |
| } |
| else if ( elements[0].Equals( "createNode" ) ) |
| { |
| int ID = int.Parse( elements[1] ); |
| int tokenIndex = int.Parse( elements[2] ); |
| // create dummy node/token filled with ID, tokenIndex |
| ProxyTree node = new ProxyTree( ID ); |
| ProxyToken token = new ProxyToken( tokenIndex ); |
| listener.CreateNode( node, token ); |
| } |
| else if ( elements[0].Equals( "nilNode" ) ) |
| { |
| int ID = int.Parse( elements[1] ); |
| ProxyTree node = new ProxyTree( ID ); |
| listener.NilNode( node ); |
| } |
| else if ( elements[0].Equals( "errorNode" ) ) |
| { |
| // TODO: do we need a special tree here? |
| int ID = int.Parse( elements[1] ); |
| int type = int.Parse( elements[2] ); |
| string text = elements[3]; |
| text = UnEscapeNewlines( text ); |
| ProxyTree node = new ProxyTree( ID, type, -1, -1, -1, text ); |
| listener.ErrorNode( node ); |
| } |
| else if ( elements[0].Equals( "becomeRoot" ) ) |
| { |
| int newRootID = int.Parse( elements[1] ); |
| int oldRootID = int.Parse( elements[2] ); |
| ProxyTree newRoot = new ProxyTree( newRootID ); |
| ProxyTree oldRoot = new ProxyTree( oldRootID ); |
| listener.BecomeRoot( newRoot, oldRoot ); |
| } |
| else if ( elements[0].Equals( "addChild" ) ) |
| { |
| int rootID = int.Parse( elements[1] ); |
| int childID = int.Parse( elements[2] ); |
| ProxyTree root = new ProxyTree( rootID ); |
| ProxyTree child = new ProxyTree( childID ); |
| listener.AddChild( root, child ); |
| } |
| else if ( elements[0].Equals( "setTokenBoundaries" ) ) |
| { |
| int ID = int.Parse( elements[1] ); |
| ProxyTree node = new ProxyTree( ID ); |
| listener.SetTokenBoundaries( |
| node, |
| int.Parse( elements[2] ), |
| int.Parse( elements[3] ) ); |
| } |
| else |
| { |
| Console.Error.WriteLine( "unknown debug event: " + line ); |
| } |
| } |
| |
| protected virtual ProxyTree DeserializeNode( string[] elements, int offset ) |
| { |
| int ID = int.Parse( elements[offset + 0] ); |
| int type = int.Parse( elements[offset + 1] ); |
| int tokenLine = int.Parse( elements[offset + 2] ); |
| int charPositionInLine = int.Parse( elements[offset + 3] ); |
| int tokenIndex = int.Parse( elements[offset + 4] ); |
| string text = elements[offset + 5]; |
| text = UnEscapeNewlines( text ); |
| return new ProxyTree( ID, type, tokenLine, charPositionInLine, tokenIndex, text ); |
| } |
| |
| protected virtual 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 = int.Parse( indexS ); |
| ProxyToken t = |
| new ProxyToken( index, |
| int.Parse( typeS ), |
| int.Parse( channelS ), |
| int.Parse( lineS ), |
| int.Parse( posS ), |
| text ); |
| return t; |
| } |
| |
| /** <summary>Create a thread to listen to the remote running recognizer</summary> */ |
| public virtual void Start() |
| { |
| System.Threading.Thread t = new System.Threading.Thread( Run ); |
| t.Start(); |
| } |
| |
| public virtual void Run() |
| { |
| EventHandler(); |
| } |
| |
| #region Misc |
| |
| public virtual string[] GetEventElements( string @event ) |
| { |
| if ( @event == null ) |
| { |
| return null; |
| } |
| string[] elements = new string[MAX_EVENT_ELEMENTS]; |
| 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 = eventWithoutString; |
| } |
| |
| string[] tokens = @event.Split('\t'); |
| Array.Copy(tokens, elements, Math.Min(tokens.Length, MAX_EVENT_ELEMENTS)); |
| if (tokens.Length >= MAX_EVENT_ELEMENTS) |
| return elements; |
| |
| if ( str != null ) |
| { |
| elements[tokens.Length] = str; |
| } |
| } |
| catch ( Exception e ) |
| { |
| ExceptionExtensions.PrintStackTrace( e, Console.Error ); |
| } |
| return elements; |
| } |
| |
| protected virtual string UnEscapeNewlines( string txt ) |
| { |
| // this unescape is slow but easy to understand |
| txt = txt.Replace( "%0A", "\n" ); // unescape \n |
| txt = txt.Replace( "%0D", "\r" ); // unescape \r |
| txt = txt.Replace( "%25", "%" ); // undo escaped escape chars |
| return txt; |
| } |
| |
| public virtual bool TokenIndexesAreInvalid() |
| { |
| return tokenIndexesInvalid; |
| } |
| |
| #endregion |
| |
| } |
| } |
