depager 0.2.3 → 0.3.0.b20250423

data/lib/depager/lr.rb

@@ -1,579 +1,589 @@
-require 'pp'
-require 'depager/grammar.rb'
-
-module Depager::ParsingMethod
-  class Grammar
-  end
-end
-
-module Depager::LALR
-  class SingleParserGenerator < Simple::SingleGenerator
-    Tmplfile = 'single_lalr_parser.erb'
-    def initialize d_parser
-      super
-      @parsing_method = LALR
-      @basis_name = @d_parser.target_name + '.new()'
-    end
-  end
-
-  class ExtensionParserGenerator < Simple::ExtensionGenerator
-    TmplfileMaster = "#{Tmpldir}/extension_lalr_master.erb"
-    TmplfileSlave  = "#{Tmpldir}/extension_lalr_slave.erb"
-    def initialize d_parser
-      super
-      @parsing_method = LALR
-      @basis_name = 'self'
-    end
-  end
-
-  Eps = Depager::ParsingMethod::Grammar::Eps
-  TLA = Eps - 1
-  class Grammar < Depager::ParsingMethod::Grammar
-    attr_accessor :memo_closure
-    def initialize_depend
-      @first1[TLA] = [TLA]
-      @sym_mask[TLA] = (1 << @sym_mask.size)
-      @mask_sym << TLA
-      make_sym_f0e
-      @memo_closure  = {}
-      @memo_closure1 = {}
-    end
-
-    def make_sym_f0e
-      @f0e = {}
-      @empty_rules.each do |lhs, rule_no|
-        @f0e[lhs] = { rule_no => symset([Eps]) }
-      end
-      begin
-        changed = false
-        @rulelist.each do |rule|
-          next unless @f0e[rule.rhs[0]]
-
-          lhs, rhs = rule.lhs, rule.rhs
-          @f0e[lhs] ||= {}
-          @f0e[rhs[0]].each do |n, fst|
-            @f0e[lhs][n] ||= symset()
-            if fst.include? Eps
-              fst = fst.dup
-              fst.delete(Eps)
-              fst.merge!(first(rhs[1 .. -1]))
-            end
-            unless fst.subset_of? @f0e[lhs][n]
-              @f0e[lhs][n].merge! fst
-              changed = true
-            end
-          end
-        end
-      end while changed
-    end
-
-    def closure1 rule, n, la
-      key = [rule.n, n, la]
-      return @memo_closure1[key] if @memo_closure1[key]
-
-      result = [ LRItem[rule, n, symset(la)] ]
-      memo   = n == 0 ? { result[0].rule.n => result[0] } : {}
-      memo2  = {}
-      i = 0
-      while i < result.size
-        ri = result[i] ; i += 1
-        dotsym = ri.dotsym
-        next unless nonterms? dotsym
-
-        b = first(ri.dotrest)
-        if    b.delete(Eps) then b.merge! ri.la
-        elsif memo2[ ri ]   then next
-        end
-        memo2[ ri ] = true
-
-        lhs_to_rule[dotsym].each do |rule|
-          if li = memo[rule.n]
-            unless b.subset_of? li.la
-              li.la.merge! b
-              result << li
-            end
-          else
-            li = memo[rule.n] = LRItem[rule, 0, b]
-            result << li
-          end
-        end
-      end
-
-      result.uniq!
-      @memo_closure1[key] = result
-    end
-
-    def closure rule, n, base=nil
-      i = 0; appended = {}
-      result = [base ? base : LRItem[rule, n]]
-      memo = memo_closure
-      
-      while i < result.size
-        ds = result[i].dotsym
-        if nonterms?(ds) && !appended[ds] 
-          unless memo[ds]
-            memo[ds] = []
-            lhs_to_rule[ds].each do |rule|
-              memo[ds] << LRItem[rule, 0]
-            end
-          end
-          result.concat memo[ds]
-          appended[ds] = true
-        end
-        i += 1
-      end
-      result
-    end
-  end
-  class Rule <  Depager::ParsingMethod::Rule
-  end
-
-  class LRItem
-    attr_accessor :rule, :n, :la
-    def initialize rule, n, la = nil
-      @rule = rule
-      @n = n
-      @la = la || rule.grammar.symset()
-      @_hash = nil
-    end
-    def self.[] rule, n, la = nil
-      LRItem.new rule, n, la
-    end
-
-    def hash
-      return @_hash if @_hash
-      @_hash = (@rule.hash * 217 + @n.hash) % 76511
-    end
-    def eql? i
-      @rule == i.rule && @n == i.n
-    end
-    alias == eql?
-
-    def to_s
-      la  = @la.map{|i| @rule.grammar.symname i}.sort.join(' ')
-      lhs = @rule.grammar.symname @rule.lhs
-      rhs = @rule.rhs.map{|i| @rule.grammar.symname i}.insert(@n, '_').join(' ')
-
-      str =  "(#{'%03s' % @rule.n}) #{lhs} : #{rhs}"
-      str << "\n     # #{la}" if $MP_DEBUG && $MP_DEBUG.match(/l/)
-      return str
-    end
-    def closure1 la
-      @rule.grammar.closure1 @rule, @n, la
-    end
-    def closure
-      @rule.grammar.closure @rule, @n, self
-    end
-    def dotsym
-      @rule.rhs[@n]
-    end
-    def dotrest
-      @rule.rhs[@n+1 .. -1]
-    end
-  end
-
-  class State
-    attr_accessor :items, :n
-    def initialize items, n = nil
-      @items = items
-      @goto = {}
-      @n = n
-      @closure = nil
-      @_hash = nil
-    end
-
-    def hash
-      return @_hash if @_hash
-      @_hash = @items.hash
-    end
-    def eql? i
-      @items == i.items
-    end
-    alias == eql?
-
-    def to_s
-      ("I%03i = \n" % n) << @items.map{|i| "  #{i}"}.join("\n")
-    end
-    def empty?
-      @items.empty?
-    end
-    def self.[] items = []
-      State.new items
-    end
-    def closure
-      return @closure if @closure
-      r = []
-      @items.each do |i|
-        r |= i.closure
-      end
-      @closure = r
-    end
-    def gg
-      @goto
-    end
-    def mkgoto
-      r = Hash.new{|h,k| h[k]=[]}
-      closure.each do |c|
-        if c.n < c.rule.rhs.size
-          r[c.dotsym].push LRItem[c.rule, c.n+1]
-        end
-      end
-      rg = []
-      r.each do |k, v|
-        rg.push [k, (@goto[k] = State.new(v))]
-      end
-      rg
-    end
-    def goto x
-      return @goto[x] || State.new([])
-    end
-  end
-
-  class Table
-    attr_accessor :grammar, :action_table, :goto_table, :states
-    attr_accessor :defred_table, :defred_after_shift_table
-    def initialize grammar
-      @grammar = grammar
-      @states = nil
-      @warning_list = []
-
-      items
-      mkset
-      mktable
-    end
-
-    def items
-      warn '** LR(0) **' if $MP_DEBUG
-      n = 0
-      m = 0
-      states = [ State.new([ LRItem[grammar[0], 0] ], 0) ]
-      memo = {states[0] => m}
-
-      while n < states.size
-        states[n].mkgoto.each do |x, a|
-          unless a.empty?
-            if memo_a = memo[a]
-              states[n].gg[x] = states[memo_a]
-            else
-              m += 1
-              a.n = m
-              states[m] = a
-              memo[a] = m
-            end
-          end
-        end
-        n += 1
-      end
-      @states = states
-    end
-
-    # -1:reduce sh; 1:shift rd(=key); 0:can't resolve
-    def resolveconf(sh, rd)
-      precs = grammar.precs
-      psh = precs[sh]
-      mrt = grammar[rd].rhs.reverse.find{|i| grammar.terms?(i) }
-      prd = grammar[rd].prec || precs[mrt]
-
-      # warn "#{grammar.syms[sh]} #{psh.inspect}"
-      # warn "#{grammar[rd]} #{prd.inspect}"
-
-      if psh && prd
-        if psh[1] == prd[1]
-          # warn :LEFT ? 'reduce' : 'shift'
-          psh[0] == :LEFT ? -1 : 1
-        elsif psh[1] > prd[1]
-          # warn 'reduce'
-          -1
-        else
-          # warn 'shift'
-          1
-        end
-      else
-        0
-      end
-    end
-
-    def checkconf newv, oldv, key, g = nil
-      return newv unless oldv
-
-      rl   = grammar.rulelist
-      syms = grammar.syms
-      if oldv == 'ACC'
-        @warning_list << "'ACC' conflict #{g}."
-        return oldv
-      end
-      # warn "\n-- N:#{newv} O:#{oldv} K:#{grammar.syms[key]} "
-      if newv < 0 and oldv > 0
-        # warn "-:shift #{grammar.syms[key]} go to #{oldv}"
-        r = resolveconf(key, -newv)
-        if r > 0
-          # warn "+:shift #{grammar.syms[key]} go to #{oldv}"
-          oldv
-        elsif r < 0
-          # warn "+:reduce #{grammar[-newv]}"
-          newv
-        else
-          @warning_list <<
-            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n" <<
-             "  shift : #{syms[key]}\n" <<
-             "  reduce: #{rl[-newv]}")
-          oldv
-        end
-      elsif newv > 0 and oldv < 0
-        r = resolveconf(key, -oldv)
-        if r > 0
-          # warn "shift"
-          newv
-        elsif r <0
-          # warn "reduce"
-          oldv
-        else
-          @warning_list <<
-            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n" <<
-             "  shift : #{syms[key]}\n" <<
-             "  reduce: #{rl[-oldv]}")
-          newv
-        end
-      elsif newv < 0 and oldv < 0
-        unless newv == oldv
-          @warning_list <<
-            ("reduce/reduce conflict #{syms[key]}.\n  #{g}\n" <<
-             "  reduce: #{rl[-newv]}\n" <<
-             "  reduce: #{rl[-oldv]}" )
-          newv
-        end
-      else
-        warn "must not happen"
-        newv
-      end
-    end
-
-    def mktable
-      warn '** TABLE **' if $MP_DEBUG
-      taction = (0...@states.size).map{ Array.new(grammar.syms.size - grammar.nonterms.size) }
-      tgoto = (0...@states.size).map{ Array.new(grammar.nonterms.size - 1) }
-
-      @states.each_with_index do |c, i|
-        c.gg.each do |k, j|
-          next unless k
-          if grammar.terms? k
-            key = k - grammar.nonterms.size
-            taction[i][key] = checkconf(j.n, taction[i][key], k, c )
-          else
-            tgoto[i][k - 1] = j.n
-          end
-        end
-        c.items.each do |j|
-          if j.n == j.rule.rhs.size and j.rule.lhs != 0 # $start
-            j.la.each do |u|
-              key = u - grammar.nonterms.size
-              taction[i][key] = checkconf(-j.rule.n, taction[i][key], u, c)
-            end
-          elsif efs = grammar.f0e[j.dotsym]
-            efs.each do |rn, ef|
-              ef.each do |es|
-                fst = grammar.symset
-                j.la.each do |la|
-                  fst |= grammar.first [es, *j.dotrest].push(la)
-                end
-                fst.each do |u|
-                  key = u - grammar.nonterms.size
-                  taction[i][key] = checkconf(-rn, taction[i][key], u, c)
-                end
-              end
-            end
-          end
-          if j.rule == grammar[0] && j.n == 1 # $start : ...
-            taction[i][0] = 'ACC'
-          end
-        end
-      end
-
-      @defred_table = []
-      taction.each_with_index do |l, x|
-        rs = l.select{|i| i.is_a? Integer}.uniq.compact
-        rs = rs.select{|i| i < 0 }
-        if rs.size == 1
-          @defred_table[x] = rs[0]
-        else
-          @defred_table[x] = nil
-        end
-      end
-
-      @defred_after_shift_table = []
-      taction.each_with_index do |l, x|
-        rs = l.select{|i| i.is_a? Integer}.uniq.compact
-        if rs.size == 1 and rs[0] < 0
-          @defred_after_shift_table[x] = rs[0]
-        else
-          @defred_after_shift_table[x] = nil
-        end
-      end
-
-      taction.each_with_index do |l, x|
-        if @defred_table[x]
-          l.size.times do |x|
-            l[x] = nil if l[x] && l[x] < 0
-          end
-        end
-      end
-
-      @action_table=taction
-      @goto_table=tgoto
-    end
-
-    def check_table dp
-      @warning_list.each{|i| dp.warning i }
-
-      if $MP_DEBUG
-        gen_state_info
-        verbose dp if $MP_VERBOSE
-      end
-    end
-
-    def mkset
-      warn '** LA **' if $MP_DEBUG
-      trn = []
-      @states.each do |state|
-        state.items.each do |sitem|
-          sitem.closure1([TLA]).each do |citem|
-            next if citem.n == citem.rule.rhs.size
-            gi = state.goto(citem.dotsym).items
-            i  = gi.find{|j| j.rule == citem.rule && j.n == citem.n+1 }
-            trn << [sitem, i] if citem.la.include? TLA
-            i.la.merge!(citem.la).delete(TLA)
-          end
-        end
-      end
-
-      warn '** LALR(1) **' if $MP_DEBUG
-      @states[0].items[0].la = @grammar.symset([grammar.nonterms.size]) # '$'
-      begin
-        changed = false
-        trn.each do |k, v|
-          unless k.la.subset_of?(v.la)
-            v.la.merge!(k.la)
-            changed
-          end
-        end
-      end while changed
-    end
-  end
-end
-
-class Depager::LALR::Table
-  def state_info
-    @state_info
-  end
-
-  #puts grammar.closure.values.join("\n")
-  #puts "-----"
-  #puts grammar.memo_closure1.sort_by{|k,v| k}.map{|k,v| "#{k.inspect}:\n#{v.join("\n")}"}
-  #puts 'mk'; mk.each{|k, v| p "#{k}=>#{v}"}
-  #trn = trn.uniq
-  #puts 'trn',trn.map{|a| "<#{a[2].n}>#{a[0]} => <#{a[3].n}>#{a[1]}"}
-
-  def gen_state_info
-    g = grammar
-    @state_info = []
-    @action_table.each_with_index {|s,x|
-      shi, red, acc = "", "", ""
-      s.each_with_index {|t, y|
-        next unless t
-        hd = ("  %-15s" % g.symname(y + g.nonterms.size))
-        if t == 'ACC'
-          acc = "#{hd} accept\n\n"
-        elsif t < 0
-          red << "#{hd} reduce using rule #{-t} (#{g.symname g[-t].lhs})\n"            
-        else
-          shi << "#{hd} shift, and goto to state #{t}\n"
-        end
-      }
-      if t = @defred_table[x]
-        as = @defred_after_shift_table[x] ? " [after shift]" : ""
-        red << ("  %-15s" % '$default') <<
-          "reduce using rule #{-t} (#{g.symname g[-t].lhs}) #{as}\n"
-      end
-
-      @state_info << (@states[x].to_s << "\n\n#{shi}\n#{red}\n#{acc}")
-    }
-  end
-
-  def verbose dp
-    g, output = grammar, []
-
-    if $MP_DEBUG.match(/f/)
-      output << "** FIRST1 **"
-      str = g.first1.map{|k, v|
-        "#{g.symname k} => #{v.map{|i| g.symname i}.join(' ')}"
-      }.join("\n")
-      output << "#{str}\n\n"
-    end
-
-    if $MP_DEBUG.match(/e/)
-      output << "** Empty Reduction **"
-      str = g.f0e.map {|k, v| 
-        "#{g.symname k} =>\n" << v.map{|n, f|
-          "  #{rulelist[n]} ? #{f.map{|i| g.symname i}.join(' ')}"
-        }.join("\n")
-      }.join("\n")
-      output << "#{str}\n\n"
-    end
-
-    if $MP_DEBUG.match(/s/)
-      output << "** SYMBOLS **"
-      str = g.syms.map{|k,_| "#{"%03i" % k} #{ g.symname k}"}.sort.join("\n")
-      output << "#{str}\n\n"
-    end
-
-    if $MP_DEBUG.match(/g/)
-      output << "*** Grammar ***"
-      str = g.rulelist.join("\n")
-      output << "#{str}\n\n"
-    end
-
-    if $MP_DEBUG.match(/c/)
-      output << "*** States ***"
-      output << @state_info.to_s
-    end
-
-    nssize = g.nonterms.size
-    if $MP_DEBUG.match(/t/)
-      output << "*** Action Table ***"
-      ws = (nssize...g.syms.size).map{|i| j = g.symname(i).size; j < 6 ? 6 : j}
-      str = "   |"
-      (nssize...g.syms.size).each_with_index{|i, x|
-        str << ("%0#{ws[x]}s|" % g.symname(i))
-      }; str << " $default|\n"
-      
-      @action_table.each_with_index{|i,x|
-        str << ("%03i|" % x)
-        i.each_with_index{|j, y|
-          str << ("%0#{ws[y]}s|" % j)
-        }
-        str << ("%04s,%04s|\n" % [@defred_table[x], @defred_after_shift_table[x]])
-      }
-      output << "#{str}\n\n"
-
-      output <<  "*** Goto Table ***"
-      ws = (1...nssize).map{|i| j = g.symname(i).size; j < 6 ? 6 : j}
-      str = "   |"
-      (1...nssize).each_with_index{|i, x|
-        str << ("%0#{ws[x]}s|" % g.symname(i))
-      }; str << "\n"
-      
-      @goto_table.each_with_index{|i,x|
-        str << ("%03i|" % x)
-        i.each_with_index{|j, y|
-          str << ("%0#{ws[y]}s|" % j)
-        }
-        str << "\n"
-      }
-      output << "#{str}\n\n"
-    end
-
-    File.open("#{File.basename(dp.files.fname, '.dr')}.output", "w"){|f|
-      f.write output.join("\n") 
-    }
-  end
-end
+require "depager/grammar"
+
+module Depager::LALR
+  class ParserGenerator < Depager::ParserGenerator
+    def initialize(d_parser)
+      super
+      @parsing_method = Depager::LALR
+    end
+
+    def parser_code_template
+      File.read("#{TEMPLATES_DIR}/single_lalr_parser.erb")
+    end
+  end
+
+  class ExtensionGenerator < Depager::ExtensionGenerator
+    def initialize(d_parser)
+      super
+      @parsing_method = Depager::LALR
+    end
+
+    def master_code_template
+      File.read("#{TEMPLATES_DIR}/extension_lalr_master.erb")
+    end
+
+    def slave_code_template
+      File.read("#{TEMPLATES_DIR}/extension_lalr_slave.erb")
+    end
+  end
+
+  EPS = Depager::EPS
+  TLA = EPS - 1
+
+  class Grammar < Depager::Grammar
+    attr_accessor :memo_closure
+
+    def initialize_depend
+      @first1[TLA] = [TLA]
+      @sym_mask[TLA] = (1 << @sym_mask.size)
+      @mask_sym << TLA
+      make_sym_f0e
+      @memo_closure  = {}
+      @memo_closure1 = {}
+    end
+
+    def make_sym_f0e
+      @f0e = {}
+      @empty_rules.each do |lhs, rule_no|
+        @f0e[lhs] = { rule_no => symset([EPS]) }
+      end
+      begin
+        changed = false
+        @rulelist.each do |rule|
+          next unless @f0e[rule.rhs[0]]
+
+          lhs = rule.lhs
+          rhs = rule.rhs
+          @f0e[lhs] ||= {}
+          @f0e[rhs[0]].each do |n, fst|
+            @f0e[lhs][n] ||= symset
+            if fst.include? EPS
+              fst = fst.dup
+              fst.delete(EPS)
+              fst.merge!(first(rhs[1..]))
+            end
+            unless fst.subset_of? @f0e[lhs][n]
+              @f0e[lhs][n].merge! fst
+              changed = true
+            end
+          end
+        end
+      end while changed
+    end
+
+    def closure1(rule, n, la)
+      key = [rule.n, n, la]
+      return @memo_closure1[key] if @memo_closure1[key]
+
+      result = [LRItem[rule, n, symset(la)]]
+      memo   = n == 0 ? { result[0].rule.n => result[0] } : {}
+      memo2  = {}
+      i = 0
+      while i < result.size
+        ri = result[i]
+        i += 1
+        dotsym = ri.dotsym
+        next unless nonterm? dotsym
+
+        b = first(ri.dotrest)
+        if    b.delete(EPS) then b.merge! ri.la
+        elsif memo2[ri] then next
+        end
+        memo2[ri] = true
+
+        lhs_to_rule[dotsym].each do |rule|
+          if (li = memo[rule.n])
+            unless b.subset_of? li.la
+              li.la.merge! b
+              result << li
+            end
+          else
+            li = memo[rule.n] = LRItem[rule, 0, b]
+            result << li
+          end
+        end
+      end
+
+      result.uniq!
+      @memo_closure1[key] = result
+    end
+
+    def closure(rule, n, base = nil)
+      i = 0
+      appended = {}
+      result = [base || LRItem[rule, n]]
+      memo = memo_closure
+
+      while i < result.size
+        ds = result[i].dotsym
+        if nonterm?(ds) && !appended[ds]
+          unless memo[ds]
+            memo[ds] = []
+            lhs_to_rule[ds].each do |rule|
+              memo[ds] << LRItem[rule, 0]
+            end
+          end
+          result.concat memo[ds]
+          appended[ds] = true
+        end
+        i += 1
+      end
+      result
+    end
+  end
+
+  class Rule < Depager::Rule
+  end
+
+  class LRItem
+    attr_accessor :rule, :n, :la
+
+    def initialize(rule, n, la = nil)
+      @rule = rule
+      @n = n
+      @la = la || rule.grammar.symset
+      @_hash = nil
+    end
+
+    def self.[](rule, n, la = nil)
+      LRItem.new rule, n, la
+    end
+
+    def hash
+      return @_hash if @_hash
+
+      @_hash = [@rule, @n].hash
+    end
+
+    def eql?(other)
+      @rule == other.rule && @n == other.n
+    end
+    alias == eql?
+
+    def to_s
+      la  = @la.map { |i| @rule.grammar.symname i }.sort.join(" ")
+      lhs = @rule.grammar.symname @rule.lhs
+      rhs = @rule.rhs.map { |i| @rule.grammar.symname i }.insert(@n, "_").join(" ")
+
+      str =  "(#{format('%03s', @rule.n)}) #{lhs} : #{rhs}"
+      str << "\n      # #{la}" if Depager.debug_mode?(:l)
+      str
+    end
+
+    def closure1(la)
+      @rule.grammar.closure1 @rule, @n, la
+    end
+
+    def closure
+      @rule.grammar.closure @rule, @n, self
+    end
+
+    def dotsym
+      @rule.rhs[@n]
+    end
+
+    def dotrest
+      @rule.rhs[@n + 1..]
+    end
+  end
+
+  class State
+    attr_accessor :items, :n
+
+    def initialize(items, n = nil)
+      @items = items
+      @goto = {}
+      @n = n
+      @closure = nil
+      @_hash = nil
+    end
+
+    def hash
+      return @_hash if @_hash
+
+      @_hash = @items.hash
+    end
+
+    def eql?(other)
+      @items == other.items
+    end
+    alias == eql?
+
+    def to_s
+      format("I%03i = \n", n) << @items.map(&:to_s).join("\n").lines.map { |i| "  #{i}" }.join
+    end
+
+    def empty?
+      @items.empty?
+    end
+
+    def self.[](items = [])
+      State.new items
+    end
+
+    def closure
+      return @closure if @closure
+
+      r = []
+      @items.each do |i|
+        r |= i.closure
+      end
+      @closure = r
+    end
+
+    def gg
+      @goto
+    end
+
+    def mkgoto
+      r = Hash.new { |h, k| h[k] = [] }
+      closure.each do |c|
+        r[c.dotsym].push LRItem[c.rule, c.n + 1] if c.n < c.rule.rhs.size
+      end
+      r.map do |k, v|
+        [k, (@goto[k] = State.new(v.sort_by { |it| [it.rule.n, it.n] }))]
+      end
+    end
+
+    def goto(x)
+      @goto[x] || State.new([])
+    end
+  end
+
+  class Table
+    attr_accessor :grammar, :action_table, :goto_table, :states, :defred_table, :defred_after_shift_table
+
+    def initialize(grammar)
+      @grammar = grammar
+      @states = nil
+      @warning_list = []
+
+      items
+      mkset
+      mktable
+    end
+
+    def items
+      warn "** LR(0) **" if Depager.debug_mode?
+      n = 0
+      m = 0
+      states = [State.new([LRItem[grammar[0], 0]], 0)]
+      memo = { states[0] => m }
+
+      while n < states.size
+        states[n].mkgoto.each do |x, a|
+          unless a.empty?
+            if (memo_a = memo[a])
+              states[n].gg[x] = states[memo_a]
+            else
+              m += 1
+              a.n = m
+              states[m] = a
+              memo[a] = m
+            end
+          end
+        end
+        n += 1
+      end
+      @states = states
+    end
+
+    # -1:reduce sh; 1:shift rd(=key); 0:can't resolve
+    def resolveconf(sh, rd)
+      precs = grammar.precs
+      psh = precs[sh]
+      mrt = grammar[rd].rhs.reverse.find { |i| grammar.term?(i) }
+      prd = grammar[rd].prec || precs[mrt]
+
+      if psh && prd
+        if psh[1] == prd[1]
+          # warn :LEFT ? 'reduce' : 'shift'
+          psh[0] == :LEFT ? -1 : 1
+        elsif psh[1] > prd[1]
+          # warn 'reduce'
+          -1
+        else
+          # warn 'shift'
+          1
+        end
+      else
+        0
+      end
+    end
+
+    def checkconf(newv, oldv, key, g = nil)
+      return newv unless oldv
+
+      rl   = grammar.rulelist
+      syms = grammar.syms
+      if oldv == "ACC"
+        @warning_list << "'ACC' conflict #{g}."
+        return oldv
+      end
+      # warn "\n-- N:#{newv} O:#{oldv} K:#{grammar.syms[key]} "
+      if (newv < 0) && (oldv > 0)
+        # warn "-:shift #{grammar.syms[key]} go to #{oldv}"
+        r = resolveconf(key, -newv)
+        if r > 0
+          # warn "+:shift #{grammar.syms[key]} go to #{oldv}"
+          oldv
+        elsif r < 0
+          # warn "+:reduce #{grammar[-newv]}"
+          newv
+        else
+          @warning_list <<
+            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n  " \
+              "shift : #{syms[key]}\n  " \
+              "reduce: #{rl[-newv]}")
+          oldv
+        end
+      elsif (newv > 0) && (oldv < 0)
+        r = resolveconf(key, -oldv)
+        if r > 0
+          # warn "shift"
+          newv
+        elsif r < 0
+          # warn "reduce"
+          oldv
+        else
+          @warning_list <<
+            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n  " \
+              "shift : #{syms[key]}\n  " \
+              "reduce: #{rl[-oldv]}")
+          newv
+        end
+      elsif (newv < 0) && (oldv < 0)
+        unless newv == oldv
+          @warning_list <<
+            ("reduce/reduce conflict #{syms[key]}.\n  #{g}\n  " \
+              "reduce: #{rl[-newv]}\n  " \
+              "reduce: #{rl[-oldv]}")
+          newv
+        end
+      else
+        warn "must not happen"
+        newv
+      end
+    end
+
+    def mktable
+      warn "** TABLE **" if Depager.debug_mode?
+      taction = (0...@states.size).map { Array.new(grammar.syms.size - grammar.nonterms.size) }
+      tgoto = (0...@states.size).map { Array.new(grammar.nonterms.size - 1) }
+
+      @states.each_with_index do |c, i|
+        c.gg.each do |k, j|
+          next unless k
+
+          if grammar.term? k
+            key = k - grammar.nonterms.size
+            taction[i][key] = checkconf(j.n, taction[i][key], k, c)
+          else
+            tgoto[i][k - 1] = j.n
+          end
+        end
+        c.items.each do |j|
+          if (j.n == j.rule.rhs.size) && (j.rule.lhs != 0) # $start
+            j.la.each do |u|
+              key = u - grammar.nonterms.size
+              taction[i][key] = checkconf(-j.rule.n, taction[i][key], u, c)
+            end
+          elsif (efs = grammar.f0e[j.dotsym])
+            efs.each do |rn, ef|
+              ef.each do |es|
+                fst = grammar.symset
+                j.la.each do |la|
+                  fst |= grammar.first [es, *j.dotrest].push(la)
+                end
+                fst.each do |u|
+                  key = u - grammar.nonterms.size
+                  taction[i][key] = checkconf(-rn, taction[i][key], u, c)
+                end
+              end
+            end
+          end
+          taction[i][0] = "ACC" if j.rule == grammar[0] && j.n == 1 # $start : ...
+        end
+      end
+
+      @defred_table = []
+      taction.each_with_index do |l, x|
+        rs = l.select { |i| i.is_a? Integer }.uniq.compact
+        rs = rs.select { |i| i < 0 }
+        @defred_table[x] = (rs[0] if rs.size == 1)
+      end
+
+      @defred_after_shift_table = []
+      taction.each_with_index do |l, x|
+        rs = l.select { |i| i.is_a? Integer }.uniq.compact
+        @defred_after_shift_table[x] = (rs[0] if (rs.size == 1) && (rs[0] < 0))
+      end
+
+      taction.each_with_index do |l, x| # rubocop:disable Style/CombinableLoops
+        next unless @defred_table[x]
+
+        l.size.times do |i|
+          l[i] = nil if l[i] && l[i] < 0
+        end
+      end
+
+      @action_table = taction
+      @goto_table = tgoto
+    end
+
+    def check_table(dp)
+      @warning_list.each { |i| dp.warning i }
+
+      return unless Depager.debug_mode?
+
+      gen_state_info
+      verbose dp if Depager.verbose_mode?
+    end
+
+    def mkset
+      warn "** LA **" if Depager.debug_mode?
+      trn = []
+      @states.each do |state|
+        state.items.each do |sitem|
+          sitem.closure1([TLA]).each do |citem|
+            next if citem.n == citem.rule.rhs.size
+
+            gi = state.goto(citem.dotsym).items
+            i  = gi.find { |j| j.rule == citem.rule && j.n == citem.n + 1 }
+            trn << [sitem, i] if citem.la.include? TLA
+            i.la.merge!(citem.la).delete(TLA)
+          end
+        end
+      end
+
+      warn "** LALR(1) **" if Depager.debug_mode?
+      @states[0].items[0].la = @grammar.symset([grammar.nonterms.size]) # '$'
+      begin
+        changed = false
+        trn.each do |k, v|
+          unless k.la.subset_of?(v.la)
+            v.la.merge!(k.la)
+            changed
+          end
+        end
+      end while changed
+    end
+  end
+end
+
+class Depager::LALR::Table
+  attr_reader :state_info
+
+  def gen_state_info
+    g = grammar
+    @state_info = []
+    @action_table.each_with_index do |s, x|
+      shi = ""
+      red = ""
+      acc = ""
+      s.each_with_index do |t, y|
+        next unless t
+
+        hd = format("  %-15s", g.symname(y + g.nonterms.size))
+        if t == "ACC"
+          acc = "#{hd} accept"
+        elsif t < 0
+          red << "#{hd} reduce using rule #{-t} (#{g.symname g[-t].lhs})\n"
+        else
+          shi << "#{hd} shift, and goto to state #{t}\n"
+        end
+      end
+      if (t = @defred_table[x])
+        as = @defred_after_shift_table[x] ? " [after shift]" : ""
+        red << format("  %-15s", "$default") <<
+          "reduce using rule #{-t} (#{g.symname g[-t].lhs}) #{as}"
+      end
+
+      @state_info << (@states[x].to_s << "\n\n#{shi}\n#{red}\n#{acc}").strip
+    end
+  end
+
+  def verbose(dp)
+    g = grammar
+    output = []
+
+    if Depager.debug_mode?(:f)
+      output << "** FIRST1 **"
+      str = g.first1.map do |k, v|
+        "#{g.symname k} => #{v.map { |i| g.symname i }.join(' ')}"
+      end.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if Depager.debug_mode?(:e)
+      output << "** Empty Reduction **"
+      str = g.f0e.map do |k, v|
+        "#{g.symname k} =>\n" << v.map  do |n, f|
+          "  #{rulelist[n]} ? #{f.map { |i| g.symname i }.join(' ')}"
+        end.join("\n")
+      end.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if Depager.debug_mode?(:s)
+      output << "** SYMBOLS **"
+      str = g.syms.map { |k, _| "#{format('%03i', k)} #{g.symname k}" }.sort.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if Depager.debug_mode?(:g)
+      output << "*** Grammar ***"
+      str = g.rulelist.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if Depager.debug_mode?(:c)
+      output << "*** States ***"
+      str = @state_info.join("\n\n").strip
+      output << "#{str}\n\n"
+    end
+
+    nssize = g.nonterms.size
+    if Depager.debug_mode?(:t)
+      output << "*** Action Table ***"
+      ws = (nssize...g.syms.size).map do |i|
+        j = g.symname(i).size
+        [j, 6].max
+      end
+      str = "   |"
+      (nssize...g.syms.size).each_with_index do |i, x|
+        str << format("%0#{ws[x]}s|", g.symname(i))
+      end; str << " $default|\n"
+
+      @action_table.each_with_index do |i, x|
+        str << format("%03i|", x)
+        i.each_with_index do |j, y|
+          str << format("%0#{ws[y]}s|", j)
+        end
+        str << (format("%04s,%04s|\n", @defred_table[x], @defred_after_shift_table[x]))
+      end
+      output << "#{str}\n\n"
+
+      output << "*** Goto Table ***"
+      ws = (1...nssize).map do |i|
+        j = g.symname(i).size
+        [j, 6].max
+      end
+      str = "   |"
+      (1...nssize).each_with_index do |i, x|
+        str << format("%0#{ws[x]}s|", g.symname(i))
+      end; str << "\n"
+
+      @goto_table.each_with_index do |i, x|
+        str << format("%03i|", x)
+        i.each_with_index do |j, y|
+          str << format("%0#{ws[y]}s|", j)
+        end
+        str << "\n"
+      end
+      output << "#{str}\n\n"
+    end
+
+    File.write("#{File.basename(dp.file.path, '.dr')}.output", output.join("\n"))
+  end
+end