antlr3 1.2.3

data/lib/antlr3/streams/interactive.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+module ANTLR3
+
+=begin rdoc ANTLR3::Main::InteractiveStringStream
+
+A special stream used in the <b>interactive mode</b> of the Main scripts. It
+uses Readline (if available) or standard IO#gets to fetch data on demand.
+
+=end
+
+class InteractiveStringStream < StringStream
+  def initialize(options = {}, &block)
+    @data = ''
+    @size = @position = @column = @mark_depth = 0
+    @line = 1
+    @markers = []
+    @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
+  end
+  
+  def consume
+    @position < @size and return(super)
+    unless @eof
+      readline
+      consume
+    end
+  end
+  
+  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]
+    elsif readline
+      peek(i)
+    else EOF
+    end
+  end
+  
+  def look(i = 1)
+    peek(i).chr rescue EOF
+  end
+  
+  alias >> peek
+  
+  def substring(start, stop)
+    fill_through(stop)
+    @data[start..stop]
+  end
+  
+  private
+  def fill_through(position)
+    @eof and return
+    if position < 0 then fill_out
+    else readline until (@size > position or @eof)
+    end
+  end
+  
+  def readline
+    @initialized = true
+    unless @eof
+      if line = @readline.call
+        self << line.to_s
+        return true
+      else
+        @eof = true
+        return false
+      end
+    end
+  end
+  
+  def fill_out
+    @eof and return
+    readline until @eof
+  end
+end
+
+end

data/lib/antlr3/streams/rewrite.rb

@@ -0,0 +1,412 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+=begin LICENSE
+
+[The "BSD licence"]
+Copyright (c) 2009 Kyle Yetter
+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.
+
+=end
+
+module ANTLR3
+
+=begin rdoc ANTLR3::TokenRewriteStream
+
+TokenRewriteStream is a specialized form of CommonTokenStream that provides simple stream editing functionality. By creating <i>rewrite programs</i>, new text output can be created based upon the tokens in the stream. The basic token stream itself is preserved, and text output is rendered on demand using the #to_s method.
+
+=end
+
+class TokenRewriteStream < CommonTokenStream
+
+=begin rdoc ANTLR3::TokenRewriteStream::RewriteOperation
+
+RewiteOperation objects represent some particular editing command that should
+be executed by a token rewrite stream at some time in future when the stream is
+rendering a rewritten stream.
+
+To perform token stream rewrites safely and efficiently, the rewrites are
+executed lazily (that is, only when the rewritten text is explicitly requested).
+Rewrite streams implement lazy rewriting by storing the parameters of
+edit-inducing methods like +delete+ and +insert+ as RewriteOperation objects in
+a rewrite program list.
+
+The three subclasses of RewriteOperation, InsertBefore, Delete, and Replace,
+define specific implementations of stream edits.
+
+=end
+
+unless defined?(RewriteOperation)
+  RewriteOperation = Struct.new(:stream, :location, :text)
+end
+
+class RewriteOperation
+  extend ClassMacros
+  @operation_name = ''
+  class << self
+    # TODO: document
+    attr_reader :operation_name
+  end
+  abstract :execute
+  
+  # TODO: document
+  def name
+    self.class.operation_name
+  end
+  
+  # TODO: document
+  def inspect
+    return "(%s @ %p : %p)" % [name, location, text]
+  end
+end
+
+=begin rdoc ANTLR3::TokenRewriteStream::InsertBefore
+
+Represents rewrite operation:
+
+add string <tt>op.text</tt> to the rewrite output immediately before adding the
+text content of the token at index <tt>op.index</tt>
+
+=end
+
+class InsertBefore < RewriteOperation
+  @operation_name = 'insert-before'.freeze
+  
+  alias index  location
+  alias index= location=
+  
+  def execute(buffer)
+    buffer << text
+    token = stream[location]
+    buffer << token.text if token
+    return location + 1
+  end
+end
+
+=begin rdoc ANTLR3::TokenRewriteStream::Replace
+
+Represents rewrite operation:
+
+add text <tt>op.text</tt> to the rewrite buffer in lieu of the text of tokens
+indexed within the range <tt>op.index .. op.last_index</tt>
+
+=end
+
+class Replace < RewriteOperation
+  @operation_name = 'replace'.freeze
+  def initialize(stream, location, text)
+    super(stream, nil, text)
+    self.location = location
+  end
+  
+  def location=(val)
+    case val
+    when Range then super(val)
+    else
+      val = val.to_i
+      super(val..val)
+    end
+  end
+  
+  def execute(buffer)
+    buffer << text unless text.nil?
+    return(location.end + 1)
+  end
+  
+  def index
+    location.first
+  end
+  
+end
+
+=begin rdoc ANTLR3::TokenRewriteStream::Delete
+
+Represents rewrite operation:
+
+skip over the tokens indexed within the range <tt>op.index .. op.last_index</tt>
+and do not add any text to the rewrite buffer
+
+=end
+
+class Delete < Replace
+  @operation_name = 'delete'.freeze
+  def initialize(stream, location)
+    super(stream, location, nil)
+  end
+end
+
+class RewriteProgram
+  def initialize(stream, name = nil)
+    @stream = stream
+    @name = name
+    @operations = []
+  end
+  
+  def replace(*range_arguments)
+    range, text = cast_range(range_arguments, 1)
+    
+    op = Replace.new(@stream, range, text)
+    @operations << op
+    return op
+  end
+  
+  def insert_before(index, text)
+    index = index.to_i
+    index < 0 and index += @stream.length
+    op = InsertBefore.new(@stream, index, text)
+    @operations << op
+    return op
+  end
+  
+  def insert_after(index, text)
+    index = index.to_i
+    index < 0 and index += @stream.length
+    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)
+    @operations << op
+    return op
+  end
+
+  def reduce
+    operations = @operations.reverse
+    reduced = []
+    
+    until operations.empty?
+      operation = operations.shift
+      location = operation.location
+      
+      case operation
+      when Replace
+        operations.delete_if do |prior_operation|
+          prior_location = prior_operation.location
+          
+          case prior_operation
+          when InsertBefore
+            location.include?(prior_location)
+          when Replace
+            if location.covers?(prior_location)
+              true
+            elsif location.overlaps?(prior_location)
+              conflict!(operation, prior_operation)
+            end
+          end
+        end
+      when InsertBefore
+        operations.delete_if do |prior_operation|
+          prior_location = prior_operation.location
+          
+          case prior_operation
+          when InsertBefore
+            if prior_location == location
+              operation.text += prior_operation.text
+              true
+            end
+          when Replace
+            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)
+            end
+          end
+        end
+      end
+      
+      reduced.unshift(operation) if operation
+    end
+    
+    @operations.replace(reduced)
+    
+    @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
+    end
+  end
+  
+  def execute(*range_arguments)
+    if range_arguments.empty?
+      range = 0 ... @stream.length
+    else
+      range, = cast_range(range_arguments)
+    end
+    
+    output = ''
+    
+    tokens = @stream.tokens
+    
+    operations = reduce
+    
+    cursor = range.first
+    while range.include?(cursor)
+      if operation = operations.delete(cursor)
+        cursor = operation.execute(output)
+      else
+        token = tokens[cursor]
+        output << token.text if token
+        cursor += 1
+      end
+    end
+    if operation = operations.delete(cursor) and
+       operation.is_a?(InsertBefore)
+      # catch edge 'insert-after' operations
+      operation.execute(output)
+    end
+    
+    return output
+  end
+  
+  def clear
+    @operations.clear
+  end
+  
+  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)
+  end
+  
+  def cast_range(args, extra = 0)
+    single, pair = extra + 1, extra + 2
+    case check_arguments(args, single, pair)
+    when single
+      loc = args.shift
+      
+      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)
+      else
+        loc = loc.to_i
+        return cast_range(args.unshift(loc, loc), extra)
+      end
+    when pair
+      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)
+      end
+      return(args.unshift(first .. last))
+    end
+  end
+  
+  def check_arguments(args, min, max)
+    n = args.length
+    if n < min
+      raise ArgumentError,
+        "wrong number of arguments (#{args.length} for #{min})",
+        caller
+    elsif n > max
+      raise ArgumentError,
+        "wrong number of arguments (#{args.length} for #{max})",
+        caller
+    else return n
+    end
+  end
+  
+  private :conflict!, :cast_range, :check_arguments
+end
+  
+  attr_reader :programs
+
+  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]
+      end
+    end
+    
+    @last_rewrite_token_indexes = {}
+  end
+  
+  def rewrite(program_name = 'default', range = nil)
+    program = @programs[program_name]
+    if block_given?
+      yield(program)
+      program.execute(range)
+    else program
+    end
+  end
+  
+  def program(name = 'default')
+    return @programs[name]
+  end
+  
+  def delete_program(name = 'default')
+    @programs.delete(name)
+  end
+  
+  def original_string(start = 0, finish = size - 1)
+    @position == -1 and fill_buffer
+    
+    return(self[start..finish].map { |t| t.text }.join(''))
+  end
+
+  def insert_before(*args)
+    @programs['default'].insert_before(*args)
+  end
+  
+  def insert_after(*args)
+    @programs['default'].insert_after(*args)
+  end
+  
+  def replace(*args)
+    @programs['default'].replace(*args)
+  end
+  
+  def delete(*args)
+    @programs['default'].delete(*args)
+  end
+  
+  def render(*arguments)
+    case arguments.first
+    when String, Symbol then name = arguments.shift.to_s
+    else name = 'default'
+    end
+    @programs[name].execute(*arguments)
+  end
+end
+end