dhaka 2.0.0 → 2.0.1

data/test/precedence_grammar.rb

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

data/test/precedence_grammar_test.rb

@@ -1,6 +1,5 @@
-require "test/unit"
-
-require "precedence_grammar"
+require File.dirname(__FILE__) + '/dhaka_test_helper'
+require File.dirname(__FILE__) + "/precedence_grammar"
 
 class TestPrecedenceGrammar < Test::Unit::TestCase
   def test_precedences_are_computed_correctly

data/test/rr_conflict_grammar.rb

@@ -1,22 +1,20 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
 class RRConflictGrammar < Dhaka::Grammar
   
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    start ['S']
+    start       %w| S |
   end
   
   for_symbol('S') do
-    a_expansion ['A', 'c', 'd']
-    b_expansion ['B', 'c', 'e']
+    a_expansion %w| A c d |
+    b_expansion %w| B c e |
   end
   
   for_symbol('A') do
-    xy ['x', 'y']
+    xy          %w| x y |
   end
 
   for_symbol('B') do
-    xy_again ['x', 'y']
+    xy_again    %w| x y |
   end
 
 end

data/test/simple_grammar.rb

@@ -1,23 +1,21 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
 class SimpleGrammar < Dhaka::Grammar
   
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    start ['S', '#']
+    start                    %w| S # |
   end
   
   for_symbol('S') do
-    expression ['E']
+    expression               %w| E |
   end
   
   for_symbol('E') do
-    subtraction ['E', '-', 'T']
-    term ['T']
+    subtraction              %w| E - T |
+    term                     %w| T |
   end
     
   for_symbol('T') do
-    literal ['n']
-    parenthetized_expression ['(', 'E', ')']
+    literal                  %w| n |
+    parenthetized_expression %w| ( E ) |
   end
 
 end

data/test/sr_conflict_grammar.rb

@@ -1,16 +1,16 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
 class SRConflictGrammar < Dhaka::Grammar
 
   for_symbol(Dhaka::START_SYMBOL_NAME) do
-    statement ['statement']
+    statement              %w| statement |
   end
+
   for_symbol('statement') do
-    if_statement ['if_statement']
+    if_statement           %w| if_statement |
   end
+
   for_symbol('if_statement') do
-    if_then_statement ['IF', 'expr', 'THEN', 'statement']
-    if_then_else_statement ['IF', 'expr', 'THEN', 'statement', 'ELSE', 'statement', 'END']
+    if_then_statement      %w| IF expr THEN statement |
+    if_then_else_statement %w| IF expr THEN statement ELSE statement END |
   end
   
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: dhaka
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
-date: 2007-01-21 00:00:00 -05:00
+  version: 2.0.1
+date: 2007-02-11 00:00:00 -05:00
 summary: An LALR1 parser generator written in Ruby
 require_paths: 
 - lib
@@ -39,6 +39,7 @@ files:
 - lib/parser/action.rb
 - lib/parser/channel.rb
 - lib/parser/compiled_parser.rb
+- lib/parser/conflict.rb
 - lib/parser/item.rb
 - lib/parser/parse_result.rb
 - lib/parser/parse_tree.rb
@@ -50,44 +51,47 @@ files:
 - 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
-- test/arithmetic_grammar_test.rb
-- test/arithmetic_precedence_evaluator.rb
-- 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/chittagong_driver_test.rb
-- test/chittagong_evaluator.rb
-- test/chittagong_evaluator_test.rb
-- test/chittagong_grammar.rb
-- test/chittagong_parser_test.rb
-- test/chittagong_test.rb
-- test/chittagong_tokenizer.rb
-- test/chittagong_tokenizer_test.rb
 - test/compiled_parser_test.rb
+- test/dhaka_test_helper.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
 - test/malformed_grammar.rb
 - test/malformed_grammar_test.rb
 - test/nullable_grammar.rb
+- test/parse_result_test.rb
+- test/parser_state_test.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
+- test/arithmetic/arithmetic_evaluator.rb
+- test/arithmetic/arithmetic_evaluator_test.rb
+- test/arithmetic/arithmetic_grammar.rb
+- test/arithmetic/arithmetic_grammar_test.rb
+- test/arithmetic/arithmetic_test_methods.rb
+- test/arithmetic/arithmetic_tokenizer.rb
+- test/arithmetic/arithmetic_tokenizer_test.rb
+- test/arithmetic_precedence/arithmetic_precedence_evaluator.rb
+- test/arithmetic_precedence/arithmetic_precedence_grammar.rb
+- test/arithmetic_precedence/arithmetic_precedence_grammar_test.rb
+- test/arithmetic_precedence/arithmetic_precedence_parser_test.rb
+- test/arithmetic_precedence/arithmetic_precedence_tokenizer.rb
+- test/brackets/bracket_grammar.rb
+- test/brackets/bracket_tokenizer.rb
+- test/brackets/brackets_test.rb
+- test/chittagong/chittagong_driver.rb
+- test/chittagong/chittagong_driver_test.rb
+- test/chittagong/chittagong_evaluator.rb
+- test/chittagong/chittagong_evaluator_test.rb
+- test/chittagong/chittagong_grammar.rb
+- test/chittagong/chittagong_parser_test.rb
+- test/chittagong/chittagong_test.rb
+- test/chittagong/chittagong_tokenizer.rb
+- test/chittagong/chittagong_tokenizer_test.rb
 test_files: []
 
 rdoc_options: []

data/test/arithmetic_grammar.rb

@@ -1,35 +0,0 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
-class ArithmeticGrammar < Dhaka::Grammar
-  for_symbol(Dhaka::START_SYMBOL_NAME) do
-    expression ['E']
-  end
-  for_symbol('E') do
-    subtraction ['E', '-', 'T']
-    addition ['E', '+', 'T']
-    term ['T']
-  end
-  for_symbol('T') do
-    factor ['F']
-    division ['T', '/', 'F']
-    multiplication ['T', '*', 'F']
-  end
-  for_symbol('F') do
-    getting_literals ['n']
-    unpacking_parenthetized_expression ['(', 'E', ')']
-    function ['Function']
-  end
-  for_symbol('Function') do
-    evaluating_function ['FunctionName', '(', 'Args', ')']
-  end
-  for_symbol('FunctionName') do
-    max_function ['h']
-    min_function ['l']
-  end
-  for_symbol('Args') do
-    empty_args []
-    single_args ['E']
-    concatenating_args ['E', ',', 'Args']
-  end
-end
-

data/test/arithmetic_precedence_grammar.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
-class ArithmeticPrecedenceGrammar < Dhaka::Grammar
-  precedences do
-    left ['+', '-']
-    left ['*', '/']
-    nonassoc ['^']
-  end
-  
-  for_symbol(Dhaka::START_SYMBOL_NAME) do
-    expression ['E']
-  end
-  
-  for_symbol('E') do
-    addition ['E', '+', 'E']
-    subtraction ['E', '-', 'E']
-    multiplication ['E', '*', 'E']
-    division ['E', '/', 'E']
-    power ['E', '^', 'E']
-    literal ['n']
-    parenthetized_expression ['(', 'E', ')']
-    negated_expression ['-', 'E'], :prec => '*'
-  end
-end

data/test/arithmetic_precedence_parser_test.rb

@@ -1,33 +0,0 @@
-require "test/unit"
-require "arithmetic_precedence_grammar"
-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)
-    eval(parser.compile_to_ruby_source_as(:ArithmeticPrecedenceParser))
-    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").parse_tree))
-    assert_equal(-4, evaluate(parse("-2^2").parse_tree))
-    assert_equal(10, evaluate(parse("2+2^3").parse_tree))
-    assert_equal(64, evaluate(parse("(2+2)^3").parse_tree))
-    assert_equal(128, evaluate(parse("(2+2)^3*2").parse_tree))
-    assert(parse("(2+2)^3^2").has_error?)
-  end
-  
-  def parse(input)
-    ArithmeticPrecedenceParser.parse(ArithmeticPrecedenceTokenizer.tokenize(input))
-  end
-
-  def evaluate(parse_tree)
-    ArithmeticPrecedenceEvaluator.new.evaluate(parse_tree)
-  end
-
-end
-

data/test/bracket_grammar.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-
-class BracketGrammar < Dhaka::Grammar
-  
-  for_symbol(Dhaka::START_SYMBOL_NAME) do
-    start ['Package']
-  end
-  
-  for_symbol('Package') do
-    soft_wrapped_package ['(', 'Contents', ')']
-    cardboard_package ['[', 'Contents', ']']
-    wooden_package ['{', 'Contents', '}']
-  end
-  
-  for_symbol('Contents') do
-    bracket ['B']
-    set_of_packages ['SetOfPackages']
-  end
-    
-  for_symbol('SetOfPackages') do
-    one_package ['Package']
-    multiple_packages ['SetOfPackages', 'Package']
-  end
-
-end

data/test/chittagong_grammar.rb

@@ -1,104 +0,0 @@
-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', 'main_body', 'opt_terms']
-  end
-
-  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('simple_statement') do
-    assignment_statement ['var_name', '=', 'expression']
-    print_statement ['print', 'expression']
-    function_call_statement ['function_name', '(', 'arg_list', ')']
-  end
-  
-  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 => '*'
-  end
-  
-  for_symbol('terms') do
-    single_term ['newline']
-    multiple_terms ['terms', 'newline']
-  end
-
-  for_symbol('opt_terms') do
-    some_terms ['terms']
-    no_terms []
-  end
-  
-end

data/test/incomplete_arithmetic_evaluator.rb

@@ -1,60 +0,0 @@
-require File.dirname(__FILE__)+'/../lib/dhaka'
-require 'arithmetic_grammar'
-
-class ArithmeticEvaluator < Dhaka::Evaluator
-  
-  self.grammar = ArithmeticGrammar
-  
-  define_evaluation_rules do
-    
-    for_subtraction do 
-      child_nodes[0] - child_nodes[2]
-    end
-
-    for_addition do
-      child_nodes[0] + child_nodes[2]
-    end
-
-    for_division do
-      child_nodes[0].to_f/child_nodes[2] 
-    end
-
-    for_multiplication do
-      child_nodes[0] * child_nodes[2]
-    end
-
-    for_getting_literals do
-      child_nodes[0].token.value
-    end
-
-    for_start_production do
-      child_nodes[0]
-    end
-
-    for_empty_args do
-      []
-    end
-
-    for_evaluating_function do
-      child_nodes[0].call child_nodes[2]
-    end
-  
-    for_concatenating_args do
-      [child_nodes[0]]+child_nodes[2]
-    end
-  
-    for_single_args do
-      [child_nodes[0]]
-    end
-  
-    for_min_function do
-      Proc.new {|args| args.inject {|min, elem| min = (elem < min ? elem : min)}}
-    end
-  
-    for_max_function do
-      Proc.new {|args| args.inject {|max, elem| max = (elem > max ? elem : max)}}
-    end
-
-  end
-
-end