antlr3 1.8.0 → 1.8.2

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

@@ -16,10 +16,10 @@ class RecordEventListener < TraceEventListener
     @events = []
   end
   
-  def record(event_message, *interpolation_arguments)
+  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
+end # module ANTLR3

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

@@ -18,38 +18,38 @@ class RuleTracer
   attr_reader :level
   attr_accessor :spaces_per_indent, :device
   
-  def initialize(options = {})
-    @input = options[:input]
+  def initialize( options = {} )
+    @input = options[ :input ]
     @level = 0
-    @spaces_per_indent = options[:spaces_per_indent] || 2
-    @device = options[:device] || options[:output] || $stderr
+    @spaces_per_indent = options[ :spaces_per_indent ] || 2
+    @device = options[ :device ] || options[ :output ] || $stderr
   end
   
-  def enter_rule(grammar_file, name)
+  def enter_rule( grammar_file, name )
     indent = @level * @spaces_per_indent
     
-    @device.print(' ' * indent, ARROW_IN, name)
+    @device.print( ' ' * indent, ARROW_IN, name )
     if @input
       input_symbol = @input.look || :EOF
-      @device.puts(" look = %p" % input_symbol)
-    else @device.print("\n")
+      @device.puts( " look = %p" % input_symbol )
+    else @device.print( "\n" )
     end
     
     @level += 1
   end
   
-  def exit_rule(grammar_file, name)
+  def exit_rule( grammar_file, name )
     @level -= 1
     
     indent = @level * @spaces_per_indent
     
-    @device.print(' ' * indent, ARROW_OUT, name)
+    @device.print( ' ' * indent, ARROW_OUT, name )
     if @input
-      input_symbol = (@input.look || :EOF)
-      @device.puts(" look = %p" % input_symbol)
-    else @device.print("\n")
+      input_symbol = ( @input.look || :EOF )
+      @device.puts( " look = %p" % input_symbol )
+    else @device.print( "\n" )
     end
   end
 end
 end
-end
+end

data/lib/antlr3/debug/socket.rb

@@ -21,43 +21,43 @@ class EventSocketProxy
   
   SOCKET_ADDR_PACK = 'snCCCCa8'.freeze
   
-  def initialize(recognizer, options = {})
+  def initialize( recognizer, options = {} )
     super()
     @grammar_file_name = recognizer.grammar_file_name
-    @adaptor = options[:adaptor]
-    @port = options[:port] || DEFAULT_PORT
-    @log = options[:log]
+    @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)
+  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 = 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)
+        @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)
+        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)
+        @connection.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
         
-        write('ANTLR %s', PROTOCOL_VERSION)
-        write('grammar %p', @grammar_file_name)
+        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  - "))
+        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
@@ -67,21 +67,21 @@ class EventSocketProxy
     return self
   end
   
-  def write(message, *interpolation_arguments)
+  def write( message, *interpolation_arguments )
     message << ?\n
-    log!("---> #{message}", *interpolation_arguments)
-    @connection.printf(message, *interpolation_arguments)
+    log!( "---> #{ message }", *interpolation_arguments )
+    @connection.printf( message, *interpolation_arguments )
     @connection.flush
   end
   
   def ack
     line = @connection.readline
-    log!("<--- %s", line)
+    log!( "<--- %s", line )
     line
   end
   
-  def transmit(event, *interpolation_arguments)
-    write(event, *interpolation_arguments)
+  def transmit( event, *interpolation_arguments )
+    write( event, *interpolation_arguments )
     ack()
   rescue IOError
     @connection.close
@@ -134,21 +134,21 @@ class EventSocketProxy
     transmit "%s\t%s", :consume_hidden_token, serialize_token( token )
   end
   
-  def look(i, item)
+  def look( i, item )
     case item
     when AST::Tree
       look_tree( i, item )
     when nil
     else
-      transmit "%s\t%i\t%s", :look, i, serialize_token(item)
+      transmit "%s\t%i\t%s", :look, i, serialize_token( item )
     end
   end
   
-  def mark(i)
+  def mark( i )
     transmit "%s\t%i", :mark, i
   end
   
-  def rewind(i = nil)
+  def rewind( i = nil )
     i ? transmit( "%s\t%i", :rewind, i ) : transmit( '%s', :rewind )
   end
   
@@ -156,7 +156,7 @@ class EventSocketProxy
     transmit "%s\t%i", :begin_backtrack, level
   end
   def end_backtrack( level, successful )
-    transmit "%s\t%i\t%p", :end_backtrack, level, (successful ? true : false)
+    transmit "%s\t%i\t%p", :end_backtrack, level, ( successful ? true : false )
   end
   
   def location( line, position )
@@ -177,7 +177,7 @@ class EventSocketProxy
   end
   
   def semantic_predicate( result, predicate )
-    pure_boolean = !(!result)
+    pure_boolean = !( !result )
     transmit "%s\t%s\t%s", :semantic_predicate, pure_boolean, escape_newlines( predicate )
   end
   
@@ -230,9 +230,9 @@ class EventSocketProxy
   attr_accessor :adaptor
   
   def serialize_token( token )
-    [token.token_index, token.type, token.channel,
+    [ token.token_index, token.type, token.channel,
      token.line, token.column,
-     escape_newlines( token.text )].join( "\t" )
+     escape_newlines( token.text ) ].join( "\t" )
   end
   
   def serialize_node( node )
@@ -249,7 +249,7 @@ class EventSocketProxy
   
   def escape_newlines( text )
     text.inspect.tap do |t|
-      t.gsub!(/%/, '%%')
+      t.gsub!( /%/, '%%' )
     end
   end
 end
@@ -263,7 +263,7 @@ over an IP socket.
 class RemoteEventSocketListener < ::Thread
   autoload :StringIO, 'stringio'
   ESCAPE_MAP = Hash.new { |h, k| k }
-  ESCAPE_MAP.update(
+  ESCAPE_MAP.update( 
     ?n => ?\n, ?t => ?\t, ?a => ?\a, ?b => ?\b, ?e => ?\e,
     ?f => ?\f, ?r => ?\r, ?v => ?\v
   )
@@ -288,33 +288,33 @@ class RemoteEventSocketListener < ::Thread
 private
   
   def handshake
-    @version = @socket.readline.split("\t")[-1]
-    @grammar_file = @socket.readline.split("\t")[-1]
+    @version = @socket.readline.split( "\t" )[ -1 ]
+    @grammar_file = @socket.readline.split( "\t" )[ -1 ]
     ack
   end
   
   def ack
-    @socket.puts("ack")
+    @socket.puts( "ack" )
     @socket.flush
   end
   
-  def unpack_event(event)
+  def unpack_event( event )
     event.nil? and raise( StopIteration )
     event.chomp!
-    name, *elements = event.split("\t",-1)
+    name, *elements = event.split( "\t",-1 )
     name = name.to_sym
     name == :terminate and raise StopIteration
     elements.map! do |elem|
-      elem.empty? and next(nil)
+      elem.empty? and next( nil )
       case elem
-      when /^\d+$/ then Integer(elem)
-      when /^\d+\.\d+$/ then Float(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)
+      when /^"(.*)"$/ then parse_string( $1 )
       end
     end
-    elements.unshift(name)
+    elements.unshift( name )
     return( elements )
   end
   
@@ -325,7 +325,7 @@ private
   end
   
   def connect
-    TCPSocket.open(@host, @port) do |socket|
+    TCPSocket.open( @host, @port ) do |socket|
       @socket = socket
       yield
     end
@@ -357,4 +357,4 @@ private
   
 end # class RemoteEventSocketListener
 end # module Debug
-end # module ANTLR3
+end # module ANTLR3

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

@@ -14,15 +14,15 @@ stdout) to record the events in a different way.
 class TraceEventListener
   include EventListener
   
-  def initialize(adaptor = nil, device = $stderr)
+  def initialize( adaptor = nil, device = $stderr )
     super()
     @device = device
     @adaptor = adaptor ||= ANTLR3::AST::CommonTreeAdaptor.new
   end
   
-  def record(event_message, *interpolation_arguments)
+  def record( event_message, *interpolation_arguments )
     event_message = event_message.to_s << "\n"
-    @device.printf(event_message, *interpolation_arguments)
+    @device.printf( event_message, *interpolation_arguments )
   end
   
   def enter_alternative( alt_number )
@@ -50,11 +50,11 @@ class TraceEventListener
   end
   
   def consume_node( tree )
-    record '(%s) unique_id=%s text=%p type=%s[%s]', __method__, @adaptor.unique_id(tree),
-           @adaptor.text_of(tree), @adaptor.type_name( tree ), @adaptor.type_of(tree)
+    record '(%s) unique_id=%s text=%p type=%s[%s]', __method__, @adaptor.unique_id( tree ),
+           @adaptor.text_of( tree ), @adaptor.type_name( tree ), @adaptor.type_of( tree )
   end
   
-  def look(i, tree)
+  def look( i, tree )
     record '(%s): k=%s unique_id=%s text=%p type=%s[%s]', __method__, i, @adaptor.unique_id( tree ),
             @adaptor.text_of( tree ), @adaptor.type_name( tree ), @adaptor.type_of( tree )
   end
@@ -63,7 +63,7 @@ class TraceEventListener
     record '(%s): unique_id=%s', __method__, @adaptor.unique_id( tree )
   end
   
-  def create_node(tree, token = nil)
+  def create_node( tree, token = nil )
     unless token
       record '(%s): unique_id=%s text=%p type=%s[%s]', __method__, @adaptor.unique_id( tree ),
             @adaptor.text_of( tree ), @adaptor.type_name( tree ), @adaptor.type_of( tree )
@@ -89,4 +89,4 @@ class TraceEventListener
   end
 end # class TraceEventListener
 end # module Debug
-end # module ANTLR3
+end # module ANTLR3

data/lib/antlr3/main.rb

@@ -378,6 +378,7 @@ class ParserMain < Main
     @parser_class     = parser_class
     @parser_rule = options[ :parser_rule ]
     if @debug = ( @parser_class.debug? rescue false )
+      @trace = options.fetch( :trace, nil )
       @port = options.fetch( :port, ANTLR3::Debug::DEFAULT_PORT )
       @log  = options.fetch( :log, @error )
     end
@@ -408,6 +409,10 @@ class ParserMain < Main
       opt.separator ''
       opt.separator "Debug Mode Options:"
       
+      opt.on( '--trace', '-t', "print rule trace instead of opening a debug socket" ) do
+        @trace = true
+      end
+      
       opt.on( '--port NUMBER', Integer, "port number to use for the debug socket" ) do |number|
         @port = number
       end
@@ -440,8 +445,12 @@ class ParserMain < Main
   def recognize( in_stream )
     parser_options = {}
     if @debug
-      parser_options[ :port ] = @port
-      parser_options[ :log ]  = @log
+      if @trace
+        parser_options[ :debug_listener ] = ANTLR3::Debug::RuleTracer.new
+      else
+        parser_options[ :port ] = @port
+        parser_options[ :log ]  = @log
+      end
     end
     lexer = @lexer_class.new( in_stream )
     # token_stream = CommonTokenStream.new( lexer )
@@ -494,24 +503,35 @@ class WalkerMain < Main
     opt.separator ''
     opt.separator "Tree Parser Configuration:"
     
-    opt.on( '--lexer-name CLASS_NAME' ) { |val| @lexer_class_name = val }
-    opt.on( '--lexer-file PATH_TO_LIBRARY' ) { |val|
+    opt.on( '--lexer-name CLASS_NAME', 'full name of the lexer class to use' ) { |val| @lexer_class_name = val }
+    opt.on(
+      '--lexer-file PATH_TO_LIBRARY',
+      'path to load to make the lexer class available'
+    ) { |val|
       begin
         test( ?f, val ) ? load( val ) : require( val )
       rescue LoadError
-        warn( "unable to load the library specified by --lexer-file: #{ $! }" )
+        warn( "unable to load the library `#{ val }' specified by --lexer-file: #{ $! }" )
       end
     }
-    opt.on( '--parser-name CLASS_NAME' ) { |val| @parser_class_name = val }
-    opt.on( '--parser-file PATH_TO_LIBRARY' ) { |val|
+    
+    opt.on(
+      '--parser-name CLASS_NAME',
+      'full name of the parser class to use'
+    ) { |val| @parser_class_name = val }
+    opt.on(
+      '--parser-file PATH_TO_LIBRARY',
+      'path to load to make the parser class available'
+    ) { |val|
       begin
         test( ?f, val ) ? load( val ) : require( val )
       rescue LoadError
         warn( "unable to load the library specified by --parser-file: #{ $! }" )
       end
     }
-    opt.on( '--parser-rule NAME' ) { |val| @parser_rule = val }
-    opt.on( '--rule NAME' ) { |val| @walker_rule = val }
+    
+    opt.on( '--parser-rule NAME', "name of the parser rule to use on the input" ) { |val| @parser_rule = val }
+    opt.on( '--rule NAME', "name of the rule to invoke in the tree parser" ) { |val| @walker_rule = val }
     
     if @debug
       opt.separator ''

data/lib/antlr3/modes/ast-builder.rb

@@ -7,15 +7,15 @@ module ANTLR3
 module ASTBuilder
   extend ClassMacros
   
-  def self.included(klass)
+  def self.included( klass )
     def klass.return_scope_members
-      super.push(:tree)
+      super.push( :tree )
     end
   end
   
   def initialize( input, options = {} )
-    @adaptor = options[:adaptor] ||= begin
-      (input.adaptor rescue nil) or
+    @adaptor = options[ :adaptor ] ||= begin
+      ( input.adaptor rescue nil ) or
         AST::CommonTreeAdaptor.new( token_class )
     end
     super( input, options )
@@ -25,15 +25,15 @@ module ASTBuilder
   
 private
   
-  def subtree_stream(desc, element = nil)
+  def subtree_stream( desc, element = nil )
     AST::RewriteRuleSubtreeStream.new( @adaptor, desc, element )
   end
   
-  def token_stream(desc, element = nil)
+  def token_stream( desc, element = nil )
     AST::RewriteRuleTokenStream.new( @adaptor, desc, element )
   end
   
-  def node_stream(desc, element = nil)
+  def node_stream( desc, element = nil )
     AST::RewriteRuleNodeStream.new( @adaptor, desc, element )
   end
 end

data/lib/antlr3/modes/filter.rb

@@ -17,40 +17,42 @@ lexer filter mode.
 =end
 module FilterMode
   def next_token
+    # if at end-of-file, return the EOF token
     @input.peek == ANTLR3::EOF and return ANTLR3::EOF_TOKEN
-    @state.token = nil
-    @state.channel = ANTLR3::DEFAULT_CHANNEL
+    
+    @state.token                = nil
+    @state.channel              = ANTLR3::DEFAULT_CHANNEL
     @state.token_start_position = @input.index
-    @state.token_start_column = @input.column
-    @state.token_start_line = @input.line
-    @state.text = nil
-    @state.backtracking = 1
+    @state.token_start_column   = @input.column
+    @state.token_start_line     = @input.line
+    @state.text                 = nil
+    @state.backtracking         = 1
+    
     m = @input.mark
-    # means we won't throw slow exception
     token!
-    @input.release(m)
+    @input.release( m )
     emit
     return @state.token
   rescue ANTLR3::BacktrackingFailed
     # token! backtracks with synpred at backtracking==2
     # and we set the synpredgate to allow actions at level 1.
-    @input.rewind(m)
-    @input.consume    # advance one char and try again
+    @input.rewind( m )
+    @input.consume # advance one char and try again
     retry
   rescue ANTLR3::Error::RecognitionError => re
     # shouldn't happen in backtracking mode, but...
-    report_error(re)
-    recover(re)
+    report_error( re )
+    recover( re )
   ensure
     @state.backtracking = 0
   end
   
-  def memoize(rule, start_index, success)
-    super(rule, start_index, success) if @state.backtracking > 1
+  def memoize( rule, start_index, success )
+    super( rule, start_index, success ) if @state.backtracking > 1
   end
   
-  def already_parsed_rule?(rule)
-    @state.backtracking > 1 ? super(rule) : false
+  def already_parsed_rule?( rule )
+    @state.backtracking > 1 ? super( rule ) : false
   end
 end
-end
+end