foreverman-dhaka 2.2.1

data/test/arithmetic_precedence/arithmetic_precedence_evaluator.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/arithmetic_precedence_grammar'
+
+class ArithmeticPrecedenceEvaluator < Dhaka::Evaluator
+  
+  self.grammar = ArithmeticPrecedenceGrammar
+  
+  define_evaluation_rules do
+    
+    for_subtraction do 
+      evaluate(child_nodes[0]) - evaluate(child_nodes[2])
+    end
+
+    for_addition do
+      evaluate(child_nodes[0]) + evaluate(child_nodes[2])
+    end
+
+    for_division do
+      evaluate(child_nodes[0]).to_f/evaluate(child_nodes[2]) 
+    end
+
+    for_multiplication do
+      evaluate(child_nodes[0]) * evaluate(child_nodes[2])
+    end
+
+    for_literal do
+      child_nodes[0].token.value.to_i
+    end
+
+    for_parenthetized_expression do
+      evaluate(child_nodes[1])
+    end
+    
+    for_negated_expression do
+      -evaluate(child_nodes[1])
+    end
+    
+    for_power do
+      evaluate(child_nodes[0])**evaluate(child_nodes[2])
+    end
+
+  end
+
+end

data/test/arithmetic_precedence/arithmetic_precedence_grammar.rb

@@ -0,0 +1,24 @@
+class ArithmeticPrecedenceGrammar < Dhaka::Grammar
+
+  precedences do
+    left                     %w| + - |
+    left                     %w| * / |
+    nonassoc                 %w| ^ |
+  end
+  
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    expression               %w| E |
+  end
+  
+  for_symbol('E') do
+    addition                 %w| E + E |
+    subtraction              %w| E - E |
+    multiplication           %w| E * E |
+    division                 %w| E / E |
+    power                    %w| E ^ E |
+    literal                  %w| n |
+    parenthetized_expression %w| ( E ) |
+    negated_expression       %w| - E |, :prec => '*'
+  end
+
+end

data/test/arithmetic_precedence/arithmetic_precedence_grammar_test.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + '/arithmetic_precedence_grammar'
+
+class TestArithmeticPrecedenceGrammar < Test::Unit::TestCase
+  def setup
+    @addop = ArithmeticPrecedenceGrammar.symbol_for_name('+')
+    @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
+    assert_equal(0, @addop.precedence.precedence_level)
+    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)
+    assert_equal(@mulop.precedence, ArithmeticPrecedenceGrammar.production_named("multiplication").precedence)
+    assert_equal(@mulop.precedence, ArithmeticPrecedenceGrammar.production_named("negated_expression").precedence)
+  end
+end

data/test/arithmetic_precedence/arithmetic_precedence_lexer_specification.rb

@@ -0,0 +1,23 @@
+class ArithmeticPrecedenceLexerSpecification < Dhaka::LexerSpecification
+  
+  for_pattern '\s' do
+    # ignore whitespace
+  end
+  
+  %w| - h l , |.each do |char|
+    for_pattern char do
+      create_token(char)
+    end
+  end
+  
+  %w| ( ) + / * ^ |.each do |char|
+    for_pattern "\\#{char}" do
+      create_token(char)
+    end
+  end
+  
+  for_pattern '\d+' do
+    create_token('n')
+  end
+
+end

data/test/arithmetic_precedence/arithmetic_precedence_parser_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/arithmetic_precedence_grammar"
+require File.dirname(__FILE__) + "/arithmetic_precedence_lexer_specification"
+require File.dirname(__FILE__) + "/arithmetic_precedence_evaluator"
+
+class TestArithmeticPrecedenceParser < Test::Unit::TestCase
+  def test_parses_arithmetic_expressions
+    fake_logger = FakeLogger.new
+    parser      = Dhaka::Parser.new(ArithmeticPrecedenceGrammar, fake_logger)
+    lexer       = Dhaka::Lexer.new(ArithmeticPrecedenceLexerSpecification)
+    eval(parser.compile_to_ruby_source_as(:ArithmeticPrecedenceParser))
+    eval(lexer.compile_to_ruby_source_as(:ArithmeticPrecedenceLexer))
+
+    assert_equal(30, fake_logger.warnings.size)
+    assert_equal(0, fake_logger.errors.size)
+    
+    assert_equal(-8, evaluate(parse("5 * -14/(2*7 - 7) + 2")))
+    assert_equal(-4, evaluate(parse("-2^2")))
+    assert_equal(10, evaluate(parse("2+2^3")))
+    assert_equal(64, evaluate(parse("(2+2)^3")))
+    assert_equal(128, evaluate(parse("(2+2)^3*2")))
+    assert(parse("(2+2)^3^2").has_error?)
+  end
+  
+  def parse(input)
+    ArithmeticPrecedenceParser.parse(ArithmeticPrecedenceLexer.lex(input))
+  end
+
+  def evaluate(parse_tree)
+    ArithmeticPrecedenceEvaluator.new.evaluate(parse_tree)
+  end
+end
+

data/test/brackets/bracket_grammar.rb

@@ -0,0 +1,23 @@
+class BracketGrammar < Dhaka::Grammar
+  
+  for_symbol(Dhaka::START_SYMBOL_NAME) do
+    start                %w| Package |
+  end
+  
+  for_symbol('Package') do
+    soft_wrapped_package %w| ( Contents ) |
+    cardboard_package    %w| [ Contents ] |
+    wooden_package       %w| { Contents } |
+  end
+  
+  for_symbol('Contents') do
+    bracket              %w| B |
+    set_of_packages      %w| SetOfPackages |
+  end
+    
+  for_symbol('SetOfPackages') do
+    one_package          %w| Package |
+    multiple_packages    %w| SetOfPackages Package |
+  end
+
+end

data/test/brackets/bracket_tokenizer.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/bracket_grammar'
+
+class BracketTokenizer < Dhaka::Tokenizer
+  
+  all_characters = %w| ( [ { B } ] ) |
+
+  for_state Dhaka::TOKENIZER_IDLE_STATE do
+    for_characters(all_characters) do
+      create_token(curr_char, nil)
+      advance
+    end
+  end
+  
+end
+
+class LazyBracketTokenizer < BracketTokenizer
+  for_state Dhaka::TOKENIZER_IDLE_STATE do
+    for_default do
+      advance
+    end
+  end
+end

data/test/brackets/brackets_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../dhaka_test_helper'
+require File.dirname(__FILE__) + "/bracket_grammar"
+require File.dirname(__FILE__) + '/bracket_tokenizer'
+
+class TestBracketGrammar < Test::Unit::TestCase
+  def test_recognizes_faulty_bracket_configuration_correctly
+    eval Dhaka::Parser.new(BracketGrammar).compile_to_ruby_source_as(:BracketParser)
+    assert correct("[{(B)[B]}(B)]")
+    assert correct("[[B]{(B)}(B)]")
+    assert correct("{(B)[B]}")
+    assert !correct("{B[B]}")
+    assert !correct("B")
+    assert !correct("[[B]{(B)}}(B)]")
+  end
+  
+  def test_ignores_invalid_characters_with_default_action
+    tokens = BracketTokenizer.tokenize("A{(B)[B]}")
+    assert tokens.has_error?
+    
+    tokens = LazyBracketTokenizer.tokenize("A{(B)[B]}")
+    assert !tokens.has_error?
+  end
+  
+  def correct input_string
+    result = BracketParser.parse(BracketTokenizer.tokenize(input_string))
+    !result.has_error?
+  end
+end

data/test/chittagong/chittagong_driver.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/chittagong_lexer_specification"
+require File.dirname(__FILE__) + "/chittagong_evaluator"
+
+class ChittagongDriver
+
+  ERROR_MARKER = ">>>"
+  
+  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#{program.dup.insert(unexpected_token.input_position, ERROR_MARKER)}"
+    end
+  end
+  
+  def tokenize_error_message unexpected_char_index, program
+    "Unexpected character #{program[unexpected_char_index].chr}:\n#{program.dup.insert(unexpected_char_index, ERROR_MARKER)}"
+  end
+  
+  def evaluation_error_message evaluation_result, program
+    "#{evaluation_result.exception}:\n#{program.dup.insert(evaluation_result.node.tokens[0].input_position, ERROR_MARKER)}"
+  end
+  
+  # lipi:run_method
+  def run(program)
+    parse_result = ChittagongParser.parse(ChittagongLexer.lex(program))
+
+    case parse_result
+      when Dhaka::TokenizerErrorResult
+        return tokenize_error_message(parse_result.unexpected_char_index, program)
+      when Dhaka::ParseErrorResult
+        return parse_error_message(parse_result.unexpected_token, program) 
+    end
+    
+    evaluation_result = ChittagongEvaluator.new([{}], output_stream = []).
+        evaluate(parse_result)
+    if evaluation_result.exception
+      return (output_stream << evaluation_error_message(evaluation_result, program)).
+        join("\n") 
+    end
+    
+    return output_stream.join("\n")
+  end
+  # lipi:run_method
+  
+end

data/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