dhaka 0.0.4 → 0.0.5

data/lib/grammar/precedence.rb

@@ -10,5 +10,9 @@ module Dhaka
     def <=> other
       self.precedence_level <=> other.precedence_level
     end
+    
+    def to_s
+      "Precedence: #{precedence_level} Associativity: #{associativity}"
+    end
   end
 end

data/lib/grammar/production.rb

@@ -2,15 +2,17 @@
 module Dhaka
   class Production
 
-    attr_reader :symbol, :expansion, :name, :precedence
+    attr_reader :symbol, :expansion, :name
 
     def initialize(symbol, expansion, name, precedence = nil)
       @symbol = symbol
       @expansion = expansion
       @name = name
-      if precedence
-        @precedence = precedence
-      else
+      @precedence = precedence
+    end
+
+    def precedence
+      unless @precedence
         @expansion.reverse_each do |symbol|
           if symbol.terminal
             @precedence = symbol.precedence
@@ -18,6 +20,7 @@ module Dhaka
           end
         end 
       end
+      @precedence
     end
 
     def to_s

data/lib/parser/item.rb

@@ -17,7 +17,7 @@ module Dhaka
     def next_item
       Item.new(@production, @next_item_index+1)
     end
-    def to_s
+    def to_s(options = {})
       expansion_symbols = @production.expansion.collect {|symbol| symbol.name}
       if @next_item_index < expansion_symbols.size
         expansion_symbols.insert(@next_item_index, '->')
@@ -25,7 +25,11 @@ module Dhaka
         expansion_symbols << '->'
       end
       expansion_repr = expansion_symbols.join(' ')
-      "#{@production.symbol} ::= #{expansion_repr} [#{@lookaheadset.collect.sort}]"
+      if options[:hide_lookaheads] 
+        "#{@production.symbol} ::= #{expansion_repr}"
+      else
+        "#{@production.symbol} ::= #{expansion_repr} [#{@lookaheadset.collect.sort}]"
+      end
     end
     def eql?(other)
       @production == other.production && @next_item_index==other.next_item_index

data/lib/parser/parser.rb

@@ -59,9 +59,9 @@ module Dhaka
       result
     end
 
-    def to_dot
+    def to_dot(options = {})
       result = ["digraph x {", "node [fontsize=\"10\" shape=box size=\"5\"]"]
-      result += states.collect { |state| state.to_dot }
+      result += states.collect { |state| state.to_dot(options) }
       states.each { |state| 
           @transitions[state].each { |symbol, dest_state| 
               result << "#{state.dot_name} -> #{dest_state.dot_name} [label=\"#{symbol.name}\"]"
@@ -95,7 +95,7 @@ module Dhaka
         new_action = ReduceAction.new(item.production) 
         if existing_action = state.actions[lookahead.name]
           if ReduceAction === existing_action
-            raise ParserReduceReduceConflictError.new(build_conflict_message(state, lookahead, new_action).join("\n"))
+            @logger.error(build_conflict_message(state, lookahead, new_action).join("\n"))
           else
             resolve_conflict state, lookahead, new_action
           end
@@ -125,7 +125,7 @@ module Dhaka
               message << "Resolving with right associativity. Choosing shift over reduce."
             when :nonassoc
               message << "Resolving with non-associativity. Eliminating action."
-              state.actions[lookahead.name] = nil
+              state.actions.delete(lookahead.name)
           end
         end
       else
@@ -135,7 +135,7 @@ module Dhaka
     end
   
     def build_conflict_message state, lookahead, new_action
-      message = ["Parser Conflict at State:"] + state.items.values.collect{|it| it.to_s}
+      message = ["Parser Conflict at State:"] + state.items.values.collect{|it| it.to_s(:hide_lookaheads => true)}
       message << "Existing: #{state.actions[lookahead.name]}"
       message << "New: #{new_action}"
       message << "Lookahead: #{lookahead}"

data/lib/parser/parser_state.rb

@@ -32,8 +32,8 @@ module Dhaka
       self.to_s
     end
 
-    def to_dot
-      label = self.items.values.join('\n')
+    def to_dot(options = {})
+      label = self.items.values.collect{|item| item.to_s(options)}.join('\n')
       "#{dot_name} [label=\"#{label}\"]"
     end
     def compile_to_ruby_source

data/test/all_tests.rb

@@ -10,4 +10,5 @@ require 'arithmetic_tokenizer_test'
 require 'malformed_grammar_test'
 require 'brackets_test'
 require 'arithmetic_precedence_grammar_test'
-require 'arithmetic_precedence_parser_test'
+require 'arithmetic_precedence_parser_test'
+require 'precedence_grammar_test'

data/test/another_lalr_but_not_slr_grammar.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+
+class AnotherLALRButNotSLRGrammar < Dhaka::Grammar
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    assignment ['L', '=', 'R']
+    rhs ['R']
+  end
+  for_symbol('L') do
+    contents ['*', 'R']
+    identifier ['id']
+  end
+  for_symbol('R') do
+    l_value ['L']
+  end
+end
+

data/test/arithmetic_evaluator_test.rb

@@ -1,8 +1,7 @@
 require 'test/unit'
-require 'compiled_arithmetic_parser'
 require 'arithmetic_evaluator'
 require 'arithmetic_test_methods'
-
+eval(Dhaka::Parser.new(ArithmeticGrammar).compile_to_ruby_source_as(:CompiledArithmeticParser))
 class TestArithmeticEvaluator < Test::Unit::TestCase
   include ArithmeticTestMethods
   
@@ -15,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)]
-    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    syntax_tree = parse(token_stream)
     assert_equal -2, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
     
   end
@@ -23,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)]
-    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    syntax_tree = parse(token_stream)
     assert_equal 1.25, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 
   end
@@ -31,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)]
-    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    syntax_tree = parse(token_stream)
     assert_equal 3.5, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 
   end
@@ -39,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)]
-    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    syntax_tree = parse(token_stream)
     assert_equal 6, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 
   end
@@ -47,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)]
-    syntax_tree = get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+    syntax_tree = parse(token_stream)
     assert_equal 5, ArithmeticEvaluator.new(syntax_tree, @min_func, @max_func).result
 
   end

data/test/arithmetic_precedence_evaluator.rb

@@ -34,6 +34,10 @@ class ArithmeticPrecedenceEvaluator < Dhaka::Evaluator
     for_negated_expression do
       -child_nodes[1]
     end
+    
+    for_power do
+      child_nodes[0]**child_nodes[2]
+    end
 
   end
 

data/test/arithmetic_precedence_grammar.rb

@@ -4,6 +4,7 @@ class ArithmeticPrecedenceGrammar < Dhaka::Grammar
   precedences do
     left ['+', '-']
     left ['*', '/']
+    nonassoc ['^']
   end
   
   for_symbol(Dhaka::START_SYMBOL_NAME) do
@@ -15,6 +16,7 @@ class ArithmeticPrecedenceGrammar < Dhaka::Grammar
     subtraction ['E', '-', 'E']
     multiplication ['E', '*', 'E']
     division ['E', '/', 'E']
+    power ['E', '^', 'E']
     literal ['n']
     parenthetized_expression ['(', 'E', ')']
     negated_expression ['-', 'E'], :prec => '*'

data/test/arithmetic_precedence_grammar_test.rb

@@ -8,6 +8,7 @@ class TestArithmeticPrecedenceGrammar < Test::Unit::TestCase
     @subop = ArithmeticPrecedenceGrammar.symbol_for_name('-')
     @mulop = ArithmeticPrecedenceGrammar.symbol_for_name('*')
     @divop = ArithmeticPrecedenceGrammar.symbol_for_name('/')
+    @powop = ArithmeticPrecedenceGrammar.symbol_for_name('^')
   end
   
   def test_precedence_levels_and_associativity_of_terminals
@@ -15,10 +16,12 @@ class TestArithmeticPrecedenceGrammar < Test::Unit::TestCase
     assert_equal(0, @subop.precedence.precedence_level)
     assert_equal(1, @mulop.precedence.precedence_level)
     assert_equal(1, @divop.precedence.precedence_level)
+    assert_equal(2, @powop.precedence.precedence_level)
     assert_equal(:left, @addop.precedence.associativity)
     assert_equal(:left, @subop.precedence.associativity)
     assert_equal(:left, @mulop.precedence.associativity)
     assert_equal(:left, @divop.precedence.associativity)
+    assert_equal(:nonassoc, @powop.precedence.associativity)
   end
   def test_precedence_of_production
     assert_equal(@addop.precedence, ArithmeticPrecedenceGrammar.production_named("addition").precedence)

data/test/arithmetic_precedence_parser_test.rb

@@ -1,30 +1,33 @@
 require "test/unit"
 require "arithmetic_precedence_grammar"
-require "arithmetic_tokenizer"
+require "arithmetic_precedence_tokenizer"
 require "arithmetic_precedence_evaluator"
+require "fake_logger"
 
 class TestArithmeticPrecedenceParser < Test::Unit::TestCase
 
   def test_parses_arithmetic_expressions
     fake_logger = FakeLogger.new
     parser = Dhaka::Parser.new(ArithmeticPrecedenceGrammar, fake_logger)
-    assert_equal(20, fake_logger.messages.size)
+    eval(parser.compile_to_ruby_source_as(:ArithmeticPrecedenceParser))
+    assert_equal(30, fake_logger.warnings.size)
+    assert_equal(0, fake_logger.errors.size)
     
-    syntax_tree = parser.parse(ArithmeticTokenizer.tokenize("5 * -14/(2*7 - 7) + 2")).syntax_tree
-#    File.open('precedence.dot', 'w') {|file| file << syntax_tree.to_dot}
-#    File.open('precedence_parser.dot', 'w') {|file| file << parser.to_dot}
-    assert_equal(-8, ArithmeticPrecedenceEvaluator.new(syntax_tree).result)
+    assert_equal(-8, evaluate(parse("5 * -14/(2*7 - 7) + 2").syntax_tree))
+    assert_equal(-4, evaluate(parse("-2^2").syntax_tree))
+    assert_equal(10, evaluate(parse("2+2^3").syntax_tree))
+    assert_equal(64, evaluate(parse("(2+2)^3").syntax_tree))
+    assert_equal(128, evaluate(parse("(2+2)^3*2").syntax_tree))
+    assert(parse("(2+2)^3^2").has_error?)
   end
-end
-
-class FakeLogger
-  attr_reader :messages
-  def initialize
-    @messages = []
+  
+  def parse(input)
+    ArithmeticPrecedenceParser.parse(ArithmeticPrecedenceTokenizer.tokenize(input))
   end
-  def debug message
-  end
-  def warn(message)
-    @messages << message
+
+  def evaluate(syntax_tree)
+    ArithmeticPrecedenceEvaluator.new(syntax_tree).result
   end
-end
+
+end
+

data/test/arithmetic_precedence_tokenizer.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+require 'arithmetic_precedence_grammar'
+
+
+class ArithmeticPrecedenceTokenizer < Dhaka::Tokenizer
+  
+  digits = ('0'..'9').to_a
+  parenths = ['(', ')']
+  operators = ['-', '+', '/', '*', '^']
+  functions = ['h', 'l']
+  arg_separator = [',']
+  whitespace = [' ']
+
+  all_characters = digits + parenths + operators + functions + arg_separator + whitespace
+
+  for_state :idle_state do
+    for_characters(all_characters - (digits + whitespace)) do
+      tokens << Dhaka::Token.new(ArithmeticPrecedenceGrammar.symbol_for_name(curr_char), nil)
+      advance
+    end
+    for_characters digits do
+      self.accumulator = ''
+      switch_to :get_integer_literal
+    end
+    for_character whitespace do
+      advance
+    end
+  end
+  
+  for_state :get_integer_literal do
+    for_characters all_characters - digits do
+      tokens << Dhaka::Token.new(ArithmeticPrecedenceGrammar.symbol_for_name('n'), accumulator.to_i)
+      switch_to :idle_state
+    end
+    for_characters digits do
+      self.accumulator += curr_char
+      advance
+      tokens << Dhaka::Token.new(ArithmeticPrecedenceGrammar.symbol_for_name('n'), accumulator.to_i) unless curr_char
+    end
+  end
+  
+end
+

data/test/arithmetic_test_methods.rb

@@ -1,6 +1,6 @@
 module ArithmeticTestMethods
   
-  def get_syntax_tree_with_compiled_arithmetic_parser(token_stream)
+  def parse(token_stream)
     CompiledArithmeticParser.parse(token_stream).syntax_tree
   end
   

data/test/compiled_parser_test.rb

@@ -1,15 +1,15 @@
 require "test/unit"
 require "simple_grammar"
-require 'compiled_arithmetic_parser'
 require 'arithmetic_test_methods'
+require 'arithmetic_grammar'
+
+eval(Dhaka::Parser.new(SimpleGrammar).compile_to_ruby_source_as('Foo'))
+eval(Dhaka::Parser.new(ArithmeticGrammar).compile_to_ruby_source_as('CompiledArithmeticParser'))
 
 class TestCompiledParser < Test::Unit::TestCase
   include ArithmeticTestMethods
-
+  
   def test_compiled_parser_generates_syntax_tree_for_simple_grammar
-    grammar = SimpleGrammar
-    parser = Dhaka::Parser.new(grammar)
-    eval(parser.compile_to_ruby_source_as('Foo'))
     syntax_tree = Foo.parse(build_tokens(['(','n','-','(','n','-','n',')',')','-','n','#'], Foo.grammar)).syntax_tree
     assert_equal \
       ["literal",
@@ -50,7 +50,7 @@ class TestCompiledParser < Test::Unit::TestCase
        "unpacking_parenthetized_expression",
        "factor",
        "term",
-       "expression"], get_syntax_tree_with_compiled_arithmetic_parser(build_tokens(parser_input, CompiledArithmeticParser.grammar)).linearize
+       "expression"], parse(build_tokens(parser_input, CompiledArithmeticParser.grammar)).linearize
   end
   
   def test_parse_result_has_error_if_empty_token_array

data/test/fake_logger.rb

@@ -0,0 +1,17 @@
+class FakeLogger
+  attr_reader :warnings, :debugs, :errors
+  def initialize
+    @warnings = []
+    @debugs = []
+    @errors = []
+  end
+  def debug message
+    @debugs << message
+  end
+  def error message
+    @errors << message
+  end
+  def warn message
+    @warnings << message
+  end
+end

data/test/parser_test.rb

@@ -4,8 +4,10 @@ require 'simple_grammar'
 require 'arithmetic_grammar'
 require 'nullable_grammar'
 require 'lalr_but_not_slr_grammar'
+require 'another_lalr_but_not_slr_grammar'
 require 'rr_conflict_grammar'
 require 'sr_conflict_grammar'
+require 'fake_logger'
 
 class ParserTest < Test::Unit::TestCase
 
@@ -142,9 +144,18 @@ class ParserTest < Test::Unit::TestCase
     assert_equal(["A_d", "E_bAc", "start"], get_linearized_parse_result(parser_input, parser))
   end
 
+  def test_with_another_grammar_that_is_not_SLR
+    grammar = AnotherLALRButNotSLRGrammar
+    parser = Dhaka::Parser.new(grammar)
+    parser_input = ['*', 'id', '=', 'id']
+    assert_equal(["identifier", "l_value", "contents", "identifier", "l_value", "assignment"], get_linearized_parse_result(parser_input, parser))
+  end
+
   def test_with_a_grammar_that_should_generate_an_RR_conflict
     grammar = RRConflictGrammar
-    assert_raise(Dhaka::ParserReduceReduceConflictError) { Dhaka::Parser.new(grammar) }
+    fake_logger = FakeLogger.new
+    Dhaka::Parser.new(grammar, fake_logger)
+    assert_equal(1,  fake_logger.errors.size)
   end
 
   def set_finder(set1, set2)

data/test/precedence_grammar.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+
+class PrecedenceGrammar < Dhaka::Grammar
+  precedences do
+    left ['*']
+  end
+  
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    expression ['E', '*', 'F']
+    whatever ['E', 'F'], :prec => '*'
+  end
+  
+  for_symbol('F') do
+    something ['foo']
+  end
+end
+    

data/test/precedence_grammar_test.rb

@@ -0,0 +1,10 @@
+require "test/unit"
+
+require "precedence_grammar"
+
+class TestPrecedenceGrammar < Test::Unit::TestCase
+  def test_precedences_are_computed_correctly
+    assert_equal(:left, PrecedenceGrammar.production_named('expression').precedence.associativity)
+    assert_equal(:left, PrecedenceGrammar.production_named('whatever').precedence.associativity)
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: dhaka
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
-date: 2006-12-11 00:00:00 -05:00
+  version: 0.0.5
+date: 2006-12-15 00:00:00 -05:00
 summary: An LALR1 parser generator written in Ruby
 require_paths: 
 - lib
@@ -49,6 +49,7 @@ files:
 - lib/parser/token.rb
 - lib/tokenizer/tokenizer.rb
 - test/all_tests.rb
+- test/another_lalr_but_not_slr_grammar.rb
 - test/arithmetic_evaluator.rb
 - test/arithmetic_evaluator_test.rb
 - test/arithmetic_grammar.rb
@@ -57,15 +58,16 @@ files:
 - test/arithmetic_precedence_grammar.rb
 - test/arithmetic_precedence_grammar_test.rb
 - test/arithmetic_precedence_parser_test.rb
+- test/arithmetic_precedence_tokenizer.rb
 - test/arithmetic_test_methods.rb
 - test/arithmetic_tokenizer.rb
 - test/arithmetic_tokenizer_test.rb
 - test/bracket_grammar.rb
 - test/bracket_tokenizer.rb
 - test/brackets_test.rb
-- test/compiled_arithmetic_parser.rb
 - test/compiled_parser_test.rb
 - test/evaluator_test.rb
+- test/fake_logger.rb
 - test/grammar_test.rb
 - test/incomplete_arithmetic_evaluator.rb
 - test/lalr_but_not_slr_grammar.rb
@@ -73,6 +75,8 @@ files:
 - test/malformed_grammar_test.rb
 - test/nullable_grammar.rb
 - test/parser_test.rb
+- test/precedence_grammar.rb
+- test/precedence_grammar_test.rb
 - test/rr_conflict_grammar.rb
 - test/simple_grammar.rb
 - test/sr_conflict_grammar.rb

data/test/compiled_arithmetic_parser.rb

@@ -1,243 +0,0 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'arithmetic_grammar'
-
-class CompiledArithmeticParser < Dhaka::CompiledParser
-
-  self.grammar = ArithmeticGrammar
-
-  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(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(23) {
-    for_symbol('(') { shift_to 24 }
-  }
-
-  at_state(16) {
-    for_symbol('(') { reduce_with 'min_function' }
-  }
-
-  at_state(13) {
-    for_symbol('(') { reduce_with 'max_function' }
-  }
-
-  at_state(20) {
-    for_symbol('+') { reduce_with 'addition' }
-    for_symbol(',') { reduce_with 'addition' }
-    for_symbol('-') { reduce_with 'addition' }
-    for_symbol('/') { shift_to 15 }
-    for_symbol('_End_') { reduce_with 'addition' }
-    for_symbol(')') { reduce_with 'addition' }
-    for_symbol('*') { shift_to 21 }
-  }
-
-  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(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(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('+') { 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(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(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(31) {
-    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(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(18) {
-    for_symbol('+') { shift_to 19 }
-    for_symbol('-') { shift_to 32 }
-    for_symbol(')') { shift_to 34 }
-  }
-
-  at_state(14) {
-    for_symbol('+') { reduce_with 'term' }
-    for_symbol(',') { reduce_with 'term' }
-    for_symbol('-') { reduce_with 'term' }
-    for_symbol('/') { shift_to 15 }
-    for_symbol('_End_') { reduce_with 'term' }
-    for_symbol(')') { reduce_with 'term' }
-    for_symbol('*') { shift_to 21 }
-  }
-
-  at_state(25) {
-    for_symbol(')') { shift_to 26 }
-  }
-
-  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(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('_End_') { reduce_with 'getting_literals' }
-    for_symbol(')') { reduce_with 'getting_literals' }
-    for_symbol('*') { reduce_with 'getting_literals' }
-  }
-
-  at_state(36) {
-    for_symbol('+') { shift_to 19 }
-    for_symbol('-') { shift_to 32 }
-    for_symbol('_End_') { reduce_with 'expression' }
-  }
-
-  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(29) {
-    for_symbol(')') { reduce_with 'concatenating_args' }
-  }
-
-  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(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