dhaka 0.0.3 → 0.0.4

data/lib/dhaka.rb

@@ -1,44 +1,45 @@
-#--
-# Copyright (c) 2006 Mushfeq Khan
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
+#--
+# Copyright (c) 2006 Mushfeq Khan
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
 
-require 'grammar/grammar_symbol'
-require 'grammar/production'
-require 'grammar/closure_hash'
-require 'grammar/grammar'
+require File.dirname(__FILE__)+'/grammar/grammar_symbol'
+require File.dirname(__FILE__)+'/grammar/production'
+require File.dirname(__FILE__)+'/grammar/closure_hash'
+require File.dirname(__FILE__)+'/grammar/grammar'
+require File.dirname(__FILE__)+'/grammar/precedence'
 
-require 'parser/parse_result'
-require 'parser/item'
-require 'parser/channel'
-require 'parser/parser_methods'
-require 'parser/parse_tree'
-require 'parser/parser_state'
-require 'parser/token'
-require 'parser/action'
-require 'parser/parser_run'
-require 'parser/parser'
-require 'parser/compiled_parser'
+require File.dirname(__FILE__)+'/parser/parse_result'
+require File.dirname(__FILE__)+'/parser/item'
+require File.dirname(__FILE__)+'/parser/channel'
+require File.dirname(__FILE__)+'/parser/parser_methods'
+require File.dirname(__FILE__)+'/parser/parse_tree'
+require File.dirname(__FILE__)+'/parser/parser_state'
+require File.dirname(__FILE__)+'/parser/token'
+require File.dirname(__FILE__)+'/parser/action'
+require File.dirname(__FILE__)+'/parser/parser_run'
+require File.dirname(__FILE__)+'/parser/parser'
+require File.dirname(__FILE__)+'/parser/compiled_parser'
 
-require 'tokenizer/tokenizer'
-require 'evaluator/evaluator'
+require File.dirname(__FILE__)+'/tokenizer/tokenizer'
+require File.dirname(__FILE__)+'/evaluator/evaluator'
 
 

data/lib/grammar/grammar.rb

@@ -11,15 +11,34 @@ module Dhaka
       @symbol = symbol
     end
   
-    def method_missing(production_name, expansion)
+    def method_missing(production_name, expansion, options = {})
       expansion_symbols = expansion.collect {|name| @grammar.symbols[name]}
-      production = Production.new(@symbol, expansion_symbols, production_name.to_s)
+      if precedence_symbol_name = options[:prec] 
+        production = Production.new(@symbol, expansion_symbols, production_name.to_s, @grammar.symbol_for_name(precedence_symbol_name).precedence)
+      else
+        production = Production.new(@symbol, expansion_symbols, production_name.to_s)
+      end
       @symbol.nullable = true if expansion_symbols.empty?
       @grammar.productions_by_symbol[production.symbol] << production
+      raise "Duplicate production named #{production.name}" if @grammar.productions_by_name[production.name]
       @grammar.productions_by_name[production.name] = production
     end
   end
 
+  class PrecedenceBuilder
+    def initialize(grammar)
+      @grammar = grammar
+      @precedence_level = 0
+    end
+    def method_missing(associativity, symbol_names)
+      symbol_names.each do |symbol_name|
+        symbol = @grammar.symbols[symbol_name]
+        symbol.precedence = Precedence.new(@precedence_level, associativity)
+      end
+      @precedence_level += 1
+    end
+  end
+
   class Grammar
 
     def self.inherited(grammar)
@@ -83,6 +102,10 @@ module Dhaka
       return channels, result
     end
 
+    def self.precedences &blk
+      PrecedenceBuilder.new(self).instance_eval(&blk)
+    end
+
     def self.first(given_symbol)
       cached_result = self.__first_cache[given_symbol] 
       return cached_result if cached_result

data/lib/grammar/grammar_symbol.rb

@@ -2,7 +2,7 @@
 module Dhaka
   class GrammarSymbol
     attr_reader :name
-    attr_accessor :non_terminal, :nullable
+    attr_accessor :non_terminal, :nullable, :precedence, :associativity
     def initialize(name)
       @name = name
     end

data/lib/grammar/precedence.rb

@@ -0,0 +1,14 @@
+module Dhaka
+  class Precedence 
+    include Comparable
+    attr_reader :precedence_level, :associativity
+    def initialize(precedence_level, associativity)
+      @precedence_level = precedence_level
+      @associativity = associativity
+    end
+    
+    def <=> other
+      self.precedence_level <=> other.precedence_level
+    end
+  end
+end

data/lib/grammar/production.rb

@@ -1,14 +1,28 @@
 #!/usr/bin/env ruby
 module Dhaka
   class Production
-    attr_reader :symbol, :expansion, :name
-    def initialize(symbol, expansion, name)
+
+    attr_reader :symbol, :expansion, :name, :precedence
+
+    def initialize(symbol, expansion, name, precedence = nil)
       @symbol = symbol
       @expansion = expansion
       @name = name
+      if precedence
+        @precedence = precedence
+      else
+        @expansion.reverse_each do |symbol|
+          if symbol.terminal
+            @precedence = symbol.precedence
+            break
+          end
+        end 
+      end
     end
+
     def to_s
       "#{@name} #{@symbol} ::= #{@expansion.join(' ')}"
     end
+
   end
 end

data/lib/parser/parser.rb

@@ -1,11 +1,19 @@
 #!/usr/bin/env ruby
 require 'set'
+require 'logger'
+
 module Dhaka
   class Parser
     include ParserMethods
     attr_reader :grammar, :start_state
   
-    def initialize(grammar)
+    def initialize(grammar, logger = nil)
+      if logger
+        @logger = logger
+      else
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::WARN
+      end
       @transitions = Hash.new {|hash, state| hash[state] = {}}
       @grammar = grammar
       @channels = []
@@ -14,6 +22,7 @@ module Dhaka
           @channels += channels.to_a
           new_state = ParserState.new(self, closure)
           hash[kernel] = new_state
+          @logger.debug("Created #{new_state}.")
           new_state.transition_items.each do |symbol, items|
             destination_kernel = ItemSet.new(items.collect{|item| item.next_item})
             destination_state = hash[destination_kernel]
@@ -31,8 +40,11 @@ module Dhaka
       start_items = ItemSet.new(start_productions.collect {|production| Item.new(production, 0)})
       start_items.each {|start_item| start_item.lookaheadset << @grammar.end_symbol}
       @start_state = @states[start_items]
+      @logger.debug("Pumping #{@channels.size} channels...")
       pump_channels
+      @logger.debug("Generating shift actions...")
       generate_shift_actions
+      @logger.debug("Generating reduce actions...")
       generate_reduce_actions
     end
 
@@ -80,10 +92,13 @@ module Dhaka
 
     def create_reduction_actions_for_item_and_state item, state
       item.lookaheadset.each do |lookahead| 
-        existing_action = state.actions[lookahead.name]
         new_action = ReduceAction.new(item.production) 
-        if existing_action
-          raise ParserConflictError.new(state, existing_action, new_action)
+        if existing_action = state.actions[lookahead.name]
+          if ReduceAction === existing_action
+            raise ParserReduceReduceConflictError.new(build_conflict_message(state, lookahead, new_action).join("\n"))
+          else
+            resolve_conflict state, lookahead, new_action
+          end
         else
           state.actions[lookahead.name] = new_action
         end
@@ -91,25 +106,64 @@ module Dhaka
     end
   
   
+    def resolve_conflict state, lookahead, new_action
+      message = build_conflict_message(state, lookahead, new_action)
+      shift_precedence = lookahead.precedence
+      reduce_precedence = new_action.production.precedence
+      if (shift_precedence && reduce_precedence)
+        if (shift_precedence > reduce_precedence)
+          message << "Resolving with precedence. Choosing shift over reduce."
+        elsif (shift_precedence < reduce_precedence)
+          message << "Resolving with precedence. Choosing reduce over shift."
+          state.actions[lookahead.name] = new_action
+        else
+          case shift_precedence.associativity
+            when :left
+              message << "Resolving with left associativity. Choosing reduce over shift."
+              state.actions[lookahead.name] = new_action
+            when :right
+              message << "Resolving with right associativity. Choosing shift over reduce."
+            when :nonassoc
+              message << "Resolving with non-associativity. Eliminating action."
+              state.actions[lookahead.name] = nil
+          end
+        end
+      else
+        message << "No precedence rule. Choosing shift over reduce."
+      end
+      @logger.warn(message.join("\n"))
+    end
+  
+    def build_conflict_message state, lookahead, new_action
+      message = ["Parser Conflict at State:"] + state.items.values.collect{|it| it.to_s}
+      message << "Existing: #{state.actions[lookahead.name]}"
+      message << "New: #{new_action}"
+      message << "Lookahead: #{lookahead}"
+      message
+    end
+  
     def pump_channels
       while true
-        break unless @channels.inject(false) do |pumped, channel| 
-          pumped || channel.pump
+        unstable_count = 0
+        @channels.each do |channel| 
+          if channel.pump
+            unstable_count += 1
+          end 
         end
+        break if unstable_count == 0
+        @logger.debug("#{unstable_count} unstable channels...")
       end
     end
   
   end
 
 
-  class ParserConflictError < StandardError
-    def initialize(state, existing_action, new_action)
-      @state = state
-      @existing_action = existing_action
-      @new_action = new_action
+  class ParserReduceReduceConflictError < StandardError
+    def initialize(message)
+      @message = message
     end
     def to_s
-      "Conflict in state #{@state}\n Existing: #{@existing_action}\n New: #{@new_action}"
+      @message
     end
   end
   

data/test/all_tests.rb

@@ -8,4 +8,6 @@ require 'compiled_parser_test'
 require 'evaluator_test'
 require 'arithmetic_tokenizer_test'
 require 'malformed_grammar_test'
-require 'brackets_test'
+require 'brackets_test'
+require 'arithmetic_precedence_grammar_test'
+require 'arithmetic_precedence_parser_test'

data/test/arithmetic_precedence_evaluator.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+require 'arithmetic_precedence_grammar'
+
+class ArithmeticPrecedenceEvaluator < Dhaka::Evaluator
+  
+  self.grammar = ArithmeticPrecedenceGrammar
+  
+  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_literal do
+      child_nodes[0].token.value
+    end
+
+    for_parenthetized_expression do
+      child_nodes[1]
+    end
+    
+    for_negated_expression do
+      -child_nodes[1]
+    end
+
+  end
+
+end

data/test/arithmetic_precedence_grammar.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__)+'/../lib/dhaka'
+
+class ArithmeticPrecedenceGrammar < Dhaka::Grammar
+  precedences do
+    left ['+', '-']
+    left ['*', '/']
+  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']
+    literal ['n']
+    parenthetized_expression ['(', 'E', ')']
+    negated_expression ['-', 'E'], :prec => '*'
+  end
+end

data/test/arithmetic_precedence_grammar_test.rb

@@ -0,0 +1,28 @@
+require "test/unit"
+require '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('/')
+  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(:left, @addop.precedence.associativity)
+    assert_equal(:left, @subop.precedence.associativity)
+    assert_equal(:left, @mulop.precedence.associativity)
+    assert_equal(:left, @divop.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_parser_test.rb

@@ -0,0 +1,30 @@
+require "test/unit"
+require "arithmetic_precedence_grammar"
+require "arithmetic_tokenizer"
+require "arithmetic_precedence_evaluator"
+
+class TestArithmeticPrecedenceParser < Test::Unit::TestCase
+
+  def test_parses_arithmetic_expressions
+    fake_logger = FakeLogger.new
+    parser = Dhaka::Parser.new(ArithmeticPrecedenceGrammar, fake_logger)
+    assert_equal(20, fake_logger.messages.size)
+    
+    syntax_tree = parser.parse(ArithmeticTokenizer.tokenize("5 * -14/(2*7 - 7) + 2")).syntax_tree
+#    File.open('precedence.dot', 'w') {|file| file << syntax_tree.to_dot}
+#    File.open('precedence_parser.dot', 'w') {|file| file << parser.to_dot}
+    assert_equal(-8, ArithmeticPrecedenceEvaluator.new(syntax_tree).result)
+  end
+end
+
+class FakeLogger
+  attr_reader :messages
+  def initialize
+    @messages = []
+  end
+  def debug message
+  end
+  def warn(message)
+    @messages << message
+  end
+end

data/test/parser_test.rb

@@ -144,12 +144,7 @@ class ParserTest < Test::Unit::TestCase
 
   def test_with_a_grammar_that_should_generate_an_RR_conflict
     grammar = RRConflictGrammar
-    assert_raise(Dhaka::ParserConflictError) { Dhaka::Parser.new(grammar) }
-  end
-
-  def test_with_a_grammar_that_should_generate_an_SR_conflict
-    grammar = SRConflictGrammar
-    assert_raise(Dhaka::ParserConflictError) { Dhaka::Parser.new(grammar) }
+    assert_raise(Dhaka::ParserReduceReduceConflictError) { Dhaka::Parser.new(grammar) }
   end
 
   def set_finder(set1, set2)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: dhaka
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
-date: 2006-12-04 00:00:00 -05:00
+  version: 0.0.4
+date: 2006-12-11 00:00:00 -05:00
 summary: An LALR1 parser generator written in Ruby
 require_paths: 
 - lib
@@ -34,6 +34,7 @@ files:
 - lib/grammar/closure_hash.rb
 - lib/grammar/grammar.rb
 - lib/grammar/grammar_symbol.rb
+- lib/grammar/precedence.rb
 - lib/grammar/production.rb
 - lib/parser/action.rb
 - lib/parser/channel.rb
@@ -52,6 +53,10 @@ files:
 - 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_test_methods.rb
 - test/arithmetic_tokenizer.rb
 - test/arithmetic_tokenizer_test.rb