depager 0.1.9

data/lib/depager/lex.dr

@@ -0,0 +1,76 @@
+%defext LexerExtension
+%extend NVAction ('depager/nvaction.rb')
+%decorate @NVAction
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%param :none
+%hook prerulelist /%LEX\{\s*\Z/ skip
+%banner '%LEX{ ... }'
+%mixin ActionParser ('depager/parse_action')
+%inner{
+  def init_parser
+    super
+    @code = []
+  end
+  def lex
+    until @file.eof?
+      until @line.empty? do
+        case @line
+        when /\A\s+/
+          #skip blank
+        when /\A%\}\s*\Z/
+          @line = $'
+          yield nil,nil
+        when /\A\/(([^\/\\]+|\\.)*)\//, /\A'([^'\\]+|\\.)*\'/
+          yield :LEX, "/\\A#{$1}/"
+        when /\A\{/
+          yield :ACTION, parse_action
+          /./=~'.'
+        when /\A(.)/
+          yield $&, $&
+        else
+          raise RuntimeError, "must not happen #{line}"
+        end
+        @line = $'
+      end
+      getline
+    end
+    yield nil, nil
+  end
+%}
+%%
+
+#begin-rule
+  start:
+      lexactlist
+      {
+        g_parser.optinner << %{
+          def lex
+            begin
+              until @line.empty? do
+                case @line
+                  #{_lexactlist}
+                else
+                  raise RuntimeError, "must not happen \#{@line}"
+                end
+                @oldline = @line
+                @line = $'
+              end
+            end while @line = getline
+            yield nil, nil
+          end
+        }; #code
+      }
+  ;
+  lexactlist:
+      lexact            { [ _lexact ] }
+    | lexactlist lexact { _lexactlist << _lexact }
+  ;
+  lexact:
+      lexlist ACTION    { "when #{_lexlist.join(', ')}\n#{_ACTION}" }
+  ;
+  lexlist:
+      LEX               { [ _LEX ] }
+    | lexlist ',' LEX   { _lexlist << _LEX }
+  ;
+#end-rule
+%%

data/lib/depager/lex.rb

@@ -0,0 +1,306 @@
+
+###
+### LexerExtension - Depager Extension (master)
+###
+require 'pp.rb'
+require 'depager/parser.rb'
+require 'depager/parse_action'
+
+
+module D4LexerExtension #:nodoc:all
+end
+
+class LexerExtension #:nodoc:all
+  include Depager::ExtensionUtils
+  
+  attr_accessor :h2p
+
+  def initialize
+    @master = self
+    @hook = []
+    @h2p = {}
+    init_parser
+  end
+
+  def __regext__ p
+    super p, :none, nil
+    
+    @hook[0] = LexerExtension_prerulelist.new(p, @nparam, self)
+    @h2p['prerulelist'] = @hook[0] 
+    p.prerulelist.push [@hook[0], :do_parse]
+    
+    regext p
+  end
+
+  ### Inner Code
+
+end
+
+### Outer Code
+
+###
+### LexerExtension_prerulelist - Part of Depager Extension (slave)
+###
+module D4LexerExtension_prerulelist #:nodoc:all
+end
+
+class LexerExtension_prerulelist < Basis #:nodoc:all
+  include Depager::ExtensionUtils
+  
+  include ActionParser
+
+  ### Reduce Table
+  reduce_table = [
+    [ -1, 1 ],
+    [ 0, 1 ],
+    [ 1, 1 ],
+    [ 1, 2 ],
+    [ 2, 2 ],
+    [ 3, 1 ],
+    [ 3, 3 ],
+  ]
+  ### Extension Params
+  nparams = {
+    'NVAction' => 2, 
+  }
+  ### Term to Int
+  t2i = {
+    nil => 0, 
+    false => 1, 
+    :ACTION => 2, 
+    :LEX => 3, 
+    "," => 4, 
+  }
+  ### Int to Term
+  i2t = [
+    nil, 
+    false, 
+    :ACTION, 
+    :LEX, 
+    ",", 
+  ]
+  ### Action Table
+  action_table = [
+    [ nil, nil, nil, 3, nil, ], 
+    [ ACC, nil, nil, nil, nil, ], 
+    [ nil, nil, nil, 3, nil, ], 
+    [ nil, nil, nil, nil, nil, ], 
+    [ nil, nil, nil, nil, nil, ], 
+    [ nil, nil, 7, nil, 8, ], 
+    [ nil, nil, nil, nil, nil, ], 
+    [ nil, nil, nil, nil, nil, ], 
+    [ nil, nil, nil, 9, nil, ], 
+    [ nil, nil, nil, nil, nil, ], 
+  ]
+  ### Default Reduce Table
+  defred_table = [
+    nil, 
+    nil, 
+    -1, 
+    -5, 
+    -2, 
+    nil, 
+    -3, 
+    -4, 
+    nil, 
+    -6, 
+  ]
+  defred_after_shift_table = [
+    nil, 
+    nil, 
+    nil, 
+    -5, 
+    -2, 
+    nil, 
+    -3, 
+    -4, 
+    nil, 
+    -6, 
+  ]
+  ### Nonterm to Int
+  nt2i = { 
+    :start => 0,  
+    :lexactlist => 1,  
+    :lexact => 2,  
+    :lexlist => 3, 
+  }
+  ### Int to Nonterm
+  i2nt = [
+    :start, 
+    :lexactlist, 
+    :lexact, 
+    :lexlist, 
+  ]
+  ### Goto Table
+  goto_table = [ 
+   [ 1, 2, 4, 5, ], 
+   [ nil, nil, nil, nil, ], 
+   [ nil, nil, 6, 5, ], 
+   [ nil, nil, nil, nil, ], 
+   [ nil, nil, nil, nil, ], 
+   [ nil, nil, nil, nil, ], 
+   [ nil, nil, nil, nil, ], 
+   [ nil, nil, nil, nil, ], 
+   [ nil, nil, nil, nil, ], 
+   [ nil, nil, nil, nil, ], 
+  ]
+
+  Tables = [ reduce_table, nparams, action_table,
+             defred_table, defred_after_shift_table, goto_table,
+             t2i, i2t, nt2i, i2nt ]
+
+  attr_accessor :p, :m
+  def initialize p, nparam, master = nil
+    super()
+    @g_parser = @p = p
+    @master   = @m = master
+    @nparam   = nparam
+    @dect     = D4LexerExtension_prerulelist::NVAction.new(self)
+    init_parser
+  end
+
+  
+  def do_parse?
+    if @line =~ /^\s*%LEX\{\s*\Z/
+       @line = $' 
+      true
+    else
+      false
+    end
+  end
+  
+
+  def banner
+    "%LEX{ ... } / #{@master.class.name}" 
+  end
+
+  ### Inner Code
+  def init_parser
+    super
+    @code = []
+  end
+  def lex
+    until @file.eof?
+      until @line.empty? do
+        case @line
+        when /\A\s+/
+          #skip blank
+        when /\A%\}\s*\Z/
+          @line = $'
+          yield nil,nil
+        when /\A\/(([^\/\\]+|\\.)*)\//, /\A'([^'\\]+|\\.)*\'/
+          yield :LEX, "/\\A#{$1}/"
+        when /\A\{/
+          yield :ACTION, parse_action
+          /./=~'.'
+        when /\A(.)/
+          yield $&, $&
+        else
+          raise RuntimeError, "must not happen #{line}"
+        end
+        @line = $'
+      end
+      getline
+    end
+    yield nil, nil
+  end
+
+end
+
+### Outer Code
+
+class D4LexerExtension_prerulelist::NVAction < Depager::Action #:nodoc:all
+  include Depager::DecoratorUtils
+          include ActionParser
+
+  on_reduce = [
+    nil,
+              :_act_0,
+  :_act_1,
+  :_act_2,
+  :_act_3,
+  :_act_4,
+  :_act_5,
+
+  ]
+  Tables = [on_reduce]
+  def initialize inside
+    super inside, 'NVAction'
+    @on_reduce, = self.class::Tables
+    init_parser
+  end
+  
+
+module_eval <<-'.,.,118028145942522.,.,', 'lex.dr', 43
+  def _act_0 val
+    _lexactlist = *val 
+
+        g_parser.optinner << %{
+          def lex
+            begin
+              until @line.empty? do
+                case @line
+                  #{_lexactlist}
+                else
+                  raise RuntimeError, "must not happen \#{@line}"
+                end
+                @oldline = @line
+                @line = $'
+              end
+            end while @line = getline
+            yield nil, nil
+          end
+        }; #code
+
+  end
+
+.,.,118028145942522.,.,
+      
+module_eval <<-'.,.,118028145936749.,.,', 'lex.dr', 63
+  def _act_1 val
+    _lexact = *val 
+     [ _lexact ] 
+
+  end
+
+.,.,118028145936749.,.,
+      
+module_eval <<-'.,.,118028145915595.,.,', 'lex.dr', 64
+  def _act_2 val
+    _lexactlist, _lexact = *val 
+     _lexactlist << _lexact 
+
+  end
+
+.,.,118028145915595.,.,
+      
+module_eval <<-'.,.,118028145922278.,.,', 'lex.dr', 67
+  def _act_3 val
+    _lexlist, _ACTION = *val 
+     "when #{_lexlist.join(', ')}\n#{_ACTION}" 
+
+  end
+
+.,.,118028145922278.,.,
+      
+module_eval <<-'.,.,118028145957906.,.,', 'lex.dr', 70
+  def _act_4 val
+    _LEX = *val 
+     [ _LEX ] 
+
+  end
+
+.,.,118028145957906.,.,
+      
+module_eval <<-'.,.,1180281459420.,.,', 'lex.dr', 71
+  def _act_5 val
+    _lexlist, _, _LEX = *val 
+     _lexlist << _LEX 
+
+  end
+
+.,.,1180281459420.,.,
+      
+end
+      
+

data/lib/depager/lr.rb

@@ -0,0 +1,604 @@
+module Depager
+  class G
+    attr_accessor :rulelist, :gh, :syms, :nonterms, :terms, :closure, :ismap, :nssize, :tla
+    attr_accessor :precs, :epr, :epr2, :f0e, :first1
+    Eps = 0x3fffffff #epsilon
+    #Eps = []
+    def initialize rulelist, ts, ns, precs = nil
+      @nssize = ns.size
+      @precs = precs
+      @syms = ns.invert.merge(ts.invert)
+      @tla = @syms.size
+
+      @rulelist = rulelist
+      @gh = []; @nssize.times{|i| @gh[i] = []}
+      @epr = {}
+      @f0e = {}
+      @rulelist.each_with_index do |rule, rx|
+        rule.g = self
+        rule.n = rx
+        @gh[rule.l].push rule
+        if rule.r.empty?
+          @epr[rule.l] = rule.n 
+          @f0e[rule.l] = { rule.n => [Eps] }
+        end
+      end
+      make_sym_first
+      make_sym_f0e
+      @closure = {}
+    end
+
+    def make_sym_f0e
+      begin
+        cnt = false
+        @rulelist.each do |rule|
+          rl = rule.l
+          if r0f0e = @f0e[rule.r[0]]
+            @f0e[rl] = {} unless @f0e[rl]
+            r0f0e.each do |ern, fst|
+              unless @f0e[rl][ern]
+                if fst.include? Eps
+                  @f0e[rl][ern] = fst - [Eps] + first(rule.r[1...rule.r.size])
+                else
+                  @f0e[rl][ern] = fst
+                end
+                cnt = true
+              else
+                if fst.include? Eps
+                  tf = fst - [Eps] + first(rule.r[1...rule.r.size])
+                else
+                  tf = fst
+                end
+                ss = tf - @f0e[rl][ern]
+                unless ss.empty?
+                  @f0e[rl][ern] |= ss
+                  cnt = true
+                end
+              end
+            end
+          end
+        end
+      end while cnt
+    end
+
+    def make_sym_first
+      @first1 = {@tla => [@tla]}
+      @syms.each_key do |s|
+        if terms? s
+          @first1[s] = [s]
+        else
+          @first1[s] = []        
+          @first1[s].push Eps if @epr[s]
+        end
+      end
+      begin
+        cnt = false
+        @syms.each_key do |s|
+          @gh[s].each do |rule|
+            rule.r.each do |es|
+              ss = @first1[es] - @first1[s]
+              unless ss.empty?
+                @first1[s] |= ss
+                cnt = true
+              end
+              break unless @first1[es].include? Eps
+            end
+            unless @first1[s].include? Eps
+              if rule.r.all?{|i| @first1[i].include? Eps }
+                @first1.push Eps
+                cnt = true
+              end
+            end
+          end if nonterms? s
+        end
+      end while cnt
+    end
+
+    def first p
+      r = []
+      x = 0
+      p.each do |i|
+        if i == Eps
+        elsif i.class == Array
+          i.each do |j|
+            r |= @first1[j]
+          end
+          break unless i.any?{|j| @epr[j] || j==Eps }
+        else
+          r |= @first1[i]
+          break unless @epr[i]
+        end
+        x += 1
+      end
+      r -= [Eps]
+      r |= [Eps] if x == p.size
+      return r
+    end
+
+    def terms? i
+      i && i >= @nssize
+    end
+
+    def nonterms? i
+      i && i < @nssize
+    end
+
+    def [](n)
+      @rulelist[n]
+    end
+  end
+
+  class Rule
+    attr_accessor :l, :r, :g, :n, :act, :epr, :prec
+    def initialize l, r, g = nil, n = nil, act = nil, prec = nil
+      @l = l
+      @r = r
+      @g = g
+      @n = n
+      @act = act
+      @epr = []
+      @prec = prec
+    end
+    def self.[] l, r, prec = nil
+      Rule.new l, r, nil, nil, nil, prec
+    end
+
+    def to_s
+      r = @r.map{|i| @g.syms[i]}.join(' ')    
+      "(#{'%03s'%@n}) #{@g.syms[@l]} : #{r}"
+    end
+
+    def hash
+      (@l.hash % 37) * (@r.hash % 37)
+    end
+    def eql? i
+      @l == i.l && @r == i.r
+    end
+    alias == eql?
+
+    def closure1 n, la
+      i = 0
+      j = [ LRItem[self, n, la] ]
+      h = {j[0] => j.size-1}
+
+      while i < j.size
+        ji = j[i]
+        b = ji.rule.r[(ji.n+1) .. ji.rule.r.size]
+        b = [] unless b
+
+        if (x = ji.rule.r[ji.n]) && (a = @g.gh[x])
+          a.each do |rule|
+            li = LRItem[rule, 0]
+            if x = h[li]
+              j[x].la.concat @g.first(b + [ji.la])
+            else
+              li.la = @g.first(b + [ji.la])
+              j << li
+              h[li] = j.size-1
+            end
+          end
+        end
+        i += 1
+      end
+      j
+    end
+
+    def closure n, base=nil
+      i = 0
+      j = [base ? base : LRItem[self, n]]
+      s = {}
+
+      while i < j.size
+        ji = j[i].rule.r[j[i].n]
+        if @g.nonterms?(ji) && !s[ji] 
+          s[ji] = true
+          if @g.closure[ji]
+            j.concat @g.closure[ji]
+          else
+            @g.closure[ji] = []
+            @g.gh[ji].each do |rule|
+              li = LRItem[rule, 0]
+              j.push li
+              @g.closure[ji].push li
+            end
+          end
+        end
+        i += 1
+      end
+      j
+    end
+  end
+
+  class LRItem
+    attr_accessor :rule, :n, :la
+    def initialize rule, n, la = []
+      @rule = rule
+      @n = n
+      @la = la
+      @goto = {}
+    end
+    def self.[] rule, n, la = []
+      LRItem.new rule, n, la
+    end
+
+    def hash
+      (@rule.hash % 37) * (@n.hash % 37)
+    end
+    def eql? i
+      @rule == i.rule && @n == i.n
+    end
+    alias == eql?
+
+    def to_s
+      la = @la.map{|i| @rule.g.syms[i] ? @rule.g.syms[i] : '$'}.join(' ')
+      r = @rule.r.map{|i| @rule.g.syms[i]}.insert(@n, '_').join(' ')
+      
+      "(#{'%03s'%@rule.n}) #{@rule.g.syms[@rule.l]} : #{r}   #   #{la}"
+    end
+    def closure1 la
+      @rule.closure1 @n, la
+    end
+    def closure
+      @rule.closure @n, self
+    end
+    def goto x
+      return  @goto[x] if @goto[x]
+      if @rule.r[@n] == x && @n < @rule.r.size
+        @goto[x] = I.new [ LRItem[@rule, @n+1] ]
+      else
+        @goto[x] = I[]
+      end
+    end
+  end
+
+  class I
+    attr_accessor :items, :n
+    def initialize items, n = nil
+      @items = items
+      @goto = {}
+      @n = n
+      @hash = nil
+      @closure = 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) << @items.join("\n"+" "*7)
+      #"I#{n}= #{@items.join(' | ')}"
+    end
+    def empty?
+      @items.empty?
+    end
+    def self.[] items = []
+      I.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.r.size
+          r[c.rule.r[c.n]].push LRItem[c.rule, c.n+1]
+        end
+      end
+      rg = []
+      r.each do |k, v|
+        rg.push [k, (@goto[k] = I.new(v))]
+      end
+      rg
+    end
+    def goto x
+      return @goto[x] || I.new([])
+    end
+  end
+
+  class LALRTable
+    attr_accessor :g, :action_table, :goto_table
+    attr_accessor :defred_table, :defred_after_shift_table
+    def initialize g
+      @g = g
+      @c = nil
+      
+      items
+      mkset
+      mktable
+      # @g.closure.each{|k,v| warn "#{k} =>"; v.each{|i| warn "  #{i}"}}
+      # @c.each{|i| warn "#{i}"; i.gg.each{|k,v| warn "  #{@g.syms[k]} => #{v}" unless v.empty?}}
+      #exit
+    end
+
+    def items
+      warn '** mk LR(0) **' if $MP_DEBUG
+      n = 0
+      m = 0
+      c = [ I.new([ LRItem[@g[0], 0] ], 0) ]
+      h = {c[0] => m}
+
+      while n < c.size
+        c[n].mkgoto.each do|x, a|
+          unless a.empty?
+            if ha = h[a]
+              c[n].gg[x] = c[ha]
+            else
+              m += 1
+              a.n = m
+              c[m] = a
+              h[a] = m
+            end
+          end
+        end
+        n += 1
+      end
+      @c = c
+    end
+
+    # -1:reduce sh; 1:shift rd(=key); 0:can't resolve
+    def resolveconf(sh, rd)
+      precs = @g.precs
+      psh = precs[sh]
+      mrt = @g[rd].r.reverse.find{|i| @g.terms?(i) }
+      prd = @g[rd].prec || precs[mrt]
+
+      # warn "#{@g.syms[sh]} #{psh.inspect}"
+      # warn "#{@g[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
+      if oldv == 'ACC'
+        warn "'ACC' conflict #{g}."
+        return oldv
+      end
+      # warn "\n-- N:#{newv} O:#{oldv} K:#{@g.syms[key]} "
+      if newv < 0 and oldv > 0
+        # warn "-:shift #{@g.syms[key]} go to #{oldv}"
+        r = resolveconf(key, -newv)
+        if r > 0
+          # warn "+:shift #{@g.syms[key]} go to #{oldv}"
+          oldv
+        elsif r < 0
+          # warn "+:reduce #{@g[-newv]}"
+          newv
+        else
+          warn "shift/reduce conflict #{@g.syms[key]} #{g}."
+          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
+          warn "shift/reduce conflict #{g}."
+          newv
+        end
+      elsif newv < 0 and oldv < 0
+        if newv == oldv
+          warn "?? newv == oldv == #{newv}."
+          newv
+        else
+          warn "reduce/reduce conflict #{g}."
+          newv
+        end
+      else
+        warn "must not happen"
+        newv
+      end
+    end
+
+    def mktable
+      warn '** mk TABLE **' if $MP_DEBUG
+      taction = (0...@c.size).map{ Array.new(@g.syms.size - @g.nssize) }
+      tgoto = (0...@c.size).map{ Array.new(@g.nssize - 1) }
+
+      @c.each_with_index do |c, i|
+        c.gg.each do |k, j|
+          next unless k
+          if @g.terms? k
+            key = k - @g.nssize
+            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.r.size and j.rule.l != 0 # $start
+            j.la.each do |u|
+              key = u - @g.nssize
+              taction[i][key] = checkconf(-j.rule.n, taction[i][key], u, c)
+            end
+          elsif efs = @g.f0e[j.rule.r[j.n]]
+            efs.each do |rn, ef|
+              ef.each do |es|
+                #fst = @g.first([es] + j.rule.r[j.n+1 ... j.rule.r.size] + [j.la])
+                _h = [es].concat(j.rule.r[j.n+1 ... j.rule.r.size]).push(j.la)
+                @g.first(_h).each do |u|
+                  key = u - @g.nssize
+                  taction[i][key] = checkconf(-rn, taction[i][key], u, c)
+                end
+              end
+            end
+          end
+          if j.rule == @g[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
+      put_table if $DEBUG
+    end
+
+    def put_table
+      syms, first1, f0e, rulelist = @g.syms, @g.first1, @g.f0e, @g.rulelist
+
+      s = syms.map{|i| "#{"%03i"%i[0]} #{i[1].inspect}"}.sort.join("\n")
+
+      f_ = first1.map {|k, v|
+        "#{syms[k]} => " << v.map{|i|
+          i == G::Eps ? ':eps' : syms[i]
+        }.join(' ')
+      }.join("\n")
+
+      e = f0e.map {|k, v| 
+        "#{syms[k].inspect} => " << v.map{|n, f|
+          "  #{rulelist[n]} ? " << f.map{|i|
+            i == G::Eps ? ':eps' : syms[i].inspect
+          }.join(' ')
+        }.join("\n")
+      }.join("\n")
+      
+      r = rulelist.join("\n")
+      c = @c.join("\n")
+
+      ws = (@g.nssize ... @g.syms.size).map{|i| syms[i].to_s.size}
+      ws = ws.map{|i| i < 6 ? 6 : i}
+      a = "   |"
+      (@g.nssize ... @g.syms.size).each_with_index{|i, x|
+        a << ("%0#{ws[x]}s|" % @g.syms[i])
+      }
+      a << " $default|\n"
+      @action_table.each_with_index{|i,x|
+        a << ("%03i|" % x)
+        i.each_with_index{|j, y|
+          a << ("%0#{ws[y]}s|" % j)
+        }
+        a << ("%04s,%04s|\n" % [@defred_table[x], @defred_after_shift_table[x]])
+      }
+
+      ws = (1 ... @g.nssize).map{|i| @g.syms[i].to_s.size}
+      ws = ws.map{|i| i < 6 ? 6 : i}
+      g = "   |"
+      (1 ... @g.nssize).each_with_index{|i, x|
+        g << ("%0#{ws[x]}s|" % @g.syms[i])
+      }
+      g << "\n"
+      @goto_table.each_with_index{|i,x|
+        g << ("%03i|" % x)
+        i.each_with_index{|j, y|
+          g << ("%0#{ws[y]}s|" % j)
+        }
+        g << "\n"
+      }
+
+      warn "** SYMS **\n\n#{s}\n\n" <<
+        "** FIRST1 **\n\n#{f_}\n\n" <<
+        "** Eps Reduce Rule **\n\n#{e}\n\n" <<
+        "*** Grammar ***\n\n#{r}\n\n" <<
+        "*** States ***\n\n#{c}\n\n" <<
+        "*** Action Table ***\n\n#{a}\n" <<
+        "*** Goto Table ***\n\n#{g}\n"
+    end
+
+    def mkset
+      warn '** cal LA **' if $MP_DEBUG
+      trn = []
+      @c.each do |ci|
+        ci.items.each do |k|
+          k.closure1([@g.tla]).each do |j|          
+            j.la.each do |ai|
+              if ai != @g.tla
+                ci.goto(j.rule.r[j.n]).items.each do |i|
+                  if i.rule == j.rule && i.n == j.n+1
+                    i.la.push ai unless i.la.include?(ai)
+                    break
+                  end
+                end
+              elsif ai == @g.tla
+                ci.goto(j.rule.r[j.n]).items.each do |i|
+                  if i.rule == j.rule && i.n == j.n+1
+                    trn.push [k, i]
+                    break
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      #puts 'mk'; mk.each{|k, v| p "#{k}=>#{v}"}
+      #puts 'trn',trn.sort{|a,b| a[0].rule.l.to_s <=> b[0].rule.l.to_s}\
+      #  .map{|a| "#{a[0]} => #{a[1]}"}
+
+      warn '** mk LALR(1) **' if $MP_DEBUG
+      @c[0].items[0].la = [@g.nssize] # '$'
+      begin
+        change = false
+        trn.each do |k, v|
+          k.la.each do |i|
+            unless v.la.include? i
+              change = true
+              v.la << i
+            end
+          end
+        end
+      end while change
+    end
+  end
+end