rltk 3.0.0 → 3.0.1

data/test/tc_cfg.rb

@@ -20,144 +20,144 @@ require 'rltk/cfg'
 class CFGTester < Minitest::Test
 	def setup
 		@grammar = RLTK::CFG.new
-		
+
 		@grammar.production(:s) do
 			clause('A G D')
 			clause('A a C')
 			clause('B a D')
 			clause('B G C')
 		end
-		
+
 		@grammar.production(:a, 'b')
 		@grammar.production(:b, 'G')
 	end
-	
+
 	def test_callback
 		grammar = RLTK::CFG.new
-		
+
 		call_count = 0
 		grammar.callback do |type, which, p|
 			refute_nil(p)
 			assert_equal(type, :optional)
-			
+
 			case call_count
 			when 0 then assert_equal(:empty, which)
 			when 1 then assert_equal(:nonempty, which)
 			end
-			
+
 			call_count += 1
 		end
-		
+
 		grammar.production(:a, 'A?') { |a| a }
 		assert_equal(2, call_count)
-		
+
 		call_count = 0
 		grammar.callback do |type, which, p|
 			refute_nil(p)
-			
+
 			case call_count
 			when 0
 				assert_equal(:elp, type)
 				assert_equal(:empty, which)
-				
+
 			when 1
 				assert_equal(:elp, type)
 				assert_equal(:nonempty, which)
-				
+
 			when 2
 				assert_equal(:nelp, type)
 				assert_equal(:single, which)
-				
+
 			when 3
 				assert_equal(:nelp, type)
 				assert_equal(:multiple, which)
 			end
-			
+
 			call_count += 1
 		end
-		
+
 		grammar.production(:a, 'A*') { |a| a }
 		assert_equal(4, call_count)
-		
+
 		call_count = 0
 		grammar.callback do |type, which, p|
 			refute_nil(p)
 			assert_equal(type, :nelp)
-			
+
 			case call_count
 			when 0 then assert_equal(:single, which)
 			when 1 then assert_equal(:multiple, which)
 			end
-			
+
 			call_count += 1
 		end
-		
+
 		grammar.production(:a, 'A+') { |a| a }
 		assert_equal(2, call_count)
 	end
-	
+
 	def test_first_set
 		@grammar.first_set(:s).each do |sym|
 			assert_includes([:A, :B], sym)
 		end
-		
+
 		assert_equal([:G], @grammar.first_set(:b))
 		assert_equal([:G], @grammar.first_set(:a))
 	end
-	
+
 	def test_follow_set
 		assert_equal(@grammar.follow_set(:s), [:EOS])
-		
+
 		@grammar.follow_set(:a).each do |sym|
 			assert([:C, :D].include?(sym))
 		end
-		
+
 		@grammar.follow_set(:b).each do |sym|
 			assert([:C, :D].include?(sym))
 		end
 	end
-	
+
 	def test_is_nonterminal
 		assert(RLTK::CFG::is_nonterminal?(:lowercase))
 		assert(!RLTK::CFG::is_nonterminal?(:UPERCASE))
 	end
-	
+
 	def test_is_terminal
 		assert(!RLTK::CFG::is_terminal?(:lowercase))
 		assert(RLTK::CFG::is_terminal?(:UPERCASE))
 	end
-	
+
 	def test_item
 		i0 = RLTK::CFG::Item.new(0, 0, :a, [:b, :C, :D, :e])
 		i1 = i0.copy
-		
+
 		assert_equal(i0, i1)
 		assert(!i0.at_end?)
 		assert_equal(:b, i0.next_symbol)
-		
+
 		i0.advance
-		
+
 		refute_equal(i0, i1)
 		assert(!i0.at_end?)
 		assert_equal(:C, i0.next_symbol)
-		
+
 		i0.advance
 		assert(!i0.at_end?)
 		assert_equal(:D, i0.next_symbol)
-		
+
 		i0.advance
 		assert(!i0.at_end?)
 		assert_equal(:e, i0.next_symbol)
-		
+
 		i0.advance
 		assert(i0.at_end?)
 		assert_nil(i0.next_symbol)
 	end
-	
+
 	def test_production
 		p0 = RLTK::CFG::Production.new(0, :a, [:b, :C, :D, :e])
 		p1 = p0.copy
-		
+
 		assert_equal(p0, p1)
 		assert_equal(:D, p0.last_terminal)
 	end

data/test/tc_lexer.rb

@@ -24,28 +24,28 @@ class LexerTester < Minitest::Test
 	class ABLongest < RLTK::Lexer
 		rule(/a+/)   { :APLUS }
 		rule(/b+/)   { :BPLUS }
-	
+
 		rule(/a+b+/) { :APLUSBPLUS }
 	end
 
 	class ABFirst < RLTK::Lexer
 		match_first
-	
+
 		rule(/a+/)   { :APLUS }
 		rule(/b+/)   { :BPLUS }
-	
+
 		rule(/a+b+/) { :APLUSBPLUS }
 	end
 
 	class ENVLexer < RLTK::Lexer
 		rule(/a/)	{ [:A, next_value] }
-	
+
 		class Environment < Environment
 			def initialize(*args)
 				super(*args)
 				@value = -1
 			end
-		
+
 			def next_value
 				@value += 1
 			end
@@ -55,7 +55,7 @@ class LexerTester < Minitest::Test
 	class FlagLexer < RLTK::Lexer
 		rule(/a/)	 { set_flag(:a); :A }
 		rule(/\s/)
-	
+
 		rule(/b/, :default, [:a])     { set_flag(:b); :B }
 		rule(/c/, :default, [:a, :b]) { :C }
 	end
@@ -63,9 +63,9 @@ class LexerTester < Minitest::Test
 	class StateLexer < RLTK::Lexer
 		rule(/a/)    { :A }
 		rule(/\s/)
-	
+
 		rule(/\(\*/) { push_state(:comment) }
-	
+
 		rule(/\(\*/, :comment) { push_state(:comment) }
 		rule(/\*\)/, :comment) { pop_state }
 		rule(/./,    :comment)
@@ -74,42 +74,42 @@ class LexerTester < Minitest::Test
 	class MatchDataLexer < RLTK::Lexer
 		rule(/a(b*)(c+)/) { [:FOO, match[1,2]] }
 	end
-	
+
 	def test_calc
 		expected = [
 			RLTK::Token.new(:NUM, 1),
-			
+
 			RLTK::Token.new(:PLS),
 			RLTK::Token.new(:SUB),
 			RLTK::Token.new(:MUL),
 			RLTK::Token.new(:DIV),
-			
+
 			RLTK::Token.new(:LPAREN),
 			RLTK::Token.new(:RPAREN),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = RLTK::Lexers::Calculator.lex('1 + - * / ( )')
-		
+
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_ebnf
 		expected = [
 			RLTK::Token.new(:NONTERM, :aaa),
 			RLTK::Token.new(:TERM, :BBB),
-			
+
 			RLTK::Token.new(:STAR),
 			RLTK::Token.new(:PLUS),
 			RLTK::Token.new(:QUESTION),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = RLTK::Lexers::EBNF.lex('aaa BBB * + ?')
-		
+
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_environment
 		expected = [
 			RLTK::Token.new(:A, 0),
@@ -117,52 +117,52 @@ class LexerTester < Minitest::Test
 			RLTK::Token.new(:A, 2),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = ENVLexer.lex('aaa')
-		
+
 		assert_equal(expected, actual)
-		
+
 		lexer = ENVLexer.new
-		
+
 		assert_equal(expected, lexer.lex('aaa'))
-		
+
 		expected = [
 			RLTK::Token.new(:A, 3),
 			RLTK::Token.new(:A, 4),
 			RLTK::Token.new(:A, 5),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		assert_equal(expected, lexer.lex('aaa'))
 	end
-	
+
 	def test_first_match
 		expected = [
 			RLTK::Token.new(:APLUS),
 			RLTK::Token.new(:BPLUS),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = ABFirst.lex('aaabbb')
-		
+
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_flags
-		
+
 		assert_raises(RLTK::LexingError) { FlagLexer.lex('b') }
 		assert_raises(RLTK::LexingError) { FlagLexer.lex('ac') }
-		
+
 		expected = [
 			RLTK::Token.new(:A),
 			RLTK::Token.new(:B),
 			RLTK::Token.new(:C),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = FlagLexer.lex('abc')
 		assert_equal(expected, actual)
-		
+
 		expected = [
 			RLTK::Token.new(:A),
 			RLTK::Token.new(:B),
@@ -172,44 +172,44 @@ class LexerTester < Minitest::Test
 			RLTK::Token.new(:C),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = FlagLexer.lex('abcabc')
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_lex
 		assert_raises(RLTK::LexingError) { ABFirst.lex('aaabbbCCC') }
 		assert_raises(RLTK::LexingError) { ABLongest.lex('aaabbbCCC') }
 	end
-	
+
 	def test_longest_match
 		expected = [
 			RLTK::Token.new(:APLUSBPLUS),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = ABLongest.lex('aaabbb')
-		
+
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_match_data
 		expected = [RLTK::Token.new(:FOO, ['', 'ccc']), RLTK::Token.new(:EOS)]
 		actual   = MatchDataLexer.lex('accc')
-		
+
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_state
 		expected = [
 			RLTK::Token.new(:A),
 			RLTK::Token.new(:A),
 			RLTK::Token.new(:EOS)
 		]
-		
+
 		actual = StateLexer.lex('a (* bbb *) a')
 		assert_equal(expected, actual)
-		
+
 		actual = StateLexer.lex('a (* b (* ccc *) b *) a')
 		assert_equal(expected, actual)
 	end

data/test/tc_parser.rb

@@ -29,606 +29,683 @@ class ParserTester < Minitest::Test
 	class ABLexer < RLTK::Lexer
 		rule(/a/) { [:A, 1] }
 		rule(/b/) { [:B, 2] }
-		
+
 		rule(/\s/)
 	end
-	
+
 	class AlphaLexer < RLTK::Lexer
 		rule(/[A-Za-z]/) { |t| [t.upcase.to_sym, t] }
-		
+
 		rule(/,/) { :COMMA }
-		
+
 		rule(/\s/)
 	end
-	
+
 	class UnderscoreLexer < RLTK::Lexer
 		rule(/\w/) { |t| [:A_TOKEN, t] }
 	end
-	
+
 	class APlusBParser < RLTK::Parser
 		production(:a, 'A+ B') { |a, _| a.length }
-		
+
 		finalize
 	end
-	
+
 	class AQuestionBParser < RLTK::Parser
 		production(:a, 'A? B') { |a, _| a }
-		
+
 		finalize
 	end
-	
+
 	class AStarBParser < RLTK::Parser
 		production(:a, 'A* B') { |a, _| a.length }
-		
+
 		finalize
 	end
-	
+
 	class AmbiguousParser < RLTK::Parser
 		production(:e) do
 			clause('NUM') {|n| n}
-			
+
 			clause('e PLS e') { |e0, _, e1| e0 + e1 }
 			clause('e SUB e') { |e0, _, e1| e0 - e1 }
 			clause('e MUL e') { |e0, _, e1| e0 * e1 }
 			clause('e DIV e') { |e0, _, e1| e0 / e1 }
 		end
-		
+
 		finalize
 	end
-	
+
 	class ArrayCalc < RLTK::Parser
 		dat :array
-		
+
 		production(:e) do
 			clause('NUM') { |v| v[0] }
-		
+
 			clause('PLS e e') { |v| v[1] + v[2] }
 			clause('SUB e e') { |v| v[1] - v[2] }
 			clause('MUL e e') { |v| v[1] * v[2] }
 			clause('DIV e e') { |v| v[1] / v[2] }
 		end
-		
+
 		finalize
 	end
-	
+
 	# This grammar is purposefully ambiguous.  This should not be equivalent
 	# to the grammar produced with `e -> A B? B?`, due to greedy Kleene
 	# operators.
 	class AmbiguousParseStackParser < RLTK::Parser
 		production(:s, 'e*') { |e| e }
-		
+
 		production(:e, 'A b_question b_question') { |a, b0, b1| [a, b0, b1] }
-		
+
 		production(:b_question) do
 			clause('')	{ | | nil }
 			clause('B')	{ |b|   b }
 		end
-		
+
 		finalize
 	end
-	
+
+	class EBNFSelectorParser < RLTK::Parser
+		dat :array
+
+		production(:s) do
+			clause('.A .B* .A') { |a| a }
+			clause('.B C* .B')  { |a| a }
+		end
+
+		finalize
+	end
+
 	class EmptyListParser0 < RLTK::Parser
 		list('list', :A, :COMMA)
-		
+
 		finalize
 	end
-	
+
 	class EmptyListParser1 < RLTK::Parser
 		dat :array
-		
+
 		list('list', ['A', 'B', 'C D'], :COMMA)
-		
+
 		finalize
 	end
-	
+
 	class GreedTestParser0 < RLTK::Parser
 		production(:e, 'A? A') { |a0, a1| [a0, a1] }
-		
+
 		finalize
 	end
-	
+
 	class GreedTestParser1 < RLTK::Parser
 		production(:e, 'A? A?') { |a0, a1| [a0, a1] }
-		
+
 		finalize
 	end
-	
+
 	class GreedTestParser2 < RLTK::Parser
 		production(:e, 'A* A') { |a0, a1| [a0, a1] }
-		
+
 		finalize
 	end
-	
+
 	class GreedTestParser3 < RLTK::Parser
 		production(:e, 'A+ A') { |a0, a1| [a0, a1] }
-		
+
 		finalize
 	end
-	
+
 	class NonEmptyListParser0 < RLTK::Parser
 		nonempty_list('list', :A, :COMMA)
-		
+
 		finalize
 	end
-	
+
 	class NonEmptyListParser1 < RLTK::Parser
 		nonempty_list('list', [:A, :B], :COMMA)
-		
+
 		finalize explain: 'nelp1.tbl'
 	end
-	
+
 	class NonEmptyListParser2 < RLTK::Parser
 		nonempty_list('list', ['A', 'B', 'C D'], :COMMA)
-		
+
 		finalize
 	end
-	
+
 	class NonEmptyListParser3 < RLTK::Parser
 		nonempty_list('list', 'A+', :COMMA)
-		
+
 		finalize
 	end
-	
+
 	class NonEmptyListParser4 < RLTK::Parser
 		nonempty_list('list', :A)
-		
+
 		finalize
 	end
-	
+
 	class NonEmptyListParser5 < RLTK::Parser
 		nonempty_list('list', :A, 'B C?')
-		
+
 		finalize
 	end
-	
+
 	class DummyError1 < StandardError; end
 	class DummyError2 < StandardError; end
-	
+
 	class ErrorCalc < RLTK::Parser
 		left :ERROR
 		right :PLS, :SUB, :MUL, :DIV, :NUM
-		
+
 		production(:e) do
 			clause('NUM') {|n| n}
-		
+
 			clause('e PLS e') { |e0, _, e1| e0 + e1 }
 			clause('e SUB e') { |e0, _, e1| e0 - e1 }
 			clause('e MUL e') { |e0, _, e1| e0 * e1 }
 			clause('e DIV e') { |e0, _, e1| e0 / e1 }
-		
+
 			clause('e PLS ERROR e') { |e0, _, ts, e1| error(ts); e0 + e1 }
 		end
-	
+
 		finalize
 	end
 
 	class ELLexer < RLTK::Lexer
-		rule(/\n/)	{ :NEWLINE }
-		rule(/;/)		{ :SEMI    }
-	
+		rule(/\n/) { :NEWLINE }
+		rule(/;/)  { :SEMI    }
+
 		rule(/\s/)
-	
-		rule(/[A-Za-z]+/)	{ |t| [:WORD, t] }
+
+		rule(/[A-Za-z]+/) { |t| [:WORD, t] }
 	end
 
 	class ErrorLine < RLTK::Parser
-	
+
 		production(:s, 'line*') { |l| l }
-	
+
 		production(:line) do
 			clause('NEWLINE') { |_| nil }
-		
+
 			clause('WORD+ SEMI NEWLINE')	{ |w, _, _| w }
 			clause('WORD+ ERROR')		{ |w, e| error(pos(1).line_number); w }
 		end
-	
+
 		finalize
 	end
-	
+
 	class UnderscoreParser < RLTK::Parser
 		production(:s, 'A_TOKEN+') { |o| o }
-		
+
 		finalize
 	end
-	
+
 	class RotatingCalc < RLTK::Parser
 		production(:e) do
 			clause('NUM') {|n| n}
-		
+
 			clause('PLS e e') { |_, e0, e1| e0.send(get_op(:+), e1) }
 			clause('SUB e e') { |_, e0, e1| e0.send(get_op(:-), e1) }
 			clause('MUL e e') { |_, e0, e1| e0.send(get_op(:*), e1) }
 			clause('DIV e e') { |_, e0, e1| e0.send(get_op(:/), e1) }
 		end
-	
+
 		class Environment < Environment
 			def initialize
 				@map = { :+ => 0, :- => 1, :* => 2, :/ => 3 }
 				@ops = [ :+, :-, :*, :/ ]
 			end
-		
+
 			def get_op(orig_op)
 				new_op = @ops[@map[orig_op]]
-			
+
 				@ops = @ops[1..-1] << @ops[0]
-			
+
 				new_op
 			end
 		end
-	
+
 		finalize
 	end
-	
+
 	class SelectionParser < RLTK::Parser
 		production(:s, 'A+ .B+') { |bs| bs.inject &:+ }
-		
+
 		finalize
 	end
-	
+
+	class UselessParser < RLTK::Parser
+		production(:s, 'A+') { |a| a }
+	end
+
+	class TokenHookParser < RLTK::Parser
+		dat :array
+
+		production(:s) do
+			clause('A A A A') { |_| nil }
+			clause('B B B B') { |_| nil }
+		end
+
+		token_hook(:A) { @counter += 1 }
+		token_hook(:B) { @counter += 2 }
+
+		class Environment < Environment
+			attr_reader :counter
+
+			def initialize
+				@counter = 0
+			end
+		end
+
+		finalize
+	end
+
 	def test_ambiguous_grammar
 		actual = AmbiguousParser.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3'), {:accept => :all})
 		assert_equal([7, 9], actual.sort)
 	end
-	
+
 	# This test is to ensure that objects placed on the output stack are
 	# cloned when we split the parse stack.  This was posted as Issue #17 on
 	# Github.
 	def test_ambiguous_parse_stack
 		assert_equal(1, AmbiguousParseStackParser.parse(ABLexer.lex('ab')).length)
 	end
-	
+
 	def test_array_args
 		actual = ArrayCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
 		assert_equal(3, actual)
-		
+
 		actual = ArrayCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 * 2 3'))
 		assert_equal(7, actual)
-		
+
 		actual = ArrayCalc.parse(RLTK::Lexers::Calculator.lex('* + 1 2 3'))
 		assert_equal(9, actual)
 	end
-	
+
+	def test_construction_error
+		assert_raises(RLTK::ParserConstructionException) do
+			Class.new(RLTK::Parser) do
+				finalize
+			end
+		end
+	end
+
 	def test_ebnf_parsing
 		################
 		# APlusBParser #
 		################
-		
+
 		assert_raises(RLTK::NotInLanguage) { APlusBParser.parse(ABLexer.lex('b')) }
-		
+
 		assert_equal(1, APlusBParser.parse(ABLexer.lex('ab')))
 		assert_equal(2, APlusBParser.parse(ABLexer.lex('aab')))
 		assert_equal(3, APlusBParser.parse(ABLexer.lex('aaab')))
 		assert_equal(4, APlusBParser.parse(ABLexer.lex('aaaab')))
-		
+
 		####################
 		# AQuestionBParser #
 		####################
-		
+
 		assert_raises(RLTK::NotInLanguage) { AQuestionBParser.parse(ABLexer.lex('aab')) }
 		assert_nil(AQuestionBParser.parse(ABLexer.lex('b')))
 		refute_nil(AQuestionBParser.parse(ABLexer.lex('ab')))
-		
+
 		################
 		# AStarBParser #
 		################
-		
+
 		assert_equal(0, AStarBParser.parse(ABLexer.lex('b')))
 		assert_equal(1, AStarBParser.parse(ABLexer.lex('ab')))
 		assert_equal(2, AStarBParser.parse(ABLexer.lex('aab')))
 		assert_equal(3, AStarBParser.parse(ABLexer.lex('aaab')))
 		assert_equal(4, AStarBParser.parse(ABLexer.lex('aaaab')))
 	end
-	
+
 	def test_empty_list
 		####################
 		# EmptyListParser0 #
 		####################
-		
+
 		expected = []
 		actual   = EmptyListParser0.parse(AlphaLexer.lex(''))
 		assert_equal(expected, actual)
-		
+
 		####################
 		# EmptyListParser1 #
 		####################
-		
+
 		expected = ['a', 'b', ['c', 'd']]
 		actual   = EmptyListParser1.parse(AlphaLexer.lex('a, b, c d'))
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_greed
-		
+
 		####################
 		# GreedTestParser0 #
 		####################
-		
+
 		expected = [nil, 'a']
 		actual   = GreedTestParser0.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
-		
+
 		expected = ['a', 'a']
 		actual   = GreedTestParser0.parse(AlphaLexer.lex('a a'))
 		assert_equal(expected, actual)
-		
+
 		####################
 		# GreedTestParser1 #
 		####################
-		
+
 		expected = [nil, nil]
 		actual   = GreedTestParser1.parse(AlphaLexer.lex(''))
 		assert_equal(expected, actual)
-		
+
 #		expected = ['a', nil]
 #		actual   = GreedTestParser1.parse(AlphaLexer.lex('a'))
 #		assert_equal(expected, actual)
-		
+
 		expected = ['a', 'a']
 		actual   = GreedTestParser1.parse(AlphaLexer.lex('a a'))
 		assert_equal(expected, actual)
-		
+
 		####################
 		# GreedTestParser2 #
 		####################
-		
+
 		expected = [[], 'a']
 		actual   = GreedTestParser2.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
-		
+
 		expected = [['a'], 'a']
 		actual   = GreedTestParser2.parse(AlphaLexer.lex('a a'))
 		assert_equal(expected, actual)
-		
+
 		expected = [['a', 'a'], 'a']
 		actual   = GreedTestParser2.parse(AlphaLexer.lex('a a a'))
 		assert_equal(expected, actual)
-		
+
 		####################
 		# GreedTestParser3 #
 		####################
-		
+
 		expected = [['a'], 'a']
 		actual   = GreedTestParser3.parse(AlphaLexer.lex('a a'))
 		assert_equal(expected, actual)
-		
+
 		expected = [['a', 'a'], 'a']
 		actual   = GreedTestParser3.parse(AlphaLexer.lex('a a a'))
 		assert_equal(expected, actual)
 	end
-	
+
+	def test_ebnf_selector_interplay
+		expected = ['a', ['b', 'b', 'b'], 'a']
+		actual   = EBNFSelectorParser.parse(AlphaLexer.lex('abbba'))
+		assert_equal(expected, actual)
+
+		expected = ['a', [], 'a']
+		actual   = EBNFSelectorParser.parse(AlphaLexer.lex('aa'))
+		assert_equal(expected, actual)
+
+		expected = ['b', 'b']
+		actual   = EBNFSelectorParser.parse(AlphaLexer.lex('bb'))
+		assert_equal(expected, actual)
+
+		expected = ['b', 'b']
+		actual   = EBNFSelectorParser.parse(AlphaLexer.lex('bcccccb'))
+		assert_equal(expected, actual)
+	end
+
 	def test_environment
 		actual = RotatingCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
 		assert_equal(3, actual)
-		
+
 		actual = RotatingCalc.parse(RLTK::Lexers::Calculator.lex('/ 1 * 2 3'))
 		assert_equal(7, actual)
-		
+
 		actual = RotatingCalc.parse(RLTK::Lexers::Calculator.lex('- + 1 2 3'))
 		assert_equal(9, actual)
-		
+
 		parser = RotatingCalc.new
-		
+
 		actual = parser.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
 		assert_equal(3, actual)
-		
+
 		actual = parser.parse(RLTK::Lexers::Calculator.lex('/ 1 2'))
 		assert_equal(3, actual)
 	end
-	
+
 	def test_error_productions
-		
+
 		# Test to see if error reporting is working correctly.
-		
+
 		test_string  = "first line;\n"
 		test_string += "second line\n"
 		test_string += "third line;\n"
 		test_string += "fourth line\n"
-		
+
 		assert_raises(RLTK::HandledError) { ErrorLine.parse(ELLexer.lex(test_string)) }
-		
+
 		begin
 			ErrorLine.parse(ELLexer.lex(test_string))
-			
+
 		rescue RLTK::HandledError => e
 			assert_equal([2,4], e.errors)
 		end
-		
+
 		# Test to see if we can continue parsing after errors are encounterd.
-		
+
 		begin
 			ErrorCalc.parse(RLTK::Lexers::Calculator.lex('1 + + 1'))
-			
+
 		rescue RLTK::HandledError => e
 			assert_equal(1, e.errors.first.length)
 			assert_equal(2, e.result)
 		end
-		
+
 		# Test to see if we pop tokens correctly after an error is
 		# encountered.
-		
+
 		begin
 			ErrorCalc.parse(RLTK::Lexers::Calculator.lex('1 + + + + + + 1'))
-			
+
 		rescue RLTK::HandledError => e
 			assert_equal(5, e.errors.first.length)
 			assert_equal(2, e.result)
 		end
 	end
-	
+
 	def test_infix_calc
 		actual = RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2'))
 		assert_equal(3, actual)
-		
+
 		actual = RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3'))
 		assert_equal(7, actual)
-		
+
 		actual = RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('(1 + 2) * 3'))
 		assert_equal(9, actual)
-		
+
 		assert_raises(RLTK::NotInLanguage) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 + 3 *')) }
 	end
-	
+
 	def test_input
 		assert_raises(RLTK::BadToken) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::EBNF.lex('A B C')) }
 	end
-	
+
 	def test_nonempty_list
 		#######################
 		# NonEmptyListParser0 #
 		#######################
-		
+
 		expected = ['a']
 		actual   = NonEmptyListParser0.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
-		
+
 		expected = ['a', 'a']
 		actual   = NonEmptyListParser0.parse(AlphaLexer.lex('a, a'))
 		assert_equal(expected, actual)
-		
+
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(''))   }
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(','))  }
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('aa')) }
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex('a,')) }
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser0.parse(AlphaLexer.lex(',a')) }
-		
+
 		#######################
 		# NonEmptyListParser1 #
 		#######################
-		
+
 		expected = ['a']
 		actual   = NonEmptyListParser1.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
-		
+
 		expected = ['b']
 		actual   = NonEmptyListParser1.parse(AlphaLexer.lex('b'))
 		assert_equal(expected, actual)
-		
+
 		expected = ['a', 'b', 'a', 'b']
 		actual   = NonEmptyListParser1.parse(AlphaLexer.lex('a, b, a, b'))
 		assert_equal(expected, actual)
-		
+
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser1.parse(AlphaLexer.lex('a b')) }
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser1.parse(AlphaLexer.lex('a, ')) }
-		
+
 		#######################
 		# NonEmptyListParser2 #
 		#######################
-		
+
 		expected = ['a']
 		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('a'))
 		assert_equal(expected, actual)
-		
+
 		expected = ['b']
 		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('b'))
 		assert_equal(expected, actual)
-		
+
 		expected = [['c', 'd']]
 		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('c d'))
 		assert_equal(expected, actual)
-		
+
 		expected = [['c', 'd'], ['c', 'd']]
 		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('c d, c d'))
 		assert_equal(expected, actual)
-		
+
 		expected = ['a', 'b', ['c', 'd']]
 		actual   = NonEmptyListParser2.parse(AlphaLexer.lex('a, b, c d'))
 		assert_equal(expected, actual)
-		
+
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('c')) }
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser2.parse(AlphaLexer.lex('d')) }
-		
+
 		#######################
 		# NonEmptyListParser3 #
 		#######################
-		
+
 		expected = [['a'], ['a', 'a'], ['a', 'a', 'a']]
 		actual   = NonEmptyListParser3.parse(AlphaLexer.lex('a, aa, aaa'))
 		assert_equal(expected, actual)
-		
+
 		#######################
 		# NonEmptyListParser4 #
 		#######################
-		
+
 		expected = ['a', 'a', 'a']
 		actual   = NonEmptyListParser4.parse(AlphaLexer.lex('a a a'))
 		assert_equal(expected, actual)
-		
+
 		#######################
 		# NonEmptyListParser5 #
 		#######################
-		
+
 		expected = ['a', 'a', 'a']
 		actual   = NonEmptyListParser5.parse(AlphaLexer.lex('a b a b c a'))
 		assert_equal(expected, actual)
-		
+
 		assert_raises(RLTK::NotInLanguage) { NonEmptyListParser5.parse(AlphaLexer.lex('a b b a')) }
 	end
-	
+
 	def test_postfix_calc
 		actual = RLTK::Parsers::PostfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 +'))
 		assert_equal(3, actual)
-		
+
 		actual = RLTK::Parsers::PostfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 3 * +'))
 		assert_equal(7, actual)
-		
+
 		actual = RLTK::Parsers::PostfixCalc.parse(RLTK::Lexers::Calculator.lex('1 2 + 3 *'))
 		assert_equal(9, actual)
-		
+
 		assert_raises(RLTK::NotInLanguage) { RLTK::Parsers::InfixCalc.parse(RLTK::Lexers::Calculator.lex('* + 1 2 3')) }
 	end
-	
+
 	def test_prefix_calc
 		actual = RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 2'))
 		assert_equal(3, actual)
-		
+
 		actual = RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('+ 1 * 2 3'))
 		assert_equal(7, actual)
-		
+
 		actual = RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('* + 1 2 3'))
 		assert_equal(9, actual)
-		
+
 		assert_raises(RLTK::NotInLanguage) { RLTK::Parsers::PrefixCalc.parse(RLTK::Lexers::Calculator.lex('1 + 2 * 3')) }
 	end
-	
+
 	def test_selection_parser
 		actual   = SelectionParser.parse(ABLexer.lex('aaabbb'))
 		expected = 6
-		
+
 		assert_equal(expected, actual)
 	end
-	
+
+	def test_token_hooks
+		parser = TokenHookParser.new
+
+		parser.parse(AlphaLexer.lex('a a a a'))
+		assert_equal(4, parser.env.counter)
+
+		parser.parse(AlphaLexer.lex('b b b b'))
+		assert_equal(12, parser.env.counter)
+	end
+
 	def test_underscore_tokens
 		actual   = UnderscoreParser.parse(UnderscoreLexer.lex('abc')).join
 		expected = 'abc'
-		
+
 		assert_equal(expected, actual)
 	end
-	
+
 	def test_use
 		tmpfile = File.join(Dir.tmpdir, 'usetest')
-		
+
 		FileUtils.rm(tmpfile) if File.exist?(tmpfile)
-		
+
 		parser0 = Class.new(RLTK::Parser) do
 			production(:a, 'A+') { |a| a.length }
-			
+
 			finalize use: tmpfile
 		end
-		
+
 		result0 = parser0.parse(ABLexer.lex('a'))
-		
+
 		assert(File.exist?(tmpfile), 'Serialized parser file not found.')
-		
+
 		parser1 = Class.new(RLTK::Parser) do
 			production(:a, 'A+') { |a| a.length }
-			
+
 			finalize use: tmpfile
 		end
-		
+
 		result1 = parser1.parse(ABLexer.lex('a'))
-		
+
 		assert_equal(result0, result1)
-		
+
 		File.unlink(tmpfile)
 	end
+
+	def test_uesless_parser_exception
+		assert_raises(RLTK::UselessParserException) { UselessParser.new }
+	end
 end