dhaka 1.0.0 → 2.0.0

data/test/chittagong_evaluator.rb

@@ -6,102 +6,273 @@ class ChittagongEvaluator < Dhaka::Evaluator
   self.grammar = ChittagongGrammar
 
   define_evaluation_rules do
+    
+    # No-ops
     ['no_terms', 'multiple_terms', 'single_term', 'some_terms'].each {|production_name| eval("for_#{production_name} do end")}
 
     for_program do
       evaluate(child_nodes[1])
     end
-    
-    for_multiple_statements do
-      evaluate(child_nodes[0])
+
+    for_multiple_main_body_statements do
+      first = evaluate(child_nodes[0])
+      return first if first.exception
+      evaluate(child_nodes[2])
+    end  
+
+    for_multiple_function_body_statements do
+      first = evaluate(child_nodes[0])
+      return first if (first.exception || first.result)
       evaluate(child_nodes[2])
     end
     
-    for_print_statement do
-      @output_stream << evaluate(child_nodes[1]).to_s
+    for_function_definition do
+      function_name = evaluate(child_nodes[1])
+      arg_declarations = evaluate(child_nodes[3])
+      body = child_nodes[6]
+      @function_table[function_name] = Function.new(arg_declarations, body)
+      ChittagongSuccessResult.new(nil)
     end
 
-    for_subtraction do 
-      evaluate(child_nodes[0]) - evaluate(child_nodes[2])
+    for_main_body_if_statement do
+      checked_if_statement
+    end
+    
+    for_function_body_if_statement do
+      checked_if_statement
     end
 
-    for_addition do
-      evaluate(child_nodes[0]) + evaluate(child_nodes[2])
+    def checked_if_statement
+      condition_eval = evaluate(child_nodes[1])
+      return condition_eval if condition_eval.exception
+      return evaluate(child_nodes[3]) if condition_eval.result
+      ChittagongSuccessResult.new(nil)
+    end
+    
+    for_main_body_if_else_statement do
+      checked_if_else_statement
     end
 
-    for_division do
-      evaluate(child_nodes[0]).to_f/evaluate(child_nodes[2])
+    for_function_body_if_else_statement do
+      checked_if_else_statement
+    end
+    
+    def checked_if_else_statement
+      condition_eval = evaluate(child_nodes[1])
+      return condition_eval if condition_eval.exception
+      if condition_eval.result
+        evaluate(child_nodes[3])
+      else
+        evaluate(child_nodes[7])
+      end
     end
 
-    for_multiplication do
-      evaluate(child_nodes[0]) * evaluate(child_nodes[2])
+    for_main_body_while_statement do
+      checked_while_statement
+    end
+    
+    for_function_body_while_statement do
+      checked_while_statement
+    end 
+    
+    def checked_while_statement
+      while true
+        condition_eval = evaluate(child_nodes[1])
+        return condition_eval if condition_eval.exception
+        break unless condition_eval.result
+        body_eval = evaluate(child_nodes[3])
+        return body_eval if (body_eval.exception || body_eval.result)
+      end
+      ChittagongSuccessResult.new(nil)
     end
 
-    for_literal do
-      child_nodes[0].token.value
+    for_assignment_statement do
+      rhs = evaluate(child_nodes[2])
+      return rhs if rhs.exception
+      @stack[-1][evaluate(child_nodes[0])] = rhs.result
+      ChittagongSuccessResult.new(nil)
+    end
+    
+    for_print_statement do
+      rhs = evaluate(child_nodes[1])
+      return rhs if rhs.exception
+      @output_stream << rhs.result.to_s
+      ChittagongSuccessResult.new(nil)
     end
 
-    for_parenthetized_expression do
-      evaluate(child_nodes[1])
+    for_function_call_statement do
+      checked_function_call
     end
     
-    for_negated_expression do
-      -evaluate(child_nodes[1])
+    for_function_call_expression do
+      checked_function_call
+    end
+
+    def checked_function_call
+      function_name = evaluate(child_nodes[0])
+      return ChittagongExceptionResult.new("Undefined function #{function_name}", 
+          child_nodes[0]) unless @function_table.has_key?(function_name)
+      
+      arg_values = evaluate(child_nodes[2])
+      return arg_values if arg_values.exception
+      
+      function = @function_table[function_name]
+      return ChittagongExceptionResult.new(
+        "Wrong number of arguments", child_nodes[1]
+        ) unless function.args.size == arg_values.result.size
+      new_frame = {}
+      function.args.zip(arg_values.result).each do |arg_name, arg_value|
+        new_frame[arg_name] = arg_value 
+      end
+      
+      @stack << new_frame
+      result = evaluate(function.body)
+      @stack.pop
+      
+      result
     end
     
-    for_power do
-      evaluate(child_nodes[0])**evaluate(child_nodes[2])
+    for_return_statement do 
+      checked_unary_operation(child_nodes[1]){|x| x}
     end
     
-    for_negation do
-      !evaluate(child_nodes[1])
+    for_single_arg_declaration do
+      [evaluate(child_nodes[0])]
     end
     
-    for_if_else_statement do
-      if evaluate(child_nodes[1])
-        evaluate(child_nodes[3])
-      else
-        evaluate(child_nodes[7])
-      end
+    for_no_arg_decl do
+      []
     end
     
-    for_if_statement do
-      if evaluate(child_nodes[1])
-        evaluate(child_nodes[3])
-      end
+    for_multiple_arg_declarations do 
+      evaluate(child_nodes[0]) + [evaluate(child_nodes[2])]
     end
     
-    for_while_statement do
-      while evaluate(child_nodes[1])
-        evaluate(child_nodes[3])
-      end
+    for_no_args do
+      ChittagongSuccessResult.new([])
+    end
+    
+    for_single_arg do
+      checked_unary_operation(child_nodes[0]) {|x| [x]}
+    end
+    
+    for_multiple_args do
+      checked_binary_operation(child_nodes[0], child_nodes[2]) {|a, b| a + [b]}
+    end
+    
+    for_variable_reference do
+      variable_name = evaluate(child_nodes[0])
+      return ChittagongExceptionResult.new("Undefined variable #{variable_name}", child_nodes[0]) unless @stack[-1].has_key? variable_name
+      ChittagongSuccessResult.new(@stack[-1][variable_name])
+    end
+
+    for_literal do
+      ChittagongSuccessResult.new(child_nodes[0].token.value.to_i)
+    end
+
+    for_subtraction do 
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a - b}
+    end
+
+    for_addition do
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a + b}
+    end
+
+    for_division do
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a.to_f / b}
+    end
+
+    for_multiplication do
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a * b}
+    end
+    
+    for_power do
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a ** b}
     end
     
     for_less_than_comparison do
-      evaluate(child_nodes[0]) < evaluate(child_nodes[2])
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a < b}
     end
 
     for_greater_than_comparison do
-      evaluate(child_nodes[0]) > evaluate(child_nodes[2])
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a > b}
     end
 
     for_equality_comparison do
-      evaluate(child_nodes[0]) == evaluate(child_nodes[2])
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a == b}
     end
         
-    for_variable_reference do
-      @symbol_table[child_nodes[0].token.value]
+    def checked_binary_operation node1, node2
+      node1_eval = evaluate(node1)
+      node2_eval = evaluate(node2)
+      return node1_eval if node1_eval.exception
+      return node2_eval if node2_eval.exception
+      ChittagongSuccessResult.new(yield(node1_eval.result, node2_eval.result))
+    end
+
+    for_negated_expression do
+      checked_unary_operation(child_nodes[1]){|x| -x}
+    end
+
+    for_negation do
+      checked_unary_operation(child_nodes[1]){|b| !b}
+    end
+
+    for_parenthetized_expression do
+      checked_unary_operation(child_nodes[1]){|x| x}
+    end
+    
+    def checked_unary_operation node
+      node_eval = evaluate(node)
+      return node_eval if node_eval.exception
+      ChittagongSuccessResult.new(yield(node_eval.result))
+    end
+    
+    for_function_name do
+      child_nodes[0].token.value
+    end
+    
+    for_variable_name do
+      child_nodes[0].token.value
     end
     
-    for_assignment_expression do
-      @symbol_table[child_nodes[0].token.value] = evaluate(child_nodes[2])
+    for_arg_declaration do
+      child_nodes[0].token.value
     end
     
-    def initialize(symbol_table, output_stream)
-      @symbol_table = symbol_table
+    def initialize(stack, output_stream)
+      @stack = stack
+      @function_table = {}
       @output_stream = output_stream
     end
 
   end
 
-end
+end
+
+class ChittagongResult
+  attr_reader :exception
+end
+
+class ChittagongSuccessResult < ChittagongResult
+  attr_reader :result
+  def initialize(result)
+    @result = result
+  end
+end
+
+class ChittagongExceptionResult < ChittagongResult
+  attr_reader :node
+  def initialize(exception, node)
+    @exception = exception
+    @node = node
+  end
+end
+
+class Function
+  attr_reader :args, :body
+  def initialize(args, body)
+    @args = args
+    @body = body
+  end
+end

data/test/chittagong_evaluator_test.rb

@@ -3,39 +3,37 @@ require "test/unit"
 require "chittagong_evaluator"
 require "fake_logger"
 
-class TestChittagongEvaluator < Test::Unit::TestCase
+unless Object.const_defined? :ChittagongParser
+  eval(Dhaka::Parser.new(ChittagongGrammar, FakeLogger.new).compile_to_ruby_source_as(:ChittagongParser)) 
+end
 
-  def setup
-    @logger = FakeLogger.new
-    @parser = Dhaka::Parser.new(ChittagongGrammar, @logger)
-  end
+class TestChittagongEvaluator < Test::Unit::TestCase
 
   def test_evaluates_a_simple_program
-    assert_equal(30, @logger.warnings.size)
-    assert_equal(0, @logger.errors.size)
     token_stream = build_tokens(
       ['newline'],
-      ['var_name', 'x'], ['='], ['int_literal', 23], ['newline'],
-      ['print'], ['var_name', 'x'], ['newline'],
+      ['word_literal', 'x'], ['='], ['int_literal', 23], ['newline'],
+      ['print'], ['word_literal', 'x'], ['newline'],
       ['newline'],
-      ['var_name', 'y'], ['='], ['var_name', 'x'], ['+'], ['var_name', 'x'], ['newline'],
-      ['print'], ['var_name', 'y'], ['*'], ['var_name', 'x'], ['newline'],
-      ['if'], ['var_name', 'x'], ['>'], ['var_name', 'y'], ['newline'],
-      ['print'], ['var_name', 'x'], ['newline'],
+      ['word_literal', 'y'], ['='], ['word_literal', 'x'], ['+'], ['word_literal', 'x'], ['newline'],
+      ['print'], ['word_literal', 'y'], ['*'], ['word_literal', 'x'], ['newline'],
+      ['if'], ['word_literal', 'x'], ['>'], ['word_literal', 'y'], ['newline'],
+      ['print'], ['word_literal', 'x'], ['newline'],
       ['else'], ['newline'],
-      ['print'], ['var_name', 'y'], ['newline'],
+      ['print'], ['word_literal', 'y'], ['newline'],
       ['end'], ['newline'],
-      ['newline']
+      ['newline'],
+      [Dhaka::END_SYMBOL_NAME]
     )
-    symbol_table = {}
+    stack = [{}]
     output_stream = []
-    ChittagongEvaluator.new(symbol_table, output_stream).evaluate(@parser.parse(token_stream).syntax_tree)
-    assert_equal(23, symbol_table['x'])
-    assert_equal(46, symbol_table['y'])
+    ChittagongEvaluator.new(stack, output_stream).evaluate(ChittagongParser.parse(token_stream).parse_tree)
+    assert_equal(23, stack[0]['x'])
+    assert_equal(46, stack[0]['y'])
     assert_equal(['23', '1058', '46'], output_stream)
   end
   
   def build_tokens *tokens
-    tokens.collect {|token| Dhaka::Token.new(ChittagongGrammar.symbol_for_name(token[0]), token[1])}
+    tokens.collect {|token| Dhaka::Token.new(token[0], token[1], nil)}
   end
 end

data/test/chittagong_grammar.rb

@@ -3,43 +3,89 @@ require File.dirname(__FILE__)+'/../lib/dhaka'
 class ChittagongGrammar < Dhaka::Grammar
 
   precedences do
+    nonassoc ['==']
+    nonassoc ['<', '>']
     left ['+', '-']
     left ['*', '/']
     nonassoc ['^']
+    nonassoc ['!']
   end
   
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    program ['opt_terms', 'statements', 'opt_terms']
+    program ['opt_terms', 'main_body', 'opt_terms']
   end
 
-  for_symbol('statements') do
-    single_statement ['statement']
-    multiple_statements ['statements', 'terms', 'statement']
+  for_symbol('main_body') do
+    single_main_body_statement ['main_body_statement']
+    multiple_main_body_statements ['main_body', 'terms', 'main_body_statement']
+  end
+  
+  for_symbol('main_body_statement') do
+    main_body_simple_statement ['simple_statement']
+    function_definition ['def', 'function_name', '(', 'arg_declarations', ')', 'terms', 
+      'function_body', 'terms', 'end']
+    main_body_if_statement ['if', 'expression', 'terms', 'main_body', 'terms', 'end']
+    main_body_if_else_statement ['if', 'expression', 'terms', 'main_body', 
+      'terms', 'else', 'terms', 'main_body', 'terms', 'end']
+    main_body_while_statement ['while', 'expression', 'terms', 'main_body', 'terms', 
+      'end']
   end
 
-  for_symbol('statement') do
-    assignment_expression ['var_name', '=', 'expression']
+  for_symbol('simple_statement') do
+    assignment_statement ['var_name', '=', 'expression']
     print_statement ['print', 'expression']
-    if_statement ['if', 'boolean_expression', 'terms', 'statements', 'terms', 'end']
-    if_else_statement ['if', 'boolean_expression', 'terms', 'statements', 'terms', 'else', 'terms', 'statements', 'terms', 'end']
-    while_statement ['while', 'boolean_expression', 'terms', 'statements', 'terms', 'end']
+    function_call_statement ['function_name', '(', 'arg_list', ')']
   end
   
-  for_symbol('boolean_expression') do
-    negation ['!', 'boolean_expression']
-    equality_comparison ['expression', '=', '=', 'expression']
-    greater_than_comparison ['expression', '>', 'expression']
-    less_than_comparison ['expression', '<', 'expression']
+  for_symbol('function_body') do
+    single_function_body_statement ['function_body_statement']
+    multiple_function_body_statements ['function_body', 'terms', 'function_body_statement']
+  end
+  
+  for_symbol('function_body_statement') do
+    function_body_simple_statement ['simple_statement']
+    return_statement ['return', 'expression']
+    function_body_if_statement ['if', 'expression', 'terms', 'function_body', 'terms', 'end']
+    function_body_if_else_statement ['if', 'expression', 'terms', 'function_body', 'terms', 'else', 'terms', 'function_body', 'terms', 'end']
+    function_body_while_statement ['while', 'expression', 'terms', 'function_body', 'terms', 'end']
+  end
+  
+  for_symbol('function_name') do
+    function_name ['word_literal']
+  end
+  
+  for_symbol('var_name') do
+    variable_name ['word_literal']
+  end
+  
+  for_symbol('arg_declarations') do
+    no_arg_decl []
+    single_arg_declaration ['arg_decl']
+    multiple_arg_declarations ['arg_declarations', ',', 'arg_decl']
+  end
+  
+  for_symbol('arg_decl') do
+    arg_declaration ['word_literal']
+  end
+  
+  for_symbol('arg_list') do
+    no_args []
+    single_arg ['expression']
+    multiple_args ['arg_list', ',', 'expression']
   end
   
-
   for_symbol('expression') do
+    negation ['!', 'expression']
+    equality_comparison ['expression', '==', 'expression']
+    greater_than_comparison ['expression', '>', 'expression']
+    less_than_comparison ['expression', '<', 'expression']
     addition ['expression', '+', 'expression']
     subtraction ['expression', '-', 'expression']
     multiplication ['expression', '*', 'expression']
     division ['expression', '/', 'expression']
     power ['expression', '^', 'expression']
     literal ['int_literal']
+    function_call_expression ['function_name', '(', 'arg_list', ')']
     variable_reference ['var_name']
     parenthetized_expression ['(', 'expression', ')']
     negated_expression ['-', 'expression'], :prec => '*'