lrama 0.1.0 → 0.2.0

data/lib/lrama/states.rb

@@ -1,58 +1,7 @@
+require "forwardable"
 require "lrama/report"
 
 module Lrama
-  # Algorithm Digraph of https://dl.acm.org/doi/pdf/10.1145/69622.357187 (P. 625)
-  class Digraph
-    def initialize(sets, relation, base_function)
-      # X in the paper
-      @sets = sets
-      # R in the paper
-      @relation = relation
-      # F' in the paper
-      @base_function = base_function
-      # S in the paper
-      @stack = []
-      # N in the paper
-      @h = Hash.new(0)
-      # F in the paper
-      @result = {}
-    end
-
-    def compute
-      @sets.each do |x|
-        next if @h[x] != 0
-        traverse(x)
-      end
-
-      return @result
-    end
-
-    private
-
-    def traverse(x)
-      @stack.push(x)
-      d = @stack.count
-      @h[x] = d
-      @result[x] = @base_function[x] # F x = F' x
-
-      @relation[x] && @relation[x].each do |y|
-        traverse(y) if @h[y] == 0
-        @h[x] = [@h[x], @h[y]].min
-        @result[x] |= @result[y] # F x = F x + F y
-      end
-
-      if @h[x] == d
-        while true do
-          z = @stack.pop
-          @h[z] = Float::INFINITY
-          @result[z] = @result[x] # F (Top of S) = F x
-
-          break if z == x
-        end
-      end
-    end
-  end
-
   class State
     class Reduce
       # https://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html
@@ -122,14 +71,17 @@ module Lrama
       end
     end
 
+    Conflict = Struct.new(:symbols, :reduce, :type, keyword_init: true)
+
     attr_reader :id, :accessing_symbol, :kernels, :conflicts, :resolved_conflicts,
-                :default_reduction_rule
-    attr_accessor :closure, :shifts, :reduces
+                :default_reduction_rule, :closure, :items
+    attr_accessor :shifts, :reduces
 
     def initialize(id, accessing_symbol, kernels)
       @id = id
       @accessing_symbol = accessing_symbol
       @kernels = kernels.freeze
+      @items = @kernels
       # Manage relationships between items to state
       # to resolve next state
       @items_to_state = {}
@@ -138,8 +90,9 @@ module Lrama
       @default_reduction_rule = nil
     end
 
-    def items
-      @kernels + @closure
+    def closure=(closure)
+      @closure = closure
+      @items = @kernels + @closure
     end
 
     def non_default_reduces
@@ -162,6 +115,7 @@ module Lrama
         end
       end
 
+      # It seems Bison 3.8.2 iterates transitions order by symbol number
       shifts = _shifts.sort_by do |next_sym, new_items|
         next_sym.number
       end.map do |next_sym, new_items|
@@ -256,241 +210,16 @@ module Lrama
         end
       end
     end
-  end
 
-  class StatesReporter
-    def initialize(states)
-      @states = states
+    def sr_conflicts
+      @conflicts.select do |conflict|
+        conflict.type == :shift_reduce
+      end
     end
 
-    def report(io, states: false, itemsets: false, lookaheads: false, solved: false, verbose: false)
-      @states.states.each do |state|
-        # Report State
-        io << "State #{state.id}\n\n"
-
-        # Report item
-        last_lhs = nil
-        list = itemsets ? state.items : state.kernels
-        list.sort_by {|i| [i.rule_id, i.position] }.each do |item|
-          rule = item.rule
-          position = item.position
-          if rule.rhs.empty?
-            r = "ε •"
-          else
-            r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
-          end
-          if rule.lhs == last_lhs
-            l = " " * rule.lhs.id.s_value.length + "|"
-          else
-            l = rule.lhs.id.s_value + ":"
-          end
-          la = ""
-          if lookaheads && item.end_of_rule?
-            reduce = state.find_reduce_by_item!(item)
-            look_ahead = reduce.selected_look_ahead
-            if !look_ahead.empty?
-              la = "  [#{look_ahead.map(&:display_name).join(", ")}]"
-            end
-          end
-          last_lhs = rule.lhs
-
-          io << sprintf("%5i %s %s%s\n", rule.id, l, r, la)
-        end
-        io << "\n"
-
-
-        # Report shifts
-        tmp = state.term_transitions.select do |shift, _|
-          !shift.not_selected
-        end.map do |shift, next_state|
-          [shift.next_sym, next_state.id]
-        end
-        max_len = tmp.map(&:first).map(&:display_name).map(&:length).max
-        tmp.each do |term, state_id|
-          io << "    #{term.display_name.ljust(max_len)}  shift, and go to state #{state_id}\n"
-        end
-        io << "\n" if !tmp.empty?
-
-
-        # Report error caused by %nonassoc
-        nl = false
-        tmp = state.resolved_conflicts.select do |resolved|
-          resolved.which == :error
-        end.map do |error|
-          error.symbol.display_name
-        end
-        max_len = tmp.map(&:length).max
-        tmp.each do |name|
-          nl = true
-          io << "    #{name.ljust(max_len)}  error (nonassociative)\n"
-        end
-        io << "\n" if !tmp.empty?
-
-
-        # Report reduces
-        nl = false
-        max_len = state.non_default_reduces.flat_map(&:look_ahead).compact.map(&:display_name).map(&:length).max || 0
-        max_len = [max_len, "$default".length].max if state.default_reduction_rule
-        @states.terms.each do |term|
-          reduce = state.non_default_reduces.find do |r|
-            r.look_ahead.include?(term)
-          end
-
-          next unless reduce
-
-          rule = reduce.item.rule
-          io << "    #{term.display_name.ljust(max_len)}  reduce using rule #{rule.id} (#{rule.lhs.display_name})\n"
-          nl = true
-        end
-        if r = state.default_reduction_rule
-          nl = true
-          s = "$default".ljust(max_len)
-
-          if r.initial_rule?
-            io << "    #{s}  accept\n"
-          else
-            io << "    #{s}  reduce using rule #{r.id} (#{r.lhs.display_name})\n"
-          end
-        end
-        io << "\n" if nl
-
-
-        # Report nonterminal transitions
-        tmp = []
-        max_len = 0
-        state.nterm_transitions.each do |shift, next_state|
-          nterm = shift.next_sym
-          tmp << [nterm, next_state.id]
-          max_len = [max_len, nterm.id.s_value.length].max
-        end
-        tmp.uniq!
-        tmp.sort_by! do |nterm, state_id|
-          nterm.number
-        end
-        tmp.each do |nterm, state_id|
-          io << "    #{nterm.id.s_value.ljust(max_len)}  go to state #{state_id}\n"
-        end
-        io << "\n" if !tmp.empty?
-
-
-        if solved
-          # Report conflict resolutions
-          state.resolved_conflicts.each do |resolved|
-            io << "    #{resolved.report_message}\n"
-          end
-          io << "\n" if !state.resolved_conflicts.empty?
-        end
-
-
-        if verbose
-          # Report direct_read_sets
-          io << "  [Direct Read sets]\n"
-          direct_read_sets = @states.direct_read_sets
-          @states.nterms.each do |nterm|
-            terms = direct_read_sets[[state.id, nterm.token_id]]
-            next if !terms
-            next if terms.empty?
-
-            str = terms.map {|sym| sym.id.s_value }.join(", ")
-            io << "    read #{nterm.id.s_value}  shift #{str}\n"
-          end
-          io << "\n"
-
-
-          # Reprot reads_relation
-          io << "  [Reads Relation]\n"
-          @states.nterms.each do |nterm|
-            a = @states.reads_relation[[state.id, nterm.token_id]]
-            next if !a
-
-            a.each do |state_id2, nterm_id2|
-              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
-              io << "    (State #{state_id2}, #{n.id.s_value})\n"
-            end
-          end
-          io << "\n"
-
-
-          # Reprot read_sets
-          io << "  [Read sets]\n"
-          read_sets = @states.read_sets
-          @states.nterms.each do |nterm|
-            terms = read_sets[[state.id, nterm.token_id]]
-            next if !terms
-            next if terms.empty?
-
-            terms.each do |sym|
-              io << "    #{sym.id.s_value}\n"
-            end
-          end
-          io << "\n"
-
-
-          # Reprot includes_relation
-          io << "  [Includes Relation]\n"
-          @states.nterms.each do |nterm|
-            a = @states.includes_relation[[state.id, nterm.token_id]]
-            next if !a
-
-            a.each do |state_id2, nterm_id2|
-              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
-              io << "    (State #{state.id}, #{nterm.id.s_value}) -> (State #{state_id2}, #{n.id.s_value})\n"
-            end
-          end
-          io << "\n"
-
-
-          # Report lookback_relation
-          io << "  [Lookback Relation]\n"
-          @states.rules.each do |rule|
-            a = @states.lookback_relation[[state.id, rule.id]]
-            next if !a
-
-            a.each do |state_id2, nterm_id2|
-              n = @states.nterms.find {|n| n.token_id == nterm_id2 }
-              io << "    (Rule: #{rule.to_s}) -> (State #{state_id2}, #{n.id.s_value})\n"
-            end
-          end
-          io << "\n"
-
-
-          # Reprot follow_sets
-          io << "  [Follow sets]\n"
-          follow_sets = @states.follow_sets
-          @states.nterms.each do |nterm|
-            terms = follow_sets[[state.id, nterm.token_id]]
-
-            next if !terms
-
-            terms.each do |sym|
-              io << "    #{nterm.id.s_value} -> #{sym.id.s_value}\n"
-            end
-          end
-          io << "\n"
-
-
-          # Report LA
-          io << "  [Look-Ahead Sets]\n"
-          tmp = []
-          max_len = 0
-          @states.rules.each do |rule|
-            syms = @states.la[[state.id, rule.id]]
-            next if !syms
-
-            tmp << [rule, syms]
-            max_len = ([max_len] + syms.map {|s| s.id.s_value.length }).max
-          end
-          tmp.each do |rule, syms|
-            syms.each do |sym|
-              io << "    #{sym.id.s_value.ljust(max_len)}  reduce using rule #{rule.id} (#{rule.lhs.id.s_value})\n"
-            end
-          end
-          io << "\n" if !tmp.empty?
-        end
-
-
-        # End of Report State
-        io << "\n"
+    def rr_conflicts
+      @conflicts.select do |conflict|
+        conflict.type == :reduce_reduce
       end
     end
   end
@@ -500,8 +229,12 @@ module Lrama
   # "Efficient Computation of LALR(1) Look-Ahead Sets"
   #   https://dl.acm.org/doi/pdf/10.1145/69622.357187
   class States
+    extend Forwardable
     include Lrama::Report::Duration
 
+    def_delegators "@grammar", :symbols, :terms, :nterms, :rules,
+      :accept_symbol, :eof_symbol, :find_symbol_by_s_value!
+
     # TODO: Validate position is not over rule rhs
     Item = Struct.new(:rule, :position, keyword_init: true) do
       # Optimization for States#setup_state
@@ -541,15 +274,14 @@ module Lrama
       end
     end
 
-    attr_reader :states, :item_to_state,
-                :reads_relation, :includes_relation, :lookback_relation
+    attr_reader :states, :reads_relation, :includes_relation, :lookback_relation
 
-    def initialize(grammar, trace_state: false)
+    def initialize(grammar, warning, trace_state: false)
       @grammar = grammar
+      @warning = warning
       @trace_state = trace_state
 
       @states = []
-      @item_to_state = {}
 
       # `DR(p, A) = {t ∈ T | p -(A)-> r -(t)-> }`
       #   where p is state, A is nterm, t is term.
@@ -568,8 +300,6 @@ module Lrama
       # value is array of [state.id, nterm.token_id].
       @reads_relation = {}
 
-      # `read_sets` is a hash whose key is [state.id, nterm.token_id]
-      #
       # `@read_sets` is a hash whose
       # key is [state.id, nterm.token_id],
       # value is bitmap of term.
@@ -605,9 +335,6 @@ module Lrama
     end
 
     def compute
-      # TODO: Move report_grammar to other place
-      # report_grammar(@grammar)
-
       # Look Ahead Sets
       report_duration(:compute_lr0_states) { compute_lr0_states }
       report_duration(:compute_direct_read_sets) { compute_direct_read_sets }
@@ -622,6 +349,8 @@ module Lrama
       report_duration(:compute_conflicts) { compute_conflicts }
 
       report_duration(:compute_default_reduction) { compute_default_reduction }
+
+      check_conflicts
     end
 
     def reporter
@@ -632,34 +361,6 @@ module Lrama
       @states.count
     end
 
-    def symbols
-      @grammar.symbols
-    end
-
-    def terms
-      @grammar.terms
-    end
-
-    def nterms
-      @grammar.nterms
-    end
-
-    def rules
-      @grammar.rules
-    end
-
-    def accept_symbol
-      @grammar.accept_symbol
-    end
-
-    def eof_symbol
-      @grammar.eof_symbol
-    end
-
-    def find_symbol_by_s_value!(s_value)
-      @grammar.find_symbol_by_s_value!(s_value)
-    end
-
     def direct_read_sets
       h = {}
 
@@ -702,32 +403,28 @@ module Lrama
 
     private
 
-    def report_grammar(grammar)
-      str = "Grammar\n\n"
-      last_lhs = nil
+    def sr_conflicts
+      @states.flat_map(&:sr_conflicts)
+    end
 
-      grammar.rules.each do |rule|
-        if rule.rhs.empty?
-          r = "ε"
-        else
-          r = rule.rhs.map(&:display_name).join(" ")
-        end
+    def rr_conflicts
+      @states.flat_map(&:rr_conflicts)
+    end
 
-        if rule.lhs == last_lhs
-          str << sprintf("%5d %s| %s\n", rule.id, " " * rule.lhs.display_name.length, r)
-        else
-          str << "\n"
-          str << sprintf("%5d %s: %s\n", rule.id, rule.lhs.display_name, r)
-        end
+    def initial_attrs
+      h = {}
 
-        last_lhs = rule.lhs
+      attrs.each do |attr|
+        h[attr.id] = false
       end
 
-      puts str
+      h
     end
 
-    def trace_state(msg)
-      puts msg if @trace_state
+    def trace_state
+      if @trace_state
+        yield STDERR
+      end
     end
 
     def create_state(accessing_symbol, kernels, states_creted)
@@ -804,32 +501,30 @@ module Lrama
       state.closure = closure.sort_by {|i| i.rule.id }
 
       # Trace
-      trace_state("Closure: input\n")
-      state.kernels.each do |item|
-        trace_state("  #{item.display_rest}\n")
-      end
-      trace_state("\n\n")
-      trace_state("Closure: output\n")
-      state.items.each do |item|
-        trace_state("  #{item.display_rest}\n")
+      trace_state do |out|
+        out << "Closure: input\n"
+        state.kernels.each do |item|
+          out << "  #{item.display_rest}\n"
+        end
+        out << "\n\n"
+        out << "Closure: output\n"
+        state.items.each do |item|
+          out << "  #{item.display_rest}\n"
+        end
+        out << "\n\n"
       end
-      trace_state("\n\n")
 
       # shift & reduce
       state.compute_shifts_reduces
-
-      state.kernels.each do |item|
-        @item_to_state[item] = state
-      end
     end
 
     def enqueue_state(states, state)
       # Trace
       previous = state.kernels.first.previous_sym
-      trace_state(
-        sprintf("state_list_append (state = %d, symbol = %d (%s))",
+      trace_state do |out|
+        out << sprintf("state_list_append (state = %d, symbol = %d (%s))",
           @states.count, previous.number, previous.display_name)
-      )
+      end
 
       states << state
     end
@@ -848,14 +543,13 @@ module Lrama
         # Bison 3.8.2 renders "(reached by "end-of-input")" for State 0 but
         # I think it is not correct...
         previous = state.kernels.first.previous_sym
-        trace_state("Processing state #{state.id} (reached by #{previous.display_name})\n")
+        trace_state do |out|
+          out << "Processing state #{state.id} (reached by #{previous.display_name})\n"
+        end
 
         setup_state(state)
 
-        # It seems Bison 3.8.2 iterates transitions order by symbol number
-        state.shifts.sort_by do |shift|
-          shift.next_sym.number
-        end.each do |shift|
+        state.shifts.each do |shift|
           new_state, created = create_state(shift.next_sym, shift.next_items, states_creted)
           state.set_items_to_state(shift.next_items, new_state)
           enqueue_state(states, new_state) if created
@@ -880,18 +574,13 @@ module Lrama
       @states.each do |state|
         state.nterm_transitions.each do |shift, next_state|
           nterm = shift.next_sym
-          bit = 0
-          a = []
 
-          next_state.term_transitions.each do |shift, _|
-            sym = shift.next_sym
-            # Encode terms into bitmap
-            bit |= (1 << sym.number)
-            a << sym
+          ary = next_state.term_transitions.map do |shift, _|
+            shift.next_sym.number
           end
 
           key = [state.id, nterm.token_id]
-          @direct_read_sets[key] = bit
+          @direct_read_sets[key] = Bitmap.from_array(ary)
         end
       end
     end
@@ -941,7 +630,6 @@ module Lrama
               sym = rule.rhs[i]
 
               break if sym.term?
-              beta = []
               state2 = transition(state, rule.rhs[0...i])
               # p' = state, B = nterm, p = state2, A = sym
               key = [state2.id, sym.token_id]
@@ -998,7 +686,7 @@ module Lrama
 
             # No risk of conflict when
             # * the state only has single reduce
-            # * the state only has term_transitions (GOTO)
+            # * the state only has nterm_transitions (GOTO)
             next if state.reduces.count == 1 && state.term_transitions.count == 0
 
             state.set_look_ahead(rule, bitmap_to_terms(look_ahead))
@@ -1008,24 +696,15 @@ module Lrama
     end
 
     def bitmap_to_terms(bit)
-      a = []
-      i = 0
-
-      while bit > 0 do
-        if bit & 1 == 1
-          a << @grammar.find_symbol_by_number!(i)
-        end
-
-        i += 1
-        bit >>= 1
+      ary = Bitmap.to_array(bit)
+      ary.map do |i|
+        @grammar.find_symbol_by_number!(i)
       end
-
-      return a
     end
 
     def compute_conflicts
       compute_shift_reduce_conflicts
-      compute_reduece_reduce_conflicts
+      compute_reduce_reduce_conflicts
     end
 
     def compute_shift_reduce_conflicts
@@ -1043,7 +722,7 @@ module Lrama
 
             # Can resolve only when both have prec
             unless shift_prec && reduce_prec
-              state.conflicts << [sym, reduce, :no_precedence]
+              state.conflicts << State::Conflict.new(symbols: [sym], reduce: reduce, type: :shift_reduce)
               next
             end
 
@@ -1090,7 +769,7 @@ module Lrama
       end
     end
 
-    def compute_reduece_reduce_conflicts
+    def compute_reduce_reduce_conflicts
       states.each do |state|
         a = []
 
@@ -1101,7 +780,7 @@ module Lrama
           a += reduce.look_ahead
 
           if !intersection.empty?
-            state.conflicts << [intersection.dup, reduce, :reduce_reduce]
+            state.conflicts << State::Conflict.new(symbols: intersection.dup, reduce: reduce, type: :reduce_reduce)
           end
         end
       end
@@ -1110,6 +789,8 @@ module Lrama
     def compute_default_reduction
       states.each do |state|
         next if state.reduces.empty?
+        # Do not set, if conflict exist
+        next if !state.conflicts.empty?
         # Do not set, if shift with `error` exists.
         next if state.shifts.map(&:next_sym).include?(@grammar.error_symbol)
 
@@ -1120,5 +801,32 @@ module Lrama
         end.first.first
       end
     end
+
+    def check_conflicts
+      sr_count = sr_conflicts.count
+      rr_count = rr_conflicts.count
+
+      if @grammar.expect
+
+        expected_sr_conflicts = @grammar.expect
+        expected_rr_conflicts = 0
+
+        if expected_sr_conflicts != sr_count
+          @warning.error("shift/reduce conflicts: #{sr_count} found, #{expected_sr_conflicts} expected")
+        end
+
+        if expected_rr_conflicts != rr_count
+          @warning.error("reduce/reduce conflicts: #{rr_count} found, #{expected_rr_conflicts} expected")
+        end
+      else
+        if sr_count != 0
+          @warning.warn("shift/reduce conflicts: #{sr_count} found")
+        end
+
+        if rr_count != 0
+          @warning.warn("reduce/reduce conflicts: #{rr_count} found")
+        end
+      end
+    end
   end
 end