simply_stored 0.1.4

data/test/vendor/dhaka-2.2.1/test/chittagong/chittagong_driver_test.rb

@@ -0,0 +1,276 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/chittagong_grammar"
+require File.dirname(__FILE__) + "/chittagong_lexer_specification"
+begin
+  require File.dirname(__FILE__) + "/chittagong_parser"
+  require File.dirname(__FILE__) + "/chittagong_lexer"
+rescue LoadError
+  puts "Please run the rake command in the root folder to generate the lexer and parser required for this test."
+  exit
+end
+require File.dirname(__FILE__) + "/chittagong_driver"
+
+class TestChittagongDriver < Test::Unit::TestCase
+  def setup
+    @driver = ChittagongDriver.new
+  end
+  
+  def test_return_statement_not_allowed_in_main
+    # Programs with problems
+    program = "
+
+    if 1 > 2
+      return 5
+    end
+
+    print 2
+    "
+    assert_equal(
+    "Unexpected token return:
+
+
+    if 1 > 2
+      >>>return 5
+    end
+
+    print 2
+    ", @driver.run(program))
+  end
+  
+  def test_catches_unexpected_end_of_input
+    program = "
+      def"
+    assert_equal("Unexpected end of file.", @driver.run(program))
+  end
+  
+  def test_catches_unexpected_characters
+    program = "
+      print 2
+      def #}
+        "
+    assert_equal(
+    "Unexpected character #:
+
+      print 2
+      def >>>#}
+        ", @driver.run(program))
+  end
+  
+  def test_catches_undefined_variables
+    program = "
+      x = 1
+      y = 2
+      def foo(n)
+        return 2
+      end
+      foo(1)
+      
+      if x > y
+        print 999
+        print 777
+      else
+        print 66
+      end
+      
+      print x
+      print y
+      print 2*3+c
+      print 888
+      
+    "
+
+    assert_equal(
+    "66.0
+1.0
+2.0
+Undefined variable c:
+
+      x = 1
+      y = 2
+      def foo(n)
+        return 2
+      end
+      foo(1)
+      
+      if x > y
+        print 999
+        print 777
+      else
+        print 66
+      end
+      
+      print x
+      print y
+      print 2*3+>>>c
+      print 888
+      
+    ", @driver.run(program))
+  end
+
+  def test_catches_undefined_functions
+    program = "
+
+      def foo(n)
+        bar(x)
+      end
+      
+      foo(2)
+      
+    "
+    assert_equal(
+    "Undefined function bar:
+
+
+      def foo(n)
+        >>>bar(x)
+      end
+      
+      foo(2)
+      
+    ", @driver.run(program))
+  end
+  # lipi:variable_scoping
+  def test_variable_scope
+    program = "
+      x = 1
+      
+      def bar(n)
+        print 999
+      end
+      
+      def foo(n)
+        bar(x)
+      end
+      
+      foo(2)
+      
+    "
+    assert_equal(
+    "Undefined variable x:
+
+      x = 1
+      
+      def bar(n)
+        print 999
+      end
+      
+      def foo(n)
+        bar(>>>x)
+      end
+      
+      foo(2)
+      
+    ", @driver.run(program))
+  end
+  # lipi:variable_scoping
+  
+  def test_nested_function_calls
+    
+    program = "
+    
+    def foo(a)
+      return a + 2
+    end
+    
+    def bar(b, c)
+      return b + c
+    end
+    
+    def baz(x, y, z)
+      return foo(y) + bar(x, z)
+    end
+    
+    print baz(foo(1), bar(2, 3), bar(6, 2))
+    
+    "
+    assert_equal("18.0", @driver.run(program))
+  end
+  
+  def test_wrong_number_of_arguments
+    
+    program = "
+    
+    def whatever(a, b)
+      return a + b
+    end
+    
+    whatever(1, 2, 3)
+    
+    "
+    assert_equal(
+    "Wrong number of arguments:
+
+    
+    def whatever(a, b)
+      return a + b
+    end
+    
+    whatever>>>(1, 2, 3)
+    
+    ", @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
+    c = 23.523
+    b = 20..2
+    "
+    
+    assert_equal("Unexpected character .:
+
+    a = .234
+    c = 23.523
+    b = 20.>>>.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.0", "1.0", "2.0", "3.0", "5.0", "8.0", "13.0", "21.0", "34.0"].join("\n"), @driver.run(program))
+  end
+  # lipi:recursive_fib
+end

data/test/vendor/dhaka-2.2.1/test/chittagong/chittagong_evaluator.rb

@@ -0,0 +1,284 @@
+require File.dirname(__FILE__) + '/chittagong_grammar'
+
+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_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
+    # lipi:function_defs
+    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
+    # lipi:function_defs
+
+    for_main_body_if_statement do
+      checked_if_statement
+    end
+    
+    for_function_body_if_statement do
+      checked_if_statement
+    end
+
+    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_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_main_body_while_statement do
+      checked_while_statement
+    end
+    
+    for_function_body_while_statement do
+      checked_while_statement
+    end 
+    
+    def checked_while_statement
+      loop do
+        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_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_function_call_statement do
+      checked_function_call
+    end
+    
+    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}", 
+          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
+    # lipi:checked_function_call
+    
+    for_return_statement do 
+      checked_unary_operation(child_nodes[1]){|x| x}
+    end
+    
+    for_single_arg_declaration do
+      [evaluate(child_nodes[0])]
+    end
+    
+    for_no_arg_decl do
+      []
+    end
+    
+    for_multiple_arg_declarations do 
+      evaluate(child_nodes[0]) + [evaluate(child_nodes[2])]
+    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_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
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a < b}
+    end
+
+    for_greater_than_comparison do
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a > b}
+    end
+
+    for_equality_comparison do
+      checked_binary_operation(child_nodes[0], child_nodes[2]){|a, b| a == b}
+    end
+        
+    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
+      token_value
+    end
+    
+    for_variable_name do
+      token_value
+    end
+    
+    for_arg_declaration do
+      token_value
+    end
+    
+    for_literal do
+      ChittagongSuccessResult.new(token_value.to_f)
+    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
+
+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/vendor/dhaka-2.2.1/test/chittagong/chittagong_evaluator_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/chittagong_evaluator"
+begin
+  require File.dirname(__FILE__) + "/chittagong_parser"
+rescue LoadError
+  puts "Please run the rake command in the root folder to generate the lexer and parser required for this test."
+  exit
+end
+
+class TestChittagongEvaluator < Test::Unit::TestCase
+  def test_evaluates_a_simple_program
+    token_stream  = build_tokens(
+      ['newline'],
+      ['word_literal', 'x'], ['='], ['numeric_literal', 23], ['newline'],
+      ['print'], ['word_literal', 'x'], ['newline'],
+      ['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'], ['word_literal', 'y'], ['newline'],
+      ['end'], ['newline'],
+      ['newline'],
+      [Dhaka::END_SYMBOL_NAME]
+    )
+    stack         = [{}]
+    output_stream = []
+    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.0", "1058.0", "46.0"], output_stream)
+  end
+  
+  def build_tokens *tokens
+    tokens.collect {|token| Dhaka::Token.new(token[0], token[1], nil)}
+  end
+end

data/test/vendor/dhaka-2.2.1/test/chittagong/chittagong_grammar.rb

@@ -0,0 +1,104 @@
+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('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