depager 0.3.0.b20160729 → 0.3.0.b20250423

data/lib/depager/lr.rb

@@ -1,9 +1,8 @@
-# -*- coding: utf-8 -*-
-require 'depager/grammar.rb'
+require "depager/grammar"
 
 module Depager::LALR
   class ParserGenerator < Depager::ParserGenerator
-    def initialize d_parser
+    def initialize(d_parser)
       super
       @parsing_method = Depager::LALR
     end
@@ -14,7 +13,7 @@ module Depager::LALR
   end
 
   class ExtensionGenerator < Depager::ExtensionGenerator
-    def initialize d_parser
+    def initialize(d_parser)
       super
       @parsing_method = Depager::LALR
     end
@@ -33,6 +32,7 @@ module Depager::LALR
 
   class Grammar < Depager::Grammar
     attr_accessor :memo_closure
+
     def initialize_depend
       @first1[TLA] = [TLA]
       @sym_mask[TLA] = (1 << @sym_mask.size)
@@ -52,14 +52,15 @@ module Depager::LALR
         @rulelist.each do |rule|
           next unless @f0e[rule.rhs[0]]
 
-          lhs, rhs = rule.lhs, rule.rhs
+          lhs = rule.lhs
+          rhs = rule.rhs
           @f0e[lhs] ||= {}
           @f0e[rhs[0]].each do |n, fst|
-            @f0e[lhs][n] ||= symset()
+            @f0e[lhs][n] ||= symset
             if fst.include? EPS
               fst = fst.dup
               fst.delete(EPS)
-              fst.merge!(first(rhs[1 .. -1]))
+              fst.merge!(first(rhs[1..]))
             end
             unless fst.subset_of? @f0e[lhs][n]
               @f0e[lhs][n].merge! fst
@@ -70,27 +71,28 @@ module Depager::LALR
       end while changed
     end
 
-    def closure1 rule, n, 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)] ]
+      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
+        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
+        elsif memo2[ri] then next
         end
-        memo2[ ri ] = true
+        memo2[ri] = true
 
         lhs_to_rule[dotsym].each do |rule|
-          if li = memo[rule.n]
+          if (li = memo[rule.n])
             unless b.subset_of? li.la
               li.la.merge! b
               result << li
@@ -106,9 +108,10 @@ module Depager::LALR
       @memo_closure1[key] = result
     end
 
-    def closure rule, n, base=nil
-      i = 0; appended = {}
-      result = [base ? base : LRItem[rule, n]]
+    def closure(rule, n, base = nil)
+      i = 0
+      appended = {}
+      result = [base || LRItem[rule, n]]
       memo = memo_closure
 
       while i < result.size
@@ -134,51 +137,60 @@ module Depager::LALR
 
   class LRItem
     attr_accessor :rule, :n, :la
-    def initialize rule, n, la = nil
+
+    def initialize(rule, n, la = nil)
       @rule = rule
       @n = n
-      @la = la || rule.grammar.symset()
+      @la = la || rule.grammar.symset
       @_hash = nil
     end
-    def self.[] rule, n, la = nil
+
+    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
+
+      @_hash = [@rule, @n].hash
     end
-    def eql? i
-      @rule == i.rule && @n == i.n
+
+    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(' ')
+      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(' ')
+      rhs = @rule.rhs.map { |i| @rule.grammar.symname i }.insert(@n, "_").join(" ")
 
-      str =  "(#{'%03s' % @rule.n}) #{lhs} : #{rhs}"
+      str =  "(#{format('%03s', @rule.n)}) #{lhs} : #{rhs}"
       str << "\n      # #{la}" if Depager.debug_mode?(:l)
-      return str
+      str
     end
-    def closure1 la
+
+    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]
+      @rule.rhs[@n + 1..]
     end
   end
 
   class State
     attr_accessor :items, :n
-    def initialize items, n = nil
+
+    def initialize(items, n = nil)
       @items = items
       @goto = {}
       @n = n
@@ -188,55 +200,60 @@ module Depager::LALR
 
     def hash
       return @_hash if @_hash
+
       @_hash = @items.hash
     end
-    def eql? i
-      @items == i.items
+
+    def eql?(other)
+      @items == other.items
     end
     alias == eql?
 
     def to_s
-      ("I%03i = \n" % n) << @items.map{|i| i.to_s }.join("\n").lines.map{|i| "  #{i}"}.join
+      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 = []
+
+    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]=[]}
+      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
+        r[c.dotsym].push LRItem[c.rule, c.n + 1] if c.n < c.rule.rhs.size
       end
-      rg = []
-      r.each do |k, v|
-        rg.push [k, (@goto[k] = State.new(v))]
+      r.map do |k, v|
+        [k, (@goto[k] = State.new(v.sort_by { |it| [it.rule.n, it.n] }))]
       end
-      rg
     end
-    def goto x
-      return @goto[x] || State.new([])
+
+    def goto(x)
+      @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
+    attr_accessor :grammar, :action_table, :goto_table, :states, :defred_table, :defred_after_shift_table
+
+    def initialize(grammar)
       @grammar = grammar
       @states = nil
       @warning_list = []
@@ -247,16 +264,16 @@ module Depager::LALR
     end
 
     def items
-      warn '** LR(0) **' if Depager.debug_mode?
+      warn "** LR(0) **" if Depager.debug_mode?
       n = 0
       m = 0
-      states = [ State.new([ LRItem[grammar[0], 0] ], 0) ]
-      memo = {states[0] => m}
+      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]
+            if (memo_a = memo[a])
               states[n].gg[x] = states[memo_a]
             else
               m += 1
@@ -275,7 +292,7 @@ module Depager::LALR
     def resolveconf(sh, rd)
       precs = grammar.precs
       psh = precs[sh]
-      mrt = grammar[rd].rhs.reverse.find{|i| grammar.term?(i) }
+      mrt = grammar[rd].rhs.reverse.find { |i| grammar.term?(i) }
       prd = grammar[rd].prec || precs[mrt]
 
       if psh && prd
@@ -294,17 +311,17 @@ module Depager::LALR
       end
     end
 
-    def checkconf newv, oldv, key, g = nil
+    def checkconf(newv, oldv, key, g = nil)
       return newv unless oldv
 
       rl   = grammar.rulelist
       syms = grammar.syms
-      if oldv == 'ACC'
+      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
+      if (newv < 0) && (oldv > 0)
         # warn "-:shift #{grammar.syms[key]} go to #{oldv}"
         r = resolveconf(key, -newv)
         if r > 0
@@ -315,32 +332,32 @@ module Depager::LALR
           newv
         else
           @warning_list <<
-            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n" <<
-             "  shift : #{syms[key]}\n" <<
-             "  reduce: #{rl[-newv]}")
+            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n  " \
+              "shift : #{syms[key]}\n  " \
+              "reduce: #{rl[-newv]}")
           oldv
         end
-      elsif newv > 0 and oldv < 0
+      elsif (newv > 0) && (oldv < 0)
         r = resolveconf(key, -oldv)
         if r > 0
           # warn "shift"
           newv
-        elsif r <0
+        elsif r < 0
           # warn "reduce"
           oldv
         else
           @warning_list <<
-            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n" <<
-             "  shift : #{syms[key]}\n" <<
-             "  reduce: #{rl[-oldv]}")
+            ("shift/reduce conflict #{syms[key]}.\n  #{g}\n  " \
+              "shift : #{syms[key]}\n  " \
+              "reduce: #{rl[-oldv]}")
           newv
         end
-      elsif newv < 0 and oldv < 0
+      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]}" )
+            ("reduce/reduce conflict #{syms[key]}.\n  #{g}\n  " \
+              "reduce: #{rl[-newv]}\n  " \
+              "reduce: #{rl[-oldv]}")
           newv
         end
       else
@@ -350,27 +367,28 @@ module Depager::LALR
     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) }
+      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 )
+            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
+          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]
+          elsif (efs = grammar.f0e[j.dotsym])
             efs.each do |rn, ef|
               ef.each do |es|
                 fst = grammar.symset
@@ -384,70 +402,61 @@ module Depager::LALR
               end
             end
           end
-          if j.rule == grammar[0] && j.n == 1 # $start : ...
-            taction[i][0] = 'ACC'
-          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 }
-        if rs.size == 1
-          @defred_table[x] = rs[0]
-        else
-          @defred_table[x] = nil
-        end
+        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
-        if rs.size == 1 and rs[0] < 0
-          @defred_after_shift_table[x] = rs[0]
-        else
-          @defred_after_shift_table[x] = nil
-        end
+        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|
-        if @defred_table[x]
-          l.size.times do |x|
-            l[x] = nil if l[x] && l[x] < 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
+      @action_table = taction
+      @goto_table = tgoto
     end
 
-    def check_table dp
-      @warning_list.each{|i| dp.warning i }
+    def check_table(dp)
+      @warning_list.each { |i| dp.warning i }
 
-      if Depager.debug_mode?
-        gen_state_info
-        verbose dp if Depager.verbose_mode?
-      end
+      return unless Depager.debug_mode?
+
+      gen_state_info
+      verbose dp if Depager.verbose_mode?
     end
 
     def mkset
-      warn '** LA **' if Depager.debug_mode?
+      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 }
+            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?
+      warn "** LALR(1) **" if Depager.debug_mode?
       @states[0].items[0].la = @grammar.symset([grammar.nonterms.size]) # '$'
       begin
         changed = false
@@ -463,60 +472,62 @@ module Depager::LALR
 end
 
 class Depager::LALR::Table
-  def state_info
-    @state_info
-  end
+  attr_reader :state_info
 
   def gen_state_info
     g = grammar
     @state_info = []
-    @action_table.each_with_index {|s,x|
-      shi, red, acc = "", "", ""
-      s.each_with_index {|t, y|
+    @action_table.each_with_index do |s, x|
+      shi = ""
+      red = ""
+      acc = ""
+      s.each_with_index do |t, y|
         next unless t
-        hd = ("  %-15s" % g.symname(y + g.nonterms.size))
-        if t == 'ACC'
+
+        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
-      }
-      if t = @defred_table[x]
+      end
+      if (t = @defred_table[x])
         as = @defred_after_shift_table[x] ? " [after shift]" : ""
-        red << ("  %-15s" % '$default') <<
+        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, output = grammar, []
+  def verbose(dp)
+    g = grammar
+    output = []
 
     if Depager.debug_mode?(:f)
       output << "** FIRST1 **"
-      str = g.first1.map{|k, v|
-        "#{g.symname k} => #{v.map{|i| g.symname i}.join(' ')}"
-      }.join("\n")
+      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 {|k, v|
-        "#{g.symname k} =>\n" << v.map{|n, f|
-          "  #{rulelist[n]} ? #{f.map{|i| g.symname i}.join(' ')}"
-        }.join("\n")
-      }.join("\n")
+      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,_| "#{"%03i" % k} #{ g.symname k}"}.sort.join("\n")
+      str = g.syms.map { |k, _| "#{format('%03i', k)} #{g.symname k}" }.sort.join("\n")
       output << "#{str}\n\n"
     end
 
@@ -535,40 +546,44 @@ class Depager::LALR::Table
     nssize = g.nonterms.size
     if Depager.debug_mode?(:t)
       output << "*** Action Table ***"
-      ws = (nssize...g.syms.size).map{|i| j = g.symname(i).size; j < 6 ? 6 : j}
+      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{|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]])
-      }
+      (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{|i| j = g.symname(i).size; j < 6 ? 6 : j}
+      output << "*** Goto Table ***"
+      ws = (1...nssize).map do |i|
+        j = g.symname(i).size
+        [j, 6].max
+      end
       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)
-        }
+      (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.open("#{File.basename(dp.file.path, '.dr')}.output", "w"){|f|
-      f.write output.join("\n")
-    }
+    File.write("#{File.basename(dp.file.path, '.dr')}.output", output.join("\n"))
   end
 end