antlr3 1.2.4 → 1.3.0

data/samples/{Cpp.g → CPP.g}

@@ -1,4 +1,4 @@
-grammar Cpp;
+grammar CPP;
 
 options {
   language = Ruby;

data/templates/AST.stg

@@ -265,7 +265,7 @@ root_<treeLevel> = @adaptor.become_root(<createImaginaryNode(tokenType=token, ..
 >>
 
 rewriteAction(action) ::= <<
-root_0 = <action><\n>
+root_0 = ( <action> )<\n>
 >>
 
 prevRuleRootRef() ::= "return_value"

data/templates/Ruby.stg

@@ -16,9 +16,10 @@ outputFile(LEXER, PARSER, TREE_PARSER, actionScope, actions, docComment, recogni
 #
 # <fileName>
 # 
-# generated using ANTLR Version: <ANTLRVersion>
-# input grammar file: <fileName>
-# generated at: <generatedTimestamp>
+# Generated using ANTLR version: <ANTLRVersion>
+# Ruby runtime library version: <runtimeLibraryVersion()>
+# Input grammar file: <fileName>
+# Generated at: <generatedTimestamp>
 # 
 
 # ~~~\> start load path setup
@@ -29,7 +30,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:
+Failed to load the ANTLR3 runtime library (version <runtimeLibraryVersion()>):
 
 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
@@ -59,7 +60,7 @@ rescue LoadError
   
   # 3: try to activate the antlr3 gem
   begin
-    Gem.activate( 'antlr3' )
+    Gem.activate( 'antlr3', '= <runtimeLibraryVersion()>' )
   rescue Gem::LoadError
     antlr_load_failed.call
   end
@@ -110,20 +111,12 @@ module TokenData
   register_names(<tokenNames:{<it>}; separator=", ", anchor, wrap="\n">)
 
 <endif>
-<if(actions.token.scheme)>
-
-  <action(name="token::scheme",code=actions.token.scheme)>
-
-<endif>
-<if(actions.token.members)>
-
-  class Token
-    <action(name="token::members",code=actions.token.members)>
-  end
-
-<endif>
+  
+  <placeAction(scope="token",name="scheme")>
+  <placeAction(scope="token",name="members")>
 end<\n>
 >>
+
 rootGrammarOutputFile() ::= <<
 module <recognizer.grammar.name>
   <placeAction(scope="module",name="head")>
@@ -132,6 +125,7 @@ module <recognizer.grammar.name>
   <placeAction(scope="module",name="foot")>
 end
 >>
+
 delegateGrammarOutputFile() ::= <<
 require '<recognizer.grammar.delegator.recognizerName>'
 
@@ -139,6 +133,7 @@ require '<recognizer.grammar.delegator.recognizerName>'
   <recognizer>
 <delegateGrammarModuleTail(gram=recognizer.grammar.delegator)>
 >>
+
 delegateGrammarModuleHead(gram) ::= <<
 <if(gram.grammarIsRoot)>
 module <gram.name>
@@ -147,6 +142,7 @@ module <gram.name>
 class <gram.name>
 <endif>
 >>
+
 delegateGrammarModuleTail(gram) ::= <<
 <if(gram.grammarIsRoot)>
 end # module <gram.name>
@@ -187,6 +183,7 @@ end # class <if(grammar.grammarIsRoot)>TreeParser<else><grammar.name><endif> \<
 at_exit { <if(grammar.grammarIsRoot)>TreeParser<else><grammar.name><endif>.main(ARGV) } if __FILE__ == $0
 <endif>
 >>
+
 parserBody(grammar, name, scopes, tokens, tokenNames, rules, numRules, bitsets, inputStreamType, superClass, filterMode, ASTLabelType="Object", labelType, members, rewriteElementType, actionScope) ::= <<
 @grammar_home = <grammar.name>
 <if(!grammar.grammarIsRoot)><autoloadDelegates()><\n><endif>
@@ -205,7 +202,7 @@ imports( <grammar.directDelegates:{d|:<d.name>}; separator=", "> )<\n>
 
 include TokenData
 
-generated_using("<fileName>", "<ANTLRVersion>")
+generated_using( "<fileName>", "<ANTLRVersion>", "<runtimeLibraryVersion()>" )
 
 <if(!grammar.grammarIsRoot)>
 require '<grammar.composite.rootGrammar.recognizerName>'
@@ -235,6 +232,7 @@ end
 <endif>
 <bitsets:{TOKENS_FOLLOWING_<it.name>_IN_<it.inName>_<it.tokenIndex> = Set[<it.tokenTypes:{<it>}; separator=", ">]<\n>}>
 >>
+
 parserConstructor() ::= <<
 def initialize(<grammar.delegators:{g|<g:delegateName()>, }>input, options = {})
   super(input, options)
@@ -346,6 +344,7 @@ loop do  #loop <decisionNumber>
   end
 end
 >>
+
 delegateName() ::= <<
 <if(it.label)><it.label; format="label"><else><it.name; format="snakecase"><endif>
 >>
@@ -355,10 +354,8 @@ element() ::= <<
 <it.el><\n>
 >>
 
-
 execForcedAction(action) ::= "<action>"
 
-
 globalAttributeScopeClass(scope) ::= <<
 <if(scope.attributes)>Scope<scope.name> = Struct.new(<scope.attributes:{:<it.decl>}; separator=", ">)<endif>
 >>
@@ -895,6 +892,12 @@ class DFA<dfa.decisionNumber> \< ANTLR3::DFA
     <dfa.javaCompressedTransition:{s|unpack(<s; wrap="\n", anchor, separator=", ">)}; separator=",\n">
   ].freeze
   
+  ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
+    if a \> 0 and z \< 0
+      MAX[ i ] %= 0x10000
+    end
+  end
+  
   @decision = <dfa.decisionNumber>
   
   <@errorMethod()>
@@ -927,7 +930,7 @@ end
 
 
 cyclicDFASynpred(name) ::= <<
-def <name>; @recognizer.<name>; end<\n>
+def <name>() @recognizer.<name> end<\n>
 >>
 
 
@@ -972,15 +975,6 @@ s = -1
 <endif>
 >>
 
-
-/*
-line_<decisionNumber>_<stateNumber> = input.line
-col_<decisionNumber>_<stateNumber> = input.column
-----
-input.column = col_<decisionNumber>_<stateNumber>
-input.line   = line_<decisionNumber>_<stateNumber>
-*/
-
 /** Just like a fixed DFA edge, test the look and indicate
   * what state to jump to next if successful.  Again, this is
   * for special states.
@@ -1002,16 +996,12 @@ e
 
 andPredicates(left,right) ::= "( ( <left> ) and ( <right> ) )"
 
-
-orPredicates(operands) ::= "(<first(operands)><rest(operands):{o |  or <o>}>)"
-
+orPredicates(operands) ::= "(<first(operands)><rest(operands):{o|  or <o>}>)"
 
 notPredicate(pred) ::= "not (<evalPredicate(...)>)"
 
-
 evalPredicate(pred,description) ::= "(<pred>)"
 
-
 evalSynPredicate(pred,description) ::= <<
 syntactic_predicate?(<pred:{<it; format="lexerRule">}; format="symbol">)
 >>
@@ -1019,7 +1009,6 @@ syntactic_predicate?(<pred:{<it; format="lexerRule">}; format="symbol">)
 
 lookaheadTest(atom, k, atomAsInt) ::= "look_<decisionNumber>_<stateNumber> == <atom>"
 
-
 /** Sometimes a look test cannot assume that LA(k) is in a
   * temp variable somewhere.  Must ask for the look
   * directly.
@@ -1161,13 +1150,12 @@ ruleLabelPropertyRef_text(scope, attr) ::= <<
 
 ruleLabelPropertyRef_st(scope, attr) ::= "(<scope; format=\"label\">.nil? ? nil : <scope; format=\"label\">.st)"
 
-
-
 /******************************************************************************
  *****************  L E X E R - O N L Y   T E M P L A T E S  ******************
  ******************************************************************************/
 
 lexerSynpred(name) ::= ""
+
 lexer(grammar, name, tokens, scopes, rules, numRules, labelType="ANTLR3::Token", filterMode, superClass="ANTLR3::Lexer") ::= <<
 <if(grammar.grammarIsRoot)><autoloadDelegates()><endif>
 
@@ -1180,7 +1168,7 @@ class <if(grammar.delegator)><grammar.name><else>Lexer<endif> \< <superClass>
 <endif>
   <scopes:{<if(it.isDynamicGlobalScope)><globalAttributeScopeClass(scope=it)><\n><endif>}>
   begin
-    generated_using('<fileName>', '<ANTLRVersion>')
+    generated_using( "<fileName>", "<ANTLRVersion>", "<runtimeLibraryVersion()>" )
   rescue NoMethodError => error
     error.name.to_sym == :generated_using or raise
   end
@@ -1466,7 +1454,7 @@ end
 
 codeFileExtension() ::= ".rb"
 
-true() ::= "true"
+true()  ::= "true"
 false() ::= "false"
 
 action(name, code) ::= <<
@@ -1510,5 +1498,4 @@ placeAction(scope, name) ::= <<
 <endif>
 >>
 
-
-
+runtimeLibraryVersion() ::= "1.3.0"

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

@@ -710,7 +710,7 @@ class TestAutoAST < ANTLR3::Test::Functional
       options {language=Ruby;output=AST;}
       a returns [result]: x+=b x+=b {
       t = $x[1]
-      $result = "2nd x=#{t.to_string_tree},"
+      $result = "2nd x=#{t.inspect},"
       };
       b : ID;
       ID : 'a'..'z'+ ;
@@ -726,7 +726,7 @@ class TestAutoAST < ANTLR3::Test::Functional
       grammar RuleListLabelRuleRoot;
       options {language=Ruby;output=AST;}
       a returns [result] : ( x+=b^ )+ {
-      $result = "x=%s," \% $x[1].to_string_tree
+      $result = "x=%s," \% $x[1].inspect
       } ;
       b : ID;
       ID : 'a'..'z'+ ;
@@ -742,7 +742,7 @@ class TestAutoAST < ANTLR3::Test::Functional
       grammar RuleListLabelBang;
       options {language=Ruby;output=AST;}
       a returns [result] : x+=b! x+=b {
-      $result = "1st x=#{$x[0].to_string_tree},"
+      $result = "1st x=#{$x[0].inspect},"
       } ;
       b : ID;
       ID : 'a'..'z'+ ;

data/test/functional/ast-output/tree-rewrite.rb

@@ -841,7 +841,7 @@ class TestASTRewritingTreeParsers < ANTLR3::Test::Functional
       rewrite=true;
     }
     s : ^(ID a) {
-      # self.buf += $s.start.to_string_tree
+      # self.buf += $s.start.inspect
     };
     a : ^(ID INT) -> {true}? ^(ID["ick"] INT)
                   -> INT

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

@@ -4,7 +4,7 @@
 require 'antlr3'
 require 'fileutils'
 require 'antlr3/test/functional'
-require 'antlr3/test/diff'
+#require 'antlr3/test/diff'
 
 class ANTLRDebugger < Thread
   self.abort_on_exception = true
@@ -61,7 +61,7 @@ end # ANTLRDebugger
 class TestDebugGrammars < ANTLR3::Test::Functional
   compile_options :debug => true
   
-  include ANTLR3::Test::Diff
+  #include ANTLR3::Test::Diff
   
   def parse(grammar, rule, input, options = {})
     @grammar = inline_grammar(grammar)

data/test/unit/test-tree-wizard.rb

@@ -6,24 +6,23 @@ require 'antlr3/tree/wizard'
 require 'test/unit'
 require 'spec'
 
-
 include ANTLR3
 include ANTLR3::AST
 
-class TestTreePatternLexer < Test::Unit::TestCase
+class TestPatternLexer < Test::Unit::TestCase
   
   # vvvvvvvv tests vvvvvvvvv
   
   def test_open
-    lexer = Wizard::TreePatternLexer.new('(')
+    lexer = Wizard::PatternLexer.new( '(' )
     type = lexer.next_token
-    assert_equal(type, :open)
-    assert_equal(lexer.text, '')
-    assert_equal(lexer.error, false)
+    assert_equal( type, :open )
+    assert_equal( lexer.text, '' )
+    assert_equal( lexer.error, false )
   end
   
   def test_close
-    lexer = Wizard::TreePatternLexer.new(')')
+    lexer = Wizard::PatternLexer.new(')')
     type = lexer.next_token
     assert_equal(type, :close)
     assert_equal(lexer.text, '')
@@ -31,7 +30,7 @@ class TestTreePatternLexer < Test::Unit::TestCase
   end
   
   def test_percent
-    lexer = Wizard::TreePatternLexer.new('%')
+    lexer = Wizard::PatternLexer.new('%')
     type = lexer.next_token
     assert_equal(type, :percent)
     assert_equal(lexer.text, '')
@@ -39,7 +38,7 @@ class TestTreePatternLexer < Test::Unit::TestCase
   end
   
   def test_dot
-    lexer = Wizard::TreePatternLexer.new('.')
+    lexer = Wizard::PatternLexer.new('.')
     type = lexer.next_token
     assert_equal(type, :dot)
     assert_equal(lexer.text, '')
@@ -47,7 +46,7 @@ class TestTreePatternLexer < Test::Unit::TestCase
   end
   
   def test_eof
-    lexer = Wizard::TreePatternLexer.new(" \n \r \t ")
+    lexer = Wizard::PatternLexer.new(" \n \r \t ")
     type = lexer.next_token
     assert_equal(type, EOF)
     assert_equal(lexer.text, '')
@@ -55,7 +54,7 @@ class TestTreePatternLexer < Test::Unit::TestCase
   end
   
   def test_id
-    lexer = Wizard::TreePatternLexer.new('__whatever_1__')
+    lexer = Wizard::PatternLexer.new('__whatever_1__')
     type = lexer.next_token
     assert_equal(:identifier, type)
     assert_equal('__whatever_1__', lexer.text)
@@ -63,7 +62,7 @@ class TestTreePatternLexer < Test::Unit::TestCase
   end
   
   def test_arg
-    lexer = Wizard::TreePatternLexer.new('[ \]bla\n]')
+    lexer = Wizard::PatternLexer.new('[ \]bla\n]')
     type = lexer.next_token
     assert_equal(type, :argument)
     assert_equal(' ]bla\n', lexer.text)
@@ -71,7 +70,7 @@ class TestTreePatternLexer < Test::Unit::TestCase
   end
   
   def test_error
-    lexer = Wizard::TreePatternLexer.new("1")
+    lexer = Wizard::PatternLexer.new("1")
     type = lexer.next_token
     assert_equal(type, EOF)
     assert_equal(lexer.text, '')
@@ -81,96 +80,75 @@ class TestTreePatternLexer < Test::Unit::TestCase
 end
 
 
-class TestTreePatternParser < Test::Unit::TestCase
+class TestPatternParser < Test::Unit::TestCase
+  Tokens = TokenScheme.build %w(A B C D E ID VAR)
+  include Tokens
+  
   def setup
-    @adaptor = CommonTreeAdaptor.new
-    @pattern_adaptor = Wizard::TreePatternTreeAdaptor.new
-    @tokens = Array.new(5, '') + %w(A B C D E ID VAR)
-    @wizard = Wizard.new(@adaptor, @tokens)
+    @adaptor = CommonTreeAdaptor.new( Tokens.token_class )
+    @pattern_adaptor = Wizard::PatternAdaptor.new( Tokens.token_class )
+    @wizard = Wizard.new( :adaptor => @adaptor, :token_scheme => Tokens )
   end
   
   # vvvvvvvv tests vvvvvvvvv
   def test_single_node
-    lexer = Wizard::TreePatternLexer.new('ID')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-  
+    tree = Wizard::PatternParser.parse( 'ID', Tokens, @adaptor )
+    
     assert_instance_of(CommonTree, tree)
-    assert_equal(10, tree.type)
-    assert_equal('ID', tree.text)
+    assert_equal( ID, tree.type )
+    assert_equal( 'ID', tree.text )
   end
   
   def test_single_node_with_arg
-    lexer = Wizard::TreePatternLexer.new('ID[foo]')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-  
-    assert_instance_of(CommonTree, tree)
-    assert_equal(10, tree.type)
-    assert_equal('foo', tree.text)
+    tree = Wizard::PatternParser.parse( 'ID[foo]', Tokens, @adaptor )
+    
+    assert_instance_of( CommonTree, tree )
+    assert_equal( ID, tree.type )
+    assert_equal( 'foo', tree.text )
   end
   
   def test_single_level_tree
-    lexer = Wizard::TreePatternLexer.new('(A B)')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-  
-    assert_instance_of(CommonTree, tree)
-    assert_equal(5, tree.type)
+    tree = Wizard::PatternParser.parse( '(A B)', Tokens, @adaptor )
+    
+    assert_instance_of( CommonTree, tree )
+    assert_equal(A, tree.type)
     assert_equal('A', tree.text)
     assert_equal(tree.child_count, 1)
-    assert_equal(tree.child(0).type, 6)
+    assert_equal(tree.child(0).type, B)
     assert_equal(tree.child(0).text, 'B')
   end
   
   def test_nil
-    lexer = Wizard::TreePatternLexer.new('nil')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-  
+    tree = Wizard::PatternParser.parse( 'nil', Tokens, @adaptor )
+    
     assert_instance_of(CommonTree, tree)
     assert_equal(0, tree.type)
     assert_nil tree.text
   end
   
   def test_wildcard
-    lexer = Wizard::Wizard::TreePatternLexer.new('(.)')
-    parser = Wizard::Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-  
-    assert_instance_of(Wizard::WildcardTreePattern, tree)
+    tree = Wizard::PatternParser.parse( '(.)', Tokens, @adaptor )
+    assert_instance_of( Wizard::WildcardPattern, tree )
   end
   
   def test_label
-    lexer = Wizard::TreePatternLexer.new('(%a:A)')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @pattern_adaptor)
-    tree = parser.pattern
-  
-    assert_instance_of(Wizard::TreePattern, tree)
+    tree = Wizard::PatternParser.parse( '(%a:A)', Tokens, @pattern_adaptor )
+    assert_instance_of(Wizard::Pattern, tree)
     assert_equal('a', tree.label)
   end
   
   def test_error_1
-    lexer = Wizard::TreePatternLexer.new(')')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-    
+    tree = Wizard::PatternParser.parse( ')', Tokens, @adaptor )
     assert_nil tree
   end
   
   def test_error_2
-    lexer = Wizard::TreePatternLexer.new('()')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-    
+    tree = Wizard::PatternParser.parse( '()', Tokens, @adaptor )
     assert_nil tree
   end
   
   def test_error_3
-    lexer = Wizard::TreePatternLexer.new('(A ])')
-    parser = Wizard::TreePatternParser.new(lexer, @wizard, @adaptor)
-    tree = parser.pattern
-    
+    tree = Wizard::PatternParser.parse( '(A ])', Tokens, @adaptor )
     assert_nil tree
   end
   
@@ -178,75 +156,60 @@ end
 
 
 class TestTreeWizard < Test::Unit::TestCase
+  Tokens = TokenScheme.build %w(A B C D E ID VAR)
+  include Tokens
 
   def setup
-    @adaptor = ANTLR3::CommonTreeAdaptor.new
-    @tokens = Array.new(5, '') + %w(A B C D E ID VAR)
-    @wizard = Wizard.new(@adaptor, @tokens)
+    @adaptor = CommonTreeAdaptor.new( Tokens.token_class )
+    @wizard = Wizard.new( :adaptor => @adaptor, :token_scheme => Tokens )
+  end
+  
+  def create_wizard( tokens )
+    Wizard.new( :tokens => tokens )
   end
   
   # vvvvvvvv tests vvvvvvvvv
   def test_init
-    wiz = Wizard.new(@adaptor, %w(a b))
+    @wizard = Wizard.new( :tokens => %w(A B), :adaptor => @adaptor )
     
-    assert_equal(wiz.adaptor, @adaptor)
-    assert_equal(wiz.token_name_to_type_map, { 'a' => 0, 'b' => 1 })
+    assert_equal( @wizard.adaptor, @adaptor )
+    assert_kind_of( ANTLR3::TokenScheme, @wizard.token_scheme )
   end
   
-  def test_token_type
-    wiz = Wizard.new(@adaptor, @tokens)
-    assert_equal(wiz.token_type('A'), 5)
-    assert_equal(wiz.token_type('VAR'), 11)
-    assert_equal(wiz.token_type('invalid'), INVALID_TOKEN_TYPE)
-  end
-
   def test_single_node
-    wiz = Wizard.new(@adaptor, @tokens)
-    t = wiz.create("ID")
-    
-    assert_equal(t.to_string_tree, 'ID')
+    t = @wizard.create("ID")
+    assert_equal(t.inspect, 'ID')
   end
   
   def test_single_node_with_arg
-    wiz = Wizard.new(@adaptor, @tokens)
-    t = wiz.create("ID[foo]")
+    t = @wizard.create("ID[foo]")
     
-    assert_equal(t.to_string_tree, 'foo')
+    assert_equal(t.inspect, 'foo')
   end
   
   def test_single_node_tree
-    wiz = Wizard.new(@adaptor, @tokens)
-    t = wiz.create("(A)")
-    
-    assert_equal(t.to_string_tree, 'A')
+    t = @wizard.create("(A)")
+    assert_equal(t.inspect, 'A')
   end
   
   def test_single_level_tree
-    wiz = Wizard.new(@adaptor, @tokens)
-    t = wiz.create("(A B C D)")
-    
-    assert_equal(t.to_string_tree, '(A B C D)')
+    t = @wizard.create("(A B C D)")
+    assert_equal(t.inspect, '(A B C D)')
   end
   
   def test_list_tree
-    wiz = Wizard.new(@adaptor, @tokens)
-    t = wiz.create("(nil A B C)")
-    
-    assert_equal(t.to_string_tree, 'A B C')
+    t = @wizard.create("(nil A B C)")
+    assert_equal(t.inspect, 'A B C')
   end
   
   def test_invalid_list_tree
-    wiz = Wizard.new(@adaptor, @tokens)
-    t = wiz.create("A B C")
-    
+    t = @wizard.create("A B C")
     assert_nil t
   end
   
   def test_double_level_tree
-    wiz = Wizard.new(@adaptor, @tokens)
-    t = wiz.create("(A (B C) (B D) E)")
-    
-    assert_equal(t.to_string_tree, "(A (B C) (B D) E)")
+    t = @wizard.create("(A (B C) (B D) E)")
+    assert_equal(t.inspect, "(A (B C) (B D) E)")
   end
   
   SIMPLIFY_MAP = lambda do |imap|
@@ -256,33 +219,30 @@ class TestTreeWizard < Test::Unit::TestCase
   end
   
   def test_single_node_index
-    wiz = Wizard.new(@adaptor, @tokens)
-    tree = wiz.create("ID")
-    index_map = SIMPLIFY_MAP[wiz.index(tree)]
+    tree = @wizard.create("ID")
+    index_map = SIMPLIFY_MAP[@wizard.index(tree)]
     
-    assert_equal(index_map, { 10 => %w(ID) })
+    assert_equal(index_map, ID => %w(ID))
   end
   
   
   def test_no_repeats_index
-    wiz = Wizard.new(@adaptor, @tokens)
-    tree = wiz.create("(A B C D)")
-    index_map = SIMPLIFY_MAP[wiz.index(tree)]
+    tree = @wizard.create("(A B C D)")
+    index_map = SIMPLIFY_MAP[@wizard.index(tree)]
     
     assert_equal(index_map,
-        8 => %w(D), 6 => %w(B),
-        7 => %w(C), 5 => %w(A)
+        D => %w(D), B => %w(B),
+        C => %w(C), A => %w(A)
     )
   end
   
   def test_repeats_index
-    wiz = Wizard.new(@adaptor, @tokens)
-    tree = wiz.create("(A B (A C B) B D D)")
-    index_map = SIMPLIFY_MAP[wiz.index(tree)]
+    tree = @wizard.create("(A B (A C B) B D D)")
+    index_map = SIMPLIFY_MAP[@wizard.index(tree)]
     
     assert_equal(index_map,
-        8 => %w(D D), 6 => %w(B B B),
-        7 => %w(C), 5 => %w(A A)
+        D => %w(D D), B => %w(B B B),
+        C => %w(C), A => %w(A A)
     )
   end
   
@@ -291,11 +251,11 @@ class TestTreeWizard < Test::Unit::TestCase
     tree = @wizard.create("(A B C D)")
     
     elements = []
-    @wizard.visit(tree, @wizard.token_type('B')) do |node, parent, child_index, labels|
+    @wizard.visit( tree, B ) do |node, parent, child_index, labels|
       elements << node.to_s
     end
     
-    assert_equal(%w(B), elements)
+    assert_equal( %w(B), elements )
   end
   
   
@@ -303,7 +263,7 @@ class TestTreeWizard < Test::Unit::TestCase
     tree = @wizard.create("(A B (A C B) B D D)")
     
     elements = []
-    @wizard.visit(tree, @wizard.token_type('C')) do |node, parent, child_index, labels|
+    @wizard.visit( tree, C ) do |node, parent, child_index, labels|
       elements << node.to_s
     end
     
@@ -315,7 +275,7 @@ class TestTreeWizard < Test::Unit::TestCase
     tree = @wizard.create("(A B (A C B) B D D)")
     
     elements = []
-    @wizard.visit(tree, @wizard.token_type('B')) do |node, parent, child_index, labels|
+    @wizard.visit( tree, B ) do |node, parent, child_index, labels|
       elements << node.to_s
     end
     
@@ -327,7 +287,7 @@ class TestTreeWizard < Test::Unit::TestCase
     tree = @wizard.create("(A B (A C B) B D D)")
     
     elements = []
-    @wizard.visit(tree, @wizard.token_type('A')) do |node, parent, child_index, labels|
+    @wizard.visit( tree, A ) do |node, parent, child_index, labels|
       elements << node.to_s
     end
     
@@ -342,7 +302,7 @@ class TestTreeWizard < Test::Unit::TestCase
     tree = @wizard.create("(A B (A C B) B D D)")
     
     elements = []
-    @wizard.visit(tree, @wizard.token_type('B')) do |node, parent, child_index, labels|
+    @wizard.visit( tree, B ) do |node, parent, child_index, labels|
       elements << context(node, parent, child_index)
     end
     
@@ -354,14 +314,13 @@ class TestTreeWizard < Test::Unit::TestCase
     tree = @wizard.create("(A B (A C B) B D D)")
     
     elements = []
-    @wizard.visit(tree, @wizard.token_type('A')) do |node, parent, child_index, labels|
+    @wizard.visit( tree, A ) do |node, parent, child_index, labels|
       elements << context(node, parent, child_index)
     end
     
-    assert_equal(['A@nil[0]', 'A@A[1]'], elements)
+    assert_equal(['A@nil[-1]', 'A@A[1]'], elements)
   end
   
-  
   def test_visit_pattern
     tree = @wizard.create("(A B C (A B) D)")
     
@@ -402,83 +361,83 @@ class TestTreeWizard < Test::Unit::TestCase
   end
   
   
-  def test_parse
+  def test_match
     tree = @wizard.create("(A B C)")
-    assert @wizard.parse(tree, "(A B C)")
+    assert @wizard.match(tree, "(A B C)")
   end
   
-  def test_parse_single_node
+  def test_match_single_node
     tree = @wizard.create('A')
-    assert @wizard.parse(tree, 'A')
+    assert @wizard.match(tree, 'A')
   end
   
-  def test_parse_single_node_fails
+  def test_match_single_node_fails
     tree = @wizard.create('A')
-    assert( !(@wizard.parse(tree, 'B')) )
+    assert( !(@wizard.match(tree, 'B')) )
   end
   
   
-  def test_parse_flat_tree
+  def test_match_flat_tree
     tree = @wizard.create('(nil A B C)')
-    assert @wizard.parse(tree, '(nil A B C)')
+    assert @wizard.match(tree, '(nil A B C)')
   end
   
-  def test_parse_flat_tree_fails
+  def test_match_flat_tree_fails
     tree = @wizard.create('(nil A B C)')
-    assert( !(@wizard.parse(tree, '(nil A B)')) )
+    assert( !(@wizard.match(tree, '(nil A B)')) )
   end
 
-  def test_parse_flat_tree_fails2
+  def test_match_flat_tree_fails2
     tree = @wizard.create('(nil A B C)')
-    assert( !(@wizard.parse(tree, '(nil A B A)')) )
+    assert( !(@wizard.match(tree, '(nil A B A)')) )
   end
   
   def test_wildcard
     tree = @wizard.create('(A B C)')
-    assert @wizard.parse(tree, '(A . .)')
+    assert @wizard.match(tree, '(A . .)')
   end
   
-  def test_parse_with_text
+  def test_match_with_text
     tree = @wizard.create('(A B[foo] C[bar])')
-    assert @wizard.parse(tree, '(A B[foo] C)')
+    assert @wizard.match(tree, '(A B[foo] C)')
   end
   
-  def test_parse_with_text_fails
+  def test_match_with_text_fails
     tree = @wizard.create('(A B C)')
-    assert( !(@wizard.parse(tree, '(A[foo] B C)')) )
+    assert( !(@wizard.match(tree, '(A[foo] B C)')) )
   end
   
-  def test_parse_labels
+  def test_match_labels
     tree = @wizard.create('(A B C)')
-    labels = {}
-    assert @wizard.parse(tree, '(%a:A %b:B %c:C)', labels)
+    labels = @wizard.match( tree, '(%a:A %b:B %c:C)' )
+    
     assert_equal('A', labels['a'].to_s)
     assert_equal('B', labels['b'].to_s)
     assert_equal('C', labels['c'].to_s)
   end
   
-  def test_parse_with_wildcard_labels
+  def test_match_with_wildcard_labels
     tree = @wizard.create('(A B C)')
-    labels = {}
-    assert @wizard.parse(tree, '(A %b:. %c:.)', labels)
+    labels = @wizard.match(tree, '(A %b:. %c:.)')
+    assert_kind_of( Hash, labels )
     assert_equal('B', labels['b'].to_s)
     assert_equal('C', labels['c'].to_s)
   end
   
   
-  def test_parse_labels_and_test_text
+  def test_match_labels_and_test_text
     tree = @wizard.create('(A B[foo] C)')
-    labels = {}
-    assert @wizard.parse(tree, '(%a:A %b:B[foo] %c:C)', labels)
+    labels = @wizard.match( tree, '(%a:A %b:B[foo] %c:C)' )
+    assert_kind_of( Hash, labels )
     assert_equal('A', labels['a'].to_s)
     assert_equal('foo', labels['b'].to_s)
     assert_equal('C', labels['c'].to_s)
   end
   
-  def test_parse_labels_in_nested_tree
+  def test_match_labels_in_nested_tree
     tree = @wizard.create('(A (B C) (D E))')
-    labels = {}
-    assert @wizard.parse(tree, '(%a:A (%b:B %c:C) (%d:D %e:E))', labels)
+    labels = @wizard.match( tree, '(%a:A (%b:B %c:C) (%d:D %e:E))' )
+    assert_kind_of( Hash, labels )
     assert_equal('A', labels['a'].to_s)
     assert_equal('B', labels['b'].to_s)
     assert_equal('C', labels['c'].to_s)
@@ -528,7 +487,7 @@ class TestTreeWizard < Test::Unit::TestCase
   
   def test_find_token_type
     tree = @wizard.create("(A B C (A[foo] B[bar]) (D (A[big] B[dog])))")
-    subtrees = @wizard.find(tree, @wizard.token_type('A')).map { |t| t.to_s }
+    subtrees = @wizard.find( tree, A ).map { |t| t.to_s }
     assert_equal(%w(A foo big), subtrees)
   end
 end