antlr3 1.2.3

data/lib/antlr3/debug/event-hub.rb

@@ -0,0 +1,210 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module ANTLR3
+module Debug
+=begin rdoc ANTLR3::Debug::EventHub
+
+A special event listener that intercepts debug events and forwards them to other
+debug event listners. As debug-mode recognizers are able to send event
+information to only one listener, EventHubs provide a simple solution in
+situations where multiple event listners are desired.
+
+=end
+class EventHub
+  include ANTLR3::Debug::EventListener
+  attr_reader :listeners
+  
+  def initialize(*listeners)
+    @listeners = [listeners].flatten!
+    @listeners.compact!
+  end
+  
+  def add(*listeners)
+    @listeners.push(*listeners)
+  end
+
+  def add_child(root, child)
+    for listener in @listeners
+      listener.add_child(root, child)
+    end
+  end
+  
+  def backtrack(level)
+    for listener in @listeners
+      listener.backtrack(level)
+    end
+  end
+  
+  def become_root(new_root, old_root)
+    for listener in @listeners
+      listener.become_root(new_root, old_root)
+    end
+  end
+  
+  def begin_backtrack(level)
+    for listener in @listeners
+      listener.begin_backtrack(level)
+    end
+  end
+  
+  def begin_resync()
+    for listener in @listeners
+      listener.begin_resync()
+    end
+  end
+  
+  def commence()
+    for listener in @listeners
+      listener.commence()
+    end
+  end
+  
+  def consume_hidden_token(tree)
+    for listener in @listeners
+      listener.consume_hidden_token(tree)
+    end
+  end
+  
+  def consume_node(tree)
+    for listener in @listeners
+      listener.consume_node(tree)
+    end
+  end
+  
+  def consume_token(tree)
+    for listener in @listeners
+      listener.consume_token(tree)
+    end
+  end
+  
+  def create_node(node, token)
+    for listener in @listeners
+      listener.create_node(node, token)
+    end
+  end
+  
+  def end_backtrack(level, successful)
+    for listener in @listeners
+      listener.end_backtrack(level, successful)
+    end
+  end
+  
+  def end_resync()
+    for listener in @listeners
+      listener.end_resync()
+    end
+  end
+  
+  def enter_alternative(alt)
+    for listener in @listeners
+      listener.enter_alternative(alt)
+    end
+  end
+  
+  def enter_decision(decision_number)
+    for listener in @listeners
+      listener.enter_decision(decision_number)
+    end
+  end
+  
+  def enter_rule(grammar_file_name, rule_name)
+    for listener in @listeners
+      listener.enter_rule(grammar_file_name, rule_name)
+    end
+  end
+  
+  def enter_sub_rule(decision_number)
+    for listener in @listeners
+      listener.enter_sub_rule(decision_number)
+    end
+  end
+  
+  def error_node(tree)
+    for listener in @listeners
+      listener.error_node(tree)
+    end
+  end
+  
+  def exit_decision(decision_number)
+    for listener in @listeners
+      listener.exit_decision(decision_number)
+    end
+  end
+  
+  def exit_rule(grammar_file_name, rule_name)
+    for listener in @listeners
+      listener.exit_rule(grammar_file_name, rule_name)
+    end
+  end
+  
+  def exit_sub_rule(decision_number)
+    for listener in @listeners
+      listener.exit_sub_rule(decision_number)
+    end
+  end
+  
+  def flat_node(tree)
+    for listener in @listeners
+      listener.flat_node(tree)
+    end
+  end
+  
+  def location(line, position)
+    for listener in @listeners
+      listener.location(line, position)
+    end
+  end
+  
+  def look(i, tree)
+    for listener in @listeners
+      listener.look(i, tree)
+    end
+  end
+  
+  def mark(marker)
+    for listener in @listeners
+      listener.mark(marker)
+    end
+  end
+  
+  def recognition_exception(exception)
+    for listener in @listeners
+      listener.recognition_exception(exception)
+    end
+  end
+  
+  def resync()
+    for listener in @listeners
+      listener.resync()
+    end
+  end
+  
+  def rewind(marker)
+    for listener in @listeners
+      listener.rewind(marker)
+    end
+  end
+  
+  def semantic_predicate(result, predicate)
+    for listener in @listeners
+      listener.semantic_predicate(result, predicate)
+    end
+  end
+  
+  def set_token_boundaries(tree, token_start_index, token_stop_index)
+    for listener in @listeners
+      listener.set_token_boundaries(tree, token_start_index, token_stop_index)
+    end
+  end
+  
+  def terminate()
+    for listener in @listeners
+      listener.terminate()
+    end
+  end
+  
+end
+
+end
+end

data/lib/antlr3/debug/record-event-listener.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module ANTLR3
+module Debug
+
+=begin rdoc ANTLR3::Debug::RecordEventListener
+
+A debug listener that records intercepted events as strings in an array.
+
+=end
+class RecordEventListener < TraceEventListener
+  attr_reader :events
+  def initialize( adaptor = nil )
+    super
+    @events = []
+  end
+  
+  def record(event_message, *interpolation_arguments)
+    event_message = event_message.to_s
+    @events << event_message % interpolation_arguments
+  end
+end
+end # module Debug
+end # module ANTLR3

data/lib/antlr3/debug/rule-tracer.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module ANTLR3
+module Debug
+=begin rdoc ANTLR3::Debug::RuleTracer
+
+RuleTracer is simple debug event listener that writes the names of rule methods
+as they are entered and exitted to an output stream.
+
+=end
+class RuleTracer
+  include EventListener
+  
+  ARROW_IN = '--> '.freeze
+  ARROW_OUT = '<-- '.freeze
+  
+  attr_reader :level
+  attr_accessor :spaces_per_indent, :device
+  
+  def initialize(options = {})
+    @input = options[:input]
+    @level = 0
+    @spaces_per_indent = options[:spaces_per_indent] || 2
+    @device = options[:device] || options[:output] || $stderr
+  end
+  
+  def enter_rule(grammar_file, name)
+    indent = @level * @spaces_per_indent
+    
+    @device.print(' ' * indent, ARROW_IN, name)
+    if @input
+      input_symbol = @input.look || :EOF
+      @device.puts(" look = %p" % input_symbol)
+    else @device.print("\n")
+    end
+    
+    @level += 1
+  end
+  
+  def exit_rule(grammar_file, name)
+    @level -= 1
+    
+    indent = @level * @spaces_per_indent
+    
+    @device.print(' ' * indent, ARROW_OUT, name)
+    if @input
+      input_symbol = (@input.look || :EOF)
+      @device.puts(" look = %p" % input_symbol)
+    else @device.print("\n")
+    end
+  end
+end
+end
+end

data/lib/antlr3/debug/socket.rb

@@ -0,0 +1,360 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'socket'
+
+module ANTLR3
+module Debug
+
+
+=begin rdoc ANTLR3::Debug::EventSocketProxy
+
+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.
+
+=end
+class EventSocketProxy
+  include EventListener
+  
+  SOCKET_ADDR_PACK = 'snCCCCa8'.freeze
+  
+  def initialize(recognizer, options = {})
+    super()
+    @grammar_file_name = recognizer.grammar_file_name
+    @adaptor = options[:adaptor]
+    @port = options[:port] || DEFAULT_PORT
+    @log = options[:log]
+    @socket = nil
+    @connection = nil
+  end
+  
+  def log!(message, *interpolation_arguments)
+    @log and @log.printf(message, *interpolation_arguments)
+  end
+  
+  def handshake
+    unless @socket
+      begin
+        @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        @socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+        @socket.bind(Socket.pack_sockaddr_in( @port, '' ))
+        @socket.listen(1)
+        log!("waiting for incoming connection on port %i\n", @port)
+        
+        @connection, addr = @socket.accept
+        port, host = Socket.unpack_sockaddr_in(addr)
+        log!("Accepted connection from %s:%s\n", host, port)
+        
+        @connection.setsockopt(Socket::SOL_TCP, Socket::TCP_NODELAY, 1)
+        
+        write('ANTLR %s', PROTOCOL_VERSION)
+        write('grammar %p', @grammar_file_name)
+        ack
+      rescue IOError => error
+        log!("handshake failed due to an IOError:\n")
+        log!("  %s: %s", error.class, error.message)
+        log!("  Backtrace: ")
+        log!("  - %s", error.backtrace.join("\n  - "))
+        @connection and @connection.close
+        @socket and @socket.close
+        @socket = nil
+        raise
+      end
+    end
+    return self
+  end
+  
+  def write(message, *interpolation_arguments)
+    message << ?\n
+    log!("---> #{message}", *interpolation_arguments)
+    @connection.printf(message, *interpolation_arguments)
+    @connection.flush
+  end
+  
+  def ack
+    line = @connection.readline
+    log!("<--- %s", line)
+    line
+  end
+  
+  def transmit(event, *interpolation_arguments)
+    write(event, *interpolation_arguments)
+    ack()
+  rescue IOError
+    @connection.close
+    raise
+  end
+  
+  def commence
+    # don't bother sending event; listener will trigger upon connection
+  end
+  
+  def terminate
+    transmit 'terminate'
+    @connection.close
+    @socket.close
+  end
+  
+  def enter_rule( grammar_file_name, rule_name )
+    transmit "%s\t%s\t%s", __method__, grammar_file_name, rule_name
+  end
+  
+  def enter_alternative( alt )
+    transmit "%s\t%s", __method__, alt
+  end
+  
+  def exit_rule( grammar_file_name, rule_name )
+    transmit "%s\t%s\t%s", __method__, grammar_file_name, rule_name
+  end
+  
+  def enter_subrule( decision_number )
+    transmit "%s\t%i", __method__, decision_number
+  end
+  
+  def exit_subrule( decision_number )
+    transmit "%s\t%i", __method__, decision_number
+  end
+  
+  def enter_decision( decision_number )
+    transmit "%s\t%i", __method__, decision_number
+  end
+  
+  def exit_decision( decision_number )
+    transmit "%s\t%i", __method__, decision_number
+  end
+  
+  def consume_token( token )
+    transmit "%s\t%s", __method__, serialize_token( token )
+  end
+  
+  def consume_hidden_token( token )
+    transmit "%s\t%s", __method__, serialize_token( token )
+  end
+  
+  def look(i, item)
+    case item
+    when AST::Tree
+      look_tree( i, item )
+    when nil
+    else
+      transmit "%s\t%i\t%s", __method__, i, serialize_token(item)
+    end
+  end
+  
+  def mark(i)
+    transmit "%s\t%i", __method__, i
+  end
+  
+  def rewind(i = nil)
+    i ? transmit( "%s\t%i", __method__, i ) : transmit( '%s', __method__ )
+  end
+  
+  def begin_backtrack( level )
+    transmit "%s\t%i", __method__, level
+  end
+  def end_backtrack( level, successful )
+    transmit "%s\t%i\t%p", __method__, level, (successful ? true : false)
+  end
+  
+  def location( line, position )
+    transmit "%s\t%i\t%i", __method__, line, position
+  end
+  
+  def recognition_exception( exception )
+    transmit "%s\t%p\t%i\t%i\t%i", __method__, exception.class,
+      exception.index, exception.line, exception.column
+  end
+  
+  def begin_resync
+    transmit '%s', __method__
+  end
+  
+  def end_resync
+    transmit '%s', __method__
+  end
+  
+  def semantic_predicate( result, predicate )
+    pure_boolean = !(!result)
+    transmit "%s\t%s\t%s", __method__, pure_boolean, escape_newlines( predicate )
+  end
+  
+  def consume_node( tree )
+    transmit "%s\t%s", __method__, serialize_node( tree )
+  end
+  
+  def adaptor
+    @adaptor ||= ANTLR3::CommonTreeAdaptor.new
+  end
+  
+  def look_tree( i, tree )
+    transmit "%s\t%s\t%s", __method__, i, serialize_node( tree )
+  end
+  
+  def flat_node( tree )
+    transmit "%s\t%i", __method__, adaptor.unique_id( tree )
+  end
+  
+  def error_node( tree )
+    transmit "%s\t%i\t%i\t%p", __method__, adaptor.unique_id( tree ),
+            Token::INVALID_TOKEN_TYPE, escape_newlines( tree.to_s )
+  end
+  
+  def create_node( node, token = nil )
+    if token
+      transmit "%s\t%i\t%i", __method__, adaptor.unique_id( node ),
+              token.token_index
+    else
+      transmit "%s\t%i\t%i\t%p", __method__, adaptor.unique_id( node ),
+          adaptor.type_of( node ), adaptor.text_of( node )
+    end
+  end
+  
+  def become_root( new_root, old_root )
+    transmit "%s\t%i\t%i", __method__, adaptor.unique_id( new_root ),
+              adaptor.unique_id( old_root )
+  end
+  
+  def add_child( root, child )
+    transmit "%s\t%i\t%i", __method__, adaptor.unique_id( root ),
+             adaptor.unique_id( child )
+  end
+  
+  def set_token_boundaries( t, token_start_index, token_stop_index )
+    transmit "%s\t%i\t%i\t%i", __method__, adaptor.unique_id( t ),
+                               token_start_index, token_stop_index
+  end
+  
+  attr_accessor :adaptor
+  
+  def serialize_token( token )
+    [token.token_index, token.type, token.channel,
+     token.line, token.column,
+     escape_newlines( token.text )].join( "\t" )
+  end
+  
+  def serialize_node( node )
+    adaptor ||= ANTLR3::AST::CommonTreeAdaptor.new
+    id = adaptor.unique_id( node )
+    type = adaptor.type_of( node )
+    token = adaptor.token( node )
+    line = token.line rescue -1
+    col  = token.column rescue -1
+    index = adaptor.token_start_index( node )
+    [ id, type, line, col, index ].join( "\t" )
+  end
+  
+  
+  def escape_newlines( text )
+    text.inspect.tap do |t|
+      t.gsub!(/%/, '%%')
+    end
+  end
+end
+
+=begin rdoc ANTLR3::Debug::RemoteEventSocketListener
+
+A debugging event listener which intercepts debug event messages sent by a EventSocketProxy
+over an IP socket.
+
+=end
+class RemoteEventSocketListener < ::Thread
+  autoload :StringIO, 'stringio'
+  ESCAPE_MAP = Hash.new { |h, k| k }
+  ESCAPE_MAP.update(
+    ?n => ?\n, ?t => ?\t, ?a => ?\a, ?b => ?\b, ?e => ?\e,
+    ?f => ?\f, ?r => ?\r, ?v => ?\v
+  )
+  
+  attr_reader :host, :port
+  
+  def initialize( options = {} )
+    @listener = listener
+    @host = options.fetch( :host, 'localhost' )
+    @port = options.fetch( :port, DEFAULT_PORT )
+    @buffer = StringIO.new
+    super do
+      connect do
+        handshake
+        loop do
+          yield( read_event )
+        end
+      end
+    end
+  end
+  
+private
+  
+  def handshake
+    @version = @socket.readline.split("\t")[-1]
+    @grammar_file = @socket.readline.split("\t")[-1]
+    ack
+  end
+  
+  def ack
+    @socket.puts("ack")
+    @socket.flush
+  end
+  
+  def unpack_event(event)
+    event.nil? and raise( StopIteration )
+    event.chomp!
+    name, *elements = event.split("\t",-1)
+    name = name.to_sym
+    name == :terminate and raise StopIteration
+    elements.map! do |elem|
+      elem.empty? and next(nil)
+      case elem
+      when /^\d+$/ then Integer(elem)
+      when /^\d+\.\d+$/ then Float(elem)
+      when /^true$/ then true
+      when /^false$/ then false
+      when /^"(.*)"$/ then parse_string($1)
+      end
+    end
+    elements.unshift(name)
+    return( elements )
+  end
+  
+  def read_event
+    event = @socket.readline or raise( StopIteration )
+    ack
+    return unpack_event( event )
+  end
+  
+  def connect
+    TCPSocket.open(@host, @port) do |socket|
+      @socket = socket
+      yield
+    end
+  end
+  
+  def parse_string( string )
+    @buffer.string = string
+    @buffer.rewind
+    out = ''
+    until @buffer.eof?
+      case c = @buffer.getc
+      when ?\\                    # escape
+        nc = @buffer.getc
+        out << 
+          if nc.between?( ?0, ?9 )  # octal integer
+            @buffer.ungetc( nc )
+            @buffer.read( 3 ).to_i( 8 ).chr
+          elsif nc == ?x
+            @buffer.read( 2 ).to_i( 16 ).chr
+          else
+            ESCAPE_MAP[ nc ]
+          end
+      else
+        out << c
+      end
+    end
+    return out
+  end
+  
+end # class RemoteEventSocketListener
+end # module Debug
+end # module ANTLR3