aurum 0.1.0

data/test/parsing_table_generator/lr_item_test.rb

@@ -0,0 +1,33 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class LRItemTest < Test::Unit::TestCase
+    def test_should_return_dot_symbol
+        assert_equal T, LR_item(0, E, T, ID).dot_symbol
+        assert_equal ID, LR_item(1, E, T, ID).dot_symbol
+    end
+
+    def test_should_be_handle_if_at_right_most_position
+        assert LR_item(2, E, T, ID).handle?
+        assert !LR_item(1, E, T, ID).handle?
+        assert LR_item(0, E).handle?
+    end
+
+    def test_should_be_kernel_if_not_at_left_most_position
+        assert LR_item(2, E, T, ID).kernel?
+        assert LR_item(1, E, T, ID).kernel?
+        assert !LR_item(0, E, T, ID).kernel?
+    end   
+
+    def test_should_return_zero_to_position_as_first_part
+        assert_equal [], LR_item(0, E, T, ID).first_part
+        assert_equal [T], LR_item(1, E, T, ID).first_part
+        assert_equal [T, ID], LR_item(2, E, T, ID).first_part
+    end
+
+    def test_should_return_position_to_end_as_second_part
+        assert_equal [T, ID], LR_item(0, E, T, ID).second_part
+        assert_equal [ID], LR_item(1, E, T, ID).second_part
+        assert_equal [], LR_item(2, E, T, ID).second_part
+    end
+end

data/test/parsing_table_generator/parsing_table_state_test.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class ParsingTableStateTest < Test::Unit::TestCase
+    def test_should_equal_to_state_with_same_items
+        state1 = parsing_table_state LR_item(1, E, T, T), LR_item(1, E, T)
+        state2 = parsing_table_state LR_item(1, E, T), LR_item(1, E, T, T)
+        assert_equal state1, state2
+    end
+
+    def test_should_be_read_reducable_if_contains_one_and_only_one_handle
+        assert parsing_table_state(LR_item(1, E, T)).read_reduce
+        assert !parsing_table_state(LR_item(1, E, T, T)).read_reduce
+        assert !parsing_table_state(LR_item(1, E, T, T), LR_item(1, E, T)).read_reduce
+    end
+
+    def test_should_not_add_duplicate_action
+        state = parsing_table_state(LR_item(1, E, T))
+        state[E] << Aurum::ReduceAction.new(production(E, T), true)
+        state[E] << Aurum::ReduceAction.new(production(E, T), true)
+        assert_equal 1, state[E].length
+    end
+
+    def test_should_be_consistent_if_contains_one_and_only_one_handle
+        assert  parsing_table_state(LR_item(1, E, T)).consistent?
+    end
+
+    def test_should_be_consistent_if_contains_no_handle
+        assert  parsing_table_state(LR_item(1, E, T, ID), LR_item(1, E, F, ID), LR_item(1, E, ID, F)).consistent?
+    end
+
+    def test_should_be_inconsistent_if_contains_handle_and_other_kernal_items
+        assert !parsing_table_state(LR_item(1, E, T), LR_item(1, E, T, ID)).consistent?
+    end
+
+    def test_should_return_all_direct_read_symbols
+        assert_equal [T], parsing_table_state(LR_item(1, E, T, T), LR_item(1, E, T)).direct_read
+    end
+end

data/test/parsing_table_generator/precedence_table_test.rb

@@ -0,0 +1,28 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class PrecedenceTableTest < Test::Unit::TestCase
+    OP_A, OP_B = terminal('+'), terminal('-')
+
+    def test_should_return_one_if_op_a_has_higher_precedence
+        precedences = precedence_table [[OP_A], [OP_B]]
+        assert_equal 1, precedences.compare(OP_A, OP_B)
+    end
+
+    def test_should_return_minus_one_if_op_a_has_lower_precedence
+        precedences = precedence_table [[OP_A], [OP_B]]
+        assert_equal -1, precedences.compare(OP_B, OP_A)
+    end
+
+    def test_should_return_one_if_ops_same_precedence_and_left_associativity
+        precedences = precedence_table [[OP_A, OP_B]] 
+        assert_equal 1, precedences.compare(OP_A, OP_B)
+        assert_equal 1, precedences.compare(OP_B, OP_A)
+    end
+
+    def test_should_return_minus_one_if_ops_same_precedence_and_right_associativity
+        precedences = precedence_table [[OP_A, OP_B]], :right => [OP_A, OP_B]
+        assert_equal -1, precedences.compare(OP_A, OP_B)
+        assert_equal -1, precedences.compare(OP_B, OP_A)
+    end
+end

data/test/parsing_table_generator/production_test.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__) + '/../')
+require 'test_helper'
+
+class ProductionTest < Test::Unit::TestCase
+    def test_should_return_last_terminal_as_opearator
+        production = production E, E, terminal('+'), E
+        assert_equal terminal('+'), production.operator 
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,103 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+require 'aurum'
+
+def terminal name
+    Aurum::Symbol.new name, true
+end
+
+def nonterminal name
+    Aurum::Symbol.new name, false
+end
+
+def production nt, *symbols
+    Aurum::Production.new nt, symbols
+end
+
+def LR_item position, nt, *symbols
+    Aurum::ParsingTableGenerator::LRItem.new production(nt, *symbols), position
+end
+
+def parsing_table_state *items
+    Aurum::ParsingTableGenerator::State.new items
+end
+
+def parser_generator(definition, precedences = [], associativities = {:left => [], :right => []}) 
+    Aurum::ParsingTableGenerator.new definition, precedences
+end
+
+def shift state
+    Aurum::ShiftAction.new state, false
+end
+
+def lookahead_shift state
+    Aurum::ShiftAction.new state, true
+end
+
+def read_reduce production_no
+    Aurum::ReduceAction.new production_no, true
+end
+
+def reduce production_no
+    Aurum::ReduceAction.new production_no, false
+end
+
+def precedence_table(precedences, associativities = {:left => [], :right => []})
+    Aurum::ParsingTableGenerator::PrecedenceTable.new precedences, associativities 
+end
+
+String.class_eval do
+    def to_char_set
+        char_set = Aurum::CharacterSet.new
+        char_set << self
+        char_set
+    end
+
+    def to_pattern
+        Aurum::Pattern.from_string self
+    end
+end
+
+Aurum::CharacterSet.class_eval do
+    def intervals
+        @intervals
+    end
+end
+
+Test::Unit::TestCase.class_eval do
+    START, E, T, F, ID = nonterminal('$start'), nonterminal('E'), nonterminal('T'), nonterminal('F'), terminal('id')
+
+    SIMPLE_GRAMMAR_LR0 = {
+    E => [production(E, T, terminal('+'), T)],
+    T => [production(T, ID)]
+    }
+
+    EXPRESSION_GRAMMAR_LALR1 = {
+    E => [production(E, E, terminal('+'), T), production(E, T)],
+    T => [production(T, T, terminal('*'), F), production(T, F)],
+    F => [production(F, terminal('('), E, terminal(')')), production(F, ID)],
+    }
+
+    BNF, RLIST, RULE, SLIST = nonterminal('bnf'), nonterminal('rlist'), nonterminal('rule'), nonterminal('slist')
+    BNF_GRAMMAR_LALR2 = {
+    BNF   => [production(BNF, RLIST)],
+    RLIST => [production(RLIST), production(RLIST, RLIST, RULE)],
+    RULE  => [production(RULE, terminal('s'), terminal('->'), SLIST)],
+    SLIST => [production(SLIST), production(SLIST, SLIST, terminal('s'))]
+    }
+
+    STATEMENT = nonterminal 'statement'
+    IF_GRAMMAR_LALR2 = {
+    STATEMENT => [production(STATEMENT, terminal('if'), STATEMENT, terminal('then'), STATEMENT),
+    production(STATEMENT, terminal('if'), STATEMENT, terminal('then'), STATEMENT, terminal('else'), STATEMENT),
+    production(STATEMENT, terminal('stmt'))]
+    }
+
+    EXPRESSION_GRAMMAR = { E => [production(E, E, terminal('+'), E), production(E, E, terminal('*'), E), production(E, ID)]}
+    NOT_LALR_GRAMMAR = EXPRESSION_GRAMMAR
+
+    PATTERN_A, PATTERN_B, PATTERN_C = 'pattern_a'.to_pattern, 'pattern_b'.to_pattern, 'pattern_c'.to_pattern,
+    ABABB = Aurum::Pattern.concat(('a'.to_pattern | 'b'.to_pattern).kleene, 'abb'.to_pattern)
+end
+
+

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: aurum
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-20 00:00:00 +10:00
+summary: Aurum is a LALR(n) parser generator written in Ruby.
+require_paths: 
+- lib
+email: x at bjug dot org
+homepage: http://rubyforge.org/projects/aurum
+rubyforge_project: 
+description: 
+autorequire: aurum
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Vincent Xu
+files: 
+- example/expression
+- example/expression/expression.rb
+- lib/aurum
+- lib/aurum/lexical_table_generator.rb
+- lib/aurum/parsing_table_generator.rb
+- lib/aurum/grammar.rb
+- lib/aurum/engine.rb
+- lib/aurum.rb
+- test/parsing_table_generator
+- test/parsing_table_generator/augmented_grammar_test.rb
+- test/parsing_table_generator/lr_0_automata_test.rb
+- test/parsing_table_generator/production_test.rb
+- test/parsing_table_generator/parsing_table_state_test.rb
+- test/parsing_table_generator/lr_item_test.rb
+- test/parsing_table_generator/precedence_table_test.rb
+- test/parsing_table_generator/lalr_n_computation_test.rb
+- test/grammar_definition
+- test/grammar_definition/grammar_definition_test.rb
+- test/grammar_definition/character_class_definition_test.rb
+- test/grammar_definition/lexical_definition_test.rb
+- test/grammar_definition/operator_precedence_definition_test.rb
+- test/grammar_definition/production_definition_test.rb
+- test/lexical_table_generator
+- test/lexical_table_generator/interval_test.rb
+- test/lexical_table_generator/character_set_test.rb
+- test/lexical_table_generator/automata_test.rb
+- test/lexical_table_generator/pattern_test.rb
+- test/lexical_table_generator/subset_determinizer_test.rb
+- test/lexical_table_generator/table_generator_test.rb
+- test/test_helper.rb
+- test/engine
+- test/engine/semantic_attributes_test.rb
+- test/engine/lexer_test.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+