depager 0.2.0 → 0.2.2

data/lib/depager/lr.rb

@@ -20,129 +20,123 @@ module Depager::LALR
     end
   end
 
-  Eps = Depager::ParsingMethodCommon::G::Eps
-  class Grammar < Depager::ParsingMethodCommon::G
-    attr_accessor :closure, :memo_closure1
+  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
-      @closure = {}
+      @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
-        cnt = false
+        changed = 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
+          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 cnt
-    end
-  end
-  class Rule <  Depager::ParsingMethodCommon::Rule
-    def initialize_depend
+      end while changed
     end
-    def closure1 n, la
-      key = [self.n, n, la]
-      return @g.memo_closure1[key] if @g.memo_closure1[key]
-      _G = @g
-      _I = [ LRItem[self, n, la] ]
-      memo = { _I[0].rule.n => _I[0] }
-      _I.each do |_IA|
-        _B, beta = _IA.dotsym, _IA.dotrest
-        next if !_B or !_G.gh[_B]
-
-        b = _G.first(beta)
-        if b.include? Eps
-          b.delete(Eps)
-          b |= _IA.la 
+
+    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
 
-        _G.gh[_B].each do |_Brule|
-          if li = memo[_Brule.n]
-            #warn "= #{li} ;"+
-            #     "   [#{(beta+[a]).map{|i| @g.syms[i] || '$' }}]"+
-            #     " :: #{b.map{|i| @g.syms[i] }}"
-            s0 = li.la.size
-            li.la |= b
-            if li.la.size > s0 # (b - li.la).empty?
-              _I << li
-              # warn "! #{b.map{|i| @g.syms[i]}}; #{li}"
+        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[_Brule.n] = LRItem[_Brule, 0, b]
-            _I << li
-            # warn "+ #{memo[_Brule.n]}"
+            li = memo[rule.n] = LRItem[rule, 0, b]
+            result << li
           end
         end
       end
-      @g.memo_closure1[key] = _I
-      _I
+
+      result.uniq!
+      @memo_closure1[key] = result
     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
+    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
-      j
+      result
     end
   end
+  class Rule <  Depager::ParsingMethod::Rule
+  end
 
   class LRItem
     attr_accessor :rule, :n, :la
-    def initialize rule, n, la = []
+    def initialize rule, n, la = nil
       @rule = rule
       @n = n
-      @la = la
-      @goto = {}
+      @la = la || rule.grammar.symset()
+      @_hash = nil
     end
-    def self.[] rule, n, la = []
+    def self.[] rule, n, la = nil
       LRItem.new rule, n, la
     end
 
     def hash
-      (@rule.hash % 37) * (@n.hash % 37)
+      return @_hash if @_hash
+      @_hash = (@rule.hash * 217 + @n.hash) % 76511
     end
     def eql? i
       @rule == i.rule && @n == i.n
@@ -150,46 +144,41 @@ module Depager::LALR
     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}"
+      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.closure1 @n, la
+      @rule.grammar.closure1 @rule, @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
+      @rule.grammar.closure @rule, @n, self
     end
     def dotsym
-      @rule.r[@n]
+      @rule.rhs[@n]
     end
     def dotrest
-      @rule.r[@n+1 .. -1]
+      @rule.rhs[@n+1 .. -1]
     end
   end
 
-  class I
+  class State
     attr_accessor :items, :n
     def initialize items, n = nil
       @items = items
       @goto = {}
       @n = n
-      @hash = nil
       @closure = nil
+      @_hash = nil
     end
 
     def hash
-      return @hash if @hash
-      @hash = @items.hash
+      return @_hash if @_hash
+      @_hash = @items.hash
     end
     def eql? i
       @items == i.items
@@ -197,14 +186,13 @@ module Depager::LALR
     alias == eql?
 
     def to_s
-      ("I%03i = " % n) << @items.join("\n"+" "*7)
-      #"I#{n}= #{@items.join(' | ')}"
+      ("I%03i = \n" % n) << @items.map{|i| "  #{i}"}.join("\n")
     end
     def empty?
       @items.empty?
     end
     def self.[] items = []
-      I.new items
+      State.new items
     end
     def closure
       return @closure if @closure
@@ -220,71 +208,68 @@ module Depager::LALR
     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]
+        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] = I.new(v))]
+        rg.push [k, (@goto[k] = State.new(v))]
       end
       rg
     end
     def goto x
-      return @goto[x] || I.new([])
+      return @goto[x] || State.new([])
     end
   end
 
   class Table
-    attr_accessor :g, :action_table, :goto_table
+    attr_accessor :grammar, :action_table, :goto_table, :states
     attr_accessor :defred_table, :defred_after_shift_table
-    def initialize g
-      @g = g
-      @c = nil
-      @warnings = []
+    def initialize grammar
+      @grammar = grammar
+      @states = nil
+      @warning_list = []
 
       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
+      warn '** LR(0) **' if $MP_DEBUG
       n = 0
       m = 0
-      c = [ I.new([ LRItem[@g[0], 0] ], 0) ]
-      h = {c[0] => m}
+      states = [ State.new([ LRItem[grammar[0], 0] ], 0) ]
+      memo = {states[0] => m}
 
-      while n < c.size
-        c[n].mkgoto.each do|x, a|
+      while n < states.size
+        states[n].mkgoto.each do |x, a|
           unless a.empty?
-            if ha = h[a]
-              c[n].gg[x] = c[ha]
+            if memo_a = memo[a]
+              states[n].gg[x] = states[memo_a]
             else
               m += 1
               a.n = m
-              c[m] = a
-              h[a] = m
+              states[m] = a
+              memo[a] = m
             end
           end
         end
         n += 1
       end
-      @c = c
+      @states = states
     end
 
     # -1:reduce sh; 1:shift rd(=key); 0:can't resolve
     def resolveconf(sh, rd)
-      precs = @g.precs
+      precs = grammar.precs
       psh = precs[sh]
-      mrt = @g[rd].r.reverse.find{|i| @g.terms?(i) }
-      prd = @g[rd].prec || precs[mrt]
+      mrt = grammar[rd].rhs.reverse.find{|i| grammar.terms?(i) }
+      prd = grammar[rd].prec || precs[mrt]
 
-      # warn "#{@g.syms[sh]} #{psh.inspect}"
-      # warn "#{@g[rd]} #{prd.inspect}"
+      # warn "#{grammar.syms[sh]} #{psh.inspect}"
+      # warn "#{grammar[rd]} #{prd.inspect}"
 
       if psh && prd
         if psh[1] == prd[1]
@@ -304,22 +289,28 @@ module Depager::LALR
 
     def checkconf newv, oldv, key, g = nil
       return newv unless oldv
+
+      rl   = grammar.rulelist
+      syms = grammar.syms
       if oldv == 'ACC'
-        @warnings << "'ACC' conflict #{g}."
+        @warning_list << "'ACC' conflict #{g}."
         return oldv
       end
-      # warn "\n-- N:#{newv} O:#{oldv} K:#{@g.syms[key]} "
+      # warn "\n-- N:#{newv} O:#{oldv} K:#{grammar.syms[key]} "
       if newv < 0 and oldv > 0
-        # warn "-:shift #{@g.syms[key]} go to #{oldv}"
+        # warn "-:shift #{grammar.syms[key]} go to #{oldv}"
         r = resolveconf(key, -newv)
         if r > 0
-          # warn "+:shift #{@g.syms[key]} go to #{oldv}"
+          # warn "+:shift #{grammar.syms[key]} go to #{oldv}"
           oldv
         elsif r < 0
-          # warn "+:reduce #{@g[-newv]}"
+          # warn "+:reduce #{grammar[-newv]}"
           newv
         else
-          @warnings << "shift/reduce conflict '#{@g.syms[key]}'\n#{g}."
+          @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
@@ -331,15 +322,18 @@ module Depager::LALR
           # warn "reduce"
           oldv
         else
-          @warnings << "shift/reduce conflict\n#{g}."
+          @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
-        if newv == oldv
-          warn "?? newv == oldv == #{newv}."
-          newv
-        else
-          @warnings << "reduce/reduce conflict\n#{g}."
+        unless newv == oldv
+          @warning_list <<
+            ("reduce/reduce conflict #{syms[key]}.\n  #{g}\n" <<
+             "  reduce: #{rl[-newv]}\n" <<
+             "  reduce: #{rl[-oldv]}" )
           newv
         end
       else
@@ -349,39 +343,41 @@ module Depager::LALR
     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) }
+      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) }
 
-      @c.each_with_index do |c, i|
+      @states.each_with_index do |c, i|
         c.gg.each do |k, j|
           next unless k
-          if @g.terms? k
-            key = k - @g.nssize
+          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.r.size and j.rule.l != 0 # $start
+          if j.n == j.rule.rhs.size and j.rule.lhs != 0 # $start
             j.la.each do |u|
-              key = u - @g.nssize
+              key = u - grammar.nonterms.size
               taction[i][key] = checkconf(-j.rule.n, taction[i][key], u, c)
             end
-          elsif efs = @g.f0e[j.rule.r[j.n]]
+          elsif efs = grammar.f0e[j.dotsym]
             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
+                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 == @g[0] && j.n == 1 # $start : ...
+          if j.rule == grammar[0] && j.n == 1 # $start : ...
             taction[i][0] = 'ACC'
           end
         end
@@ -418,121 +414,44 @@ module Depager::LALR
 
       @action_table=taction
       @goto_table=tgoto
-      put_table if $DEBUG
     end
 
     def check_table dp
-      @warnings.each{|i| dp.warning i }
-    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 == 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 == 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"
-      }
-
-      gh = ""
-      @g.gh.each_with_index{|i, x|
-        gh << "#{syms[x]}(#{x}) => #{i}\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" <<
-        "** GH **\n\n#{gh}\n\n" <<
-        "*** States ***\n\n#{c}\n\n" <<
-        "*** Action Table ***\n\n#{a}\n" <<
-        "*** Goto Table ***\n\n#{g}\n"
+      @warning_list.each{|i| dp.warning i }
+
+      if $MP_DEBUG
+        require 'depager/lr_put_table.rb'
+        gen_state_info
+        verbose dp if $MP_VERBOSE
+      end
     end
 
     def mkset
-      warn '** cal LA **' if $MP_DEBUG
+      warn '** LA **' if $MP_DEBUG
       trn = []
-      @c.each do |_K|
-        _K.items.each do |_B|
-          _B.closure1([@g.tla]).each do |_A|
-            _K.goto(_A.dotsym).items.each do |i|
-              if i.rule == _A.rule and i.n == _A.n+1
-                _A.la.each do |a|
-                  if a != @g.tla
-                    i.la << a unless i.la.include?(a)
-                  else
-                    trn.push [_B, i, _K, _K.goto(_A.dotsym)]
-                  end
-                end
-                break
-              end
-            end
+      @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
 
-      #puts @g.closure.values.join("\n")
-      #puts "-----"
-      #puts @g.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]}"}
-      warn '** mk LALR(1) **' if $MP_DEBUG
-      @c[0].items[0].la = [@g.nssize] # '$'
+      warn '** LALR(1) **' if $MP_DEBUG
+      @states[0].items[0].la = @grammar.symset([grammar.nonterms.size]) # '$'
       begin
-        change = false
-        trn.each do |k, v, _|
-          k.la.each do |i|
-            unless v.la.include? i
-              change = true
-              v.la << i
-            end
+        changed = false
+        trn.each do |k, v|
+          unless k.la.subset_of?(v.la)
+            v.la.merge!(k.la)
+            changed
           end
         end
-      end while change
+      end while changed
     end
   end
 end