antlr3 1.2.3

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

@@ -0,0 +1,318 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestRewritingLexerOutputDirectly < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    lexer grammar SimpleRewriting;
+    options {
+        language = Ruby;
+    }
+    
+    A: 'a';
+    B: 'b';
+    C: 'c';
+  END
+  
+  def rewrite(input, expected)
+    lexer = SimpleRewriting::Lexer.new(input)
+    tokens = ANTLR3::TokenRewriteStream.new(lexer)
+    yield(tokens)
+    tokens.render.should == expected
+    return(tokens)
+  end
+
+  example 'insert before' do
+    rewrite( 'abc', '0abc' ) do |stream|
+      stream.insert_before(0, '0')
+    end
+  end
+  
+  example 'insert after last index' do
+    rewrite( 'abc', 'abcx' ) do |stream|
+      stream.insert_after(2, 'x')
+    end
+  end
+  
+  example 'insert before after middle index' do
+    rewrite( 'abc', 'axbxc' ) do |stream|
+      stream.insert_before 1, 'x'
+      stream.insert_after 1, 'x'
+    end
+  end
+  
+  example 'replace index 0' do
+    rewrite( 'abc', 'xbc' ) do |stream|
+      stream.replace(0, 'x')
+    end
+  end
+  
+  example 'replace last index' do
+    rewrite( 'abc', 'abx' ) do |stream|
+      stream.replace 2, 'x'
+    end
+  end
+  
+  example 'replace last index' do
+    rewrite( 'abc', 'abx' ) do |stream|
+      stream.replace(2, 'x')
+    end
+  end
+  
+  example 'replace middle index' do
+    rewrite( 'abc', 'axc' ) do |stream|
+      stream.replace 1, 'x'
+    end
+  end
+  
+  example 'replace middle index' do
+    rewrite( 'abc', 'ayc' ) do |stream|
+      stream.replace 1, 'x'
+      stream.replace 1, 'y'
+    end
+  end
+  
+  example 'replace middle index 1 insert before' do
+    rewrite( 'abc', '_ayc' ) do |stream|
+      stream.insert_before 0, '_'
+      stream.replace 1, 'x'
+      stream.replace 1, 'y'
+    end
+  end
+  
+  example 'replace then delete middle index' do
+    rewrite( 'abc', 'ac' ) do |stream|
+      stream.replace 1, 'x'
+      stream.delete 1
+    end
+  end
+  
+  example 'insert then replace same index' do
+    rewrite 'abc', 'xbc' do |stream|
+      stream.insert_before 0, '0'
+      stream.replace 0, 'x'
+    end
+  end
+  
+  example 'insert middle index' do
+    rewrite( "abc", "ayxbc" ) do |stream|
+      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")
+    end
+  end
+  
+  example 'replace then insert before last index' do
+    rewrite( "abc", "abyx" ) do |stream|
+      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")
+    end
+  end
+  
+  example 'replace then insert after last index' do
+    rewrite( "abc", "abxy" ) do |stream|
+      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")
+    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")
+    end
+  end
+  
+  example 'replace all' do
+    rewrite( "abcccba", "x" ) do |stream|
+      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")
+    end
+  end
+  
+  example 'combine inserts' do
+    rewrite( "abc", "yxabc" ) do |stream|
+      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")
+    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")
+    end
+  end
+  
+  example 'leave alone disjoint insert' do
+    rewrite( "abcc", "axbfoo" ) do |stream|
+      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")
+    end
+  end
+  
+  example 'combine insert on left with delete' do
+    rewrite( "abc", "z" ) do |stream|
+      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")
+    end
+  end
+  
+  example 'overlapping replace3' do
+    rewrite( "abcc", "barc" ) do |stream|
+      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")
+    end
+  end
+
+  example 'overlapping replace 2' do
+    lexer = SimpleRewriting::Lexer.new( 'abcc' )
+    stream = ANTLR3::TokenRewriteStream.new( lexer )
+    stream.replace 0, 3, 'bar'
+    stream.replace 1, 2, 'foo'
+    
+    lambda { stream.render }.
+    should raise_error { |error|
+      error.to_s.should == %q<operation (replace @ 1..2 : "foo") overlaps with previous operation (replace @ 0..3 : "bar")>
+    }
+  end
+  
+  example 'replace range then insert at right edge' do
+    lexer = SimpleRewriting::Lexer.new( 'abcccba' )
+    stream = ANTLR3::TokenRewriteStream.new( lexer )
+    stream.replace 2, 4, 'x'
+    stream.insert_before 4, 'y'
+    lambda { stream.render }.
+    should raise_error { |error|
+      error.to_s.should == %q<operation (insert-before @ 4 : "y") overlaps with previous operation (replace @ 2..4 : "x")>
+    }
+  end
+  
+  example 'replace then replace superset' do
+    lexer = SimpleRewriting::Lexer.new( 'abcccba' )
+    stream = ANTLR3::TokenRewriteStream.new( lexer )
+    stream.replace 2, 4, 'xyz'
+    stream.replace 3, 5, 'foo'
+    lambda { stream.render }.
+    should raise_error { |error|
+      error.to_s.should == %q<operation (replace @ 3..5 : "foo") overlaps with previous operation (replace @ 2..4 : "xyz")>
+    }
+  end
+  
+  example 'replace then replace lower indexed superset' do
+    lexer = SimpleRewriting::Lexer.new( 'abcccba' )
+    stream = ANTLR3::TokenRewriteStream.new( lexer )
+    stream.replace 2, 4, 'xyz'
+    stream.replace 1, 3, 'foo'
+    lambda { stream.render }.
+    should raise_error { |error|
+      error.to_s.should == %q<operation (replace @ 1..3 : "foo") overlaps with previous operation (replace @ 2..4 : "xyz")>
+    }
+  end
+  
+end
+
+class TestRewritingWithTokenStream2 < ANTLR3::Test::Functional
+  inline_grammar( <<-END )
+    lexer grammar SimpleRewriting2;
+    options {
+        language = Ruby;
+    }
+    
+    ID : 'a'..'z'+;
+    INT : '0'..'9'+;
+    SEMI : ';';
+    PLUS : '+';
+    MUL : '*';
+    ASSIGN : '=';
+    WS : ' '+;
+  END
+  
+  def rewrite(input)
+    lexer = SimpleRewriting2::Lexer.new(input)
+    ANTLR3::TokenRewriteStream.new(lexer)
+  end
+  
+  example 'rendering over a range' do
+    stream = rewrite 'x = 3 * 0;'
+    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'
+  end
+  
+  example 'more rendering over a range' do
+    stream = rewrite 'x = 3 * 0 + 2 * 0;'
+    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'
+  end
+
+end
+

data/test/functional/token-rewrite/via-parser.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestRewritingWhileParsing < ANTLR3::Test::Functional
+
+  inline_grammar(<<-'END')
+    grammar TokenRewrites;
+    options { language = Ruby; }
+    
+    program
+    @after {
+      @input.insert_before($start,"public class Wrapper {\n")
+      @input.insert_after($stop, "\n}\n")
+    }
+        :   method+
+        ;
+    
+    method
+        :   m='method' ID '(' ')' body
+            {@input.replace($m, "public void");}
+        ; 
+    
+    body
+    scope {
+        decls
+    }
+    @init {
+        $body::decls = []
+    }
+        :   lcurly='{' stat* '}'
+            {
+            $body::decls.uniq!
+            for it in $body::decls
+              @input.insert_after($lcurly, "\nint "+it+";")
+            end
+            }
+        ;
+    
+    stat:   ID '=' expr ';' {$body::decls << $ID.text.to_s}
+        ;
+    
+    expr:   mul ('+' mul)* 
+        ;
+    
+    mul :   atom ('*' atom)*
+        ;
+    
+    atom:   ID
+        |   INT
+        ;
+    
+    ID  :   ('a'..'z'|'A'..'Z')+ ;
+    
+    INT :   ('0'..'9')+ ;
+    
+    WS  :   (' '|'\t'|'\n')+ {$channel=HIDDEN;}
+        ;
+  END
+
+  example 'using a TokenRewriteStream to rewrite input text while parsing' do
+    input = <<-END.fixed_indent(0)
+      method foo() {
+        i = 3;
+        k = i;
+        i = k*4;
+      }
+      
+      method bar() {
+        j = i*2;
+      }
+    END
+    expected_output = <<-END.fixed_indent(0).strip!
+      public class Wrapper {
+      public void foo() {
+      int k;
+      int i;
+        i = 3;
+        k = i;
+        i = k*4;
+      }
+      
+      public void bar() {
+      int j;
+        j = i*2;
+      }
+      }
+    END
+    
+    lexer = TokenRewrites::Lexer.new( input )
+    tokens = ANTLR3::TokenRewriteStream.new( lexer )
+    parser = TokenRewrites::Parser.new( tokens )
+    parser.program
+    
+    tokens.render.strip.should == expected_output
+  end
+
+end
+

data/test/functional/tree-parser/basic.rb

@@ -0,0 +1,750 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+
+require 'antlr3/test/functional'
+
+class TestTreeParser1 < ANTLR3::Test::Functional
+  
+  example "flat list" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar FlatList;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : ID INT;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar FlatListWalker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ID INT
+          {self.capture("\%s, \%s" \% [$ID, $INT])}
+        ;
+    END
+    
+    lexer  = FlatList::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = FlatList::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = FlatListWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "abc, 34"
+  end
+  
+  example "simple tree" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar SimpleTree;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : ID INT -> ^(ID INT);
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      WS : (' '|'\\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar SimpleTreeWalker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      
+      a : ^(ID INT)
+          {capture('\%s, \%s' \% [$ID, $INT])}
+        ;
+    END
+    lexer  = SimpleTree::Lexer.new( "abc 34" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = SimpleTree::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = SimpleTreeWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "abc, 34"
+  end
+  
+  example "flat vs tree decision" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar FlatVsTreeDecision;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : b c ;
+      b : ID INT -> ^(ID INT);
+      c : ID INT;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      WS : (' '|'\\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar FlatVsTreeDecisionWalker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      
+      a : b b ;
+      b : ID INT    {capture("\%s \%s\n" \% [$ID, $INT])}
+        | ^(ID INT) {capture("^(\%s \%s)" \% [$ID, $INT])}
+        ;
+    END
+    lexer  = FlatVsTreeDecision::Lexer.new( "a 1 b 2" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = FlatVsTreeDecision::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = FlatVsTreeDecisionWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "^(a 1)b 2\n"
+  end
+  
+  example "flat vs tree decision2" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar FlatVsTreeDecision2;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : b c ;
+      b : ID INT+ -> ^(ID INT+);
+      c : ID INT+;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar FlatVsTreeDecision2Walker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : b b ;
+      b : ID INT+    {say("#{$ID} #{$INT}")}
+        | ^(x=ID (y=INT)+) {capture("^(#{$x} #{$y})")}
+        ;
+    END
+    lexer  = FlatVsTreeDecision2::Lexer.new( "a 1 2 3 b 4 5" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = FlatVsTreeDecision2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = FlatVsTreeDecision2Walker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "^(a 3)b 5\n"
+  end
+  
+  example "cyclic dfa lookahead" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar CyclicDFALookahead;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : ID INT+ PERIOD;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      PERIOD : '.' ;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar CyclicDFALookaheadWalker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ID INT+ PERIOD {capture("alt 1")}
+        | ID INT+ SEMI   {capture("alt 2")}
+        ;
+    END
+    lexer  = CyclicDFALookahead::Lexer.new( "a 1 2 3." )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = CyclicDFALookahead::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = CyclicDFALookaheadWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "alt 1"
+  end
+  
+  example "nullable child list" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar NullableChildList;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : ID INT? -> ^(ID INT?);
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      WS : (' '|'\\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar NullableChildListWalker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ^(ID INT?)
+          {capture($ID.to_s)}
+        ;
+    END
+    lexer  = NullableChildList::Lexer.new( "abc" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = NullableChildList::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = NullableChildListWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "abc"
+  end
+  
+  example "nullable child list2" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar NullableChildList2;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : ID INT? SEMI -> ^(ID INT?) SEMI ;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar NullableChildList2Walker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ^(ID INT?) SEMI
+          {capture($ID.to_s)}
+        ;
+    END
+    lexer  = NullableChildList2::Lexer.new( "abc;" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = NullableChildList2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = NullableChildList2Walker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "abc"
+  end
+  
+  example "nullable child list3" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar NullableChildList3;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : x=ID INT? (y=ID)? SEMI -> ^($x INT? $y?) SEMI ;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      WS : (' '|'\\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar NullableChildList3Walker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ^(ID INT? b) SEMI
+          {self.capture($ID.to_s + ", " + $b.text.to_s)}
+        ;
+      b : ID? ;
+    END
+    lexer  = NullableChildList3::Lexer.new( "abc def;" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = NullableChildList3::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = NullableChildList3Walker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "abc, def"
+  end
+  
+  example "actions after root" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar ActionsAfterRoot;
+      options {
+          language=Ruby;
+          output=AST;
+      }
+      a : x=ID INT? SEMI -> ^($x INT?) ;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar ActionsAfterRootWalker;
+      options {
+          language=Ruby;
+          ASTLabelType=CommonTree;
+      }
+      @members { include ANTLR3::Test::CaptureOutput }
+      a @init {x=0} : ^(ID {x=1} {x=2} INT?)
+          {say( $ID.to_s + ", " + x.to_s )}
+        ;
+    END
+    lexer  = ActionsAfterRoot::Lexer.new( "abc;" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = ActionsAfterRoot::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = ActionsAfterRootWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "abc, 2\n"
+  end
+  
+  example "wildcard lookahead" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar WildcardLookahead;
+      options {language=Ruby; output=AST;}
+      a : ID '+'^ INT;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      PERIOD : '.' ;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar WildcardLookaheadWalker;
+      options {language=Ruby; tokenVocab=WildcardLookahead; ASTLabelType=CommonTree;}
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ^('+' . INT) { capture("alt 1") }
+        ;
+    END
+    lexer  = WildcardLookahead::Lexer.new( "a + 2" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardLookahead::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardLookaheadWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "alt 1"
+  end
+  
+  example "wildcard lookahead2" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar WildcardLookahead2;
+      options {language=Ruby; output=AST;}
+      a : ID '+'^ INT;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      PERIOD : '.' ;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar WildcardLookahead2Walker;
+      options {language=Ruby; tokenVocab=WildcardLookahead2; ASTLabelType=CommonTree;}
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ^('+' . INT) { capture("alt 1") }
+        | ^('+' . .)   { capture("alt 2") }
+        ;
+    END
+    lexer  = WildcardLookahead2::Lexer.new( "a + 2" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardLookahead2::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardLookahead2Walker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "alt 1"
+  end
+  
+  example "wildcard lookahead3" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar WildcardLookahead3;
+      options {language=Ruby; output=AST;}
+      a : ID '+'^ INT;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      PERIOD : '.' ;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar WildcardLookahead3Walker;
+      options {language=Ruby; tokenVocab=WildcardLookahead3; ASTLabelType=CommonTree;}
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ^('+' ID INT) { capture("alt 1") }
+        | ^('+' . .)   { capture("alt 2") }
+        ;
+    END
+    lexer  = WildcardLookahead3::Lexer.new( "a + 2" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardLookahead3::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardLookahead3Walker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "alt 1"
+  end
+  
+  example "wildcard plus lookahead" do
+    compile_and_load inline_grammar(<<-'END')
+      grammar WildcardPlusLookahead;
+      options {language=Ruby; output=AST;}
+      a : ID '+'^ INT;
+      ID : 'a'..'z'+ ;
+      INT : '0'..'9'+;
+      SEMI : ';' ;
+      PERIOD : '.' ;
+      WS : (' '|'\n') {$channel=HIDDEN;} ;
+    END
+    compile_and_load inline_grammar(<<-'END')
+      tree grammar WildcardPlusLookaheadWalker;
+      options {language=Ruby; tokenVocab=WildcardPlusLookahead; ASTLabelType=CommonTree;}
+      @members { include ANTLR3::Test::CaptureOutput }
+      a : ^('+' INT INT ) { capture("alt 1") }
+        | ^('+' .+)   { capture("alt 2") }
+        ;
+    END
+    lexer  = WildcardPlusLookahead::Lexer.new( "a + 2" )
+    tokens = ANTLR3::CommonTokenStream.new( lexer )
+    parser = WildcardPlusLookahead::Parser.new( tokens )
+    
+    result = parser.a
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = tokens
+    walker = WildcardPlusLookaheadWalker::TreeParser.new( nodes )
+    walker.a
+    walker.output.should == "alt 2"
+  end
+  
+end
+
+
+class TestTreeParser2 < ANTLR3::Test::Functional
+  inline_grammar(<<-'END')
+    grammar GenericLanguage;
+    options {
+        language = Ruby;
+        output=AST;
+    }
+    
+    tokens {
+        VAR_DEF;
+        ARG_DEF;
+        FUNC_HDR;
+        FUNC_DECL;
+        FUNC_DEF;
+        BLOCK;
+    }
+    
+    program
+        :   declaration+
+        ;
+    
+    declaration
+        :   variable
+        |   functionHeader ';' -> ^(FUNC_DECL functionHeader)
+        |   functionHeader block -> ^(FUNC_DEF functionHeader block)
+        ;
+    
+    variable
+        :   type declarator ';' -> ^(VAR_DEF type declarator)
+        ;
+    
+    declarator
+        :   ID 
+        ;
+    
+    functionHeader
+        :   type ID '(' ( formalParameter ( ',' formalParameter )* )? ')'
+            -> ^(FUNC_HDR type ID formalParameter+)
+        ;
+    
+    formalParameter
+        :   type declarator -> ^(ARG_DEF type declarator)
+        ;
+    
+    type
+        :   'int'   
+        |   'char'  
+        |   'void'
+        |   ID        
+        ;
+    
+    block
+        :   lc='{'
+                variable*
+                stat*
+            '}'
+            -> ^(BLOCK[$lc,"BLOCK"] variable* stat*)
+        ;
+    
+    stat: forStat
+        | expr ';'!
+        | block
+        | assignStat ';'!
+        | ';'!
+        ;
+    
+    forStat
+        :   'for' '(' start=assignStat ';' expr ';' next=assignStat ')' block
+            -> ^('for' $start expr $next block)
+        ;
+    
+    assignStat
+        :   ID EQ expr -> ^(EQ ID expr)
+        ;
+    
+    expr:   condExpr
+        ;
+    
+    condExpr
+        :   aexpr ( ('=='^ | '<'^) aexpr )?
+        ;
+    
+    aexpr
+        :   atom ( '+'^ atom )*
+        ;
+    
+    atom
+        : ID      
+        | INT      
+        | '(' expr ')' -> expr
+        ; 
+    
+    FOR : 'for' ;
+    INT_TYPE : 'int' ;
+    CHAR: 'char';
+    VOID: 'void';
+    
+    ID  :   ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*
+        ;
+    
+    INT :	('0'..'9')+
+        ;
+    
+    EQ   : '=' ;
+    EQEQ : '==' ;
+    LT   : '<' ;
+    PLUS : '+' ;
+    
+    WS  :   (   ' '
+            |   '\t'
+            |   '\r'
+            |   '\n'
+            )+
+            { $channel=HIDDEN }
+        ;
+  END
+
+  inline_grammar(<<-'END')
+    tree grammar GenericLanguageWalker;
+    options {
+        language = Ruby;
+        tokenVocab = GenericLanguage;
+        ASTLabelType = CommonTree;
+    }
+    
+    @init { @traces = [] }
+    @members {
+      attr_reader :traces
+      
+      def trace_in(rule_name, rule_index)
+        @traces << ">#{rule_name}"
+      end
+      
+      def trace_out(rule_name, rule_index)
+        @traces << "<#{rule_name}"
+      end
+    }
+    
+    program
+        :   declaration+
+        ;
+    
+    declaration
+        :   variable
+        |   ^(FUNC_DECL functionHeader)
+        |   ^(FUNC_DEF functionHeader block)
+        ;
+    
+    variable returns [res]
+        :   ^(VAR_DEF type declarator)
+            { 
+                $res = $declarator.text; 
+            }
+        ;
+    
+    declarator
+        :   ID 
+        ;
+    
+    functionHeader
+        :   ^(FUNC_HDR type ID formalParameter+)
+        ;
+    
+    formalParameter
+        :   ^(ARG_DEF type declarator)
+        ;
+    
+    type
+        :   'int'
+        |   'char'
+        |   'void'
+        |   ID        
+        ;
+    
+    block
+        :   ^(BLOCK variable* stat*)
+        ;
+    
+    stat: forStat
+        | expr
+        | block
+        ;
+    
+    forStat
+        :   ^('for' expr expr expr block)
+        ;
+    
+    expr:   ^(EQEQ expr expr)
+        |   ^(LT expr expr)
+        |   ^(PLUS expr expr)
+        |   ^(EQ ID expr)
+        |   atom
+        ;
+    
+    atom
+        : ID      
+        | INT      
+        ;
+  END
+  
+  compile_options :trace => true
+  
+  example "processing AST output from a parser with a tree parser" do
+    input_source = <<-END.fixed_indent(0)
+      char c;
+      int x;
+      
+      void bar(int x);
+      
+      int foo(int y, char d) {
+        int i;
+        for (i=0; i<3; i=i+1) {
+          x=3;
+          y=5;
+        }
+      }
+    END
+    
+    lexer = GenericLanguage::Lexer.new( input_source )
+    parser = GenericLanguage::Parser.new( lexer )
+    
+    expected_tree = <<-END.strip!.gsub!(/\s+/, ' ')
+      (VAR_DEF char c)
+      (VAR_DEF int x)
+      (FUNC_DECL (FUNC_HDR void bar (ARG_DEF int x)))
+      (FUNC_DEF
+        (FUNC_HDR int foo (ARG_DEF int y) (ARG_DEF char d))
+        (BLOCK
+          (VAR_DEF int i)
+          (for (= i 0) (< i 3) (= i (+ i 1))
+            (BLOCK (= x 3) (= y 5)))))
+    END
+    
+    result = parser.program
+    result.tree.inspect.should == expected_tree
+    
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = parser.input
+    tree_parser = GenericLanguageWalker::TreeParser.new( nodes )
+    
+    tree_parser.program
+    tree_parser.traces.should == %w(
+      >program          >declaration      >variable         >type           
+      <type             >declarator       <declarator       <variable       
+      <declaration      >declaration      >variable         >type           
+      <type             >declarator       <declarator       <variable       
+      <declaration      >declaration      >functionHeader   >type           
+      <type             >formalParameter  >type             <type           
+      >declarator       <declarator       <formalParameter  <functionHeader 
+      <declaration      >declaration      >functionHeader   >type           
+      <type             >formalParameter  >type             <type           
+      >declarator       <declarator       <formalParameter  >formalParameter
+      >type             <type             >declarator       <declarator     
+      <formalParameter  <functionHeader   >block            >variable       
+      >type             <type             >declarator       <declarator     
+      <variable         >stat             >forStat          >expr           
+      >expr             >atom             <atom             <expr           
+      <expr             >expr             >expr             >atom           
+      <atom             <expr             >expr             >atom           
+      <atom             <expr             <expr             >expr           
+      >expr             >expr             >atom             <atom           
+      <expr             >expr             >atom             <atom           
+      <expr             <expr             <expr             >block          
+      >stat             >expr             >expr             >atom           
+      <atom             <expr             <expr             <stat           
+      >stat             >expr             >expr             >atom           
+      <atom             <expr             <expr             <stat           
+      <block            <forStat          <stat             <block          
+      <declaration      <program        
+    )
+  end
+  
+  example 'tree parser rule label property references' do
+    input = "char c;\n"
+    lexer  = GenericLanguage::Lexer.new( "char c;\n" )
+    parser = GenericLanguage::Parser.new( lexer )
+    
+    result = parser.variable
+    nodes = ANTLR3::AST::CommonTreeNodeStream.new( result.tree )
+    nodes.token_stream = parser.input
+    
+    tree_parser = GenericLanguageWalker::TreeParser.new( nodes )
+    tree_parser.variable.should == 'c'
+  end
+  
+end
+