antlr3 1.7.5 → 1.8.0

data/test/functional/parser/calc.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class TestCalcParser < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TestCalc;
     options { language = Ruby; }
     
@@ -64,12 +64,12 @@ class TestCalcParser < ANTLR3::Test::Functional
     WS: (' ' | '\n' | '\t')+ {$channel = HIDDEN};
   END
   
-  def evaluate(expression)
+  def evaluate( expression )
     lexer  = TestCalc::Lexer.new( expression )
     parser = TestCalc::Parser.new lexer
     value = parser.evaluate
     errors = parser.reported_errors
-    return [value, errors]
+    return [ value, errors ]
   end
   
   tests = %[
@@ -77,14 +77,14 @@ class TestCalcParser < ANTLR3::Test::Functional
     1 + 2 * 3        = 7
     10 / 2           = 5
     6 + 2*(3+1) - 4  = 10
-  ].strip!.split(/\n/).map { |line| 
-    expr, val = line.strip.split(/\s+=\s+/, 2)
-    [expr, Integer(val)]
+  ].strip!.split( /\n/ ).map { |line| 
+    expr, val = line.strip.split( /\s+=\s+/, 2 )
+    [ expr, Integer( val ) ]
   }
   
   tests.each do |expression, true_value|
-    example "should parse '#{expression}'" do
-      parser_value, errors = evaluate(expression)
+    example "should parse '#{ expression }'" do
+      parser_value, errors = evaluate( expression )
       parser_value.should == true_value
     end
   end
@@ -92,7 +92,7 @@ class TestCalcParser < ANTLR3::Test::Functional
   example "badly formed input" do
     val, errors = evaluate "6 - (2*1"
     
-    errors.should have(1).thing
+    errors.should have( 1 ).thing
     errors.first.should =~ /mismatched/
   end
 end

data/test/functional/parser/ll-star.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class TestLLStarParser < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar LLStar;
     
     options { language = Ruby; }
@@ -117,7 +117,7 @@ class TestLLStarParser < ANTLR3::Test::Functional
   
   
   example "parsing with a LL(*) grammar" do
-    lexer = LLStar::Lexer.new(<<-'END'.fixed_indent(0))
+    lexer = LLStar::Lexer.new( <<-'END'.fixed_indent( 0 ) )
       char c;
       int x;
       
@@ -134,7 +134,7 @@ class TestLLStarParser < ANTLR3::Test::Functional
     parser = LLStar::Parser.new lexer
     
     parser.program
-    parser.output.should == <<-'END'.fixed_indent(0)
+    parser.output.should == <<-'END'.fixed_indent( 0 )
       bar is a declaration
       foo is a definition
     END

data/test/functional/parser/nuances.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestEmptyAlternative < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar EmptyAlt;
     options {
       language = Ruby;
@@ -34,7 +34,7 @@ end
 
 class TestSubrulePrediction < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar Subrule;
     options {
       language = Ruby;
@@ -65,7 +65,7 @@ end
 
 class TestSpecialStates < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar SpecialStates;
     options { language = Ruby; }
     
@@ -121,7 +121,7 @@ end
 
 class TestDFABug < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar DFABug;
     options {
         language = Ruby;
@@ -162,4 +162,3 @@ class TestDFABug < ANTLR3::Test::Functional
   end
   
 end
-

data/test/functional/parser/predicates.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestPredicateHoist < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TestHoist;
     options {
         language = Ruby;
@@ -68,7 +68,7 @@ end
 
 class TestSyntacticPredicate < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar SyntacticPredicate;
     options {
       language = Ruby;
@@ -95,9 +95,8 @@ class TestSyntacticPredicate < ANTLR3::Test::Functional
   END
   
   example "rule with syntactic predicate" do
-    lexer = SyntacticPredicate::Lexer.new('   +foo>')
+    lexer = SyntacticPredicate::Lexer.new( '   +foo>' )
     parser = SyntacticPredicate::Parser.new lexer
     events = parser.a
   end
 end
-

data/test/functional/parser/properties.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestRulePropertyReference < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RuleProperties;
     options { language = Ruby; }
     
@@ -52,7 +52,7 @@ end
 
 class TestLabels < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar Labels;
     options { language = Ruby; }
     
@@ -88,13 +88,13 @@ class TestLabels < ANTLR3::Test::Functional
     parser = Labels::Parser.new lexer
     ids, w = parser.a
     
-    ids.should have(6).things
-    ids[0].text.should == 'a'
-    ids[1].text.should == 'b'
-    ids[2].text.should == 'c'
-    ids[3].text.should == '1'
-    ids[4].text.should == '2'
-    ids[5].text.should == 'A'
+    ids.should have( 6 ).things
+    ids[ 0 ].text.should == 'a'
+    ids[ 1 ].text.should == 'b'
+    ids[ 2 ].text.should == 'c'
+    ids[ 3 ].text.should == '1'
+    ids[ 4 ].text.should == '2'
+    ids[ 5 ].text.should == 'A'
     
     w.text.should == 'GNU1'
   end
@@ -105,7 +105,7 @@ end
 
 class TestTokenLabelReference < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TokenLabels;
     options {
       language = Ruby;
@@ -162,7 +162,7 @@ class TestTokenLabelReference < ANTLR3::Test::Functional
     lexer = TokenLabels::Lexer.new( '   a' )
     parser = TokenLabels::Parser.new lexer
     tk = parser.a
-    tk.should == [
+    tk.should == [ 
       'a', TokenLabels::TokenData::A, 'A',
       1, 3, 1, :default
     ]
@@ -173,7 +173,7 @@ end
 
 class TestRuleLabelReference < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RuleLabelReference;
     options {language = Ruby;}
     
@@ -224,7 +224,7 @@ end
 
 class TestReferenceDoesntSetChannel < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar ReferenceSetChannel;
     options {language=Ruby;}
     a returns [foo]: A EOF { $foo = '\%s, channel=\%p' \% [$A.text, $A.channel]; } ;
@@ -234,7 +234,7 @@ class TestReferenceDoesntSetChannel < ANTLR3::Test::Functional
   END
 
   example 'verifying that a token reference does not set its channel' do
-    lexer = ReferenceSetChannel::Lexer.new("- 34")
+    lexer = ReferenceSetChannel::Lexer.new( "- 34" )
     parser = ReferenceSetChannel::Parser.new lexer
     parser.a.should == "- 34, channel=:default"
   end

data/test/functional/parser/rule-methods.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestParameters < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar Parameters;
     options {
       language = Ruby;
@@ -54,7 +54,7 @@ end
 
 class TestMultipleReturnValues < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar MultipleReturnValues;
     options { language = Ruby; }
     @parser::members {
@@ -109,7 +109,7 @@ end
 
 
 class TestRuleVisibility < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RuleVisibility;
     options { language=Ruby; }
     
@@ -123,10 +123,11 @@ class TestRuleVisibility < ANTLR3::Test::Functional
   END
   
   example 'using visibility modifiers on rules' do
-    RuleVisibility::Parser.public_instance_methods.should include('a')
-    RuleVisibility::Parser.protected_instance_methods.should include('c')
-    RuleVisibility::Parser.private_instance_methods.should include('b')
+    mname = RUBY_VERSION =~ /^1\.9/ ? proc { | n | n.to_sym } : proc { | n | n.to_s }
+    
+    RuleVisibility::Parser.public_instance_methods.should include( mname[ 'a' ] )
+    RuleVisibility::Parser.protected_instance_methods.should include( mname[ 'c' ] )
+    RuleVisibility::Parser.private_instance_methods.should include( mname[ 'b' ] )
   end
 
 end
-

data/test/functional/parser/scopes.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestScopes1 < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar SimpleScope;
     
     options {
@@ -34,7 +34,7 @@ class TestScopes1 < ANTLR3::Test::Functional
 end
 
 class TestScopes2 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar LotsaScopes;
     
     options {
@@ -175,25 +175,25 @@ class TestScopes2 < ANTLR3::Test::Functional
   END
 
   example "parsing 'foobar' with rule a" do
-    lexer = LotsaScopes::Lexer.new("foobar")
+    lexer = LotsaScopes::Lexer.new( "foobar" )
     parser = LotsaScopes::Parser.new lexer
     parser.a
   end
   
   example "failing to parse 'foobar' with rule b[false]" do
-    lexer = LotsaScopes::Lexer.new("foobar")
+    lexer = LotsaScopes::Lexer.new( "foobar" )
     parser = LotsaScopes::Parser.new lexer
-    proc { parser.b(false) }.should raise_error(ANTLR3::RecognitionError)
+    proc { parser.b( false ) }.should raise_error( ANTLR3::RecognitionError )
   end
   
   example "parsing 'foobar' with rule b[true]" do
-    lexer = LotsaScopes::Lexer.new("foobar")
+    lexer = LotsaScopes::Lexer.new( "foobar" )
     parser = LotsaScopes::Parser.new lexer
-    parser.b(true)
+    parser.b( true )
   end
   
   example "parsing a decl block with rule c" do
-    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    lexer = LotsaScopes::Lexer.new( <<-END.here_indent! )
     | {
     |     int i;
     |     int j;
@@ -203,13 +203,13 @@ class TestScopes2 < ANTLR3::Test::Functional
     parser = LotsaScopes::Parser.new lexer
 
     symbols = parser.c
-    symbols.should have(2).things
+    symbols.should have( 2 ).things
     symbols.should include 'i'
     symbols.should include 'j'
   end
   
   example "failing to parse undeclared symbols with rule c" do
-    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    lexer = LotsaScopes::Lexer.new( <<-END.here_indent! )
     | {
     |     int i;
     |     int j;
@@ -223,7 +223,7 @@ class TestScopes2 < ANTLR3::Test::Functional
   end
   
   example "parsing nested declaration blocks" do
-    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    lexer = LotsaScopes::Lexer.new( <<-END.here_indent! )
     | {
     |     int i;
     |     int j;
@@ -238,13 +238,13 @@ class TestScopes2 < ANTLR3::Test::Functional
     parser = LotsaScopes::Parser.new lexer
 
     symbols = parser.d 
-    symbols.should have(2).things
+    symbols.should have( 2 ).things
     symbols.should include 'i'
     symbols.should include 'j'
   end
   
   example "parsing a deeply nested set of blocks with rule e" do
-    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    lexer = LotsaScopes::Lexer.new( <<-END.here_indent! )
     | { { { { 12 } } } }
     END
 
@@ -253,7 +253,7 @@ class TestScopes2 < ANTLR3::Test::Functional
   end
   
   example "parsing a deeply nested set of blocks with rule f" do
-    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    lexer = LotsaScopes::Lexer.new( <<-END.here_indent! )
     | { { { { 12 } } } }
     END
 
@@ -262,7 +262,7 @@ class TestScopes2 < ANTLR3::Test::Functional
   end
   
   example "parsing a 2-level nested set of blocks with rule f" do
-    lexer = LotsaScopes::Lexer.new(<<-END.here_indent!)
+    lexer = LotsaScopes::Lexer.new( <<-END.here_indent! )
     | { { 12 } }
     END
     parser = LotsaScopes::Parser.new lexer
@@ -271,4 +271,3 @@ class TestScopes2 < ANTLR3::Test::Functional
   end
 
 end
-

data/test/functional/template-output/template-output.rb

@@ -401,4 +401,4 @@ class TestTemplateOutput < ANTLR3::Test::Functional
     tree_parser.prog
     tokens.render.should == expected
   end
-end
+end

data/test/functional/token-rewrite/basic.rb

@@ -4,7 +4,7 @@
 require 'antlr3/test/functional'
 
 class TestRewritingLexerOutputDirectly < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar SimpleRewriting;
     options {
         language = Ruby;
@@ -15,23 +15,23 @@ class TestRewritingLexerOutputDirectly < ANTLR3::Test::Functional
     C: 'c';
   END
   
-  def rewrite(input, expected)
-    lexer = SimpleRewriting::Lexer.new(input)
-    tokens = ANTLR3::TokenRewriteStream.new(lexer)
-    yield(tokens)
+  def rewrite( input, expected )
+    lexer = SimpleRewriting::Lexer.new( input )
+    tokens = ANTLR3::TokenRewriteStream.new( lexer )
+    yield( tokens )
     tokens.render.should == expected
-    return(tokens)
+    return( tokens )
   end
 
   example 'insert before' do
     rewrite( 'abc', '0abc' ) do |stream|
-      stream.insert_before(0, '0')
+      stream.insert_before( 0, '0' )
     end
   end
   
   example 'insert after last index' do
     rewrite( 'abc', 'abcx' ) do |stream|
-      stream.insert_after(2, 'x')
+      stream.insert_after( 2, 'x' )
     end
   end
   
@@ -44,7 +44,7 @@ class TestRewritingLexerOutputDirectly < ANTLR3::Test::Functional
   
   example 'replace index 0' do
     rewrite( 'abc', 'xbc' ) do |stream|
-      stream.replace(0, 'x')
+      stream.replace( 0, 'x' )
     end
   end
   
@@ -56,7 +56,7 @@ class TestRewritingLexerOutputDirectly < ANTLR3::Test::Functional
   
   example 'replace last index' do
     rewrite( 'abc', 'abx' ) do |stream|
-      stream.replace(2, 'x')
+      stream.replace( 2, 'x' )
     end
   end
   
@@ -97,129 +97,129 @@ class TestRewritingLexerOutputDirectly < ANTLR3::Test::Functional
   
   example 'insert middle index' do
     rewrite( "abc", "ayxbc" ) do |stream|
-      stream.insert_before(1, "x")
-      stream.insert_before(1, "y")
+      stream.insert_before( 1, "x" )
+      stream.insert_before( 1, "y" )
     end
   end
   
   example 'insert then replace index0' do
     rewrite( "abc", "zbc" ) do |stream|
-      stream.insert_before(0, "x")
-      stream.insert_before(0, "y")
-      stream.replace(0, "z")
+      stream.insert_before( 0, "x" )
+      stream.insert_before( 0, "y" )
+      stream.replace( 0, "z" )
     end
   end
   
   example 'replace then insert before last index' do
     rewrite( "abc", "abyx" ) do |stream|
-      stream.replace(2, "x")
-      stream.insert_before(2, "y")
+      stream.replace( 2, "x" )
+      stream.insert_before( 2, "y" )
     end
   end
   
   example 'insert then replace last index' do
     rewrite( "abc", "abx" ) do |stream|
-      stream.insert_before(2, "y")
-      stream.replace(2, "x")
+      stream.insert_before( 2, "y" )
+      stream.replace( 2, "x" )
     end
   end
   
   example 'replace then insert after last index' do
     rewrite( "abc", "abxy" ) do |stream|
-      stream.replace(2, "x")
-      stream.insert_after(2, "y")
+      stream.replace( 2, "x" )
+      stream.insert_after( 2, "y" )
     end
   end
   
   example 'replace range then insert at left edge' do
     rewrite( "abcccba", "abyxba" ) do |stream|
-      stream.replace(2, 4, "x")
-      stream.insert_before(2, "y")
+      stream.replace( 2, 4, "x" )
+      stream.insert_before( 2, "y" )
     end
   end
   
   example 'replace range then insert after right edge' do
     rewrite( "abcccba", "abxyba" ) do |stream|
-      stream.replace(2, 4, "x")
-      stream.insert_after(4, "y")
+      stream.replace( 2, 4, "x" )
+      stream.insert_after( 4, "y" )
     end
   end
   
   example 'replace all' do
     rewrite( "abcccba", "x" ) do |stream|
-      stream.replace(0, 6, "x")
+      stream.replace( 0, 6, "x" )
     end
   end
   
   example 'replace single middle then overlapping superset' do
     rewrite( "abcba", "fooa" ) do |stream|
-      stream.replace(2, 2, "xyz")
-      stream.replace(0, 3, "foo")
+      stream.replace( 2, 2, "xyz" )
+      stream.replace( 0, 3, "foo" )
     end
   end
   
   example 'combine inserts' do
     rewrite( "abc", "yxabc" ) do |stream|
-      stream.insert_before(0, "x")
-      stream.insert_before(0, "y")
+      stream.insert_before( 0, "x" )
+      stream.insert_before( 0, "y" )
     end
   end
   
   example 'combine3 inserts' do
     rewrite( "abc", "yazxbc" ) do |stream|
-      stream.insert_before(1, "x")
-      stream.insert_before(0, "y")
-      stream.insert_before(1, "z")
+      stream.insert_before( 1, "x" )
+      stream.insert_before( 0, "y" )
+      stream.insert_before( 1, "z" )
     end
   end
   
   example 'disjoint inserts' do
     rewrite( "abc", "zaxbyc" ) do |stream|
-      stream.insert_before(1, "x")
-      stream.insert_before(2, "y")
-      stream.insert_before(0, "z")
+      stream.insert_before( 1, "x" )
+      stream.insert_before( 2, "y" )
+      stream.insert_before( 0, "z" )
     end
   end
   
   example 'leave alone disjoint insert' do
     rewrite( "abcc", "axbfoo" ) do |stream|
-      stream.insert_before(1, "x")
-      stream.replace(2, 3, "foo")
+      stream.insert_before( 1, "x" )
+      stream.replace( 2, 3, "foo" )
     end
   end
   
   example 'leave alone disjoint insert2' do
     rewrite( "abcc", "axbfoo" ) do |stream|
-      stream.replace(2, 3, "foo")
-      stream.insert_before(1, "x")
+      stream.replace( 2, 3, "foo" )
+      stream.insert_before( 1, "x" )
     end
   end
   
   example 'combine insert on left with delete' do
     rewrite( "abc", "z" ) do |stream|
-      stream.delete(0, 2)
-      stream.insert_before(0, "z")
+      stream.delete( 0, 2 )
+      stream.insert_before( 0, "z" )
     end
   end
   
   example 'overlapping replace' do
     rewrite( "abcc", "bar" ) do |stream|
-      stream.replace(1, 2, "foo")
-      stream.replace(0, 3, "bar")
+      stream.replace( 1, 2, "foo" )
+      stream.replace( 0, 3, "bar" )
     end
   end
   
   example 'overlapping replace3' do
     rewrite( "abcc", "barc" ) do |stream|
-      stream.replace(1, 2, "foo")
-      stream.replace(0, 2, "bar")
+      stream.replace( 1, 2, "foo" )
+      stream.replace( 0, 2, "bar" )
     end
   end
   
   example 'overlapping replace 4' do
     rewrite( "abcc", "abar" ) do |stream|
-      stream.replace(1, 2, "foo")
-      stream.replace(1, 3, "bar")
+      stream.replace( 1, 2, "foo" )
+      stream.replace( 1, 3, "bar" )
     end
   end
 
@@ -286,9 +286,9 @@ class TestRewritingWithTokenStream2 < ANTLR3::Test::Functional
     WS : ' '+;
   END
   
-  def rewrite(input)
-    lexer = SimpleRewriting2::Lexer.new(input)
-    ANTLR3::TokenRewriteStream.new(lexer)
+  def rewrite( input )
+    lexer = SimpleRewriting2::Lexer.new( input )
+    ANTLR3::TokenRewriteStream.new( lexer )
   end
   
   example 'rendering over a range' do
@@ -296,8 +296,8 @@ class TestRewritingWithTokenStream2 < ANTLR3::Test::Functional
     stream.replace 4, 8, '0'
     stream.original_string.should == 'x = 3 * 0;'
     stream.render.should == 'x = 0;'
-    stream.render(0, 9).should == 'x = 0;'
-    stream.render(4, 8).should == '0'
+    stream.render( 0, 9 ).should == 'x = 0;'
+    stream.render( 4, 8 ).should == '0'
   end
   
   example 'more rendering over a range' do
@@ -305,14 +305,13 @@ class TestRewritingWithTokenStream2 < ANTLR3::Test::Functional
     stream.original_string.should == 'x = 3 * 0 + 2 * 0;'
     stream.replace 4, 8, '0'
     stream.render.should == 'x = 0 + 2 * 0;'
-    stream.render(0, 17).should == 'x = 0 + 2 * 0;'
-    stream.render(4, 8).should  == '0'
-    stream.render(0, 8).should  == 'x = 0'
-    stream.render(12, 16).should == '2 * 0'
-    stream.insert_after(17, '// comment')
-    stream.render(12, 17).should == '2 * 0;// comment'
-    stream.render(0, 8).should == 'x = 0'
+    stream.render( 0, 17 ).should == 'x = 0 + 2 * 0;'
+    stream.render( 4, 8 ).should  == '0'
+    stream.render( 0, 8 ).should  == 'x = 0'
+    stream.render( 12, 16 ).should == '2 * 0'
+    stream.insert_after( 17, '// comment' )
+    stream.render( 12, 17 ).should == '2 * 0;// comment'
+    stream.render( 0, 8 ).should == 'x = 0'
   end
 
 end
-