dhaka 2.0.0 → 2.0.1

data/test/{chittagong_driver_test.rb → chittagong/chittagong_driver_test.rb}

@@ -1,65 +1,11 @@
-require "test/unit"
-require "yaml"
-require "chittagong_grammar"
-require "chittagong_tokenizer"
-require "chittagong_evaluator"
-require "fake_logger"
-
+require File.dirname(__FILE__)+'/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/chittagong_grammar"
 unless Object.const_defined? :ChittagongParser
   eval(Dhaka::Parser.new(ChittagongGrammar, FakeLogger.new).compile_to_ruby_source_as(:ChittagongParser)) 
 end
-
-class ChittagongDriver
-  def marked_program(program, error_position)
-    if error_position > 0
-      program[0..(error_position-1)] + ">>>" + program[error_position..-1]
-    else
-      ">>>"+program
-    end
-  end
-  
-  def parse_error_message unexpected_token, program
-    if unexpected_token.symbol_name == Dhaka::END_SYMBOL_NAME
-      "Unexpected end of file."
-    else
-      "Unexpected token #{unexpected_token.symbol_name}:\n#{marked_program(program, unexpected_token.input_position)}"
-    end
-  end
-  
-  def tokenize_error_message unexpected_char_index, program
-    "Unexpected character #{program[unexpected_char_index].chr}:\n#{marked_program(program, unexpected_char_index)}"
-  end
-  
-  def evaluation_error_message evaluation_result, program
-    "#{evaluation_result.exception}:\n#{marked_program(program, evaluation_result.node.tokens[0].input_position)}"
-  end
-  
-  def run(program)
-    tokenize_result = ChittagongTokenizer.tokenize(program)
-    if tokenize_result.has_error?
-      return tokenize_error_message(tokenize_result.unexpected_char_index, program) 
-    end
-    
-    parse_result = ChittagongParser.parse(tokenize_result)
-    if parse_result.has_error?
-      return parse_error_message(parse_result.unexpected_token, program) 
-    end
-    
-    evaluation_result = ChittagongEvaluator.new([{}], output_stream = []).
-        evaluate(parse_result.parse_tree)
-    if evaluation_result.exception
-      return (output_stream << evaluation_error_message(evaluation_result, program)).
-        join("\n") 
-    end
-    
-    return output_stream.join("\n")
-  end
-  
-end
-
+require File.dirname(__FILE__) + "/chittagong_driver"
 
 class TestChittagongDriver < Test::Unit::TestCase
-  
   def setup
     @driver = ChittagongDriver.new
   end
@@ -178,7 +124,7 @@ Undefined variable c:
       
     ", @driver.run(program))
   end
-  
+  # lipi:variable_scoping
   def test_variable_scope
     program = "
       x = 1
@@ -211,6 +157,7 @@ Undefined variable c:
       
     ", @driver.run(program))
   end
+  # lipi:variable_scoping
   
   def test_nested_function_calls
     
@@ -258,4 +205,65 @@ Undefined variable c:
     ", @driver.run(program))
     
   end
+
+  def test_an_empty_program
+    program = ""
+    assert_equal("Unexpected end of file.", @driver.run(program))
+  end
+
+  def test_associating_equality_tests_should_show_an_error
+    program = "
+    def foo()
+      print 999
+    end
+
+    foo()
+    print 1 == 1 == 1"
+    
+    assert_equal("Unexpected token ==:
+
+    def foo()
+      print 999
+    end
+
+    foo()
+    print 1 == 1 >>>== 1",  @driver.run(program))
+  end
+
+  def test_catches_bad_decimal_points
+    program = "
+    a = .234
+    b = 20.234.2
+    "
+    
+    assert_equal("Unexpected token .:
+
+    a = .234
+    b = 20.234>>>.2
+    ",  @driver.run(program))
+  end
+  # lipi:recursive_fib
+  def test_recursive_fibonacci
+    program = "
+
+    def fib(n)
+      if n == 0
+        return 1
+      end
+      if n == 1
+        return 1
+      end
+      return fib(n-1) + fib(n-2)
+    end
+    
+    x = 0
+    while x < 9
+      print fib(x)
+      x = x + 1
+    end
+    
+    "
+    assert_equal(["1", "1", "2", "3", "5", "8", "13", "21", "34"].join("\n"), @driver.run(program))
+  end
+  # lipi:recursive_fib
 end

data/test/{chittagong_evaluator.rb → chittagong/chittagong_evaluator.rb}

@@ -1,5 +1,4 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'chittagong_grammar'
+require File.dirname(__FILE__) + '/chittagong_grammar'
 
 class ChittagongEvaluator < Dhaka::Evaluator
 
@@ -25,14 +24,15 @@ class ChittagongEvaluator < Dhaka::Evaluator
       return first if (first.exception || first.result)
       evaluate(child_nodes[2])
     end
-    
+    # lipi:function_defs
     for_function_definition do
-      function_name = evaluate(child_nodes[1])
+      function_name    = evaluate(child_nodes[1])
       arg_declarations = evaluate(child_nodes[3])
-      body = child_nodes[6]
+      body             = child_nodes[6]
       @function_table[function_name] = Function.new(arg_declarations, body)
       ChittagongSuccessResult.new(nil)
     end
+    # lipi:function_defs
 
     for_main_body_if_statement do
       checked_if_statement
@@ -76,7 +76,7 @@ class ChittagongEvaluator < Dhaka::Evaluator
     end 
     
     def checked_while_statement
-      while true
+      loop do
         condition_eval = evaluate(child_nodes[1])
         return condition_eval if condition_eval.exception
         break unless condition_eval.result
@@ -107,7 +107,7 @@ class ChittagongEvaluator < Dhaka::Evaluator
     for_function_call_expression do
       checked_function_call
     end
-
+    # lipi:checked_function_call
     def checked_function_call
       function_name = evaluate(child_nodes[0])
       return ChittagongExceptionResult.new("Undefined function #{function_name}", 
@@ -121,6 +121,7 @@ class ChittagongEvaluator < Dhaka::Evaluator
         "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
@@ -131,6 +132,7 @@ class ChittagongEvaluator < Dhaka::Evaluator
       
       result
     end
+    # lipi:checked_function_call
     
     for_return_statement do 
       checked_unary_operation(child_nodes[1]){|x| x}
@@ -166,7 +168,16 @@ class ChittagongEvaluator < Dhaka::Evaluator
       ChittagongSuccessResult.new(@stack[-1][variable_name])
     end
 
-    for_literal do
+
+    for_float_without_leading_digits do
+      ChittagongSuccessResult.new(('.' + child_nodes[1].token.value).to_f)
+    end
+    
+    for_float_with_leading_digits do
+      ChittagongSuccessResult.new((child_nodes[0].token.value + '.' +child_nodes[2].token.value).to_f)
+    end
+
+    for_integer do
       ChittagongSuccessResult.new(child_nodes[0].token.value.to_i)
     end
 
@@ -229,23 +240,27 @@ class ChittagongEvaluator < Dhaka::Evaluator
     end
     
     for_function_name do
-      child_nodes[0].token.value
+      token_value
     end
     
     for_variable_name do
-      child_nodes[0].token.value
+      token_value
     end
     
     for_arg_declaration do
-      child_nodes[0].token.value
+      token_value
     end
-    
+
+    def token_value
+      child_nodes.first.token.value
+    end
+    # lipi:initialize
     def initialize(stack, output_stream)
       @stack = stack
       @function_table = {}
       @output_stream = output_stream
     end
-
+    # lipi:initialize
   end
 
 end

data/test/{chittagong_evaluator_test.rb → chittagong/chittagong_evaluator_test.rb}

@@ -1,16 +1,12 @@
-require "test/unit"
-
-require "chittagong_evaluator"
-require "fake_logger"
-
-unless Object.const_defined? :ChittagongParser
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/chittagong_evaluator"
+unless defined? ChittagongParser
   eval(Dhaka::Parser.new(ChittagongGrammar, FakeLogger.new).compile_to_ruby_source_as(:ChittagongParser)) 
 end
 
 class TestChittagongEvaluator < Test::Unit::TestCase
-
   def test_evaluates_a_simple_program
-    token_stream = build_tokens(
+    token_stream  = build_tokens(
       ['newline'],
       ['word_literal', 'x'], ['='], ['int_literal', 23], ['newline'],
       ['print'], ['word_literal', 'x'], ['newline'],
@@ -25,9 +21,9 @@ class TestChittagongEvaluator < Test::Unit::TestCase
       ['newline'],
       [Dhaka::END_SYMBOL_NAME]
     )
-    stack = [{}]
+    stack         = [{}]
     output_stream = []
-    ChittagongEvaluator.new(stack, output_stream).evaluate(ChittagongParser.parse(token_stream).parse_tree)
+    ChittagongEvaluator.new(stack, output_stream).evaluate(ChittagongParser.parse(token_stream))
     assert_equal(23, stack[0]['x'])
     assert_equal(46, stack[0]['y'])
     assert_equal(['23', '1058', '46'], output_stream)

data/test/chittagong/chittagong_grammar.rb

@@ -0,0 +1,110 @@
+class ChittagongGrammar < Dhaka::Grammar
+
+  precedences do
+    nonassoc %w| == |
+    nonassoc %w| < > |
+    left     %w| + - |
+    left     %w| * / |
+    nonassoc %w| ^ |
+    nonassoc %w| ! |
+  end
+  # lipi:grammar_overview
+  
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    program                             %w| opt_terms main_body opt_terms |
+  end
+
+  for_symbol('main_body') do
+    single_main_body_statement          %w| main_body_statement |
+    multiple_main_body_statements       %w| main_body terms main_body_statement |
+  end
+  
+  for_symbol('main_body_statement') do
+    main_body_simple_statement          %w| simple_statement |
+    function_definition                 %w| def function_name ( arg_declarations ) terms 
+                                                function_body terms end |
+    main_body_if_statement              %w| if expression terms main_body terms end |
+    main_body_if_else_statement         %w| if expression terms main_body terms else terms main_body 
+                                                terms end |
+    main_body_while_statement           %w| while expression terms main_body terms end |
+  end
+  # lipi:grammar_overview
+
+  for_symbol('simple_statement') do
+    assignment_statement                %w| var_name = expression |
+    print_statement                     %w| print expression |
+    function_call_statement             %w| function_name ( arg_list ) |
+  end
+  
+  for_symbol('function_body') do
+    single_function_body_statement      %w| function_body_statement |
+    multiple_function_body_statements   %w| function_body terms function_body_statement |
+  end
+  
+  for_symbol('function_body_statement') do
+    function_body_simple_statement      %w| simple_statement |
+    return_statement                    %w| return expression |
+    function_body_if_statement          %w| if expression terms function_body terms end |
+    function_body_if_else_statement     %w| if expression terms function_body terms else terms function_body terms end |
+    function_body_while_statement       %w| while expression terms function_body terms end |
+  end
+  
+  for_symbol('function_name') do
+    function_name                       %w| word_literal |
+  end
+  
+  for_symbol('var_name') do
+    variable_name                       %w| word_literal |
+  end
+  
+  for_symbol('arg_declarations') do
+    no_arg_decl                         %w| |
+    single_arg_declaration              %w| arg_decl |
+    multiple_arg_declarations           %w| arg_declarations , arg_decl |
+  end
+  
+  for_symbol('arg_decl') do
+    arg_declaration                     %w| word_literal |
+  end
+  
+  for_symbol('arg_list') do
+    no_args                             %w| |
+    single_arg                          %w| expression |
+    multiple_args                       %w| arg_list , expression |
+  end
+  # lipi:expressions
+  for_symbol('expression') do
+    negation                            %w| ! expression |
+    equality_comparison                 %w| expression == expression |
+    greater_than_comparison             %w| expression > expression |
+    less_than_comparison                %w| expression < expression |
+    addition                            %w| expression + expression |
+    subtraction                         %w| expression - expression |
+    multiplication                      %w| expression * expression |
+    division                            %w| expression / expression |
+    power                               %w| expression ^ expression |
+    literal                             %w| numeric_literal |
+    function_call_expression            %w| function_name ( arg_list ) |
+    variable_reference                  %w| var_name |
+    parenthetized_expression            %w| ( expression ) |
+    negated_expression                  %w| - expression |, :prec => '*'
+  end
+  # lipi:expressions
+  
+  for_symbol('numeric_literal') do
+    integer                             %w| int_literal |
+    float_with_leading_digits           %w| int_literal . int_literal |
+    float_without_leading_digits        %w| . int_literal |
+  end
+  
+  for_symbol('terms') do
+    single_term                         %w| newline |
+    multiple_terms                      %w| terms newline |
+  end
+
+  for_symbol('opt_terms') do
+    some_terms                          %w| terms |
+    no_terms                            %w| |
+  end
+  
+end

data/test/{chittagong_parser_test.rb → chittagong/chittagong_parser_test.rb}

@@ -1,8 +1,5 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
-require 'chittagong_grammar'
-require "test/unit"
-require "fake_logger"
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/chittagong_grammar'
 
 class TestChittagongParser < Test::Unit::TestCase
   def setup
@@ -10,7 +7,7 @@ class TestChittagongParser < Test::Unit::TestCase
     @parser = Dhaka::Parser.new(ChittagongGrammar, fake_logger)
     assert_equal(80, fake_logger.warnings.size)
     assert_equal(0, fake_logger.errors.size)
-    eval(@parser.compile_to_ruby_source_as(:ChittagongParser)) unless Module.const_defined? :ChittagongParser
+    eval(@parser.compile_to_ruby_source_as(:ChittagongParser)) unless defined? ChittagongParser
   end
 
   def test_parses_a_series_of_statements
@@ -28,6 +25,7 @@ class TestChittagongParser < Test::Unit::TestCase
     assert_equal(["single_term",
      "some_terms",
      "variable_name",
+     "integer",
      "literal",
      "assignment_statement",
      "main_body_simple_statement",
@@ -49,7 +47,7 @@ class TestChittagongParser < Test::Unit::TestCase
      "single_term",
      "multiple_terms",
      "some_terms",
-     "program"], result.parse_tree.linearize.collect {|node| node.production.name})
+     "program"], result.linearize.collect {|node| node.production.name})
      
   end
 

data/test/{chittagong_test.rb → chittagong/chittagong_test.rb}

@@ -1,15 +1,11 @@
-require "test/unit"
-
-require "chittagong_grammar"
-require "chittagong_tokenizer"
-require "chittagong_evaluator"
-require "fake_logger"
-
-unless Object.const_defined? :ChittagongParser
-  eval(Dhaka::Parser.new(ChittagongGrammar, FakeLogger.new).compile_to_ruby_source_as(:ChittagongParser)) 
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/chittagong_grammar"
+require File.dirname(__FILE__) + "/chittagong_tokenizer"
+require File.dirname(__FILE__) + "/chittagong_evaluator"
+unless defined? ChittagongParser
+  eval(Dhaka::Parser.new(ChittagongGrammar, FakeLogger.new).compile_to_ruby_source_as(:ChittagongParser))
 end
 
-
 class TestChittagong < Test::Unit::TestCase
   
   def fact(n)
@@ -20,7 +16,7 @@ class TestChittagong < Test::Unit::TestCase
   def program_output program
     output_stream = []
     parse_result = ChittagongParser.parse(ChittagongTokenizer.tokenize(program))
-    result = ChittagongEvaluator.new([{}], output_stream).evaluate(parse_result.parse_tree)
+    result = ChittagongEvaluator.new([{}], output_stream).evaluate(parse_result)
     return result, output_stream
   end
   
@@ -71,30 +67,6 @@ class TestChittagong < Test::Unit::TestCase
     assert_equal(["1", "1", "2", "3", "5", "8", "13", "21", "34"], output_stream)
   end
   
-  def test_recursive_fibonacci
-    program = "
-
-    def fib(n)
-      if n == 0
-        return 1
-      end
-      if n == -1
-        return 0
-      end
-      return fib(n-1) + fib(n-2)
-    end
-    
-    x = 0
-    while x < 9
-      print fib(x)
-      x = x + 1
-    end
-    
-    "
-    result, output_stream = program_output(program)
-    assert_equal(["1", "1", "2", "3", "5", "8", "13", "21", "34"], output_stream)
-  end
-  
   def test_recursive_factorial
     program = "
     def fact(n)
@@ -172,4 +144,23 @@ class TestChittagong < Test::Unit::TestCase
     assert_equal(["1", "2"], output_stream)
   end
 
-end
+  def test_decimal_numbers
+    program = "
+    print .2347 * 23.34
+    a = 1.012
+    b = 345.44
+    c = .234
+    print (a^b)/c
+    def foo(a)
+      print a
+    end
+    foo(3.4)
+    "
+
+    result, output_stream = program_output(program)
+    assert_equal(["5.477898", "263.233029427781", "3.4"], output_stream)
+  end
+
+  
+  
+end