depager 0.2.3 → 0.3.0.b20250423

data/lib/depager/grammar.rb

@@ -1,291 +1,253 @@
-module Depager::ParsingMethod
-  class Grammar
-    attr_accessor :rulelist, :lhs_to_rule, :syms, :nonterms, :terms
-    attr_accessor :precs, :f0e, :first1
-    Eps = 0x3fffffff #epsilon #Eps = []
-    def initialize_depend ; end # template method for inheritance
-    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] = []}
-      @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
-      end
-      make_sym_mask
-      make_sym_first
-      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[i[0]] = 1 << x
-        @mask_sym[x] = i[0]
-      end
-
-      @sym_mask[Eps] = (1 << @sym_mask.size)
-      @mask_sym << Eps
-    end
-    
-    def symset syms=nil
-      ss = SymbolSet.new(self)
-      syms ? ss.concat_array(syms) : ss
-    end
-    def sym_mask sym
-      @sym_mask[sym]
-    end
-    def mask_size
-      @mask_sym.size
-    end
-    def mask_sym
-      @mask_sym
-    end
-
-    def make_sym_first
-      @first1 = { }
-      @syms.each_key do |s|
-        @first1[s] = symset()
-        
-        @first1[s] << s   if terms? s
-        @first1[s] << Eps if @empty_rules[s]
-      end
-
-      begin
-        changed = false
-        @nonterms.size.times do |lhs|
-          @lhs_to_rule[lhs].each do |rule|
-            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}"
-                @first1[lhs].merge! @first1[s]
-                #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
-            end
-          end
-        end
-      end while changed
-
-=begin
-      old_make_sym_first
-      warn "check.."
-      @first1.each do |k,v|
-        old = @old_first1[k].sort
-        new = v.to_a.sort
-        unless new == old
-          warn "#{symname(k)}:#{old.join(',')}:#{new.join(',')}"
-        end
-      end
-      warn "ok?"
-=end
-    end
-
-    def first p
-      return symset([Eps]) if p.empty?
-      r, x = symset(), 0
-      p.each do |i|
-        unless i == Eps
-          r.merge! @first1[i]
-          break unless @first1[i].include? Eps
-        end
-        x += 1
-      end
-      r.delete Eps
-      r << Eps if x == p.size
-
-      # check
-      #old = old_first(p).sort
-      #new = r.to_a.sort
-      #warn "???:#{old.join(',')}:#{new.join(',')}" unless new == old
-
-      return r
-    end
-
-    def old_make_sym_first
-      first1 = { }
-      @syms.each_key do |s|
-        if terms? s
-          first1[s] = [s]
-        else
-          first1[s] = []        
-          first1[s] << Eps if @empty_rules[s]
-        end
-      end
-      begin
-        changed = false
-        @nonterms.size.times do |lhs|
-          @lhs_to_rule[lhs].each do |rule|
-            rule.rhs.each do |s|
-              ss = first1[s] - first1[lhs]
-              unless ss.empty?
-                first1[lhs] |= ss
-                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
-            end
-          end
-        end
-      end while changed
-      @old_first1 = first1
-    end
-
-    def old_first p
-      return [Eps] if p.empty?
-      first1 = @old_first1
-      r = []
-      x = 0
-      p.each do |i|
-        unless i == Eps
-          r.concat first1[i]
-          break unless first1[i].include? Eps
-        end
-        x += 1
-      end
-      r.uniq! ; r.delete Eps
-      r << Eps if x == p.size
-      return r
-    end
-
-    def terms? i
-      i && i >= @nonterms.size
-    end
-
-    def nonterms? i
-      i && i < @nonterms.size
-    end
-
-    def [](n)
-      @rulelist[n]
-    end
-
-    def symname sym
-      name = @syms[sym]
-      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}'"      
-    end
-
-    class SymbolSet
-      include Enumerable
-      attr_accessor :set
-      def initialize g, set=0
-        raise g.class.name unless g.is_a? Depager::LALR::Grammar
-        @grammar = g
-        @set = set
-      end
-      def concat_array set
-        set.each do |i|
-          self << i
-        end
-        self
-      end
-      def << sym
-        @set |= @grammar.sym_mask(sym)
-        self
-      end
-      def & symset
-        SymbolSet.new(@grammar, @set & symset.set)
-      end
-      def | symset
-        SymbolSet.new(@grammar, @set | symset.set)
-      end
-      def merge! symset
-        @set |= symset.set
-        self
-      end
-      def - symset
-        SymbolSet.new(@grammar, @set ^ symset.set & @set)
-      end
-      def subset_of? symset
-        # "a is a subset of b" is a-b={}
-        d = (@set ^ symset.set & @set)
-        d == 0 ? true : false
-      end
-      def empty?
-        @set == 0
-      end
-      def include? sym
-        (@set & @grammar.sym_mask(sym) != 0) ? true : false
-      end
-      def delete sym
-        old = @set
-        @set = @set & ~@grammar.sym_mask(sym)
-        old != @set ? sym : nil
-      end
-      def each &block
-        mask_sym = @grammar.mask_sym
-        @grammar.mask_size.times do |x|
-          @set[x] == 1 and yield mask_sym[x]
-        end
-      end
-      def inspect
-        self.map{|i| @grammar.symname(i)}.inspect
-      end
-    end
-  end
-
-  class Rule
-    def self.[] l, r, prec = nil
-      self.new l, r, prec
-    end
-
-    attr_accessor :lhs, :rhs, :grammar, :n, :prec
-    def initialize lhs, rhs, prec = nil
-      @lhs = lhs
-      @rhs = rhs
-      @prec = prec
-
-      @grammar = nil
-      @n = 0
-
-      initialize_depend
-    end
-    def initialize_depend
-    end
-
-    def to_s
-      lhs = grammar.symname @lhs
-      rhs = @rhs.map{|i| grammar.symname i}.join(' ')
-
-      "(#{'%03s' % @n}) #{lhs} : #{rhs}"
-    end
-
-    def hash
-      1117 * @rhs.hash + @lhs.hash % 3037
-    end
-    def eql? i
-      @lhs == i.lhs && @rhs == i.rhs
-    end
-    alias == eql?
-  end
-end
+module Depager
+  EPS = 0x3fffffff # epsilon
+
+  class Grammar
+    attr_accessor :rulelist, :lhs_to_rule, :syms, :nonterms, :terms, :precs, :f0e, :first1
+
+    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] = [] }
+      @empty_rules = {}
+      @rulelist.each_with_index do |rule, rx|
+        rule.grammar = self
+        rule.n = rx
+        @lhs_to_rule[rule.lhs] << rule
+        @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 make_sym_mask
+      @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
+
+      @sym_mask[EPS] = (1 << @sym_mask.size)
+      @mask_sym << EPS
+    end
+
+    def symset(syms = nil)
+      ss = SymbolSet.new(self)
+      syms ? ss.concat_array(syms) : ss
+    end
+
+    def sym_mask(sym)
+      @sym_mask[sym]
+    end
+
+    def mask_size
+      @mask_sym.size
+    end
+
+    attr_reader :mask_sym
+
+    def make_sym_first
+      @first1 = {}
+      @syms.each_key do |s|
+        @first1[s] = symset
+
+        @first1[s] << s   if term? s
+        @first1[s] << EPS if @empty_rules[s]
+      end
+
+      begin
+        changed = false
+        @nonterms.size.times do |lhs|
+          @lhs_to_rule[lhs].each do |rule|
+            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}"
+                @first1[lhs].merge! @first1[s]
+                # warn "  L:#{symname(lhs)}:#{@first1[lhs].inspect}"
+                # warn "}"
+                changed = true
+              end
+              break unless @first1[s].include? EPS
+            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)
+      return symset([EPS]) if p.empty?
+
+      r = symset
+      x = 0
+      p.each do |i|
+        unless i == EPS
+          r.merge! @first1[i]
+          break unless @first1[i].include? EPS
+        end
+        x += 1
+      end
+      r.delete EPS
+      r << EPS if x == p.size
+
+      r
+    end
+
+    def term?(i)
+      i && i >= @nonterms.size
+    end
+
+    def nonterm?(i)
+      i && i < @nonterms.size
+    end
+
+    def [](n)
+      @rulelist[n]
+    end
+
+    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.to_s  if name.is_a? Symbol
+
+      "'#{name}'"
+    end
+
+    class SymbolSet
+      include Enumerable
+      attr_accessor :set
+
+      def initialize(g, set = 0)
+        raise g.class.name unless g.is_a? Depager::Grammar
+
+        @grammar = g
+        @set = set
+      end
+
+      def concat_array(set)
+        set.each do |i|
+          self << i
+        end
+        self
+      end
+
+      def <<(sym)
+        @set |= @grammar.sym_mask(sym)
+        self
+      end
+
+      def &(other)
+        SymbolSet.new(@grammar, @set & other.set)
+      end
+
+      def |(other)
+        SymbolSet.new(@grammar, @set | other.set)
+      end
+
+      def merge!(symset)
+        @set |= symset.set
+        self
+      end
+
+      def -(other)
+        SymbolSet.new(@grammar, @set ^ (other.set & @set))
+      end
+
+      def subset_of?(symset)
+        # "a is a subset of b" is a-b={}
+        d = (@set ^ (symset.set & @set))
+        d == 0
+      end
+
+      def empty?
+        @set == 0
+      end
+
+      def include?(sym)
+        (@set & @grammar.sym_mask(sym) != 0)
+      end
+
+      def delete(sym)
+        old = @set
+        @set &= ~@grammar.sym_mask(sym)
+        old == @set ? nil : sym
+      end
+
+      def each
+        mask_sym = @grammar.mask_sym
+        @grammar.mask_size.times do |x|
+          @set[x] == 1 and yield mask_sym[x]
+        end
+      end
+
+      def inspect
+        map { |i| @grammar.symname(i) }.inspect
+      end
+    end
+  end
+
+  class Rule
+    def self.[](*args)
+      new(*args)
+    end
+
+    attr_accessor :lhs, :rhs, :grammar, :n, :prec, :rhs_names
+
+    def initialize(lhs, rhs, prec = nil, rhs_names = nil)
+      @lhs = lhs
+      @rhs = rhs
+      @prec = prec
+      @rhs_names = rhs_names
+
+      @grammar = nil
+      @n = 0
+
+      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 StandardError
+      nil
+    end
+
+    def to_s
+      rhs = @rhs.map { |i| grammar.symname i }.join(" ")
+
+      "(#{format('%03s', @n)}) #{lhs_name} : #{rhs}"
+    end
+
+    def hash
+      [@rhs, @lhs].hash
+    end
+
+    def eql?(other)
+      @lhs == other.lhs && @rhs == other.rhs
+    end
+    alias == eql?
+  end
+end