antlr3 1.7.5 → 1.8.0

data/test/functional/debugging/profile-mode.rb

@@ -6,7 +6,7 @@ require 'antlr3/test/functional'
 class TestProfileMode < ANTLR3::Test::Functional
   compile_options :profile => true
   
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar SimpleC;
     
     options { language = Ruby; }
@@ -108,7 +108,7 @@ class TestProfileMode < ANTLR3::Test::Functional
   END
   
   example 'profile mode output' do
-    input = <<-END.fixed_indent(0)
+    input = <<-END.fixed_indent( 0 )
       char c;
       int x;
       
@@ -123,9 +123,9 @@ class TestProfileMode < ANTLR3::Test::Functional
       }
     END
     
-    lexer = SimpleC::Lexer.new(input)
-    tokens = ANTLR3::CommonTokenStream.new(lexer)
-    parser = SimpleC::Parser.new(tokens)
+    lexer = SimpleC::Lexer.new( input )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = SimpleC::Parser.new( tokens )
     parser.program
     
     profile_data = parser.profile
@@ -162,4 +162,4 @@ class TestProfileMode < ANTLR3::Test::Functional
   end
   
   
-end
+end

data/test/functional/debugging/rule-tracing.rb

@@ -5,7 +5,7 @@ require 'antlr3/test/functional'
 
 class TestRuleTracing < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar Traced;
     options {
       language = Ruby;
@@ -56,19 +56,18 @@ class TestRuleTracing < ANTLR3::Test::Functional
   compile_options :trace => true
   
   example "setting up rule tracing" do
-    lexer = Traced::Lexer.new('< 1 + 2 + 3 >')
+    lexer = Traced::Lexer.new( '< 1 + 2 + 3 >' )
     parser = Traced::Parser.new lexer
     parser.a
-    lexer.traces.should == [
+    lexer.traces.should == [ 
             '>t__6!', '<t__6!', '>ws!', '<ws!', '>int!', '<int!', '>ws!', '<ws!',
             '>t__8!', '<t__8!', '>ws!', '<ws!', '>int!', '<int!', '>ws!', '<ws!',
             '>t__8!', '<t__8!', '>ws!', '<ws!', '>int!', '<int!', '>ws!', '<ws!',
             '>t__7!', '<t__7!'
     ]
-    parser.traces.should == [
+    parser.traces.should == [ 
       '>a', '>synpred1_Traced', '<synpred1_Traced',
       '>b', '>c', '<c', '>c', '<c', '>c', '<c', '<b', '<a'
     ]
   end
 end
-

data/test/functional/delegation/import.rb

@@ -5,16 +5,16 @@ require 'antlr3/test/functional'
 
 class TestImportedGrammars < ANTLR3::Test::Functional
   
-  def load(grammar)
+  def load( grammar )
     grammar.compile
-    $:.unshift(grammar.output_directory) unless $:.include?(grammar.output_directory)
-    for file in grammar.target_files(false)
-      require File.basename(file, '.rb')
+    $:.unshift( grammar.output_directory ) unless $:.include?( grammar.output_directory )
+    for file in grammar.target_files( false )
+      require File.basename( file, '.rb' )
     end
   end
   
   example 'delegator invokes delegate rule' do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar DIDRSlave;
       options { language=Ruby; }
       @members {
@@ -24,7 +24,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       }
       a : B { capture("S.a") } ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       grammar DIDRMaster;
       options { language=Ruby; }
       import DIDRSlave;
@@ -44,7 +44,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
   end
   
   example 'delegator invokes delegate rule with args' do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave2;
       options {
           language=Ruby;
@@ -56,7 +56,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       }
       a[x] returns [y] : B {capture("S.a"); $y="1000";} ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       grammar Master2;
       options {language=Ruby;}
       import Slave2;
@@ -75,7 +75,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
   end
   
   example "delegator accesses delegate members" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave3;
       options {
           language=Ruby;
@@ -91,7 +91,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       }
       a : B ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       grammar Master3;
       options {
         language=Ruby;
@@ -109,7 +109,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
   end
   
   example "delegator invokes first version of delegate rule" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave4A;
       options {
           language=Ruby;
@@ -122,7 +122,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       a : b {capture("S.a")} ;
       b : B ;
     END
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave4B;
       options {
         language=Ruby;
@@ -134,7 +134,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       }
       a : B {capture("T.a")} ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       grammar Master4;
       options {
         language=Ruby;
@@ -152,7 +152,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
   end
   
   example "delegates see same token type" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave5A; // A, B, C token type order
       options {
         language=Ruby;
@@ -165,7 +165,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       }
       x : A {capture("S.x ")} ;
     END
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave5B;
       options {
         language=Ruby;
@@ -178,7 +178,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       }
       y : A {capture("T.y")} ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       grammar Master5;
       options {
           language=Ruby;
@@ -200,7 +200,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
   end
   
   example "delegator rule overrides delegate" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave6;
       options {
           language=Ruby;
@@ -213,7 +213,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       a : b {capture("S.a")} ;
       b : B ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       grammar Master6;
       options { language=Ruby; }
       import Slave6;
@@ -228,7 +228,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
   end
   
   example "lexer delegator invokes delegate rule" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       lexer grammar Slave7;
       options {
         language=Ruby;
@@ -241,7 +241,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       A : 'a' {capture("S.A ")} ;
       C : 'c' ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       lexer grammar Master7;
       options {
         language=Ruby;
@@ -253,12 +253,12 @@ class TestImportedGrammars < ANTLR3::Test::Functional
     END
     
     lexer = Master7::Lexer.new( 'abc' )
-    lexer.map { |tk| lexer.capture(tk.text) }
+    lexer.map { |tk| lexer.capture( tk.text ) }
     lexer.output.should == 'S.A abc'
   end
   
   example "lexer delegator rule overrides delegate" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       lexer grammar Slave8;
       options {language=Ruby;}
       @members {
@@ -268,7 +268,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       }
       A : 'a' {capture("S.A")} ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       lexer grammar Master8;
       options {language=Ruby;}
       import Slave8;
@@ -277,13 +277,13 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       WS : (' '|'\n') {skip} ;
     END
     
-    lexer = Master8::Lexer.new('a')
-    lexer.map { |tk| lexer.capture(tk.text) }
+    lexer = Master8::Lexer.new( 'a' )
+    lexer.map { |tk| lexer.capture( tk.text ) }
     lexer.output.should == 'M.A a'
   end
 
   example "delegator rule with syntactic predicates" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       parser grammar Slave9;
       options { language=Ruby; }
       @members {
@@ -296,7 +296,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
         | ('c' 'c')=> 'c'
         ;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       grammar Master9;
       options { language=Ruby; }
       import Slave9;
@@ -313,7 +313,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
   end
   
   example "lots of imported lexers" do
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       lexer grammar SlaveOfSlaves;
       options { language=Ruby; }
       
@@ -321,7 +321,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       FLOAT: INTEGER '.' DIGITS (('e'|'E') INTEGER)?;
       fragment DIGITS: ('0'..'9')+;
     END
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       lexer grammar FirstSlave;
       options { language=Ruby; }
       
@@ -330,14 +330,14 @@ class TestImportedGrammars < ANTLR3::Test::Functional
       ID: ('A'..'Z')+;
       OPS: '+' | '-' | '*' | '/';
     END
-    inline_grammar(<<-'END')
+    inline_grammar( <<-'END' )
       lexer grammar SecondSlave;
       options { language=Ruby; }
       
       INT: ('0'..'9')+;
       ID: ('a'..'z'|'A'..'Z'|'_')+;
     END
-    load inline_grammar(<<-'END')
+    load inline_grammar( <<-'END' )
       lexer grammar MasterOfAll;
       options { language=Ruby; }
       
@@ -371,7 +371,7 @@ class TestImportedGrammars < ANTLR3::Test::Functional
     master.first_slave.slave_of_slaves.should respond_to :first_slave
     master.first_slave.slave_of_slaves.should respond_to :master_of_all
     dels = master.each_delegate.map { |d| d }
-    dels.should have(2).things
+    dels.should have( 2 ).things
     dels.should include master.first_slave
     dels.should include master.second_slave
   end

data/test/functional/lexer/basic.rb

@@ -3,7 +3,7 @@
 require 'antlr3/test/functional'
 
 class LexerTest001 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Zero;
     options {
       language = Ruby;
@@ -15,7 +15,7 @@ class LexerTest001 < ANTLR3::Test::Functional
   END
   
   example %(lexing '0') do
-    lexer = Zero::Lexer.new('0')
+    lexer = Zero::Lexer.new( '0' )
     
     token = lexer.next_token
     token.name.should == 'ZERO'
@@ -25,18 +25,18 @@ class LexerTest001 < ANTLR3::Test::Functional
   end
   
   example %(iterating over tokens) do
-    lexer = Zero::Lexer.new('0')
+    lexer = Zero::Lexer.new( '0' )
     
     token_types = lexer.map { |token| token.name }
     token_types.should == %w(ZERO)
   end
 
   example "mismatched token" do
-    lexer = Zero::Lexer.new('1')
+    lexer = Zero::Lexer.new( '1' )
     
-    proc {
+    proc { 
       token = lexer.next_token
-    }.should raise_error(ANTLR3::Error::MismatchedToken) do |e|
+    }.should raise_error( ANTLR3::Error::MismatchedToken ) do |e|
       e.expecting.should == '0'
       e.unexpected_type.should == '1'
     end
@@ -44,7 +44,7 @@ class LexerTest001 < ANTLR3::Test::Functional
 end
 
 class LexerTest002 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Binary;
     options {
       language = Ruby;
@@ -73,7 +73,7 @@ class LexerTest002 < ANTLR3::Test::Functional
     lexer = Binary::Lexer.new( '2' )
     
     b = lambda { token = lexer.next_token }
-    b.should raise_error(ANTLR3::Error::NoViableAlternative) do |exc|
+    b.should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc|
       exc.unexpected_type.should == '2'
     end
   end
@@ -81,7 +81,7 @@ class LexerTest002 < ANTLR3::Test::Functional
 end
 
 class LexerTest003 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar BinaryFooze;
     options {
       language = Ruby;
@@ -114,7 +114,7 @@ class LexerTest003 < ANTLR3::Test::Functional
     lexer = BinaryFooze::Lexer.new( '2' )
     
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::NoViableAlternative) do |exc|
+    should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc|
       exc.unexpected_type.should == '2'
     end
   end
@@ -122,7 +122,7 @@ end
 
 
 class LexerTest004 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar FooStar;
     options {
       language = Ruby;
@@ -168,7 +168,7 @@ class LexerTest004 < ANTLR3::Test::Functional
     lexer = FooStar::Lexer.new( '2' )
     
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::MismatchedToken) do |exc|
+    should raise_error( ANTLR3::Error::MismatchedToken ) do |exc|
       exc.expecting.should == 'f'
       exc.unexpected_type.should == '2'
     end
@@ -176,7 +176,7 @@ class LexerTest004 < ANTLR3::Test::Functional
 end
 
 class LexerTest005 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar FooPlus;
     options {
       language = Ruby;
@@ -216,7 +216,7 @@ class LexerTest005 < ANTLR3::Test::Functional
     lexer = FooPlus::Lexer.new( '2' )
     
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::MismatchedToken) do |exc|
+    should raise_error( ANTLR3::Error::MismatchedToken ) do |exc|
       exc.expecting.should == 'f'
       exc.unexpected_type.should == '2'
     end
@@ -226,7 +226,7 @@ class LexerTest005 < ANTLR3::Test::Functional
     lexer = FooPlus::Lexer.new( 'f' )
     
     proc { token = lexer.next_token }.
-    should raise_error(ANTLR3::Error::EarlyExit) { |exc|
+    should raise_error( ANTLR3::Error::EarlyExit ) { |exc|
       exc.unexpected_type.should == ANTLR3::Constants::EOF
     }
   end
@@ -234,7 +234,7 @@ class LexerTest005 < ANTLR3::Test::Functional
 end
 
 class LexerTest006 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar FoaStar;
     options {
       language = Ruby;
@@ -270,7 +270,7 @@ class LexerTest006 < ANTLR3::Test::Functional
     lexer.next_token
     lexer.next_token
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::MismatchedToken) do |exc|
+    should raise_error( ANTLR3::Error::MismatchedToken ) do |exc|
       exc.expecting.should == 'f'
       exc.unexpected_type.should == '2'
       exc.column.should == 10
@@ -280,7 +280,7 @@ class LexerTest006 < ANTLR3::Test::Functional
 end
 
 class LexerTest007 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Foab;
     options {
       language = Ruby;
@@ -314,7 +314,7 @@ class LexerTest007 < ANTLR3::Test::Functional
     lexer = Foab::Lexer.new( 'foaboao' )
     
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::EarlyExit) do |exc|
+    should raise_error( ANTLR3::Error::EarlyExit ) do |exc|
       exc.unexpected_type.should == 'o'
       exc.column.should == 6
       exc.line.should == 1
@@ -323,7 +323,7 @@ class LexerTest007 < ANTLR3::Test::Functional
 end
 
 class LexerTest008 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Fa;
     options {
       language = Ruby;
@@ -365,7 +365,7 @@ class LexerTest008 < ANTLR3::Test::Functional
     lexer.next_token
     lexer.next_token
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::MismatchedToken) do |exc|
+    should raise_error( ANTLR3::Error::MismatchedToken ) do |exc|
       exc.unexpected_type.should == 'b'
       exc.column.should == 3
       exc.line.should == 1
@@ -375,7 +375,7 @@ end
 
 
 class LexerTest009 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar Digit;
     options {
       language = Ruby;
@@ -416,7 +416,7 @@ class LexerTest009 < ANTLR3::Test::Functional
     
     lexer.next_token
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::MismatchedRange) do |exc|
+    should raise_error( ANTLR3::Error::MismatchedRange ) do |exc|
       exc.min.should == '0'
       exc.max.should == '9'
       exc.unexpected_type.should == 'a'
@@ -427,7 +427,7 @@ class LexerTest009 < ANTLR3::Test::Functional
 end
 
 class LexerTest010 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar IDsAndSpaces;
     options {
       language = Ruby;
@@ -481,7 +481,7 @@ class LexerTest010 < ANTLR3::Test::Functional
     
     lexer.next_token
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::NoViableAlternative) do |exc|
+    should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc|
       exc.unexpected_type.should == '-'
       exc.column.should == 1
       exc.line.should == 1
@@ -490,7 +490,7 @@ class LexerTest010 < ANTLR3::Test::Functional
 end
 
 class LexerTest011 < ANTLR3::Test::Functional
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     lexer grammar IDsWithAction;
     options {language = Ruby;}
         
@@ -550,7 +550,7 @@ class LexerTest011 < ANTLR3::Test::Functional
     
     lexer.next_token
     proc { lexer.next_token }.
-    should raise_error(ANTLR3::Error::NoViableAlternative) do |exc|
+    should raise_error( ANTLR3::Error::NoViableAlternative ) do |exc|
       exc.unexpected_type.should == '-'
       exc.column.should == 1
       exc.line.should == 1