dhaka 0.0.2 → 0.0.3

data/lib/parser/parse_tree.rb

@@ -11,6 +11,23 @@ module Dhaka
     def to_s
       "CompositeNode: #{production.symbol} --> [#{child_nodes.join(", ")}]"
     end
+    def dot_name
+      "Node#{object_id}"
+    end
+
+    def to_dot
+      result = []
+      result << ["digraph x {", "node [fontsize=\"10\" shape=box size=\"5\"]"] if head_node?
+      label = self.production
+      result << "#{dot_name} [label=\"#{label}\"]"
+      child_nodes.each do |child|
+        result << "#{dot_name} -> #{child.dot_name}"
+        result << "#{child.to_dot}"
+      end
+      result << ['}'] if head_node?
+      result.join("\n")
+    end
+    
     def head_node?
       production.symbol.name == START_SYMBOL_NAME
     end
@@ -27,6 +44,13 @@ module Dhaka
     def to_s
       "LeafNode: #{token}"
     end
+    def dot_name
+      "Node#{object_id}"
+    end
+    def to_dot
+      label = "#{token}#{' : '+token.value.to_s if token.value}"
+      "#{dot_name} [label=\"#{label}\"]"
+    end
     def head_node?
       false
     end

data/lib/parser/parser_methods.rb

@@ -2,8 +2,7 @@
 module Dhaka
   module ParserMethods
     def parse token_stream
-      return nil if token_stream.empty?
-      parser_run = ParserRun.new(grammar, start_state, token_stream+[Token.new(@grammar.end_symbol, nil)])
+      parser_run = ParserRun.new(grammar, start_state, token_stream)
       parser_run.run
     end
   end

data/lib/parser/parser_run.rb

@@ -1,6 +1,6 @@
 module Dhaka
   class ParserRun
-    attr_reader :state_stack, :token_stream, :node_stack
+
     def initialize(grammar, start_state, token_stream)
       @grammar = grammar
       @node_stack = []
@@ -8,21 +8,29 @@ module Dhaka
       @token_stream = token_stream
       @current_token_index = 0
     end
-    def current_token
-      @token_stream[@current_token_index]
-    end
-    def advance
-      node_stack << ParseTreeLeafNode.new(current_token)
-      @current_token_index += 1
-    end
+
     def run
-      while current_token
+      for_each_token_with_end do
         error = execute_action current_token.grammar_symbol.name
         return error if error
-        self.advance
+        node_stack << ParseTreeLeafNode.new(current_token)
+        @current_token_index += 1
       end
       ParseSuccessResult.new(node_stack[0])
     end
+
+    private
+
+    attr_reader :state_stack, :token_stream, :node_stack, :current_token
+
+    def for_each_token_with_end
+      token_stream.each do |@current_token|
+        yield
+      end
+      @current_token = Token.new(@grammar.end_symbol, nil)
+      yield
+    end
+
     def execute_action symbol_name
       action = state_stack[-1].actions[symbol_name]
       return ParseErrorResult.new(@current_token_index) unless action
@@ -31,5 +39,6 @@ module Dhaka
       end
       nil
     end
+
   end
 end

data/test/arithmetic_evaluator.rb

@@ -27,10 +27,6 @@ class ArithmeticEvaluator < Dhaka::Evaluator
       child_nodes[0].token.value
     end
 
-    for_start_production do
-      child_nodes[0]
-    end
-
     for_unpacking_parenthetized_expression do
       child_nodes[1]
     end

data/test/arithmetic_evaluator_test.rb

@@ -14,7 +14,7 @@ class TestArithmeticEvaluator < Test::Unit::TestCase
 
   def test_results_simple_arithmetic_given_tokens_and_syntax_tree_1
     
-    token_stream = [token('n', 2), token('-', nil), token('n', 4), token('#', nil)]
+    token_stream = [token('n', 2), token('-', nil), token('n', 4)]
     syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
     assert_equal -2, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
     
@@ -22,7 +22,7 @@ class TestArithmeticEvaluator < Test::Unit::TestCase
 
   def test_results_simple_arithmetic_given_tokens_and_syntax_tree_2
 
-    token_stream = [token('n', 2), token('-', nil), token('(', nil), token('n', 3), token('/', nil), token('n', 4), token(')', nil), token('#', nil)]
+    token_stream = [token('n', 2), token('-', nil), token('(', nil), token('n', 3), token('/', nil), token('n', 4), token(')', nil)]
     syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
     assert_equal 1.25, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 
@@ -30,7 +30,7 @@ class TestArithmeticEvaluator < Test::Unit::TestCase
 
   def test_results_simple_arithmetic_given_tokens_and_syntax_tree_3
 
-    token_stream = [token('n', 2), token('+', nil), token('(', nil), token('n', 3), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil), token('#', nil)]
+    token_stream = [token('n', 2), token('+', nil), token('(', nil), token('n', 3), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil)]
     syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
     assert_equal 3.5, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 
@@ -38,7 +38,7 @@ class TestArithmeticEvaluator < Test::Unit::TestCase
 
   def test_results_simple_arithmetic_given_tokens_and_syntax_tree_4
 
-    token_stream = [token('n', 2), token('+', nil), token('h', nil), token('(', nil), token('n', 3), token(',', nil), token('n', 4), token(')', nil), token('#', nil)]
+    token_stream = [token('n', 2), token('+', nil), token('h', nil), token('(', nil), token('n', 3), token(',', nil), token('n', 4), token(')', nil)]
     syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
     assert_equal 6, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 
@@ -46,7 +46,7 @@ class TestArithmeticEvaluator < Test::Unit::TestCase
 
   def test_results_simple_arithmetic_given_tokens_and_syntax_tree_5
 
-    token_stream = [token('n', 2), token('+', nil), token('l', nil), token('(', nil), token('n', 3), token(',', nil), token('n', 4), token(')', nil), token('#', nil)]
+    token_stream = [token('n', 2), token('+', nil), token('l', nil), token('(', nil), token('n', 3), token(',', nil), token('n', 4), token(')', nil)]
     syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
     assert_equal 5, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 

data/test/arithmetic_grammar.rb

@@ -2,9 +2,6 @@ require File.dirname(__FILE__)+'/../lib/dhaka'
 
 class ArithmeticGrammar < Dhaka::Grammar
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    start_production ['S', '#']
-  end
-  for_symbol('S') do
     expression ['E']
   end
   for_symbol('E') do

data/test/arithmetic_tokenizer.rb

@@ -9,10 +9,9 @@ class ArithmeticTokenizer < Dhaka::Tokenizer
   operators = ['-', '+', '/', '*']
   functions = ['h', 'l']
   arg_separator = [',']
-  sentinel = ['#']
   whitespace = [' ']
 
-  all_characters = digits + parenths + operators + functions + arg_separator + sentinel + whitespace
+  all_characters = digits + parenths + operators + functions + arg_separator + whitespace
 
   for_state :idle_state do
     for_characters(all_characters - (digits + whitespace)) do
@@ -36,6 +35,7 @@ class ArithmeticTokenizer < Dhaka::Tokenizer
     for_characters digits do
       self.accumulator += curr_char
       advance
+      tokens << Dhaka::Token.new(ArithmeticGrammar.symbol_for_name('n'), accumulator.to_i) unless curr_char
     end
   end
   

data/test/arithmetic_tokenizer_test.rb

@@ -6,24 +6,24 @@ class TestArithmeticTokenizer < Test::Unit::TestCase
     assert_equal([], ArithmeticTokenizer.tokenize([]))
   end
   def test_tokenizes_given_a_string_input
-    assert_equal([token('n', 2), token('-', nil), token('n', 4), token('#', nil)], ArithmeticTokenizer.tokenize('2 - 4 #')) 
+    assert_equal([token('n', 2), token('-', nil), token('n', 4)], ArithmeticTokenizer.tokenize('2 - 4')) 
   end
   def test_a_longer_input
-    actual = ArithmeticTokenizer.tokenize('2+(3 / (7 - 5))#')
-    assert_equal([token('n', 2), token('+', nil), token('(', nil), token('n', 3), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil), token('#', nil)], actual)
+    actual = ArithmeticTokenizer.tokenize('2+(3 / (7 - 5))')
+    assert_equal([token('n', 2), token('+', nil), token('(', nil), token('n', 3), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil)], actual)
   end
 
   def test_another_input_with_multi_digit_numbers
-    actual = ArithmeticTokenizer.tokenize('2034 +(3433 / (7 - 5))#')
-    assert_equal([token('n', 2034), token('+', nil), token('(', nil), token('n', 3433), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil), token('#', nil)], actual)
+    actual = ArithmeticTokenizer.tokenize('2034 +(3433 / (7 - 5))')
+    assert_equal([token('n', 2034), token('+', nil), token('(', nil), token('n', 3433), token('/', nil), token('(', nil), token('n', 7), token('-', nil), token('n', 5), token(')', nil) , token(')', nil)], actual)
   end
 
   def test_an_input_with_unrecognized_characters
-    assert_raise(Dhaka::UnrecognizedInputCharacterException) {ArithmeticTokenizer.tokenize('2+(3 / (7 -& 5))#')}
+    assert_raise(Dhaka::UnrecognizedInputCharacterException) {ArithmeticTokenizer.tokenize('2+(3 / (7 -& 5))')}
   end
 
   def test_another_input_with_illegal_characters
-    assert_raise(Dhaka::UnrecognizedInputCharacterException) {ArithmeticTokenizer.tokenize('2034 +(34b3 / (7 - 5))#')}
+    assert_raise(Dhaka::UnrecognizedInputCharacterException) {ArithmeticTokenizer.tokenize('2034 +(34b3 / (7 - 5))')}
   end
 
   def token(symbol_name, value)

data/test/compiled_arithmetic_parser.rb

@@ -5,248 +5,239 @@ class CompiledArithmeticParser < Dhaka::CompiledParser
 
   self.grammar = ArithmeticGrammar
 
-  start_with 33
+  start_with 11
+
+  at_state(21) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 22 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
+  }
+
+  at_state(28) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('E') { shift_to 27 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 30 }
+    for_symbol('Args') { shift_to 29 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
+    for_symbol(')') { reduce_with 'empty_args' }
+    for_symbol('T') { shift_to 14 }
+  }
 
-  at_state(48) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('F') { shift_to 49 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
+  at_state(17) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('E') { shift_to 18 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 30 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
+    for_symbol('T') { shift_to 14 }
   }
 
-  at_state(43) {
-    for_symbol('+') { reduce_with 'subtraction' }
-    for_symbol(',') { reduce_with 'subtraction' }
-    for_symbol('-') { reduce_with 'subtraction' }
-    for_symbol('#') { reduce_with 'subtraction' }
-    for_symbol('/') { shift_to 44 }
-    for_symbol(')') { reduce_with 'subtraction' }
-    for_symbol('*') { shift_to 48 }
+  at_state(23) {
+    for_symbol('(') { shift_to 24 }
   }
 
-  at_state(55) {
-    for_symbol('+') { shift_to 52 }
-    for_symbol(',') { shift_to 56 }
-    for_symbol('-') { shift_to 40 }
-    for_symbol(')') { reduce_with 'single_args' }
+  at_state(16) {
+    for_symbol('(') { reduce_with 'min_function' }
+  }
+
+  at_state(13) {
+    for_symbol('(') { reduce_with 'max_function' }
   }
 
-  at_state(53) {
+  at_state(20) {
     for_symbol('+') { reduce_with 'addition' }
     for_symbol(',') { reduce_with 'addition' }
     for_symbol('-') { reduce_with 'addition' }
-    for_symbol('#') { reduce_with 'addition' }
-    for_symbol('/') { shift_to 44 }
+    for_symbol('/') { shift_to 15 }
+    for_symbol('_End_') { reduce_with 'addition' }
     for_symbol(')') { reduce_with 'addition' }
-    for_symbol('*') { shift_to 48 }
+    for_symbol('*') { shift_to 21 }
   }
 
-  at_state(50) {
-    for_symbol('+') { reduce_with 'factor' }
-    for_symbol(',') { reduce_with 'factor' }
-    for_symbol('-') { reduce_with 'factor' }
-    for_symbol('#') { reduce_with 'factor' }
-    for_symbol('/') { reduce_with 'factor' }
-    for_symbol(')') { reduce_with 'factor' }
-    for_symbol('*') { reduce_with 'factor' }
+  at_state(34) {
+    for_symbol('+') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol(',') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('-') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('/') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('_End_') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol(')') { reduce_with 'unpacking_parenthetized_expression' }
+    for_symbol('*') { reduce_with 'unpacking_parenthetized_expression' }
   }
 
-  at_state(47) {
-    for_symbol('(') { reduce_with 'min_function' }
+  at_state(32) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 30 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
+    for_symbol('T') { shift_to 33 }
   }
 
-  at_state(52) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('F') { shift_to 50 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
-    for_symbol('T') { shift_to 53 }
+  at_state(15) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 35 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
   }
 
   at_state(33) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('E') { shift_to 58 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('F') { shift_to 50 }
-    for_symbol('S') { shift_to 59 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
-    for_symbol('T') { shift_to 54 }
-  }
-
-  at_state(59) {
-    for_symbol('#') { shift_to 60 }
-  }
-
-  at_state(38) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('E') { shift_to 39 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('F') { shift_to 50 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
-    for_symbol('T') { shift_to 54 }
-  }
-
-  at_state(34) {
-    for_symbol('(') { shift_to 35 }
+    for_symbol('+') { reduce_with 'subtraction' }
+    for_symbol(',') { reduce_with 'subtraction' }
+    for_symbol('-') { reduce_with 'subtraction' }
+    for_symbol('/') { shift_to 15 }
+    for_symbol('_End_') { reduce_with 'subtraction' }
+    for_symbol(')') { reduce_with 'subtraction' }
+    for_symbol('*') { shift_to 21 }
+  }
+
+  at_state(24) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('E') { shift_to 27 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 30 }
+    for_symbol('Args') { shift_to 25 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
+    for_symbol(')') { reduce_with 'empty_args' }
+    for_symbol('T') { shift_to 14 }
   }
 
-  at_state(41) {
-    for_symbol('(') { reduce_with 'max_function' }
+  at_state(11) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('E') { shift_to 36 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 30 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
+    for_symbol('T') { shift_to 14 }
   }
 
-  at_state(60) {
-    for_symbol('_End_') { reduce_with 'start_production' }
+  at_state(35) {
+    for_symbol('+') { reduce_with 'division' }
+    for_symbol(',') { reduce_with 'division' }
+    for_symbol('-') { reduce_with 'division' }
+    for_symbol('/') { reduce_with 'division' }
+    for_symbol('_End_') { reduce_with 'division' }
+    for_symbol(')') { reduce_with 'division' }
+    for_symbol('*') { reduce_with 'division' }
   }
 
-  at_state(46) {
+  at_state(31) {
     for_symbol('+') { reduce_with 'function' }
     for_symbol(',') { reduce_with 'function' }
     for_symbol('-') { reduce_with 'function' }
-    for_symbol('#') { reduce_with 'function' }
     for_symbol('/') { reduce_with 'function' }
+    for_symbol('_End_') { reduce_with 'function' }
     for_symbol(')') { reduce_with 'function' }
     for_symbol('*') { reduce_with 'function' }
   }
 
-  at_state(45) {
-    for_symbol('+') { reduce_with 'division' }
-    for_symbol(',') { reduce_with 'division' }
-    for_symbol('-') { reduce_with 'division' }
-    for_symbol('#') { reduce_with 'division' }
-    for_symbol('/') { reduce_with 'division' }
-    for_symbol(')') { reduce_with 'division' }
-    for_symbol('*') { reduce_with 'division' }
+  at_state(26) {
+    for_symbol('+') { reduce_with 'evaluating_function' }
+    for_symbol(',') { reduce_with 'evaluating_function' }
+    for_symbol('-') { reduce_with 'evaluating_function' }
+    for_symbol('/') { reduce_with 'evaluating_function' }
+    for_symbol('_End_') { reduce_with 'evaluating_function' }
+    for_symbol(')') { reduce_with 'evaluating_function' }
+    for_symbol('*') { reduce_with 'evaluating_function' }
   }
 
-  at_state(35) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('E') { shift_to 55 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('F') { shift_to 50 }
-    for_symbol('Args') { shift_to 36 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
-    for_symbol(')') { reduce_with 'empty_args' }
-    for_symbol('T') { shift_to 54 }
+  at_state(18) {
+    for_symbol('+') { shift_to 19 }
+    for_symbol('-') { shift_to 32 }
+    for_symbol(')') { shift_to 34 }
   }
 
-  at_state(54) {
+  at_state(14) {
     for_symbol('+') { reduce_with 'term' }
     for_symbol(',') { reduce_with 'term' }
     for_symbol('-') { reduce_with 'term' }
-    for_symbol('#') { reduce_with 'term' }
-    for_symbol('/') { shift_to 44 }
+    for_symbol('/') { shift_to 15 }
+    for_symbol('_End_') { reduce_with 'term' }
     for_symbol(')') { reduce_with 'term' }
-    for_symbol('*') { shift_to 48 }
-  }
-
-  at_state(58) {
-    for_symbol('+') { shift_to 52 }
-    for_symbol('-') { shift_to 40 }
-    for_symbol('#') { reduce_with 'expression' }
+    for_symbol('*') { shift_to 21 }
   }
 
-  at_state(56) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('E') { shift_to 55 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('F') { shift_to 50 }
-    for_symbol('Args') { shift_to 57 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
-    for_symbol(')') { reduce_with 'empty_args' }
-    for_symbol('T') { shift_to 54 }
+  at_state(25) {
+    for_symbol(')') { shift_to 26 }
   }
 
-  at_state(51) {
-    for_symbol('+') { reduce_with 'unpacking_parenthetized_expression' }
-    for_symbol(',') { reduce_with 'unpacking_parenthetized_expression' }
-    for_symbol('-') { reduce_with 'unpacking_parenthetized_expression' }
-    for_symbol('#') { reduce_with 'unpacking_parenthetized_expression' }
-    for_symbol('/') { reduce_with 'unpacking_parenthetized_expression' }
-    for_symbol(')') { reduce_with 'unpacking_parenthetized_expression' }
-    for_symbol('*') { reduce_with 'unpacking_parenthetized_expression' }
-  }
-
-  at_state(44) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('F') { shift_to 45 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
+  at_state(22) {
+    for_symbol('+') { reduce_with 'multiplication' }
+    for_symbol(',') { reduce_with 'multiplication' }
+    for_symbol('-') { reduce_with 'multiplication' }
+    for_symbol('/') { reduce_with 'multiplication' }
+    for_symbol('_End_') { reduce_with 'multiplication' }
+    for_symbol(')') { reduce_with 'multiplication' }
+    for_symbol('*') { reduce_with 'multiplication' }
   }
 
-  at_state(42) {
+  at_state(12) {
     for_symbol('+') { reduce_with 'getting_literals' }
     for_symbol(',') { reduce_with 'getting_literals' }
     for_symbol('-') { reduce_with 'getting_literals' }
-    for_symbol('#') { reduce_with 'getting_literals' }
     for_symbol('/') { reduce_with 'getting_literals' }
+    for_symbol('_End_') { reduce_with 'getting_literals' }
     for_symbol(')') { reduce_with 'getting_literals' }
     for_symbol('*') { reduce_with 'getting_literals' }
   }
 
   at_state(36) {
-    for_symbol(')') { shift_to 37 }
+    for_symbol('+') { shift_to 19 }
+    for_symbol('-') { shift_to 32 }
+    for_symbol('_End_') { reduce_with 'expression' }
   }
 
-  at_state(49) {
-    for_symbol('+') { reduce_with 'multiplication' }
-    for_symbol(',') { reduce_with 'multiplication' }
-    for_symbol('-') { reduce_with 'multiplication' }
-    for_symbol('#') { reduce_with 'multiplication' }
-    for_symbol('/') { reduce_with 'multiplication' }
-    for_symbol(')') { reduce_with 'multiplication' }
-    for_symbol('*') { reduce_with 'multiplication' }
+  at_state(30) {
+    for_symbol('+') { reduce_with 'factor' }
+    for_symbol(',') { reduce_with 'factor' }
+    for_symbol('-') { reduce_with 'factor' }
+    for_symbol('/') { reduce_with 'factor' }
+    for_symbol('_End_') { reduce_with 'factor' }
+    for_symbol(')') { reduce_with 'factor' }
+    for_symbol('*') { reduce_with 'factor' }
   }
 
-  at_state(57) {
+  at_state(29) {
     for_symbol(')') { reduce_with 'concatenating_args' }
   }
 
-  at_state(40) {
-    for_symbol('l') { shift_to 47 }
-    for_symbol('n') { shift_to 42 }
-    for_symbol('FunctionName') { shift_to 34 }
-    for_symbol('Function') { shift_to 46 }
-    for_symbol('F') { shift_to 50 }
-    for_symbol('h') { shift_to 41 }
-    for_symbol('(') { shift_to 38 }
-    for_symbol('T') { shift_to 43 }
-  }
-
-  at_state(39) {
-    for_symbol('+') { shift_to 52 }
-    for_symbol('-') { shift_to 40 }
-    for_symbol(')') { shift_to 51 }
+  at_state(27) {
+    for_symbol('+') { shift_to 19 }
+    for_symbol(',') { shift_to 28 }
+    for_symbol('-') { shift_to 32 }
+    for_symbol(')') { reduce_with 'single_args' }
   }
 
-  at_state(37) {
-    for_symbol('+') { reduce_with 'evaluating_function' }
-    for_symbol(',') { reduce_with 'evaluating_function' }
-    for_symbol('-') { reduce_with 'evaluating_function' }
-    for_symbol('#') { reduce_with 'evaluating_function' }
-    for_symbol('/') { reduce_with 'evaluating_function' }
-    for_symbol(')') { reduce_with 'evaluating_function' }
-    for_symbol('*') { reduce_with 'evaluating_function' }
+  at_state(19) {
+    for_symbol('l') { shift_to 16 }
+    for_symbol('FunctionName') { shift_to 23 }
+    for_symbol('n') { shift_to 12 }
+    for_symbol('Function') { shift_to 31 }
+    for_symbol('F') { shift_to 30 }
+    for_symbol('(') { shift_to 17 }
+    for_symbol('h') { shift_to 13 }
+    for_symbol('T') { shift_to 20 }
   }
 
 end

data/test/compiled_parser_test.rb

@@ -29,7 +29,7 @@ class TestCompiledParser < Test::Unit::TestCase
   end
 
   def test_compiled_parser_generates_syntax_tree_for_arithmetic_grammar
-    parser_input = ['(','n','-','(','n','/','n','-','n',')','/','n',')','#']
+    parser_input = ['(','n','-','(','n','/','n','-','n',')','/','n',')']
     assert_equal \
       ["getting_literals",
        "factor",
@@ -50,16 +50,15 @@ class TestCompiledParser < Test::Unit::TestCase
        "unpacking_parenthetized_expression",
        "factor",
        "term",
-       "expression",
-       "start_production"], get_syntax_tree_with_compiled_arithmetic_parser(build_tokens(parser_input, CompiledArithmeticParser.grammar)).linearize
+       "expression"], get_syntax_tree_with_compiled_arithmetic_parser(build_tokens(parser_input, CompiledArithmeticParser.grammar)).linearize
   end
   
-  def test_parser_returns_nil_syntax_tree_if_empty_token_array
-    assert_nil CompiledArithmeticParser.parse([])
+  def test_parse_result_has_error_if_empty_token_array
+    assert CompiledArithmeticParser.parse([]).has_error?
   end
 
   def test_parser_returns_error_result_with_index_of_bad_token_if_parse_error
-    parse_result = CompiledArithmeticParser.parse(build_tokens(['(', '-', ')', '#'], CompiledArithmeticParser.grammar))
+    parse_result = CompiledArithmeticParser.parse(build_tokens(['(', '-', ')'], CompiledArithmeticParser.grammar))
     assert parse_result.has_error?
     assert_equal 1, parse_result.bad_token_index
   end

data/test/nullable_grammar.rb

@@ -2,7 +2,7 @@ require File.dirname(__FILE__)+'/../lib/dhaka'
 
 class NullableGrammar < Dhaka::Grammar
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    tuple ['Tuple', '#']
+    tuple ['Tuple']
   end
   for_symbol('Tuple') do
     element_list ['(', 'Elements', ')']

data/test/parser_test.rb

@@ -76,8 +76,7 @@ class ParserTest < Test::Unit::TestCase
   def test_with_a_different_grammar_with_division
     grammar = ArithmeticGrammar
     parser = Dhaka::Parser.new(grammar)
-    #write_parser(parser)
-    parser_input = ['(','n','-','(','n','/','n','-','n',')','/','n',')','#']
+    parser_input = ['(','n','-','(','n','/','n','-','n',')','/','n',')']
     assert_equal \
       ["getting_literals",
        "factor",
@@ -98,10 +97,9 @@ class ParserTest < Test::Unit::TestCase
        "unpacking_parenthetized_expression",
        "factor",
        "term",
-       "expression",
-       "start_production"], get_linearized_parse_result(parser_input, parser)
+       "expression"], get_linearized_parse_result(parser_input, parser)
 
-    parser_input = ['h','(','(','n',')','-','n',',','n',')','#']
+    parser_input = ['h','(','(','n',')','-','n',',','n',')']
     assert_equal \
       ["max_function",
        "getting_literals",
@@ -122,14 +120,13 @@ class ParserTest < Test::Unit::TestCase
        "function",
        "factor",
        "term",
-       "expression",
-       "start_production"], get_linearized_parse_result(parser_input, parser)
+       "expression"], get_linearized_parse_result(parser_input, parser)
   end
   
   def test_with_a_grammar_with_nullables_after_terminals
     grammar = NullableGrammar
     parser = Dhaka::Parser.new(grammar)
-    parser_input = ['(','a',')','#']
+    parser_input = ['(','a',')']
     assert_equal \
       ["literal_a",
        "empty_element_list",

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: dhaka
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2006-11-28 00:00:00 -05:00
+  version: 0.0.3
+date: 2006-12-04 00:00:00 -05:00
 summary: An LALR1 parser generator written in Ruby
 require_paths: 
 - lib