antlr3 1.7.5 → 1.8.0

data/lib/antlr3/template/group-file-parser.rb

@@ -2,10 +2,10 @@
 #
 # GroupFile.g
 # 
-# Generated using ANTLR version: 3.2.1-SNAPSHOT Apr 29, 2010 11:36:19
-# Ruby runtime library version: 1.7.3
+# Generated using ANTLR version: 3.2.1-SNAPSHOT Jun 18, 2010 05:38:11
+# Ruby runtime library version: 1.7.5
 # Input grammar file: GroupFile.g
-# Generated at: 2010-05-16 18:30:20
+# Generated at: 2010-07-03 23:15:35
 # 
 
 # ~~~> start load path setup
@@ -16,7 +16,7 @@ antlr_load_failed = proc do
   load_path = $LOAD_PATH.map { |dir| '  - ' << dir }.join( $/ )
   raise LoadError, <<-END.strip!
   
-Failed to load the ANTLR3 runtime library (version 1.7.3):
+Failed to load the ANTLR3 runtime library (version 1.7.5):
 
 Ensure the library has been installed on your system and is available
 on the load path. If rubygems is available on your system, this can
@@ -46,7 +46,7 @@ rescue LoadError
   
   # 3: try to activate the antlr3 gem
   begin
-    Gem.activate( 'antlr3', '~> 1.7.3' )
+    Gem.activate( 'antlr3', '~> 1.7.5' )
   rescue Gem::LoadError
     antlr_load_failed.call
   end
@@ -103,7 +103,7 @@ module GroupFile
     include TokenData
 
     begin
-      generated_using( "GroupFile.g", "3.2.1-SNAPSHOT Apr 29, 2010 11:36:19", "1.7.3" )
+      generated_using( "GroupFile.g", "3.2.1-SNAPSHOT Jun 18, 2010 05:38:11", "1.7.5" )
     rescue NoMethodError => error
       # ignore
     end

data/lib/antlr3/test/functional.rb

@@ -22,28 +22,33 @@ module Location
     File.dirname( test_path )
   end
   
-  def local_path(*parts)
+  def local_path( *parts )
     File.join( test_directory, *parts )
   end
   
-  def output_directory(name = test_group)
+  def output_directory( name = test_group )
     local_path( name )
   end
   
 end # module Location
 
 module NameSpace
+  
+  #
+  # import( ruby_file )   => [ new constants, ... ]
+  # Read the source code from the path given by +ruby_file+ and
+  # evaluate it within the class body. Return new constants
+  # created in the class after the evaluation.
+  # 
   def import( ruby_file )
     constants_before = constants
-    class_eval(File.read(ruby_file), ruby_file, 1)
+    class_eval( File.read( ruby_file ), ruby_file, 1 )
     constants - constants_before
   end
   
-  def import_grammar_targets(grammar)
-    # reverse because delegates need to be in the test class's name
-    # space before the masters
+  def import_grammar_targets( grammar )
     for file in grammar.target_files
-      import(file)
+      import( file )
     end
   end
 end
@@ -59,22 +64,40 @@ module GrammarManager
   end
   module_function :add_default_compile_option
   
-  if ANTLR_JAR = ENV['ANTLR_JAR'] || ANTLR3.antlr_jar
+  if ANTLR_JAR = ENV[ 'ANTLR_JAR' ] || ANTLR3.antlr_jar
     add_default_compile_option( :antlr_jar, ANTLR_JAR )
     
     Grammar.global_dependency( ANTLR_JAR )
   end
   
+  #
+  # Compile and load inline grammars on demand when their constant name
+  # is referenced in the code. This makes it easier to catch big errors
+  # quickly as test cases are run, instead of waiting a few minutes
+  # for all grammars to compile, and then discovering there's a big dumb
+  # error ruining most of the grammars.
+  # 
   def const_missing( name )
     if g = grammars[ name.to_s ]
       compile( g )
       grammars.delete( name.to_s )
       const_get( name )
+    elsif superclass.respond_to?( :grammars )
+      superclass.const_missing( name )
+      # ^-- for some reason, in ruby 1.9, rspec runs examples as instances of
+      # anonymous subclasses, of the actual test class, which messes up the
+      # assumptions made in the test code. Grammars are stored in @grammars belonging
+      # to the test class, so in 1.9, this method is called with @grammars = {}
+      # since it's a subclass
     else
       super
     end
   end
   
+  # 
+  # An index of grammar file objects created in the test class
+  # (defined inline or loaded from a file)
+  # 
   def grammars
     @grammars ||= {}
   end
@@ -91,38 +114,39 @@ module GrammarManager
     return grammar
   end
   
-  def inline_grammar(source, options = {})
-    call = call_stack.find { |call| call.file != __FILE__}
+  def inline_grammar( source, options = {} )
+    call = call_stack.find { |call| call.file != __FILE__ }
     grammar = Grammar.inline source,
                 :output_directory => output_directory,
-                :file => (call.file rescue nil),
-                :line => (call.line rescue nil)
-    register_grammar(grammar)
+                :file => ( call.file rescue nil ),
+                :line => ( call.line rescue nil )
+    register_grammar( grammar )
     return grammar
   end
   
-  def compile_options(defaults = nil)
+  def compile_options( defaults = nil )
     @compile_options ||= DEFAULT_COMPILE_OPTIONS.clone
-    @compile_options.update(defaults) if defaults
+    @compile_options.update( defaults ) if defaults
     return @compile_options
   end
   
-  def compile(grammar, options = {})
-    grammar.compile( compile_options.merge(options) )
+  def compile( grammar, options = {} )
+    grammar.compile( compile_options.merge( options ) )
     import_grammar_targets( grammar )
     return grammar
   end
   
 private
   
-  def register_grammar(grammar)
+  def register_grammar( grammar )
     name = grammar.name
+    @grammars ||= {}
     
-    if conflict = grammars[ name ] and conflict.source != grammar.source
-      message = "Multiple grammars exist with the name ``#{name}''"
+    if conflict = @grammars[ name ] and conflict.source != grammar.source
+      message = "Multiple grammars exist with the name ``#{ name }''"
       raise NameError, message
     else
-      grammars[ name ] = grammar
+      @grammars[ name ] = grammar
     end
   end
 end # module GrammarManager
@@ -130,13 +154,17 @@ end # module GrammarManager
 class Functional < ::Test::Unit::TestCase
   extend GrammarManager
   
-  def self.inherited(klass)
+  def self.inherited( klass )
+    super
+    klass.test_path = call_stack[ 0 ].file
+  end
+  
+  def self.example( *args, &b )
     super
-    klass.test_path = call_stack[0].file
   end
   
-  def local_path(*args)
-    self.class.local_path(*args)
+  def local_path( *args )
+    self.class.local_path( *args )
   end
   
   def test_path
@@ -148,7 +176,7 @@ class Functional < ::Test::Unit::TestCase
   end
   
   def inline_grammar( source )
-    call = call_stack.find { |call| call.file != __FILE__}
+    call = call_stack.find { |call| call.file != __FILE__ }
     grammar = Grammar.inline source,
                 :output_directory => output_directory,
                 :file => call.file,
@@ -165,7 +193,7 @@ end # class Functional
 module CaptureOutput
   require 'stringio'
   def output_buffer
-    defined?(@output_buffer) or @output_buffer = StringIO.new('')
+    defined?( @output_buffer ) or @output_buffer = StringIO.new( '' )
     @output_buffer
   end
   
@@ -173,35 +201,35 @@ module CaptureOutput
     output_buffer.string
   end
   
-  def say(*args)
-    output_buffer.puts(*args)
+  def say( *args )
+    output_buffer.puts( *args )
   end
   
-  def capture(*args)
-    output_buffer.write(*args)
+  def capture( *args )
+    output_buffer.write( *args )
   end
 end
 
 module RaiseErrors
-  def emit_error_message(msg)
+  def emit_error_message( msg )
     # do nothing
   end
   
-  def report_error(error)
+  def report_error( error )
     raise error
   end
 end
 
 module CollectErrors
   def reported_errors
-    defined?(@reported_errors) or @reported_errors = []
+    defined?( @reported_errors ) or @reported_errors = []
     return @reported_errors
   end
   
-  def emit_error_message(msg)
+  def emit_error_message( msg )
     reported_errors << msg
   end
 end
 
 end # module Test
-end # module ANTLR3
+end # module ANTLR3

data/lib/antlr3/version.rb

@@ -19,8 +19,8 @@ module ANTLR3
   # The version data for the current state the library itself
   # 
   MAJOR_VERSION = 1
-  MINOR_VERSION = 7
-  PATCH_VERSION = 5
+  MINOR_VERSION = 8
+  PATCH_VERSION = 0
   VERSION = [ MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION ]
   VERSION_STRING = VERSION.join( '.' ).freeze
   

data/templates/Ruby.stg

@@ -1459,4 +1459,4 @@ placeAction(scope, name) ::= <<
 <endif>
 >>
 
-runtimeLibraryVersion() ::= "1.7.5"
+runtimeLibraryVersion() ::= "1.8.0"

data/test/functional/ast-output/auto-ast.rb

@@ -5,60 +5,60 @@ require 'antlr3/test/functional'
 
 class TestAutoAST < ANTLR3::Test::Functional
   
-  def parse(grammar, rule, input, expect_errors = false)
-    @grammar = inline_grammar(grammar)
+  def parse( grammar, rule, input, expect_errors = false )
+    @grammar = inline_grammar( grammar )
     compile_and_load @grammar
-    grammar_module = self.class.const_get(@grammar.name)
+    grammar_module = self.class.const_get( @grammar.name )
     
-    grammar_module::Lexer.send(:include, ANTLR3::Test::CollectErrors)
-    grammar_module::Lexer.send(:include, ANTLR3::Test::CaptureOutput)
-    grammar_module::Parser.send(:include, ANTLR3::Test::CollectErrors)
-    grammar_module::Parser.send(:include, ANTLR3::Test::CaptureOutput)
+    grammar_module::Lexer.send( :include, ANTLR3::Test::CollectErrors )
+    grammar_module::Lexer.send( :include, ANTLR3::Test::CaptureOutput )
+    grammar_module::Parser.send( :include, ANTLR3::Test::CollectErrors )
+    grammar_module::Parser.send( :include, ANTLR3::Test::CaptureOutput )
     
     lexer  = grammar_module::Lexer.new( input )
     parser = grammar_module::Parser.new( lexer )
     
-    r = parser.send(rule)
+    r = parser.send( rule )
     parser.reported_errors.should be_empty unless expect_errors
     result = ''
     
     unless r.nil?
-      result += r.result if r.respond_to?(:result)
+      result += r.result if r.respond_to?( :result )
       result += r.tree.inspect if r.tree
     end
-    return(expect_errors ? [result, parser.reported_errors] : result)
+    return( expect_errors ? [ result, parser.reported_errors ] : result )
   end
   
-  def tree_parse(grammar, tree_grammar, rule, tree_rule, input)
-    @grammar = inline_grammar(grammar)
-    @tree_grammar = inline_grammar(tree_grammar)
+  def tree_parse( grammar, tree_grammar, rule, tree_rule, input )
+    @grammar = inline_grammar( grammar )
+    @tree_grammar = inline_grammar( tree_grammar )
     compile_and_load @grammar
     compile_and_load @tree_grammar
     
-    grammar_module = self.class.const_get(@grammar.name)
-    tree_grammar_module = self.class.const_get(@tree_grammar.name)
+    grammar_module = self.class.const_get( @grammar.name )
+    tree_grammar_module = self.class.const_get( @tree_grammar.name )
     
-    grammar_module::Lexer.send(:include, ANTLR3::Test::CollectErrors)
-    grammar_module::Lexer.send(:include, ANTLR3::Test::CaptureOutput)
-    grammar_module::Parser.send(:include, ANTLR3::Test::CollectErrors)
-    grammar_module::Parser.send(:include, ANTLR3::Test::CaptureOutput)
-    tree_grammar_module::TreeParser.send(:include, ANTLR3::Test::CollectErrors)
-    tree_grammar_module::TreeParser.send(:include, ANTLR3::Test::CaptureOutput)
+    grammar_module::Lexer.send( :include, ANTLR3::Test::CollectErrors )
+    grammar_module::Lexer.send( :include, ANTLR3::Test::CaptureOutput )
+    grammar_module::Parser.send( :include, ANTLR3::Test::CollectErrors )
+    grammar_module::Parser.send( :include, ANTLR3::Test::CaptureOutput )
+    tree_grammar_module::TreeParser.send( :include, ANTLR3::Test::CollectErrors )
+    tree_grammar_module::TreeParser.send( :include, ANTLR3::Test::CaptureOutput )
     
     lexer  = grammar_module::Lexer.new( input )
     parser = grammar.module::Parser.new( lexer )
-    r = parser.send(rule)
+    r = parser.send( rule )
     nodes = ANTLR3::CommonTreeNodeStream( r.tree )
     nodes.token_stream = parser.input
     walker = tree_grammar_module::TreeParser.new( nodes )
-    r = walker.send(tree_rule)
+    r = walker.send( tree_rule )
     
-    return(r ? r.tree.inspect : '')
+    return( r ? r.tree.inspect : '' )
   end
   
   
   example 'flat token list' do
-    result = parse(<<-'END', :a, 'abc 34')
+    result = parse( <<-'END', :a, 'abc 34' )
       grammar TokenList;
       options {language=Ruby;output=AST;}
       a : ID INT ;
@@ -70,7 +70,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example 'token list in a single-alternative subrule' do
-    result = parse(<<-'END', :a, 'abc 34')
+    result = parse( <<-'END', :a, 'abc 34' )
       grammar TokenListInSingleAltBlock;
       options {language=Ruby;output=AST;}
       a : (ID INT) ;
@@ -82,7 +82,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "simple root at the outer level via the `^' operator" do
-    result = parse(<<-'END', :a, 'abc 34')
+    result = parse( <<-'END', :a, 'abc 34' )
       grammar SimpleRootAtOuterLevel;
       options {language=Ruby;output=AST;}
       a : ID^ INT ;
@@ -94,7 +94,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "outer-level root changing token order from the `^' operator" do
-    result = parse(<<-'END', :a, '34 abc')
+    result = parse( <<-'END', :a, '34 abc' )
       grammar SimpleRootAtOuterLevelReverse;
       options {language=Ruby;output=AST;}
       a : INT ID^ ;
@@ -106,7 +106,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "leaving out tokens using the `!' operator" do
-    result = parse(<<-'END', :a, 'abc 34 dag 4532')
+    result = parse( <<-'END', :a, 'abc 34 dag 4532' )
       grammar Bang;
       options {language=Ruby;output=AST;}
       a : ID INT! ID! INT ;
@@ -119,7 +119,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "tokens in `(...)?' optional subrule" do
-    result = parse(<<-'END', :a, 'a 1 b')
+    result = parse( <<-'END', :a, 'a 1 b' )
       grammar OptionalThenRoot;
       options {language=Ruby;output=AST;}
       a : ( ID INT )? ID^ ;
@@ -131,7 +131,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "labeled literal-string root token" do
-    result = parse(<<-'END', :a, 'void foo;')
+    result = parse( <<-'END', :a, 'void foo;' )
       grammar LabeledStringRoot;
       options {language=Ruby;output=AST;}
       a : v='void'^ ID ';' ;
@@ -143,7 +143,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example 'rule with token wildcard' do
-    result = parse(<<-'END', :a, 'void foo;')
+    result = parse( <<-'END', :a, 'void foo;' )
       grammar Wildcard;
       options {language=Ruby;output=AST;}
       a : v='void'^ . ';' ;
@@ -155,7 +155,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "token wildcard as root via the `^' operator" do
-    result = parse(<<-'END', :a, 'void foo;')
+    result = parse( <<-'END', :a, 'void foo;' )
       grammar WildcardRoot;
       options {language=Ruby;output=AST;}
       a : v='void' .^ ';' ;
@@ -167,7 +167,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "labeled token wildcard as root via the `^' operator" do
-    result = parse(<<-'END', :a, 'void foo;')
+    result = parse( <<-'END', :a, 'void foo;' )
       grammar WildcardRootWithLabel;
       options {language=Ruby;output=AST;}
       a : v='void' x=.^ ';' ;
@@ -180,7 +180,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   
   
   example "token wildcard as root (with list label)" do
-    result = parse(<<-'END', :a, 'void foo;')
+    result = parse( <<-'END', :a, 'void foo;' )
       grammar WildcardRootWithListLabel;
       options {language=Ruby;output=AST;}
       a : v='void' x=.^ ';' ;
@@ -193,7 +193,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "trashed token wildcard" do
-    result = parse(<<-'END', :a, 'void foo;')
+    result = parse( <<-'END', :a, 'void foo;' )
       grammar WildcardBangWithListLabel;
       options {language=Ruby;output=AST;}
       a : v='void' x=.! ';' ;
@@ -206,7 +206,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "multiple occurences of the `^' operator in a list of tokens" do
-    result = parse(<<-'END', :a, 'a 34 c')
+    result = parse( <<-'END', :a, 'a 34 c' )
       grammar RootRoot;
       options {language=Ruby;output=AST;}
       a : ID^ INT^ ID ;
@@ -219,7 +219,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "another case of multiple occurences of the `^' operator" do
-    result = parse(<<-'END', :a, 'a 34 c')
+    result = parse( <<-'END', :a, 'a 34 c' )
       grammar RootRoot2;
       options {language=Ruby;output=AST;}
       a : ID INT^ ID^ ;
@@ -232,7 +232,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "root-hoist using `^' from within a (...)+ block" do
-    result = parse(<<-'END', :a, 'a 34 * b 9 * c')
+    result = parse( <<-'END', :a, 'a 34 * b 9 * c' )
       grammar RootThenRootInLoop;
       options {language=Ruby;output=AST;}
       a : ID^ (INT '*'^ ID)+ ;
@@ -245,7 +245,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "nested subrules without any AST ops resulting in a flat list" do
-    result = parse(<<-'END', :a, 'void a b;')
+    result = parse( <<-'END', :a, 'void a b;' )
       grammar NestedSubrule;
       options {language=Ruby;output=AST;}
       a : 'void' (({
@@ -260,7 +260,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "invoking another rule without any AST ops, resulting in a flat list" do
-    result = parse(<<-'END', :a, 'int a')
+    result = parse( <<-'END', :a, 'int a' )
       grammar InvokeRule;
       options {language=Ruby;output=AST;}
       a  : type ID ;
@@ -276,7 +276,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting the results of another rule as root using the `^' operator" do
-    result = parse(<<-'END', :a, 'int a')
+    result = parse( <<-'END', :a, 'int a' )
       grammar InvokeRuleAsRoot;
       options {language=Ruby;output=AST;}
       a  : type^ ID ;
@@ -292,7 +292,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting another rule's true as root using the `^' operator (with a label)" do
-    result = parse(<<-'END', :a, 'int a')
+    result = parse( <<-'END', :a, 'int a' )
       grammar InvokeRuleAsRootWithLabel;
       options {language=Ruby;output=AST;}
       a  : x=type^ ID ;
@@ -308,7 +308,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting another rule's result tree as root using the `^' operator (with a list += label)" do
-    result = parse(<<-'END', :a, 'int a')
+    result = parse( <<-'END', :a, 'int a' )
       grammar InvokeRuleAsRootWithListLabel;
       options {language=Ruby;output=AST;}
       a  : x+=type^ ID ;
@@ -324,7 +324,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "root-hoist via `^' within a (...)* loop resulting in a deeply-nested tree" do
-    result = parse(<<-'END', :a, 'a+b+c+d')
+    result = parse( <<-'END', :a, 'a+b+c+d' )
       grammar RuleRootInLoop;
       options {language=Ruby;output=AST;}
       a : ID ('+'^ ID)* ;
@@ -337,7 +337,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting another rule's result tree as root from within a (...)* loop resulting in a deeply nested tree" do
-    result = parse(<<-'END', :a, 'a+b+c-d')
+    result = parse( <<-'END', :a, 'a+b+c-d' )
       grammar RuleInvocationRuleRootInLoop;
       options {language=Ruby;output=AST;}
       a : ID (op^ ID)* ;
@@ -353,7 +353,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "using tail recursion to build deeply-nested expression trees" do
-    result = parse(<<-'END', :s, '3 exp 4 exp 5')
+    result = parse( <<-'END', :s, '3 exp 4 exp 5' )
       grammar TailRecursion;
       options {language=Ruby;output=AST;}
       s : a ;
@@ -368,7 +368,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "simple token node from a token type set" do
-    result = parse(<<-'END', :a, 'abc')
+    result = parse( <<-'END', :a, 'abc' )
       grammar TokenSet;
       options {language=Ruby; output=AST;}
       a : ID|INT ;
@@ -380,7 +380,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting a token-type set token as root with `^'" do
-    result = parse(<<-'END', :a, '+abc')
+    result = parse( <<-'END', :a, '+abc' )
       grammar SetRoot;
       options {language=Ruby;output=AST;}
       a : ('+' | '-')^ ID ;
@@ -393,7 +393,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting a token-type set token as root with `^' (with a label)" do
-    result = parse(<<-'END', :a, '+abc')
+    result = parse( <<-'END', :a, '+abc' )
       grammar SetRootWithLabel;
       options {language=Ruby;output=AST;}
       a : (x=('+' | '-'))^ ID ;
@@ -406,7 +406,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting a token-type set token as root from within a (...)* loop" do
-    result = parse(<<-'END', :a, 'a+b-c')
+    result = parse( <<-'END', :a, 'a+b-c' )
       grammar SetAsRuleRootInLoop;
       options {language=Ruby;output=AST;}
       a : ID (('+'|'-')^ ID)* ;
@@ -419,7 +419,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "an `~' inverted token-type set element" do
-    result = parse(<<-'END', :a, '34+2')
+    result = parse( <<-'END', :a, '34+2' )
       grammar NotSet;
       options {language=Ruby;output=AST;}
       a : ~ID '+' INT ;
@@ -432,7 +432,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "a `~' inverted token-type set in a rule (with a label)" do
-    result = parse(<<-'END', :a, '34+2')
+    result = parse( <<-'END', :a, '34+2' )
       grammar NotSetWithLabel;
       options {language=Ruby;output=AST;}
       a : x=~ID '+' INT ;
@@ -445,7 +445,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "a `~' inverted token-type set element in a rule (with a list += label)" do
-    result = parse(<<-'END', :a, '34+2')
+    result = parse( <<-'END', :a, '34+2' )
       grammar NotSetWithListLabel;
       options {language=Ruby;output=AST;}
       a : x=~ID '+' INT ;
@@ -458,7 +458,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "a `~' inverted token-type set element hoisted to root via `^'" do
-    result = parse(<<-'END', :a, '34 55')
+    result = parse( <<-'END', :a, '34 55' )
       grammar NotSetRoot;
       options {language=Ruby;output=AST;}
       a : ~'+'^ INT ;
@@ -473,7 +473,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   # FIXME: no label actually in the grammar
   
   example "hoisting a `~' inverted token-type set to root using `^' (with label)" do
-    result = parse(<<-'END', :a, '34 55')
+    result = parse( <<-'END', :a, '34 55' )
       grammar NotSetRootWithLabel;
       options {language=Ruby;output=AST;}
       a   : x=~'+'^ INT ;
@@ -487,7 +487,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   # FIXME:  no label here either
   
   example "hoisting a `~' inverted token-type set to root using `^' (with list += label)" do
-    result = parse(<<-'END', :a, '34 55')
+    result = parse( <<-'END', :a, '34 55' )
       grammar NotSetRootWithListLabel;
       options {language=Ruby;output=AST;}
       a : x+=~'+'^ INT ;
@@ -500,7 +500,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "hoisting a `~' inverted token-type set to root from within a (...)* loop" do
-    result = parse(<<-'END', :a, '3+4+5')
+    result = parse( <<-'END', :a, '3+4+5' )
       grammar NotSetRuleRootInLoop;
       options {language=Ruby;output=AST;}
       a : INT (~INT^ INT)* ;
@@ -514,7 +514,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "multiple tokens with the same label in a rule" do
-    result = parse(<<-'END', :a, 'a b')
+    result = parse( <<-'END', :a, 'a b' )
       grammar TokenLabelReuse;
       options {language=Ruby;output=AST;}
       a returns [result] : id=ID id=ID {
@@ -529,7 +529,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "multiple tokens with the same label in a rule (with a `^' root hoist)" do
-    result = parse(<<-'END', :a, 'a b')
+    result = parse( <<-'END', :a, 'a b' )
       grammar TokenLabelReuse2;
       options {language=Ruby;output=AST;}
       a returns [result]: id=ID id=ID^ {$result = "2nd id=#{$id.text},"} ;
@@ -542,7 +542,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "extra token in a simple declaration" do
-    result, errors = parse(<<-'END', :decl, 'int 34 x=1;', true)
+    result, errors = parse( <<-'END', :decl, 'int 34 x=1;', true )
       grammar ExtraTokenInSimpleDecl;
       options {language=Ruby;output=AST;}
       decl : type^ ID '='! INT ';'! ;
@@ -552,12 +552,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       WS : (' '|'\n') {$channel=HIDDEN;} ;
   
     END
-    errors.should == ["line 1:4 extraneous input \"34\" expecting ID"]
+    errors.should == [ "line 1:4 extraneous input \"34\" expecting ID" ]
     result.should == '(int x 1)'
   end
   
   example "missing ID in a simple declaration" do
-    result, errors = parse(<<-'END', :decl, 'int =1;', true)
+    result, errors = parse( <<-'END', :decl, 'int =1;', true )
       grammar MissingIDInSimpleDecl;
       options {language=Ruby;output=AST;}
       tokens {EXPR;}
@@ -567,12 +567,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       INT : '0'..'9'+;
       WS : (' '|'\n') {$channel=HIDDEN;} ;
     END
-    errors.should == ["line 1:4 missing ID at \"=\""]
+    errors.should == [ "line 1:4 missing ID at \"=\"" ]
     result.should == '(int <missing ID> 1)'
   end
   
   example "missing token of a token-type set in a simple declaration" do
-    result, errors = parse(<<-'END', :decl, 'x=1;', true)
+    result, errors = parse( <<-'END', :decl, 'x=1;', true )
       grammar MissingSetInSimpleDecl;
       options {language=Ruby;output=AST;}
       tokens {EXPR;}
@@ -583,12 +583,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       WS : (' '|'\n') {$channel=HIDDEN;} ;
   
     END
-    errors.should == ["line 1:0 mismatched input \"x\" expecting set nil"]
+    errors.should == [ "line 1:0 mismatched input \"x\" expecting set nil" ]
     result.should == '(<error: x> x 1)'
   end
   
   example "missing INT token simulated with a `<missing INT>' error node" do
-    result, errors = parse(<<-'END', :a, 'abc', true)
+    result, errors = parse( <<-'END', :a, 'abc', true )
       grammar MissingTokenGivesErrorNode;
       options {language=Ruby;output=AST;}
       a : ID INT ; // follow is EOF
@@ -597,12 +597,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       WS : (' '|'\n') {$channel=HIDDEN;} ;
   
     END
-    errors.should == ["line 0:-1 missing INT at \"<EOF>\""]
+    errors.should == [ "line 0:-1 missing INT at \"<EOF>\"" ]
     result.should == 'abc <missing INT>'
   end
   
   example "missing token from invoked rule results in error node with a resync attribute" do
-    result, errors = parse(<<-'END', :a, 'abc', true)
+    result, errors = parse( <<-'END', :a, 'abc', true )
       grammar MissingTokenGivesErrorNodeInInvokedRule;
       options {language=Ruby;output=AST;}
       a : b ;
@@ -612,12 +612,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       WS : (' '|'\n') {$channel=HIDDEN;} ;
   
     END
-    errors.should == ["line 0:-1 mismatched input \"<EOF>\" expecting INT"]
+    errors.should == [ "line 0:-1 mismatched input \"<EOF>\" expecting INT" ]
     result.should == '<mismatched token: <EOF>, resync = abc>'
   end
   
   example "extraneous ID token displays error and is ignored in AST output" do
-    result, errors = parse(<<-'END', :a, 'abc ick 34', true)
+    result, errors = parse( <<-'END', :a, 'abc ick 34', true )
       grammar ExtraTokenGivesErrorNode;
       options {language=Ruby;output=AST;}
       a : b c ;
@@ -628,12 +628,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       WS : (' '|'\n') {$channel=HIDDEN;} ;
   
     END
-    errors.should == ["line 1:4 extraneous input \"ick\" expecting INT"]
+    errors.should == [ "line 1:4 extraneous input \"ick\" expecting INT" ]
     result.should == 'abc 34'
   end
   
   example "missing ID token simulated with a `<missing ID>' error node" do
-    result, errors = parse(<<-'END', :a, '34', true)
+    result, errors = parse( <<-'END', :a, '34', true )
       grammar MissingFirstTokenGivesErrorNode;
       options {language=Ruby;output=AST;}
       a : ID INT ;
@@ -642,12 +642,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       WS : (' '|'\n') {$channel=HIDDEN;} ;
   
     END
-    errors.should == ["line 1:0 missing ID at \"34\""]
+    errors.should == [ "line 1:0 missing ID at \"34\"" ]
     result.should == '<missing ID> 34'
   end
   
   example "another case where a missing ID token is simulated with a `<missing ID>' error node" do
-    result, errors = parse(<<-'END', :a, '34', true)
+    result, errors = parse( <<-'END', :a, '34', true )
       grammar MissingFirstTokenGivesErrorNode2;
       options {language=Ruby;output=AST;}
       a : b c ;
@@ -658,12 +658,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       WS : (' '|'\n') {$channel=HIDDEN;} ;
   
     END
-    errors.should == ["line 1:0 missing ID at \"34\""]
+    errors.should == [ "line 1:0 missing ID at \"34\"" ]
     result.should == '<missing ID> 34'
   end
   
   example "no viable alternative for rule is represented as a single `<unexpected: ...>' error node" do
-    result, errors = parse(<<-'END', :a, '*', true)
+    result, errors = parse( <<-'END', :a, '*', true )
       grammar NoViableAltGivesErrorNode;
       options {language=Ruby;output=AST;}
       a : b | c ;
@@ -674,12 +674,12 @@ class TestAutoAST < ANTLR3::Test::Functional
       INT : '0'..'9'+;
       WS : (' '|'\n') {$channel=HIDDEN;} ;
     END
-    errors.should == ["line 1:0 no viable alternative at input \"*\""]
+    errors.should == [ "line 1:0 no viable alternative at input \"*\"" ]
     result.should == "<unexpected: 0 S[\"*\"] @ line 1 col 0 (0..0), resync = *>"
   end
   
   example "token with a `+=' list label hoisted to root with `^'" do
-    result = parse(<<-'END', :a, 'a')
+    result = parse( <<-'END', :a, 'a' )
       grammar TokenListLabelRuleRoot;
       options {language=Ruby;output=AST;}
       a : id+=ID^ ;
@@ -692,7 +692,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "token with a list `+=' label trashed with `!'" do
-    result = parse(<<-'END', :a, 'a')
+    result = parse( <<-'END', :a, 'a' )
       grammar TokenListLabelBang;
       options {language=Ruby;output=AST;}
       a : id+=ID! ;
@@ -705,7 +705,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "using list `+=' labels to collect trees of invoked rules" do
-    result = parse(<<-'END', :a, 'a b')
+    result = parse( <<-'END', :a, 'a b' )
       grammar RuleListLabel;
       options {language=Ruby;output=AST;}
       a returns [result]: x+=b x+=b {
@@ -722,7 +722,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "using a list `+=' label to collect the trees of invoked rules within a (...)+ block" do
-    result = parse(<<-'END', :a, 'a b')
+    result = parse( <<-'END', :a, 'a b' )
       grammar RuleListLabelRuleRoot;
       options {language=Ruby;output=AST;}
       a returns [result] : ( x+=b^ )+ {
@@ -738,7 +738,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "trashing the tree of an invoked rule with `!' while collecting the tree with a list `+=' label" do
-    result = parse(<<-'END', :a, 'a b')
+    result = parse( <<-'END', :a, 'a b' )
       grammar RuleListLabelBang;
       options {language=Ruby;output=AST;}
       a returns [result] : x+=b! x+=b {
@@ -754,7 +754,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "a whole bunch of different elements" do
-    result = parse(<<-'END', :a, 'a b b c c d')
+    result = parse( <<-'END', :a, 'a b b c c d' )
       grammar ComplicatedMelange;
       options {language=Ruby;output=AST;}
       a : A b=B b=B c+=C c+=C D {s = $D.text} ;
@@ -768,7 +768,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "rule return values in addition to AST output" do
-    result = parse(<<-'END', :a, 'abc 34')
+    result = parse( <<-'END', :a, 'abc 34' )
       grammar ReturnValueWithAST;
       options {language=Ruby;output=AST;}
       a returns [result] : ID b { $result = $b.i.to_s + "\n" } ;
@@ -782,7 +782,7 @@ class TestAutoAST < ANTLR3::Test::Functional
   end
   
   example "a (...)+ loop containing a token-type set" do
-    result = parse(<<-'END', :r, 'abc 34 d')
+    result = parse( <<-'END', :r, 'abc 34 d' )
       grammar SetLoop;
       options { language=Ruby;output=AST; }
       r : (INT|ID)+ ;