depager 0.3.0.b20160729 → 0.3.0.b20250423

data/lib/depager/grammar.rb

@@ -1,39 +1,36 @@
-# -*- coding: utf-8 -*-
 module Depager
-  EPS = 0x3fffffff #epsilon
+  EPS = 0x3fffffff # epsilon
 
   class Grammar
-    attr_accessor :rulelist, :lhs_to_rule, :syms, :nonterms, :terms
-    attr_accessor :precs, :f0e, :first1
+    attr_accessor :rulelist, :lhs_to_rule, :syms, :nonterms, :terms, :precs, :f0e, :first1
 
-    def initialize rulelist, terms, nonterms, precs = nil
+    def initialize(rulelist, terms, nonterms, precs = nil)
       @precs    = precs
       @nonterms = nonterms.invert
       @terms    = terms.invert
       @syms     = nonterms.invert.merge(terms.invert)
 
       @rulelist = rulelist
-      @lhs_to_rule = []; @nonterms.size.times{|i| @lhs_to_rule[i] = []}
+      @lhs_to_rule = []
+      @nonterms.size.times { |i| @lhs_to_rule[i] = [] }
       @empty_rules = {}
       @rulelist.each_with_index do |rule, rx|
         rule.grammar = self
         rule.n = rx
         @lhs_to_rule[rule.lhs] << rule
-        if rule.rhs.empty?
-          @empty_rules[rule.lhs] = rule.n
-        end
+        @empty_rules[rule.lhs] = rule.n if rule.rhs.empty?
       end
       make_sym_mask
       make_sym_first
       initialize_depend
     end
 
-    def initialize_depend
-    end
+    def initialize_depend; end
 
     def make_sym_mask
-      @sym_mask, @mask_sym = {}, []
-      @terms.sort_by{|a, b| a}.each_with_index do |i,x|
+      @sym_mask = {}
+      @mask_sym = []
+      @terms.sort_by { |a, _b| a }.each_with_index do |i, x|
         @sym_mask[i[0]] = 1 << x
         @mask_sym[x] = i[0]
       end
@@ -42,12 +39,12 @@ module Depager
       @mask_sym << EPS
     end
 
-    def symset syms=nil
+    def symset(syms = nil)
       ss = SymbolSet.new(self)
       syms ? ss.concat_array(syms) : ss
     end
 
-    def sym_mask sym
+    def sym_mask(sym)
       @sym_mask[sym]
     end
 
@@ -55,14 +52,12 @@ module Depager
       @mask_sym.size
     end
 
-    def mask_sym
-      @mask_sym
-    end
+    attr_reader :mask_sym
 
     def make_sym_first
-      @first1 = { }
+      @first1 = {}
       @syms.each_key do |s|
-        @first1[s] = symset()
+        @first1[s] = symset
 
         @first1[s] << s   if term? s
         @first1[s] << EPS if @empty_rules[s]
@@ -75,30 +70,30 @@ module Depager
             rule.rhs.each do |s|
               unless @first1[s].subset_of?(@first1[lhs])
                 # warn "%b\n%b" % [@first1[s].set, @first1[lhs].set]
-                #warn "update{"
-                #warn "  R:#{symname(s)}:#{@first1[s].inspect}"
-                #warn "  L:#{symname(lhs)}:#{@first1[lhs].inspect}"
+                # warn "update{"
+                # warn "  R:#{symname(s)}:#{@first1[s].inspect}"
+                # warn "  L:#{symname(lhs)}:#{@first1[lhs].inspect}"
                 @first1[lhs].merge! @first1[s]
-                #warn "  L:#{symname(lhs)}:#{@first1[lhs].inspect}"
-                #warn "}"
+                # warn "  L:#{symname(lhs)}:#{@first1[lhs].inspect}"
+                # warn "}"
                 changed = true
               end
               break unless @first1[s].include? EPS
             end
-            unless @first1[lhs].include? EPS
-              if rule.rhs.all?{|i| @first1[i].include? EPS }
-                @first1[lhs] << EPS
-                changed = true
-              end
+            if !@first1[lhs].include?(EPS) && rule.rhs.all? { |i| @first1[i].include? EPS }
+              @first1[lhs] << EPS
+              changed = true
             end
           end
         end
       end while changed
     end
 
-    def first p
+    def first(p)
       return symset([EPS]) if p.empty?
-      r, x = symset(), 0
+
+      r = symset
+      x = 0
       p.each do |i|
         unless i == EPS
           r.merge! @first1[i]
@@ -109,14 +104,14 @@ module Depager
       r.delete EPS
       r << EPS if x == p.size
 
-      return r
+      r
     end
 
-    def term? i
+    def term?(i)
       i && i >= @nonterms.size
     end
 
-    def nonterm? i
+    def nonterm?(i)
       i && i < @nonterms.size
     end
 
@@ -124,77 +119,79 @@ module Depager
       @rulelist[n]
     end
 
-    def symname sym
+    def symname(sym)
       name = @syms[sym]
       return nil        unless sym.is_a? Integer
-      return '$start'   if sym == 0
-      return '$empty'   if sym == EPS
-      return '$end'     if name == nil
-      return '$error'   if name == false
-      return "#{name}"  if name.is_a? Symbol
-      return "'#{name}'"
+      return "$start"   if sym == 0
+      return "$empty"   if sym == EPS
+      return "$end"     if name.nil?
+      return "$error"   if name == false
+      return name.to_s  if name.is_a? Symbol
+
+      "'#{name}'"
     end
 
     class SymbolSet
       include Enumerable
       attr_accessor :set
 
-      def initialize g, set=0
+      def initialize(g, set = 0)
         raise g.class.name unless g.is_a? Depager::Grammar
+
         @grammar = g
         @set = set
       end
 
-      def concat_array set
+      def concat_array(set)
         set.each do |i|
           self << i
         end
         self
       end
 
-      def << sym
+      def <<(sym)
         @set |= @grammar.sym_mask(sym)
         self
       end
 
-      def & symset
-        SymbolSet.new(@grammar, @set & symset.set)
+      def &(other)
+        SymbolSet.new(@grammar, @set & other.set)
       end
 
-      def | symset
-        SymbolSet.new(@grammar, @set | symset.set)
+      def |(other)
+        SymbolSet.new(@grammar, @set | other.set)
       end
 
-      def merge! symset
+      def merge!(symset)
         @set |= symset.set
         self
       end
 
-      def - symset
-        SymbolSet.new(@grammar, @set ^ symset.set & @set)
+      def -(other)
+        SymbolSet.new(@grammar, @set ^ (other.set & @set))
       end
 
-      def subset_of? symset
+      def subset_of?(symset)
         # "a is a subset of b" is a-b={}
-        d = (@set ^ symset.set & @set)
-        d == 0 ? true : false
+        d = (@set ^ (symset.set & @set))
+        d == 0
       end
 
       def empty?
         @set == 0
       end
 
-      def include? sym
-        (@set & @grammar.sym_mask(sym) != 0) ? true : false
+      def include?(sym)
+        (@set & @grammar.sym_mask(sym) != 0)
       end
 
-      def delete sym
+      def delete(sym)
         old = @set
-        @set = @set & ~@grammar.sym_mask(sym)
-        old != @set ? sym : nil
+        @set &= ~@grammar.sym_mask(sym)
+        old == @set ? nil : sym
       end
 
-      def each &block
+      def each
         mask_sym = @grammar.mask_sym
         @grammar.mask_size.times do |x|
           @set[x] == 1 and yield mask_sym[x]
@@ -202,19 +199,19 @@ module Depager
       end
 
       def inspect
-        self.map{|i| @grammar.symname(i)}.inspect
+        map { |i| @grammar.symname(i) }.inspect
       end
     end
   end
 
   class Rule
-    def self.[] *args
-      self.new *args
+    def self.[](*args)
+      new(*args)
     end
 
     attr_accessor :lhs, :rhs, :grammar, :n, :prec, :rhs_names
 
-    def initialize lhs, rhs, prec = nil, rhs_names = nil
+    def initialize(lhs, rhs, prec = nil, rhs_names = nil)
       @lhs = lhs
       @rhs = rhs
       @prec = prec
@@ -226,30 +223,30 @@ module Depager
       initialize_depend
     end
 
-    def initialize_depend
-    end
+    def initialize_depend; end
 
     def lhs_name
       grammar.symname @lhs
     end
 
-    def rhs_name_to_sym name
-      @rhs and @rhs[@rhs_names.index(name)] rescue nil
+    def rhs_name_to_sym(name)
+      @rhs and @rhs[@rhs_names.index(name)]
+    rescue StandardError
+      nil
     end
 
     def to_s
-      lhs = grammar.symname @lhs
-      rhs = @rhs.map{|i| grammar.symname i}.join(' ')
+      rhs = @rhs.map { |i| grammar.symname i }.join(" ")
 
-      "(#{'%03s' % @n}) #{lhs_name} : #{rhs}"
+      "(#{format('%03s', @n)}) #{lhs_name} : #{rhs}"
     end
 
     def hash
-      1117 * @rhs.hash + @lhs.hash % 3037
+      [@rhs, @lhs].hash
     end
 
-    def eql? i
-      @lhs == i.lhs && @rhs == i.rhs
+    def eql?(other)
+      @lhs == other.lhs && @rhs == other.rhs
     end
     alias == eql?
   end