antlr3 1.7.5 → 1.8.0

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

@@ -370,20 +370,20 @@ class TestASTConstructingParser < ANTLR3::Test::Functional
     WS: (' ' | '\n' | '\t')+ {$channel = HIDDEN;};
   END
   
-  def self.ast_test(opts, &special_test)
-    input = opts[:input]
-    rule  = opts[:rule]
-    expected_tree = opts[:ast]
-    flag = opts[:flag]
-    args = opts[:arguments] || []
-    message = opts[:message] || rule.to_s #"should parse %p with rule %s and make tree %s" % [input, rule, expected_tree]
-    
-    example(message) do
+  def self.ast_test( opts, &special_test )
+    input = opts[ :input ]
+    rule  = opts[ :rule ]
+    expected_tree = opts[ :ast ]
+    flag = opts[ :flag ]
+    args = opts[ :arguments ] || []
+    message = opts[ :message ] || rule.to_s #"should parse %p with rule %s and make tree %s" % [input, rule, expected_tree]
+    
+    example( message ) do
       lexer = ASTBuilder::Lexer.new( input )
       parser = ASTBuilder::Parser.new( lexer )
       parser.flag = flag unless flag.nil?
-      result = parser.send(rule, *args)
-      if special_test then instance_exec(result, &special_test)
+      result = parser.send( rule, *args )
+      if special_test then instance_exec( result, &special_test )
       elsif expected_tree then
         result.tree.inspect.should == expected_tree
       else result.tree.should be_nil
@@ -477,11 +477,11 @@ class TestASTConstructingParser < ANTLR3::Test::Functional
   
   ast_test :input => "public int gnurz = 1 + 2;", :rule => :r31, :ast => "(FIELD gnurz public int (+ 1 2))", :flag => 2
   
-  ast_test :input => 'gnurz 32', :rule => :r32, :arguments => [1], :flag => 2, :ast => 'gnurz'
+  ast_test :input => 'gnurz 32', :rule => :r32, :arguments => [ 1 ], :flag => 2, :ast => 'gnurz'
   
-  ast_test :input => 'gnurz 32', :rule => :r32, :arguments => [2], :flag => 2, :ast => '32'
+  ast_test :input => 'gnurz 32', :rule => :r32, :arguments => [ 2 ], :flag => 2, :ast => '32'
   
-  ast_test :input => 'gnurz', :rule => :r32, :arguments => [3], :flag => 2, :ast => nil
+  ast_test :input => 'gnurz', :rule => :r32, :arguments => [ 3 ], :flag => 2, :ast => nil
   
   ast_test :input => "public private fooze", :rule => :r33, :ast => "fooze"
   
@@ -552,4 +552,3 @@ class TestASTConstructingParser < ANTLR3::Test::Functional
   ast_test :input => 'a b c fooze', :rule => :r59, :ast => '(a fooze) (b fooze) (c fooze)'
 
 end
-

data/test/functional/ast-output/hetero-nodes.rb

@@ -6,7 +6,7 @@ require 'antlr3/test/functional'
 
 class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar VToken;
     options {
         language=Ruby;
@@ -25,7 +25,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TokenWithQualifiedType;
     options {
         language=Ruby;
@@ -44,7 +44,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TokenWithLabel;
     options {
         language=Ruby;
@@ -63,7 +63,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TokenWithListLabel;
     options {
         language=Ruby;
@@ -82,7 +82,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TokenRoot;
     options {
         language=Ruby;
@@ -102,7 +102,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TokenRootWithListLabel;
     options {
         language=Ruby;
@@ -122,7 +122,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar FromString;
     options {
         language=Ruby;
@@ -142,7 +142,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar StringRoot;
     options {
         language=Ruby;
@@ -162,7 +162,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RewriteToken;
     options {
         language=Ruby;
@@ -182,7 +182,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RewriteTokenWithArgs;
     options {
         language=Ruby;
@@ -215,7 +215,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RewriteTokenRoot;
     options {
         language=Ruby;
@@ -236,7 +236,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RewriteString;
     options {
         language=Ruby;
@@ -256,7 +256,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RewriteStringRoot;
     options {
         language=Ruby;
@@ -277,7 +277,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar RewriteRuleResults;
     options {
         language=Ruby;
@@ -308,7 +308,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar CopySemanticsWithHetero;
     options {
         language=Ruby;
@@ -332,7 +332,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TreeParserRewriteFlatList;
     options {
         language=Ruby;
@@ -345,7 +345,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     tree grammar TreeParserRewriteFlatListWalker;
     options {
         language=Ruby;
@@ -370,7 +370,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TreeParserRewriteTree;
     options {
         language=Ruby;
@@ -383,7 +383,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     tree grammar TreeParserRewriteTreeWalker;
     options {
         language=Ruby;
@@ -409,7 +409,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TreeParserRewriteImaginary;
     options {
         language=Ruby;
@@ -422,7 +422,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     tree grammar TreeParserRewriteImaginaryWalker;
     options {
         language=Ruby;
@@ -443,7 +443,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TreeParserRewriteImaginaryWithArgs;
     options {
         language=Ruby;
@@ -456,7 +456,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     tree grammar TreeParserRewriteImaginaryWithArgsWalker;
     options {
         language=Ruby;
@@ -481,7 +481,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TreeParserRewriteImaginaryRoot;
     options {
         language=Ruby;
@@ -494,7 +494,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     tree grammar TreeParserRewriteImaginaryRootWalker;
     options {
         language=Ruby;
@@ -515,7 +515,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TreeParserRewriteImaginaryFromReal;
     options {
         language=Ruby;
@@ -528,7 +528,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     tree grammar TreeParserRewriteImaginaryFromRealWalker;
     options {
         language=Ruby;
@@ -557,7 +557,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     grammar TreeParserAutoHeteroAST;
     options {
         language=Ruby;
@@ -570,7 +570,7 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
   END
 
 
-  inline_grammar(<<-'END')
+  inline_grammar( <<-'END' )
     tree grammar TreeParserAutoHeteroASTWalker;
     options {
         language=Ruby;
@@ -590,165 +590,162 @@ class TestHeterogeneousNodeTypes < ANTLR3::Test::Functional
     a : ID<V> ';'<V>;
   END
 
-  def parse(grammar_name, grammar_rule, input)
-    grammar_module = self.class.const_get(grammar_name.to_s)
+  def parse( grammar_name, grammar_rule, input )
+    grammar_module = self.class.const_get( grammar_name.to_s )
     lexer  = grammar_module::Lexer.new( input )
     tokens = ANTLR3::CommonTokenStream.new( lexer )
     parser = grammar_module::Parser.new( tokens )
-    r = parser.send(grammar_rule)
+    r = parser.send( grammar_rule )
     
-    return(r.tree.inspect rescue '')
+    return( r.tree.inspect rescue '' )
   end
   
-  def tree_parse(grammar_name, grammar_rule, tree_grammar_rule, input)
-    grammar_module = self.class.const_get(grammar_name.to_s)
-    tree_grammar_module = self.class.const_get(grammar_name.to_s + 'Walker')
+  def tree_parse( grammar_name, grammar_rule, tree_grammar_rule, input )
+    grammar_module = self.class.const_get( grammar_name.to_s )
+    tree_grammar_module = self.class.const_get( grammar_name.to_s + 'Walker' )
     
     lexer  = grammar_module::Lexer.new( input )
     tokens = ANTLR3::CommonTokenStream.new( lexer )
     parser = grammar_module::Parser.new( tokens )
-    r = parser.send(grammar_rule)
+    r = parser.send( grammar_rule )
     
-    nodes = ANTLR3::CommonTreeNodeStream.new(r.tree)
+    nodes = ANTLR3::CommonTreeNodeStream.new( r.tree )
     nodes.token_stream = tokens
-    tree_parser = tree_grammar_module::TreeParser.new(nodes)
-    r = tree_parser.send(tree_grammar_rule)
+    tree_parser = tree_grammar_module::TreeParser.new( nodes )
+    r = tree_parser.send( tree_grammar_rule )
     
-    return(r.tree.inspect rescue '')
+    return( r.tree.inspect rescue '' )
   end
 
   example "v token" do
-    result = parse(:VToken, :a, 'a')
+    result = parse( :VToken, :a, 'a' )
     result.should == 'a<V>'
   end
 
 
   example "token with qualified type" do
-    result = parse(:TokenWithQualifiedType, :a, 'a')
+    result = parse( :TokenWithQualifiedType, :a, 'a' )
     result.should == 'a<V>'
   end
 
 
   example "token with label" do
-    result = parse(:TokenWithLabel, :a, 'a')
+    result = parse( :TokenWithLabel, :a, 'a' )
     result.should == 'a<V>'
   end
 
 
   example "token with list label" do
-    result = parse(:TokenWithListLabel, :a, 'a')
+    result = parse( :TokenWithListLabel, :a, 'a' )
     result.should == 'a<V>'
   end
 
 
   example "token root" do
-    result = parse(:TokenRoot, :a, 'a')
+    result = parse( :TokenRoot, :a, 'a' )
     result.should == 'a<V>'
   end
 
 
   example "token root with list label" do
-    result = parse(:TokenRootWithListLabel, :a, 'a')
+    result = parse( :TokenRootWithListLabel, :a, 'a' )
     result.should == 'a<V>'
   end
 
 
   example "string" do
-    result = parse(:FromString, :a, 'begin')
+    result = parse( :FromString, :a, 'begin' )
     result.should == 'begin<V>'
   end
 
 
   example "string root" do
-    result = parse(:StringRoot, :a, 'begin')
+    result = parse( :StringRoot, :a, 'begin' )
     result.should == 'begin<V>'
   end
 
 
   example "rewrite token" do
-    result = parse(:RewriteToken, :a, 'a')
+    result = parse( :RewriteToken, :a, 'a' )
     result.should == 'a<V>'
   end
 
 
   example "rewrite token with args" do
-    result = parse(:RewriteTokenWithArgs, :a, 'a')
+    result = parse( :RewriteTokenWithArgs, :a, 'a' )
     result.should == '<V>;421930 a<V>;9900'
   end
 
 
   example "rewrite token root" do
-    result = parse(:RewriteTokenRoot, :a, 'a 2')
+    result = parse( :RewriteTokenRoot, :a, 'a 2' )
     result.should == '(a<V> 2)'
   end
 
 
   example "rewrite string" do
-    result = parse(:RewriteString, :a, 'begin')
+    result = parse( :RewriteString, :a, 'begin' )
     result.should == 'begin<V>'
   end
 
 
   example "rewrite string root" do
-    result = parse(:RewriteStringRoot, :a, 'begin 2')
+    result = parse( :RewriteStringRoot, :a, 'begin 2' )
     result.should == '(begin<V> 2)'
   end
 
 
   example "rewrite rule results" do
-    result = parse(:RewriteRuleResults, :a, 'a,b,c')
+    result = parse( :RewriteRuleResults, :a, 'a,b,c' )
     result.should == '(LIST<W> a<V> b<V> c<V>)'
   end
 
 
   example "copy semantics with hetero" do
-    result = parse(:CopySemanticsWithHetero, :a, 'int a, b, c;')
+    result = parse( :CopySemanticsWithHetero, :a, 'int a, b, c;' )
     result.should == '(int<V> a) (int<V> b) (int<V> c)'
   end
 
 
   example "tree parser rewrite flat list" do
-    result = tree_parse(:TreeParserRewriteFlatList, :a, :a, 'abc 34')
+    result = tree_parse( :TreeParserRewriteFlatList, :a, :a, 'abc 34' )
     result.should == '34<V> abc<W>'
   end
 
 
   example "tree parser rewrite tree" do
-    result = tree_parse(:TreeParserRewriteTree, :a, :a, 'abc 34')
+    result = tree_parse( :TreeParserRewriteTree, :a, :a, 'abc 34' )
     result.should == '(34<V> abc<W>)'
   end
 
 
   example "tree parser rewrite imaginary" do
-    result = tree_parse(:TreeParserRewriteImaginary, :a, :a, 'abc')
+    result = tree_parse( :TreeParserRewriteImaginary, :a, :a, 'abc' )
     result.should == 'ROOT<V> abc'
   end
 
 
   example "tree parser rewrite imaginary with args" do
-    result = tree_parse(:TreeParserRewriteImaginaryWithArgs, :a, :a, 'abc')
+    result = tree_parse( :TreeParserRewriteImaginaryWithArgs, :a, :a, 'abc' )
     result.should == 'ROOT<V>;42 abc'
   end
 
 
   example "tree parser rewrite imaginary root" do
-    result = tree_parse(:TreeParserRewriteImaginaryRoot, :a, :a, 'abc')
+    result = tree_parse( :TreeParserRewriteImaginaryRoot, :a, :a, 'abc' )
     result.should == '(ROOT<V> abc)'
   end
 
 
   example "tree parser rewrite imaginary from real" do
-    result = tree_parse(:TreeParserRewriteImaginaryFromReal, :a, :a, 'abc')
+    result = tree_parse( :TreeParserRewriteImaginaryFromReal, :a, :a, 'abc' )
     result.should == 'ROOT<V>@1'
   end
 
 
   example "tree parser auto hetero ast" do
-    result = tree_parse(:TreeParserAutoHeteroAST, :a, :a, 'abc;')
+    result = tree_parse( :TreeParserAutoHeteroAST, :a, :a, 'abc;' )
     result.should == 'abc<V> ;<V>'
   end
 
 end
-
-
-