/*
* [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 System;
using Antlr.Runtime.JavaExtensions;
using IOException = System.IO.IOException;
using ITreeAdaptor = Antlr.Runtime.Tree.ITreeAdaptor;
using Socket = System.Net.Sockets.Socket;
using StringBuilder = System.Text.StringBuilder;
using TcpListener = System.Net.Sockets.TcpListener;
/** <summary>
* 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.
* </summary>
*/
public class DebugEventSocketProxy : BlankDebugEventListener
{
public const int DefaultDebuggerPort = 49100;
protected int port = DefaultDebuggerPort;
protected TcpListener serverSocket;
protected Socket socket;
protected string grammarFileName;
//protected PrintWriter @out;
//protected BufferedReader @in;
/** <summary>Who am i debugging?</summary> */
protected BaseRecognizer recognizer;
/** <summary>
* 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. :(
* </summary>
*/
protected ITreeAdaptor adaptor;
public DebugEventSocketProxy( BaseRecognizer recognizer, ITreeAdaptor adaptor ) :
this( recognizer, DefaultDebuggerPort, adaptor )
{
}
public DebugEventSocketProxy( BaseRecognizer recognizer, int port, ITreeAdaptor adaptor )
{
this.grammarFileName = recognizer.GrammarFileName;
this.adaptor = adaptor;
this.port = port;
}
#region Properties
public virtual ITreeAdaptor TreeAdaptor
{
get
{
return adaptor;
}
set
{
adaptor = value;
}
}
#endregion
public virtual void Handshake()
{
if ( serverSocket == null )
{
System.Net.IPHostEntry hostInfo = System.Net.Dns.GetHostEntry( "localhost" );
System.Net.IPAddress ipAddress = hostInfo.AddressList[0];
serverSocket = new TcpListener( ipAddress, port );
socket = serverSocket.AcceptSocket();
socket.NoDelay = true;
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
socket.Send( encoding.GetBytes( "ANTLR " + DebugEventListenerConstants.ProtocolVersion + "\n" ) );
socket.Send( encoding.GetBytes( "grammar \"" + grammarFileName + "\n" ) );
Ack();
//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 " + DebugEventListenerConstants.PROTOCOL_VERSION );
//@out.println( "grammar \"" + grammarFileName );
//@out.flush();
//ack();
}
}
public override void Commence()
{
// don't bother sending event; listener will trigger upon connection
}
public override void Terminate()
{
Transmit( "terminate" );
//@out.close();
try
{
socket.Close();
}
catch ( IOException ioe )
{
ExceptionExtensions.PrintStackTrace( ioe, Console.Error );
}
}
protected virtual void Ack()
{
try
{
throw new NotImplementedException();
//@in.readLine();
}
catch ( IOException ioe )
{
ExceptionExtensions.PrintStackTrace( ioe, Console.Error );
}
}
protected virtual void Transmit( string @event )
{
socket.Send( new System.Text.UTF8Encoding().GetBytes( @event + "\n" ) );
//@out.println( @event );
//@out.flush();
Ack();
}
public override void EnterRule( string grammarFileName, string ruleName )
{
Transmit( "enterRule\t" + grammarFileName + "\t" + ruleName );
}
public override void EnterAlt( int alt )
{
Transmit( "enterAlt\t" + alt );
}
public override void ExitRule( string grammarFileName, string ruleName )
{
Transmit( "exitRule\t" + grammarFileName + "\t" + ruleName );
}
public override void EnterSubRule( int decisionNumber )
{
Transmit( "enterSubRule\t" + decisionNumber );
}
public override void ExitSubRule( int decisionNumber )
{
Transmit( "exitSubRule\t" + decisionNumber );
}
public override void EnterDecision(int decisionNumber, bool couldBacktrack)
{
Transmit( "enterDecision\t" + decisionNumber );
}
public override void ExitDecision( int decisionNumber )
{
Transmit( "exitDecision\t" + decisionNumber );
}
public override void ConsumeToken( IToken t )
{
string buf = SerializeToken( t );
Transmit( "consumeToken\t" + buf );
}
public override void ConsumeHiddenToken( IToken t )
{
string buf = SerializeToken( t );
Transmit( "consumeHiddenToken\t" + buf );
}
public override void LT( int i, IToken t )
{
if ( t != null )
Transmit( "LT\t" + i + "\t" + SerializeToken( t ) );
}
public override void Mark( int i )
{
Transmit( "mark\t" + i );
}
public override void Rewind( int i )
{
Transmit( "rewind\t" + i );
}
public override void Rewind()
{
Transmit( "rewind" );
}
public override void BeginBacktrack( int level )
{
Transmit( "beginBacktrack\t" + level );
}
public override void EndBacktrack( int level, bool successful )
{
Transmit( "endBacktrack\t" + level + "\t" + ( successful ? DebugEventListenerConstants.True : DebugEventListenerConstants.False ) );
}
public override void Location( int line, int pos )
{
Transmit( "location\t" + line + "\t" + pos );
}
public override void RecognitionException( RecognitionException e )
{
StringBuilder buf = new StringBuilder( 50 );
buf.Append( "exception\t" );
buf.Append( e.GetType().Name );
// 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 override void BeginResync()
{
Transmit( "beginResync" );
}
public override void EndResync()
{
Transmit( "endResync" );
}
public override void SemanticPredicate( bool result, string predicate )
{
StringBuilder buf = new StringBuilder( 50 );
buf.Append( "semanticPredicate\t" );
buf.Append( result );
SerializeText( buf, predicate );
Transmit( buf.ToString() );
}
#region AST Parsing Events
public override void ConsumeNode( object t )
{
StringBuilder buf = new StringBuilder( 50 );
buf.Append( "consumeNode" );
SerializeNode( buf, t );
Transmit( buf.ToString() );
}
public override void LT( int i, object t )
{
int ID = adaptor.GetUniqueID( t );
string text = adaptor.GetText( t );
int type = adaptor.GetType( t );
StringBuilder buf = new StringBuilder( 50 );
buf.Append( "LN\t" ); // lookahead node; distinguish from LT in protocol
buf.Append( i );
SerializeNode( buf, t );
Transmit( buf.ToString() );
}
protected virtual void SerializeNode( StringBuilder 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 );
IToken token = adaptor.GetToken( t );
int line = -1;
int pos = -1;
if ( token != null )
{
line = token.Line;
pos = token.CharPositionInLine;
}
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 );
}
#endregion
#region AST Events
public override void NilNode( object t )
{
int ID = adaptor.GetUniqueID( t );
Transmit( "nilNode\t" + ID );
}
public override void ErrorNode( object t )
{
int ID = adaptor.GetUniqueID( t );
string text = t.ToString();
StringBuilder buf = new StringBuilder( 50 );
buf.Append( "errorNode\t" );
buf.Append( ID );
buf.Append( "\t" );
buf.Append( TokenTypes.Invalid );
SerializeText( buf, text );
Transmit( buf.ToString() );
}
public override void CreateNode( object t )
{
int ID = adaptor.GetUniqueID( t );
string text = adaptor.GetText( t );
int type = adaptor.GetType( t );
StringBuilder buf = new StringBuilder( 50 );
buf.Append( "createNodeFromTokenElements\t" );
buf.Append( ID );
buf.Append( "\t" );
buf.Append( type );
SerializeText( buf, text );
Transmit( buf.ToString() );
}
public override void CreateNode( object node, IToken token )
{
int ID = adaptor.GetUniqueID( node );
int tokenIndex = token.TokenIndex;
Transmit( "createNode\t" + ID + "\t" + tokenIndex );
}
public override void BecomeRoot( object newRoot, object oldRoot )
{
int newRootID = adaptor.GetUniqueID( newRoot );
int oldRootID = adaptor.GetUniqueID( oldRoot );
Transmit( "becomeRoot\t" + newRootID + "\t" + oldRootID );
}
public override void AddChild( object root, object child )
{
int rootID = adaptor.GetUniqueID( root );
int childID = adaptor.GetUniqueID( child );
Transmit( "addChild\t" + rootID + "\t" + childID );
}
public override void SetTokenBoundaries( object t, int tokenStartIndex, int tokenStopIndex )
{
int ID = adaptor.GetUniqueID( t );
Transmit( "setTokenBoundaries\t" + ID + "\t" + tokenStartIndex + "\t" + tokenStopIndex );
}
#endregion
#region Support
protected virtual string SerializeToken( IToken t )
{
StringBuilder buf = new StringBuilder( 50 );
buf.Append( t.TokenIndex );
buf.Append( '\t' );
buf.Append( t.Type );
buf.Append( '\t' );
buf.Append( t.Channel );
buf.Append( '\t' );
buf.Append( t.Line );
buf.Append( '\t' );
buf.Append( t.CharPositionInLine );
SerializeText( buf, t.Text );
return buf.ToString();
}
protected virtual void SerializeText( StringBuilder 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 virtual string EscapeNewlines( string txt )
{
txt = txt.Replace( "%", "%25" ); // escape all escape char ;)
txt = txt.Replace( "\n", "%0A" ); // escape \n
txt = txt.Replace( "\r", "%0D" ); // escape \r
return txt;
}
#endregion
}
}