antlr3 1.8.0 → 1.8.2

data/lib/antlr3/test/functional.rb

@@ -159,10 +159,6 @@ class Functional < ::Test::Unit::TestCase
     klass.test_path = call_stack[ 0 ].file
   end
   
-  def self.example( *args, &b )
-    super
-  end
-  
   def local_path( *args )
     self.class.local_path( *args )
   end

data/lib/antlr3/test/grammar.rb

@@ -24,17 +24,17 @@ module DependantFile
     @dependencies ||= GLOBAL_DEPENDENCIES.clone
   end
   
-  def depends_on(path)
+  def depends_on( path )
     path = File.expand_path path.to_s
-    dependencies << path if test(?f, path)
+    dependencies << path if test( ?f, path )
     return path
   end
   
   def stale?
-    force and return(true)
+    force and return( true )
     target_files.any? do |target|
-      not test(?f, target) or
-        dependencies.any? { |dep| test(?>, dep, target) }
+      not test( ?f, target ) or
+        dependencies.any? { |dep| test( ?>, dep, target ) }
     end
   end
 end # module DependantFile
@@ -43,35 +43,35 @@ class Grammar
   include DependantFile
 
   GRAMMAR_TYPES = %w(lexer parser tree combined)
-  TYPE_TO_CLASS = {
+  TYPE_TO_CLASS = { 
     'lexer'  => 'Lexer',
     'parser' => 'Parser',
     'tree'   => 'TreeParser'
   }
   CLASS_TO_TYPE = TYPE_TO_CLASS.invert
 
-  def self.global_dependency(path)
+  def self.global_dependency( path )
     path = File.expand_path path.to_s
-    GLOBAL_DEPENDENCIES << path if test(?f, path)
+    GLOBAL_DEPENDENCIES << path if test( ?f, path )
     return path
   end
   
-  def self.inline(source, *args)
-    InlineGrammar.new(source, *args)
+  def self.inline( source, *args )
+    InlineGrammar.new( source, *args )
   end
   
   ##################################################################
   ######## CONSTRUCTOR #############################################
   ##################################################################
-  def initialize(path, options = {})
+  def initialize( path, options = {} )
     @path = path.to_s
     @source = File.read( @path )
-    @output_directory = options.fetch(:output_directory, '.')
+    @output_directory = options.fetch( :output_directory, '.' )
     @verbose = options.fetch( :verbose, $VERBOSE )
     study
     build_dependencies
     
-    yield(self) if block_given?
+    yield( self ) if block_given?
   end
   
   ##################################################################
@@ -87,9 +87,9 @@ class Grammar
   def lexer_file_name
     if lexer? then base = name
     elsif combined? then base = name + 'Lexer'
-    else return(nil)
+    else return( nil )
     end
-    return(base + '.rb')
+    return( base + '.rb' )
   end
   
   def parser_class_name
@@ -99,9 +99,9 @@ class Grammar
   def parser_file_name
     if parser? then base = name
     elsif combined? then base = name + 'Parser'
-    else return(nil)
+    else return( nil )
     end
-    return(base + '.rb')
+    return( base + '.rb' )
   end
   
   def tree_parser_class_name
@@ -138,11 +138,11 @@ class Grammar
     @type == "combined"
   end
   
-  def target_files(include_imports = true)
+  def target_files( include_imports = true )
     targets = []
     
     for target_type in %w(lexer parser tree_parser)
-      target_name = self.send(:"#{target_type}_file_name") and
+      target_name = self.send( :"#{ target_type }_file_name" ) and
         targets.push( output_directory / target_name )
     end
     
@@ -151,37 +151,37 @@ class Grammar
   end
   
   def imports
-    @source.scan(/^\s*import\s+(\w+)\s*;/).
+    @source.scan( /^\s*import\s+(\w+)\s*;/ ).
       tap { |list| list.flatten! }
   end
   
   def imported_target_files
     imports.map! do |delegate|
-      output_directory / "#{@name}_#{delegate}.rb"
+      output_directory / "#{ @name }_#{ delegate }.rb"
     end
   end
 
   ##################################################################
   ##### COMMAND METHODS ############################################
   ##################################################################
-  def compile(options = {})
-    if options[:force] or stale?
-      compile!(options)
+  def compile( options = {} )
+    if options[ :force ] or stale?
+      compile!( options )
     end
   end
   
-  def compile!(options = {})
-    command = build_command(options)
+  def compile!( options = {} )
+    command = build_command( options )
     
     blab( command )
-    output = IO.popen(command) do |pipe|
+    output = IO.popen( command ) do |pipe|
       pipe.read
     end
     
     case status = $?.exitstatus
     when 0, 130
-      post_compile(options)
-    else compilation_failure!(command, status, output)
+      post_compile( options )
+    else compilation_failure!( command, status, output )
     end
     
     return target_files
@@ -190,8 +190,8 @@ class Grammar
   def clean!
     deleted = []
     for target in target_files
-      if test(?f, target)
-        File.delete(target)
+      if test( ?f, target )
+        File.delete( target )
         deleted << target
       end
     end
@@ -204,7 +204,7 @@ class Grammar
   
 private
   
-  def post_compile(options)
+  def post_compile( options )
     # do nothing for now
   end
   
@@ -216,50 +216,50 @@ private
     ENV[ 'ANTLR_JAR' ] || ANTLR3.antlr_jar
   end
   
-  def compilation_failure!(command, status, output)
+  def compilation_failure!( command, status, output )
     for f in target_files
-      test(?f, f) and File.delete(f)
+      test( ?f, f ) and File.delete( f )
     end
-    raise CompilationFailure.new(self, command, status, output)
+    raise CompilationFailure.new( self, command, status, output )
   end
 
   def build_dependencies
-    depends_on(@path)
+    depends_on( @path )
     
     if @source =~ /tokenVocab\s*=\s*(\S+)\s*;/
       foreign_grammar_name = $1
       token_file = output_directory / foreign_grammar_name + '.tokens'
       grammar_file = File.dirname( path ) / foreign_grammar_name << '.g'
-      depends_on(token_file)
-      depends_on(grammar_file)
+      depends_on( token_file )
+      depends_on( grammar_file )
     end    
   end
   
-  def shell_escape(token)
+  def shell_escape( token )
     token = token.to_s.dup
     token.empty? and return "''"
-    token.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\1')
-    token.gsub!(/\n/, "'\n'")
+    token.gsub!( /([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\1' )
+    token.gsub!( /\n/, "'\n'" )
     return token
   end
   
-  def build_command(options)
+  def build_command( options )
     parts = %w(java)
     jar_path = options.fetch( :antlr_jar, default_antlr_jar )
-    parts.push('-cp', jar_path)
+    parts.push( '-cp', jar_path )
     parts << 'org.antlr.Tool'
-    parts.push('-fo', output_directory)
-    options[:profile] and parts << '-profile'
-    options[:debug]   and parts << '-debug'
-    options[:trace]   and parts << '-trace'
-    options[:debug_st] and parts << '-XdbgST'
-    parts << File.expand_path(@path)
-    parts.map! { |part| shell_escape(part) }.join(' ') << ' 2>&1'
+    parts.push( '-fo', output_directory )
+    options[ :profile ] and parts << '-profile'
+    options[ :debug ]   and parts << '-debug'
+    options[ :trace ]   and parts << '-trace'
+    options[ :debug_st ] and parts << '-XdbgST'
+    parts << File.expand_path( @path )
+    parts.map! { |part| shell_escape( part ) }.join( ' ' ) << ' 2>&1'
   end
   
   def study
     @source =~ /^\s*(lexer|parser|tree)?\s*grammar\s*(\S+)\s*;/ or
-      raise Grammar::FormatError[source, path]
+      raise Grammar::FormatError[ source, path ]
     @name = $2
     @type = $1 || 'combined'
   end
@@ -271,9 +271,9 @@ class Grammar::InlineGrammar < Grammar
   def initialize( source, options = {} )
     host = call_stack.find { |call| call.file != __FILE__ }
     
-    @host_file = File.expand_path(options[:file] || host.file)
-    @host_line = (options[:line] || host.line)
-    @output_directory = options.fetch(:output_directory, File.dirname(@host_file))
+    @host_file = File.expand_path( options[ :file ] || host.file )
+    @host_line = ( options[ :line ] || host.line )
+    @output_directory = options.fetch( :output_directory, File.dirname( @host_file ) )
     @verbose = options.fetch( :verbose, $VERBOSE )
     
     @source = source.to_s.fixed_indent( 0 )
@@ -291,7 +291,7 @@ class Grammar::InlineGrammar < Grammar
     File.basename( @host_file )
   end
   
-  def path=(v)
+  def path=( v )
     previous, @path = @path, v.to_s
     previous == @path or write_to_disk
   end
@@ -304,9 +304,9 @@ private
   
   def write_to_disk
     @path ||= output_directory / @name + '.g'
-    test(?d, output_directory) or Dir.mkdir( output_directory )
-    unless test(?f, @path) and MD5.digest(@source) == MD5.digest(File.read(@path))
-      open(@path, 'w') { |f| f.write(@source) }
+    test( ?d, output_directory ) or Dir.mkdir( output_directory )
+    unless test( ?f, @path ) and MD5.digest( @source ) == MD5.digest( File.read( @path ) )
+      open( @path, 'w' ) { |f| f.write( @source ) }
     end
   end
 end # class Grammar::InlineGrammar
@@ -315,12 +315,12 @@ class Grammar::CompilationFailure < StandardError
   JAVA_TRACE = /^(org\.)?antlr\.\S+\(\S+\.java:\d+\)\s*/
   attr_reader :grammar, :command, :status, :output
   
-  def initialize(grammar, command, status, output)
+  def initialize( grammar, command, status, output )
     @command = command
     @status = status
     @output = output.gsub( JAVA_TRACE, '' )
     
-    message = <<-END.here_indent! % [command, status, grammar, @output]
+    message = <<-END.here_indent! % [ command, status, grammar, @output ]
     | command ``%s'' failed with status %s
     | %p
     | ~ ~ ~ command output ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
@@ -334,32 +334,32 @@ end # error Grammar::CompilationFailure
 class Grammar::FormatError < StandardError
   attr_reader :file, :source
   
-  def self.[](*args)
-    new(*args)
+  def self.[]( *args )
+    new( *args )
   end
   
-  def initialize(source, file = nil)
+  def initialize( source, file = nil )
     @file = file
     @source = source
     message = ''
     if file.nil? # inline
       message << "bad inline grammar source:\n"
-      message << ("-" * 80) << "\n"
+      message << ( "-" * 80 ) << "\n"
       message << @source
-      message[-1] == ?\n or message << "\n"
-      message << ("-" * 80) << "\n"
+      message[ -1 ] == ?\n or message << "\n"
+      message << ( "-" * 80 ) << "\n"
       message << "could not locate a grammar name and type declaration matching\n"
       message << "/^\s*(lexer|parser|tree)?\s*grammar\s*(\S+)\s*;/"
     else
       message << 'bad grammar source in file %p' % @file
-      message << ("-" * 80) << "\n"
+      message << ( "-" * 80 ) << "\n"
       message << @source
-      message[-1] == ?\n or message << "\n"
-      message << ("-" * 80) << "\n"
+      message[ -1 ] == ?\n or message << "\n"
+      message << ( "-" * 80 ) << "\n"
       message << "could not locate a grammar name and type declaration matching\n"
       message << "/^\s*(lexer|parser|tree)?\s*grammar\s*(\S+)\s*;/"
     end
-    super(message)
+    super( message )
   end
 end # error Grammar::FormatError
 

data/lib/antlr3/token.rb

@@ -101,16 +101,32 @@ module Token
   alias :token_index :index
   alias :token_index= :index=
   
+  #
+  # The match operator has been implemented to match against several different
+  # attributes of a token for convenience in quick scripts
+  #
+  # @example Match against an integer token type constant
+  #   token =~ VARIABLE_NAME   => true/false
+  # @example Match against a token type name as a Symbol
+  #   token =~ :FLOAT          => true/false
+  # @example Match the token text against a Regular Expression
+  #   token =~ /^@[a-z_]\w*$/i
+  # @example Compare the token's text to a string
+  #   token =~ "class"
+  # 
   def =~ obj
     case obj
     when Integer then type == obj
-    when Symbol then name.to_sym == obj
+    when Symbol then name == obj.to_s
     when Regexp then obj =~ text
     when String then text == obj
     else super
     end
   end
   
+  #
+  # Tokens are comparable by their stream index values
+  # 
   def <=> tk2
     index <=> tk2.index
   end
@@ -139,6 +155,10 @@ module Token
     token_name( type )
   end
   
+  def source_name
+    i = input and i.source_name
+  end
+  
   def hidden?
     channel == HIDDEN_CHANNEL
   end
@@ -147,28 +167,19 @@ module Token
     concrete? ? input.substring( start, stop ) : text
   end
   
+  #
+  # Sets the token's channel value to HIDDEN_CHANNEL
+  # 
   def hide!
     self.channel = HIDDEN_CHANNEL
   end
   
-  def range
-    start..stop rescue nil
-  end
-  
-  def to_i
-    index.to_i
-  end
-  
-  def to_s
-    text.to_s
-  end
-  
   def inspect
-    text_inspect    = text  ? '[%p] ' % text : ' '
-    text_position   = line != 0  ? '@ line %s col %s ' % [ line, column ] : ''
-    stream_position = start ? '(%s..%s)' % [ start, stop ] : ''
+    text_inspect    = text  ? "[#{ text.inspect }] " : ' '
+    text_position   = line > 0  ? "@ line #{ line } col #{ column } " : ''
+    stream_position = start ? "(#{ range.inspect })" : ''
     
-    front =  index != -1 ? index.to_s << ' ' : ''
+    front =  index >= 0 ? "#{ index } " : ''
     rep = front << name << text_inspect <<
                 text_position << stream_position
     rep.strip!
@@ -180,6 +191,18 @@ module Token
     printer.text( inspect )
   end
   
+  def range
+    start..stop rescue nil
+  end
+  
+  def to_i
+    index.to_i
+  end
+  
+  def to_s
+    text.to_s
+  end
+  
 private
   
   def token_name( type )
@@ -526,6 +549,7 @@ class TokenScheme < ::Module
     mod.extend( self )
   end
   private :included
+  
   attr_reader :unused, :types
   
   def define_tokens( token_map = {} )

data/lib/antlr3/tree.rb

@@ -355,8 +355,6 @@ class BaseTree < ::Array
   alias add_children concat
   alias each_child each
   
-  
-  
   def set_child( index, tree )
     return if tree.nil?
     tree.flat_list? and raise ArgumentError, "Can't set single child to a list"
@@ -443,9 +441,6 @@ class BaseTree < ::Array
   
   def root?() @parent.nil? end
   alias leaf? empty?
-  
-  
-  
 end
 
 
@@ -828,6 +823,7 @@ builds and manipulates CommonTree nodes.
 =end
 
 class CommonTreeAdaptor
+  extend ClassMacros
   include TreeAdaptor
   include ANTLR3::Constants
   
@@ -892,16 +888,17 @@ class CommonTreeAdaptor
     end
   end
   
-  # TODO: deprecate create...! methods -- they don't make sense
+  creation_methods = %w(
+    create_from_token create_from_type
+    create_error_node create_with_payload
+    create
+  )
   
-  # aliases in preparation for deprecation to avoid breaking
-  # backward compatibility
-  
-  alias create_from_token! create_from_token
-  alias create_from_type! create_from_type
-  alias create_error_node! create_error_node
-  alias create_with_payload! create_with_payload
-  alias create! create
+  for method_name in creation_methods
+    bang_method = method_name + '!'
+    alias_method( bang_method, method_name )
+    deprecate( bang_method, "use method ##{ method_name } instead" )
+  end
   
   def rule_post_processing( root )
     if root and root.flat_list?