dhaka 2.0.0 → 2.0.1

data/lib/grammar/grammar_symbol.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 module Dhaka
   # Each grammar symbol is uniquely identified by a string name. The name of a symbol can 
   # be anything and need not correspond to its character representation. For example, an ampersand in the 
@@ -7,17 +6,21 @@ module Dhaka
   class GrammarSymbol
     attr_reader :name
     attr_accessor :non_terminal, :nullable, :precedence, :associativity
+
     def initialize(name)
       @name = name
     end
+
     def terminal
       !non_terminal
     end
+
     def to_s #:nodoc:
-      name
+      name.dup
     end
+
     def <=> other
-      self.name <=> other.name
+      name <=> other.name
     end
   end
 end

data/lib/grammar/precedence.rb

@@ -2,13 +2,14 @@ module Dhaka
   class Precedence #:nodoc:
     include Comparable
     attr_reader :precedence_level, :associativity
+    
     def initialize(precedence_level, associativity)
       @precedence_level = precedence_level
-      @associativity = associativity
+      @associativity    = associativity
     end
     
     def <=> other
-      self.precedence_level <=> other.precedence_level
+      precedence_level <=> other.precedence_level
     end
     
     def to_s

data/lib/grammar/production.rb

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

data/lib/parser/action.rb

@@ -8,43 +8,48 @@ module Dhaka
     attr_reader :destination_state
     def initialize destination_state
       @destination_state = destination_state
-      @action_code = Proc.new do
+      @action_code       = Proc.new do
         state_stack << destination_state
         []
       end
     end
+    
     def compile_to_ruby_source
-      "shift_to #{@destination_state.id}"
+      "shift_to #{destination_state.id}"
     end
+    
     def to_s
-      "Shift to #{@destination_state}"
+      "Shift"
     end
   end
 
   class ReduceAction < Action #:nodoc:
     attr_reader :production
+    
     def initialize(production)
-      @production = production
+      @production  = production
       @action_code = Proc.new do
         composite_node = ParseTreeCompositeNode.new(production)
 
-        production.expansion.each { |symbol| 
-            state_stack.pop
-            composite_node.child_nodes.unshift(node_stack.pop)
-           }
+        production.expansion.each do |symbol| 
+          state_stack.pop
+          composite_node.child_nodes.unshift(node_stack.pop)
+        end
 
         node_stack << composite_node
 
         unless composite_node.head_node?
-          @symbol_queue += [@current_token.symbol_name, production.symbol.name]
+          @symbol_queue.concat [@current_token.symbol_name, production.symbol.name]
         end
       end
     end
+    
     def compile_to_ruby_source
-      "reduce_with '#{@production.name}'"
+      "reduce_with '#{production.name}'"
     end
+    
     def to_s
       "Reduce with #{production}"
     end
   end
-end
+end

data/lib/parser/channel.rb

@@ -1,52 +1,58 @@
-#!/usr/bin/env ruby
 module Dhaka
   # Represents channels for pumping of lookaheads between items
   class Channel #:nodoc:
     attr_reader :start_item, :end_item
+
     def initialize(grammar, start_item, end_item)
-      @grammar = grammar
+      @grammar    = grammar
       @start_item = start_item
-      @end_item = end_item
+      @end_item   = end_item
     end
+
     def propagate cargo
-      diff = cargo - @end_item.lookaheadset
-      @end_item.lookaheadset.merge(diff)
+      diff = cargo - end_item.lookaheadset
+      end_item.lookaheadset.merge(diff)
       !diff.empty?
     end
+
     def to_s
-      "Channel from #{@start_item} to #{@end_item}"
+      "Channel from #{start_item} to #{end_item}"
     end
+
     def eql? other
-      @start_item.eql?(other.start_item) and @end_item.eql?(other.end_item)
+      start_item.eql?(other.start_item) and end_item.eql?(other.end_item)
     end
+    
     def hash
-      @start_item.hash ^ @end_item.hash
+      start_item.hash ^ end_item.hash
     end
   end
 
   class SpontaneousChannel < Channel #:nodoc:
     def to_s
-      "Spontaneous " + super.to_s
+      "Spontaneous " + super
     end
+    
     def pump
-      follow_index = @start_item.next_item_index + 1
-      cargo = Set.new
-      while follow_symbol = @start_item.production.expansion[follow_index]
-        cargo += @grammar.first(follow_symbol)
+      follow_index = start_item.next_item_index + 1
+      cargo        = Set.new
+      while follow_symbol = start_item.production.expansion[follow_index]
+        cargo.merge @grammar.first(follow_symbol)
         return propagate(cargo) unless follow_symbol.nullable
         follow_index += 1
       end
-      cargo += @start_item.lookaheadset
+      cargo.merge start_item.lookaheadset
       propagate cargo
     end
   end
 
   class PassiveChannel < Channel #:nodoc:
     def to_s
-      "Passive " + super.to_s
+      "Passive " + super
     end
+    
     def pump
-      propagate @start_item.lookaheadset
+      propagate start_item.lookaheadset
     end
   end
 end

data/lib/parser/compiled_parser.rb

@@ -2,35 +2,41 @@ module Dhaka
   # This is the superclass of all compiled Parsers. It is only used by generated code.
   class CompiledParser
 
-    private
-    def self.inherited(compiled_parser)
-      class << compiled_parser
-        attr_accessor :states, :grammar, :start_state_id
-      end
-      compiled_parser.states = Hash.new {|hash, state_id| hash[state_id] = ParserState.new(compiled_parser, {}, state_id)}
-    end
+    class << self
+      private
+        def inherited(compiled_parser)
+          class << compiled_parser
+            attr_accessor :states, :grammar, :start_state_id
+          end
+          compiled_parser.states = Hash.new {|hash, state_id| hash[state_id] = ParserState.new(compiled_parser, {}, state_id)}
+        end
 
-    def self.at_state x, &blk
-      self.states[x].instance_eval(&blk)
-    end
+        def at_state x, &blk
+          states[x].instance_eval(&blk)
+        end
   
-    def self.start_state
-      states[start_state_id]
-    end
+        def start_state
+          states[start_state_id]
+        end
   
-    def self.start_with start_state_id
-      self.start_state_id = start_state_id
-    end
+        def start_with start_state_id
+          self.start_state_id = start_state_id
+        end
   
-    def self.reduce_with production_name
-      ReduceAction.new(grammar.production_named(production_name))
-    end
+        def reduce_with production_name
+          ReduceAction.new(grammar.production_named(production_name))
+        end
   
-    def self.shift_to state_id
-      ShiftAction.new(states[state_id])
+        def shift_to state_id
+          ShiftAction.new(states[state_id])
+        end
+        
+        def inspect
+          "<Dhaka::CompiledParser grammar : #{grammar}>"
+        end
     end
   
-    self.extend(ParserMethods)
+    extend(ParserMethods)
   
   end
 

data/lib/parser/conflict.rb

@@ -0,0 +1,54 @@
+module Dhaka
+  # Represents parser shift-reduce and reduce-reduce conflicts and encapsulates logic for resolving them.
+  class Conflict #:nodoc:
+    def initialize(state, lookahead, new_action)
+      @lookahead, @new_action, @state = lookahead, new_action, state
+    end
+
+    def build_conflict_message
+      lines = ["Parser Conflict at State:", @state.to_s(:hide_lookaheads => true)]
+      lines << "Existing: #{@state.actions[@lookahead.name]}"
+      lines << "New: #{@new_action}"
+      lines << "Lookahead: #{@lookahead}"
+      lines.join("\n")
+    end
+  end
+
+
+  class ReduceReduceConflict < Conflict #:nodoc:
+    def resolve
+      build_conflict_message
+    end
+  end
+
+  class ShiftReduceConflict < Conflict #:nodoc:
+    
+    def resolve
+      lines = [build_conflict_message]
+      shift_precedence  = @lookahead.precedence
+      reduce_precedence = @new_action.production.precedence
+      if shift_precedence && reduce_precedence
+        if shift_precedence > reduce_precedence
+          lines << "Resolving with precedence. Choosing shift over reduce."
+        elsif shift_precedence < reduce_precedence
+          lines << "Resolving with precedence. Choosing reduce over shift."
+          @state.actions[@lookahead.name] = @new_action
+        else
+          case shift_precedence.associativity
+            when :left
+              lines << "Resolving with left associativity. Choosing reduce over shift."
+              @state.actions[@lookahead.name] = @new_action
+            when :right
+              lines << "Resolving with right associativity. Choosing shift over reduce."
+            when :nonassoc
+              lines << "Resolving with non-associativity. Eliminating action."
+              @state.actions.delete(@lookahead.name)
+          end
+        end
+      else
+        lines << "No precedence rule. Choosing shift over reduce."
+      end
+      lines.join("\n")
+    end
+  end
+end

data/lib/parser/item.rb

@@ -1,42 +1,42 @@
-#!/usr/bin/env ruby
 module Dhaka
   # Represents parser state items
   class Item #:nodoc:
     attr_reader :production, :next_item_index, :lookaheadset
+
     def initialize(production, next_item_index)
-      @production = production
+      @production      = production
       @next_item_index = next_item_index
-      @lookaheadset = Set.new
+      @lookaheadset    = Set.new
     end
+    
     def next_symbol
-      if @next_item_index < @production.expansion.size
-        @production.expansion[@next_item_index]
-      else
-        nil
-      end
+      production.expansion[next_item_index]
     end
+    
     def next_item
-      Item.new(@production, @next_item_index+1)
+      Item.new(production, @next_item_index + 1)
     end
+    
     def to_s(options = {})
-      expansion_symbols = @production.expansion.collect {|symbol| symbol.name}
-      if @next_item_index < expansion_symbols.size
-        expansion_symbols.insert(@next_item_index, '->')
+      expansion_symbols = production.expansion.collect {|symbol| symbol.name}
+      if next_item_index < expansion_symbols.size
+        expansion_symbols.insert(next_item_index, '->')
       else
         expansion_symbols << '->'
       end
       expansion_repr = expansion_symbols.join(' ')
-      if options[:hide_lookaheads] 
-        "#{@production.symbol} ::= #{expansion_repr}"
-      else
-        "#{@production.symbol} ::= #{expansion_repr} [#{@lookaheadset.collect.sort}]"
-      end
+
+      item = "#{production.symbol} ::= #{expansion_repr}"
+      item << " [#{lookaheadset.collect.sort}]" unless options[:hide_lookaheads]
+      item
     end
+   
     def eql?(other)
-      @production == other.production && @next_item_index==other.next_item_index
+      production == other.production && next_item_index == other.next_item_index
     end
+
     def hash
-      @production.hash ^ @next_item_index.hash
+      production.hash ^ next_item_index.hash
     end
   end
 end

data/lib/parser/parse_result.rb

@@ -1,15 +1,28 @@
 module Dhaka
   # Returned on successful parsing of the input token stream. 
-  class ParseSuccessResult
+  class ParseSuccessResult < DelegateClass(ParseTreeCompositeNode)
     # Contains the parse result.
     attr_accessor :parse_tree 
+    
     def initialize(parse_tree) #:nodoc:
+      super
       @parse_tree = parse_tree
     end
+    
     # This is false.
     def has_error? 
       false
     end
+    
+    # Returns the dot representation of the parse tree
+    def to_dot
+      result = []
+      result << ["digraph x {", %(node [fontsize="10" shape=box size="5"])] 
+      result << parse_tree.to_dot
+      result << ['}']
+      result.join("\n")
+    end
+    
     # Deprecated. Use the +parse_tree+ accessor.
     alias syntax_tree parse_tree
   end
@@ -18,9 +31,11 @@ module Dhaka
   class ParseErrorResult
     # The token that caused the parse error.
     attr_reader :unexpected_token
+    
     def initialize(unexpected_token) #:nodoc:
       @unexpected_token = unexpected_token
     end
+    
     # This is true.
     def has_error? 
       true

data/lib/parser/parse_tree.rb

@@ -2,30 +2,32 @@ module Dhaka
   # These are composite nodes of the syntax tree returned by the successful parsing of a token stream.
   class ParseTreeCompositeNode 
     attr_reader :production, :child_nodes
+    
     def initialize(production) #:nodoc:
-      @production = production
+      @production  = production
       @child_nodes = []
     end  
     def linearize #:nodoc:
       child_nodes.collect {|child_node| child_node.linearize}.flatten + [self]
     end
+    
     def tokens
       child_nodes.collect{|child_node| child_node.tokens}.flatten
     end
+    
     def to_s #:nodoc:
       "CompositeNode: #{production.symbol} --> [#{child_nodes.join(", ")}]"
     end
-    # Returns the dot representation of the syntax tree.
+    
+    # Returns the dot representation of this node.
     def to_dot
       result = []
-      result << ["digraph x {", "node [fontsize=\"10\" shape=box size=\"5\"]"] if head_node?
-      label = self.production
-      result << "#{dot_name} [label=\"#{label}\"]"
+      label  = production
+      result << %(#{dot_name} [label="#{label}"])
       child_nodes.each do |child|
         result << "#{dot_name} -> #{child.dot_name}"
         result << "#{child.to_dot}"
       end
-      result << ['}'] if head_node?
       result.join("\n")
     end
     
@@ -42,23 +44,28 @@ module Dhaka
   # These are leaf nodes of syntax trees. They contain tokens.
   class ParseTreeLeafNode 
     attr_reader :token
+    
     def initialize(token) #:nodoc:
       @token = token
     end
+    
     def linearize #:nodoc:
       []
     end
+    
     def tokens
       [token]
     end
+    
     def to_s #:nodoc:
       "LeafNode: #{token}"
     end
+    
     # Returns the dot representation of this node.
     def to_dot
-      label = "#{token}#{' : '+token.value.to_s if token.value}"
-      "#{dot_name} [label=\"#{label}\"]"
+      %(#{dot_name} [label="#{token.to_s}"])
     end
+    
     def head_node? #:nodoc:
       false
     end
@@ -66,6 +73,5 @@ module Dhaka
     def dot_name #:nodoc:
       "Node#{object_id}"
     end
-    
   end
 end