antlr3 1.6.0 → 1.6.3

data/lib/antlr3/streams/interactive.rb

@@ -11,61 +11,54 @@ uses Readline (if available) or standard IO#gets to fetch data on demand.
 =end
 
 class InteractiveStringStream < StringStream
-  def initialize(options = {}, &block)
+  def initialize( options = {}, &block )
     @data = ''
-    @size = @position = @column = @mark_depth = 0
+    @position = @column = @mark_depth = 0
     @line = 1
     @markers = []
+    mark
     @initialized = @eof = false
-    @last_marker = @name = nil
-    @readline = block or raise(ArgumentError, "no block was provided")
-    @name = options.fetch(:name, '(interactive)')
-  end
-  
-  def <<(data)
-    tail = data.to_s
-    @size += tail.length
-    @data << tail
+    @readline = block or raise( ArgumentError, "no line-reading block was provided" )
+    @name = options.fetch( :name, '(interactive)' )
   end
   
   def consume
-    @position < @size and return(super)
+    @position < @data.size and return( super )
     unless @eof
       readline
       consume
     end
   end
   
-  def peek(i = 1)
+  def peek( i = 1 )
     i.zero? and return 0
     i += 1 if i < 0
     index = @position + i - 1
     index < 0 and return 0
     
-    if index < @size
-      char = @data[index]
+    if index < @data.size
+      char = @data[ index ]
     elsif readline
-      peek(i)
+      peek( i )
     else EOF
     end
   end
   
-  def look(i = 1)
-    peek(i).chr rescue EOF
+  def look( i = 1 )
+    peek( i ).chr rescue EOF
   end
   
-  alias >> peek
-  
-  def substring(start, stop)
-    fill_through(stop)
-    @data[start..stop]
+  def substring( start, stop )
+    fill_through( stop )
+    @data[ start..stop ]
   end
   
-  private
-  def fill_through(position)
+private
+  
+  def fill_through( position )
     @eof and return
     if position < 0 then fill_out
-    else readline until (@size > position or @eof)
+    else readline until ( @data.size > position or @eof )
     end
   end
   
@@ -73,7 +66,7 @@ class InteractiveStringStream < StringStream
     @initialized = true
     unless @eof
       if line = @readline.call
-        self << line.to_s
+        @data << line.to_s
         return true
       else
         @eof = true

data/lib/antlr3/streams/rewrite.rb

@@ -4,7 +4,7 @@
 =begin LICENSE
 
 [The "BSD licence"]
-Copyright (c) 2009 Kyle Yetter
+Copyright (c) 2009-2010 Kyle Yetter
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -59,8 +59,8 @@ define specific implementations of stream edits.
 
 =end
 
-unless defined?(RewriteOperation)
-  RewriteOperation = Struct.new(:stream, :location, :text)
+unless defined?( RewriteOperation )
+  RewriteOperation = Struct.new( :stream, :location, :text )
 end
 
 class RewriteOperation
@@ -79,7 +79,7 @@ class RewriteOperation
   
   # TODO: document
   def inspect
-    return "(%s @ %p : %p)" % [name, location, text]
+    return "(%s @ %p : %p)" % [ name, location, text ]
   end
 end
 
@@ -98,9 +98,9 @@ class InsertBefore < RewriteOperation
   alias index  location
   alias index= location=
   
-  def execute(buffer)
+  def execute( buffer )
     buffer << text.to_s
-    token = stream[location]
+    token = stream[ location ]
     buffer << token.text.to_s if token
     return location + 1
   end
@@ -117,23 +117,23 @@ indexed within the range <tt>op.index .. op.last_index</tt>
 
 class Replace < RewriteOperation
   @operation_name = 'replace'.freeze
-  def initialize(stream, location, text)
-    super(stream, nil, text)
+  def initialize( stream, location, text )
+    super( stream, nil, text )
     self.location = location
   end
   
-  def location=(val)
+  def location=( val )
     case val
-    when Range then super(val)
+    when Range then super( val )
     else
       val = val.to_i
-      super(val..val)
+      super( val..val )
     end
   end
   
-  def execute(buffer)
+  def execute( buffer )
     buffer << text.to_s unless text.nil?
-    return(location.end + 1)
+    return( location.end + 1 )
   end
   
   def index
@@ -153,45 +153,45 @@ and do not add any text to the rewrite buffer
 
 class Delete < Replace
   @operation_name = 'delete'.freeze
-  def initialize(stream, location)
-    super(stream, location, nil)
+  def initialize( stream, location )
+    super( stream, location, nil )
   end
 end
 
 class RewriteProgram
-  def initialize(stream, name = nil)
+  def initialize( stream, name = nil )
     @stream = stream
     @name = name
     @operations = []
   end
   
-  def replace(*range_arguments)
-    range, text = cast_range(range_arguments, 1)
+  def replace( *range_arguments )
+    range, text = cast_range( range_arguments, 1 )
     
-    op = Replace.new(@stream, range, text)
+    op = Replace.new( @stream, range, text )
     @operations << op
     return op
   end
   
-  def insert_before(index, text)
+  def insert_before( index, text )
     index = index.to_i
     index < 0 and index += @stream.length
-    op = InsertBefore.new(@stream, index, text)
+    op = InsertBefore.new( @stream, index, text )
     @operations << op
     return op
   end
   
-  def insert_after(index, text)
+  def insert_after( index, text )
     index = index.to_i
     index < 0 and index += @stream.length
-    op = InsertBefore.new(@stream, index + 1, text)
+    op = InsertBefore.new( @stream, index + 1, text )
     @operations << op
     return op
   end
   
-  def delete(*range_arguments)
-    range, = cast_range(range_arguments)
-    op = Delete.new(@stream, range)
+  def delete( *range_arguments )
+    range, = cast_range( range_arguments )
+    op = Delete.new( @stream, range )
     @operations << op
     return op
   end
@@ -211,12 +211,12 @@ class RewriteProgram
           
           case prior_operation
           when InsertBefore
-            location.include?(prior_location)
+            location.include?( prior_location )
           when Replace
-            if location.covers?(prior_location)
+            if location.covers?( prior_location )
               true
-            elsif location.overlaps?(prior_location)
-              conflict!(operation, prior_operation)
+            elsif location.overlaps?( prior_location )
+              conflict!( operation, prior_operation )
             end
           end
         end
@@ -234,35 +234,35 @@ class RewriteProgram
             if location == prior_location.first
               prior_operation.text = operation.text << prior_operation.text.to_s
               operation = nil
-              break(false)
-            elsif prior_location.include?(location)
-              conflict!(operation, prior_operation)
+              break( false )
+            elsif prior_location.include?( location )
+              conflict!( operation, prior_operation )
             end
           end
         end
       end
       
-      reduced.unshift(operation) if operation
+      reduced.unshift( operation ) if operation
     end
     
-    @operations.replace(reduced)
+    @operations.replace( reduced )
     
-    @operations.inject({}) do |map, operation|
-      other_operaiton = map[operation.index] and
-        ANTLR3.bug!( Util.tidy(<<-END) % [self.class, operation, other_operaiton] )
+    @operations.inject( {} ) do |map, operation|
+      other_operaiton = map[ operation.index ] and
+        ANTLR3.bug!( Util.tidy( <<-END ) % [ self.class, operation, other_operaiton ] )
         | %s#reduce! should have left only one operation per index,
         | but %p conflicts with %p
         END
-      map[operation.index] = operation
+      map[ operation.index ] = operation
       map
     end
   end
   
-  def execute(*range_arguments)
+  def execute( *range_arguments )
     if range_arguments.empty?
       range = 0 ... @stream.length
     else
-      range, = cast_range(range_arguments)
+      range, = cast_range( range_arguments )
     end
     
     output = ''
@@ -272,19 +272,19 @@ class RewriteProgram
     operations = reduce
     
     cursor = range.first
-    while range.include?(cursor)
-      if operation = operations.delete(cursor)
-        cursor = operation.execute(output)
+    while range.include?( cursor )
+      if operation = operations.delete( cursor )
+        cursor = operation.execute( output )
       else
-        token = tokens[cursor]
+        token = tokens[ cursor ]
         output << token.text if token
         cursor += 1
       end
     end
-    if operation = operations.delete(cursor) and
-       operation.is_a?(InsertBefore)
+    if operation = operations.delete( cursor ) and
+       operation.is_a?( InsertBefore )
       # catch edge 'insert-after' operations
-      operation.execute(output)
+      operation.execute( output )
     end
     
     return output
@@ -294,51 +294,51 @@ class RewriteProgram
     @operations.clear
   end
   
-  def undo(number_of_operations = 1)
-    @operations.pop(number_of_operations)
+  def undo( number_of_operations = 1 )
+    @operations.pop( number_of_operations )
   end
   
-  def conflict!(current, previous)
-    message = 'operation %p overlaps with previous operation %p' % [current, previous]
-    raise(RangeError, message, caller)
+  def conflict!( current, previous )
+    message = 'operation %p overlaps with previous operation %p' % [ current, previous ]
+    raise( RangeError, message, caller )
   end
   
-  def cast_range(args, extra = 0)
+  def cast_range( args, extra = 0 )
     single, pair = extra + 1, extra + 2
-    case check_arguments(args, single, pair)
+    case check_arguments( args, single, pair )
     when single
       loc = args.shift
       
-      if loc.is_a?(Range)
+      if loc.is_a?( Range )
         first, last = loc.first.to_i, loc.last.to_i
         loc.exlude_end? and last -= 1
-        return cast_range(args.unshift(first, last), extra)
+        return cast_range( args.unshift( first, last ), extra )
       else
         loc = loc.to_i
-        return cast_range(args.unshift(loc, loc), extra)
+        return cast_range( args.unshift( loc, loc ), extra )
       end
     when pair
-      first, last = args.shift(2).map! { |arg| arg.to_i }
+      first, last = args.shift( 2 ).map! { |arg| arg.to_i }
       if first < 0 and last < 0
         first += @stream.length
         last += @stream.length
       else
         last < 0 and last += @stream.length
-        first = first.at_least(0)
+        first = first.at_least( 0 )
       end
-      return(args.unshift(first .. last))
+      return( args.unshift( first .. last ) )
     end
   end
   
-  def check_arguments(args, min, max)
+  def check_arguments( args, min, max )
     n = args.length
     if n < min
       raise ArgumentError,
-        "wrong number of arguments (#{args.length} for #{min})",
+        "wrong number of arguments (#{ args.length } for #{ min })",
         caller
     elsif n > max
       raise ArgumentError,
-        "wrong number of arguments (#{args.length} for #{max})",
+        "wrong number of arguments (#{ args.length } for #{ max })",
         caller
     else return n
     end
@@ -349,64 +349,64 @@ end
   
   attr_reader :programs
 
-  def initialize(token_source, options = {})
-    super(token_source, options)
+  def initialize( token_source, options = {} )
+    super( token_source, options )
     
     @programs = Hash.new do |programs, name|
-      if name.is_a?(String)
-        programs[name] = RewriteProgram.new(self, name)
-      else programs[name.to_s]
+      if name.is_a?( String )
+        programs[ name ] = RewriteProgram.new( self, name )
+      else programs[ name.to_s ]
       end
     end
     
     @last_rewrite_token_indexes = {}
   end
   
-  def rewrite(program_name = 'default', range = nil)
-    program = @programs[program_name]
+  def rewrite( program_name = 'default', range = nil )
+    program = @programs[ program_name ]
     if block_given?
-      yield(program)
-      program.execute(range)
+      yield( program )
+      program.execute( range )
     else program
     end
   end
   
-  def program(name = 'default')
-    return @programs[name]
+  def program( name = 'default' )
+    return @programs[ name ]
   end
   
-  def delete_program(name = 'default')
-    @programs.delete(name)
+  def delete_program( name = 'default' )
+    @programs.delete( name )
   end
   
-  def original_string(start = 0, finish = size - 1)
+  def original_string( start = 0, finish = size - 1 )
     @position == -1 and fill_buffer
     
-    return(self[start..finish].map { |t| t.text }.join(''))
+    return( self[ start..finish ].map { |t| t.text }.join( '' ) )
   end
 
-  def insert_before(*args)
-    @programs['default'].insert_before(*args)
+  def insert_before( *args )
+    @programs[ 'default' ].insert_before( *args )
   end
   
-  def insert_after(*args)
-    @programs['default'].insert_after(*args)
+  def insert_after( *args )
+    @programs[ 'default' ].insert_after( *args )
   end
   
-  def replace(*args)
-    @programs['default'].replace(*args)
+  def replace( *args )
+    @programs[ 'default' ].replace( *args )
   end
   
-  def delete(*args)
-    @programs['default'].delete(*args)
+  def delete( *args )
+    @programs[ 'default' ].delete( *args )
   end
   
-  def render(*arguments)
+  def render( *arguments )
     case arguments.first
     when String, Symbol then name = arguments.shift.to_s
     else name = 'default'
     end
-    @programs[name].execute(*arguments)
+    @programs[ name ].execute( *arguments )
   end
 end
 end