antlr3 1.8.0 → 1.8.2

data/lib/antlr3/tree/debug.rb

@@ -11,53 +11,53 @@ Adds debugging event hooks to TreeAdaptor objects
 module TreeAdaptor
   
   def self.wrap( adaptor, debug_listener = nil )
-    adaptor.extend(self)
+    adaptor.extend( self )
     adaptor.debug_listener = debug_listener
     return( adaptor )
   end
   
   attr_accessor :debug_listener
   
-  def create_with_payload(payload)
+  def create_with_payload( payload )
     node = super
-    @debug_listener.create_node(node, payload)
+    @debug_listener.create_node( node, payload )
     return node
   end
   
-  def create_from_token(token_type, from_token, text = nil)
+  def create_from_token( token_type, from_token, text = nil )
     node = super
-    @debug_listener.create_node(node)
+    @debug_listener.create_node( node )
     return node
   end
   
-  def create_from_type(token_type, text)
+  def create_from_type( token_type, text )
     node = super
-    @debug_listener.create_node(node)
+    @debug_listener.create_node( node )
     return node
   end
   
-  def create_error_node(input, start, stop, exc)
+  def create_error_node( input, start, stop, exc )
     node = super
-    node.nil? or @debug_listener.error_node(node)
+    node.nil? or @debug_listener.error_node( node )
     return node
   end
   
-  def copy_tree(tree)
+  def copy_tree( tree )
     t = super
-    simulate_tree_construction(t)
+    simulate_tree_construction( t )
     return t
   end
   
-  def simulate_tree_construction(tree)
-    @debug_listener.create_node(tree)
-    child_count(tree).times do |i|
-      child = self.child_of(tree, i)
-      simulate_tree_construction(child)
-      @debug_listener.add_child(tree, child)
+  def simulate_tree_construction( tree )
+    @debug_listener.create_node( tree )
+    child_count( tree ).times do |i|
+      child = self.child_of( tree, i )
+      simulate_tree_construction( child )
+      @debug_listener.add_child( tree, child )
     end
   end
   
-  def copy_node(tree_node)
+  def copy_node( tree_node )
     duplicate = super
     @debug_listener.create_node duplicate
     return duplicate
@@ -65,39 +65,39 @@ module TreeAdaptor
   
   def create_flat_list
     node = super
-    @debug_listener.flat_node(node)
+    @debug_listener.flat_node( node )
     return node
   end
   
-  def add_child(tree, child)
+  def add_child( tree, child )
     case child
     when Token
-      node = create_with_payload(child)
-      add_child(tree, node)
+      node = create_with_payload( child )
+      add_child( tree, node )
     else
       tree.nil? || child.nil? and return
-      super(tree, child)
-      @debug_listener.add_child(tree, child)
+      super( tree, child )
+      @debug_listener.add_child( tree, child )
     end
   end
   
-  def become_root(new_root, old_root)
+  def become_root( new_root, old_root )
     case new_root
     when Token
-      n = create_with_payload(new_root)
-      super(n, old_root)
+      n = create_with_payload( new_root )
+      super( n, old_root )
     else
-      n = super(new_root, old_root)
+      n = super( new_root, old_root )
     end
-    @debug_listener.become_root(new_root, old_root)
+    @debug_listener.become_root( new_root, old_root )
     return n
   end
   
-  def set_token_boundaries(tree, start_token, stop_token)
-    super(tree, start_token, stop_token)
+  def set_token_boundaries( tree, start_token, stop_token )
+    super( tree, start_token, stop_token )
     return unless tree && start_token && stop_token
-    @debug_listener.set_token_boundaries(tree,
-      start_token.token_index, stop_token.token_index)
+    @debug_listener.set_token_boundaries( tree,
+      start_token.token_index, stop_token.token_index )
   end
 end
 
@@ -110,8 +110,8 @@ not already a Debug::TreeNodeStream.
 =end
 class TreeNodeStream
   
-  def self.wrap(stream, debug_listener = nil)
-    stream.extend(self)
+  def self.wrap( stream, debug_listener = nil )
+    stream.extend( self )
     stream.debug_listener ||= debug_listener
   end
   attr_accessor :debug_listener
@@ -119,36 +119,36 @@ class TreeNodeStream
   def consume
     node = @input >> 1
     super
-    @debug_listener.consume_node(node)
+    @debug_listener.consume_node( node )
   end
   
-  def look(i = 1)
+  def look( i = 1 )
     node = super
-    id = @adaptor.unique_id(node)
-    text = @adaptor.text_of(node)
-    type = @adaptor.type_of(node)
-    @debug_listener.look(i, node)
-    return(node)
+    id = @adaptor.unique_id( node )
+    text = @adaptor.text_of( node )
+    type = @adaptor.type_of( node )
+    @debug_listener.look( i, node )
+    return( node )
   end
   
-  def peek(i = 1)
+  def peek( i = 1 )
     node = self >> 1
-    id = @adaptor.unique_id(node)
-    text = @adaptor.text_of(node)
-    type = @adaptor.type_of(node)
-    @debug_listener.look(i, node)
-    return(type)
+    id = @adaptor.unique_id( node )
+    text = @adaptor.text_of( node )
+    type = @adaptor.type_of( node )
+    @debug_listener.look( i, node )
+    return( type )
   end
   
   def mark
     @last_marker = super
-    @debug_listener.mark(@last_marker)
-    return(@last_marker)
+    @debug_listener.mark( @last_marker )
+    return( @last_marker )
   end
   
-  def rewind(marker = nil)
-    @debug_listener.rewind(marker)
-    super(marker || @last_marker)
+  def rewind( marker = nil )
+    @debug_listener.rewind( marker )
+    super( marker || @last_marker )
   end
 
 =begin   This actually differs with reset in CommonTreeNodeStream -- why is this one blank?

data/lib/antlr3/tree/visitor.rb

@@ -48,34 +48,34 @@ children have been visited.
 =end
 
 class Visitor
-  def initialize(adaptor = nil)
+  def initialize( adaptor = nil )
     @adaptor = adaptor || CommonTreeAdaptor.new()
     @pre_action = nil
     @post_action = nil
-    block_given? and yield(self)
+    block_given? and yield( self )
   end
   
-  def pre_action(&block)
+  def pre_action( &block )
     block_given? and @pre_action = block
     return @pre_action
   end
   
-  def post_action(&block)
+  def post_action( &block )
     block_given? and @post_action = block
     return @post_action
   end
   
-  def visit(tree, pre_action = nil, post_action = nil)
-    flat = @adaptor.flat_list?(tree)
+  def visit( tree, pre_action = nil, post_action = nil )
+    flat = @adaptor.flat_list?( tree )
     before = pre_action || @pre_action
     after = post_action || @post_action
     
-    tree = before.call(tree) unless before.nil? or flat
-    @adaptor.child_count(tree).times do |index|
-      child = @adaptor.child_of(tree, index)
-      visit(child, pre_action, post_action)
+    tree = before.call( tree ) unless before.nil? or flat
+    @adaptor.child_count( tree ).times do |index|
+      child = @adaptor.child_of( tree, index )
+      visit( child, pre_action, post_action )
     end
-    tree = after.call(tree) unless after.nil? or flat
+    tree = after.call( tree ) unless after.nil? or flat
     
     return tree
   end

data/lib/antlr3/tree/wizard.rb

@@ -130,15 +130,15 @@ A class that is used internally by AST::Wizard to tokenize tree patterns
     
     autoload :StringScanner, 'strscan'
     
-    PATTERNS = [
-      [:space, /\s+/],
-      [:identifier, /[a-z_]\w*/i],
-      [:open, /\(/],
-      [:close, /\)/],
-      [:percent, /%/],
-      [:colon, /:/],
-      [:dot, /\./],
-      [:argument, /\[((?:[^\[\]\\]|\\\[|\\\]|\\.)*?)\]/]
+    PATTERNS = [ 
+      [ :space, /\s+/ ],
+      [ :identifier, /[a-z_]\w*/i ],
+      [ :open, /\(/ ],
+      [ :close, /\)/ ],
+      [ :percent, /%/ ],
+      [ :colon, /:/ ],
+      [ :dot, /\./ ],
+      [ :argument, /\[((?:[^\[\]\\]|\\\[|\\\]|\\.)*?)\]/ ]
     ]
     
     attr_reader :text, :error, :pattern
@@ -154,7 +154,7 @@ A class that is used internally by AST::Wizard to tokenize tree patterns
         @scanner.eos? and return EOF
         
         type, = PATTERNS.find do |type, pattern|
-          @scanner.scan(pattern)
+          @scanner.scan( pattern )
         end
         
         case type
@@ -164,7 +164,7 @@ A class that is used internally by AST::Wizard to tokenize tree patterns
         when :identifier then @text = @scanner.matched
         when :argument
           # remove escapes from \] sequences in the text argument
-          (@text = @scanner[1]).gsub!(/\\(?=[\[\]])/, '')
+          ( @text = @scanner[ 1 ] ).gsub!( /\\(?=[\[\]])/, '' )
         end
       end while type == :space
       
@@ -208,7 +208,7 @@ from a tokenized tree pattern
       return nil
     end
     
-    CONTINUE_TYPES = [:open, :identifier, :percent, :dot]
+    CONTINUE_TYPES = [ :open, :identifier, :percent, :dot ]
     
     def parse_tree
       @token_type != :open and return nil
@@ -219,10 +219,10 @@ from a tokenized tree pattern
         case @token_type
         when :open
           subtree = parse_tree
-          @adaptor.add_child(root, subtree)
+          @adaptor.add_child( root, subtree )
         when :identifier, :percent, :dot
           child = parse_node or return nil
-          @adaptor.add_child(root, child)
+          @adaptor.add_child( root, child )
         else break
         end
       end
@@ -234,16 +234,16 @@ from a tokenized tree pattern
     def parse_node
       label = nil
       if @token_type == :percent
-        (@token_type = @tokenizer.next_token) == :identifier or return nil
+        ( @token_type = @tokenizer.next_token ) == :identifier or return nil
         label = @tokenizer.text
-        (@token_type = @tokenizer.next_token) == :colon or return nil
+        ( @token_type = @tokenizer.next_token ) == :colon or return nil
         @token_type = @tokenizer.next_token
       end
       
       if @token_type == :dot
         @token_type = @tokenizer.next_token
-        wildcard_payload = CommonToken.create(:type => 0, :text => '.')
-        node = WildcardPattern.new(wildcard_payload)
+        wildcard_payload = CommonToken.create( :type => 0, :text => '.' )
+        node = WildcardPattern.new( wildcard_payload )
         label and node.label = label
         return node
       end
@@ -281,7 +281,7 @@ to validate tree structures as well as to extract nodes that match the pattern.
 
   class Pattern < CommonTree
     def self.parse( pattern_str, scheme )
-      PatternParser.parse(
+      PatternParser.parse( 
         pattern_str, scheme, PatternAdaptor.new( scheme.token_class )
       )
     end
@@ -349,20 +349,20 @@ A customized TreeAdaptor used by AST::Wizards to build tree patterns.
   
   def find( tree, what )
     case what
-    when Integer then find_token_type(tree, what)
-    when String  then find_pattern(tree, what)
+    when Integer then find_token_type( tree, what )
+    when String  then find_pattern( tree, what )
     when Symbol  then find_token_type( tree, @token_scheme[ what ] )
     else raise ArgumentError, "search subject must be a token type (integer) or a string"
     end
   end
   
-  def find_token_type(tree, type)
+  def find_token_type( tree, type )
     nodes = []
     visit( tree, type ) { | t, | nodes << t }
     return nodes
   end
   
-  def find_pattern(tree, pattern)
+  def find_pattern( tree, pattern )
     subtrees = []
     visit_pattern( tree, pattern ) { | t, | subtrees << t }
     return( subtrees )
@@ -392,7 +392,7 @@ A customized TreeAdaptor used by AST::Wizards to build tree patterns.
   end
   
   def visit_type( tree, parent, type, &block )
-    tree.nil? and return(nil)
+    tree.nil? and return( nil )
     index = @adaptor.child_index( tree )
     @adaptor.type_of( tree ) == type and yield( tree, parent, index, nil )
     @adaptor.each_child( tree ) do | child |
@@ -422,20 +422,20 @@ A customized TreeAdaptor used by AST::Wizards to build tree patterns.
   def match!( tree, pattern, labels = {} )
     tree.nil? || pattern.nil? and return false
     unless pattern.is_a? WildcardPattern
-      @adaptor.type_of(tree) == pattern.type or return false
-      pattern.has_text_arg && (@adaptor.text_of(tree) != pattern.text) and
+      @adaptor.type_of( tree ) == pattern.type or return false
+      pattern.has_text_arg && ( @adaptor.text_of( tree ) != pattern.text ) and
         return false
     end
     labels[ pattern.label ] = tree if labels && pattern.label
     
-    number_of_children = @adaptor.child_count(tree)
+    number_of_children = @adaptor.child_count( tree )
     return false unless number_of_children == pattern.child_count
     
     number_of_children.times do |index|
-      actual_child = @adaptor.child_of(tree, index)
+      actual_child = @adaptor.child_of( tree, index )
       pattern_child = pattern.child( index )
       
-      return(false) unless match!( actual_child, pattern_child, labels )
+      return( false ) unless match!( actual_child, pattern_child, labels )
     end
     
     return labels
@@ -444,11 +444,11 @@ A customized TreeAdaptor used by AST::Wizards to build tree patterns.
   def equals( tree_a, tree_b, adaptor = @adaptor )
     tree_a && tree_b or return( false )
     
-    adaptor.type_of(tree_a) == adaptor.type_of(tree_b) or return false
-    adaptor.text_of(tree_a) == adaptor.text_of(tree_b) or return false
+    adaptor.type_of( tree_a ) == adaptor.type_of( tree_b ) or return false
+    adaptor.text_of( tree_a ) == adaptor.text_of( tree_b ) or return false
     
-    child_count_a = adaptor.child_count(tree_a)
-    child_count_b = adaptor.child_count(tree_b)
+    child_count_a = adaptor.child_count( tree_a )
+    child_count_b = adaptor.child_count( tree_b )
     child_count_a == child_count_b or return false
     
     child_count_a.times do | i |
@@ -469,9 +469,9 @@ A customized TreeAdaptor used by AST::Wizards to build tree patterns.
     when DOUBLE_ETC_PATTERN then raise ArgumentError, "invalid syntax: ... ..."
     end
     
-    context = context.gsub(/([^\.\s])\.{3}([^\.])/, '\1 ... \2')
+    context = context.gsub( /([^\.\s])\.{3}([^\.])/, '\1 ... \2' )
     context.strip!
-    nodes = context.split(/\s+/)
+    nodes = context.split( /\s+/ )
     
     while tree = @adaptor.parent( tree ) and node = nodes.pop
       if node == '...'

data/lib/antlr3/util.rb

@@ -73,6 +73,24 @@ private
     END
   end
   
+  def deprecate( name, extra_message = nil )
+    hidden_name = "deprecated_#{ name }"
+    method_defined?( hidden_name ) and return
+    
+    alias_method( hidden_name, name )
+    private( hidden_name )
+    
+    message = "warning: method #{ self }##{ name } is deprecated"
+    extra_message and message << '; ' << extra_message.to_s
+    
+    class_eval( <<-END )
+      def #{ name }( *args, &block )
+        warn( #{ message.inspect } )
+        #{ hidden_name }( *args, &block )
+      end
+    END
+  end
+  
   def alias_accessor( alias_name, attr_name )
     alias_method( alias_name, attr_name )
     alias_method( :"#{ alias_name }=", :"#{ attr_name }=" )

data/lib/antlr3/version.rb

@@ -20,7 +20,7 @@ module ANTLR3
   # 
   MAJOR_VERSION = 1
   MINOR_VERSION = 8
-  PATCH_VERSION = 0
+  PATCH_VERSION = 2
   VERSION = [ MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION ]
   VERSION_STRING = VERSION.join( '.' ).freeze