depager 0.2.0 → 0.2.2

data/lib/depager/grammar.rb

@@ -1,29 +1,27 @@
-module Depager::ParsingMethodCommon
-  class G
-    attr_accessor :rulelist, :gh, :syms, :nonterms, :terms, :closure, :ismap, :nssize, :tla
-    attr_accessor :precs, :epr, :epr2, :f0e, :first1, :eoi
+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 rulelist, ts, ns, precs = nil
-      @nssize = ns.size
-      @precs = precs
-      @eoi = ts[nil]
-      @syms = ns.invert.merge(ts.invert)
-      @tla = @syms.size
+    def initialize rulelist, terms, nonterms, precs = nil
+      @precs    = precs
+      @nonterms = nonterms.invert
+      @terms    = terms.invert
+      @syms     = nonterms.invert.merge(terms.invert)
 
       @rulelist = rulelist
-      @gh = []; @nssize.times{|i| @gh[i] = []}
-      @epr = {}
-      @f0e = {}
+      @lhs_to_rule = []; @nonterms.size.times{|i| @lhs_to_rule[i] = []}
+      @empty_rules = {}
       @rulelist.each_with_index do |rule, rx|
-        rule.g = self
+        rule.grammar = self
         rule.n = rx
-        @gh[rule.l].push rule
-        if rule.r.empty?
-          @epr[rule.l] = rule.n 
-          @f0e[rule.l] = { rule.n => [Eps] }
+        @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
@@ -31,105 +29,266 @@ module Depager::ParsingMethodCommon
     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
+    def mask_sym
+      @mask_sym
+    end
+
     def make_sym_first
-      @first1 = {@tla => [@tla]}
+      @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
+
+      old_make_sym_first
+=begin
+      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]
+          first1[s] = [s]
         else
-          @first1[s] = []        
-          @first1[s].push Eps if @epr[s]
+          first1[s] = []        
+          first1[s] << Eps if @empty_rules[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]
+        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[s] |= ss
-                cnt = true
+                first1[lhs] |= ss
+                changed = true
               end
-              break unless @first1[es].include? Eps
+              break unless first1[s].include? Eps
             end
-            unless @first1[s].include? Eps
-              if rule.r.all?{|i| @first1[i].include? Eps }
-                @first1.push Eps
-                cnt = true
+            unless first1[lhs].include? Eps
+              if rule.rhs.all?{|i| first1[i].include? Eps }
+                first1[lhs] << Eps
+                changed = true
               end
             end
-          end if nonterms? s
+          end
         end
-      end while cnt
+      end while changed
+      @old_first1 = first1
     end
 
-    def first p
+    def old_first p
+      return [Eps] if p.empty?
+      first1 = @old_first1
       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]
+        unless i == Eps
+          r.concat first1[i]
+          break unless first1[i].include? Eps
         end
         x += 1
       end
-      r -= [Eps]
-      r |= [Eps] if x == p.size
+      r.uniq! ; r.delete Eps
+      r << Eps if x == p.size
       return r
     end
 
     def terms? i
-      i && i >= @nssize
+      i && i >= @nonterms.size
     end
 
     def nonterms? i
-      i && i < @nssize
+      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
+  G = Grammar
 
   class Rule
     def self.[] l, r, prec = nil
-      self.new l, r, nil, nil, nil, prec
+      self.new l, r, prec
     end
 
-    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 = []
+    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
 
-    alias lhs l
-    alias rhs r
-
     def to_s
-      r = @r.map{|i| @g.syms[i]}.join(' ')    
-      "(#{'%03s'%@n}) #{@g.syms[@l]} : #{r}"
+      lhs = grammar.symname @lhs
+      rhs = @rhs.map{|i| grammar.symname i}.join(' ')
+
+      "(#{'%03s' % @n}) #{lhs} : #{rhs}"
     end
 
     def hash
-      (@l.hash % 37) * (@r.hash % 37)
+      1117 * @rhs.hash + @lhs.hash % 3037
     end
     def eql? i
-      @l == i.l && @r == i.r
+      @lhs == i.lhs && @rhs == i.rhs
     end
     alias == eql?
   end

data/lib/depager/lex.dr

@@ -65,7 +65,7 @@
       }
   ;
   lexactlist:
-      lexact            { [ _lexact ] }
+      lexact            { _lexact }
     | lexactlist lexact { _lexactlist << _lexact }
   ;
   lexact:

data/lib/depager/lex.rb

@@ -89,12 +89,12 @@ class LexerExtension_prerulelist < Depager::LALR::Basis #:nodoc:all
     [ ACC, nil, nil, nil, nil, nil, ], 
     [ nil, nil, nil, nil, 5, nil, ], 
     [ nil, nil, nil, nil, nil, nil, ], 
-    [ nil, nil, nil, 9, nil, 8, ], 
+    [ nil, nil, nil, 8, nil, 9, ], 
     [ nil, nil, nil, nil, nil, nil, ], 
     [ nil, nil, nil, nil, nil, nil, ], 
     [ nil, nil, 10, nil, nil, nil, ], 
-    [ nil, nil, nil, nil, 11, nil, ], 
     [ nil, nil, nil, nil, nil, nil, ], 
+    [ nil, nil, nil, nil, 11, nil, ], 
     [ nil, nil, nil, nil, nil, nil, ], 
     [ nil, nil, nil, nil, nil, nil, ], 
   ]
@@ -108,8 +108,8 @@ class LexerExtension_prerulelist < Depager::LALR::Basis #:nodoc:all
     -7, 
     -3, 
     nil, 
-    nil, 
     -6, 
+    nil, 
     -4, 
     -8, 
   ]
@@ -122,8 +122,8 @@ class LexerExtension_prerulelist < Depager::LALR::Basis #:nodoc:all
     -7, 
     -3, 
     nil, 
-    nil, 
     -6, 
+    nil, 
     -4, 
     -8, 
   ]
@@ -230,8 +230,7 @@ end
 
 class D4LexerExtension_prerulelist::NVAction < Depager::LALR::Action #:nodoc:all
   include Depager::DecoratorUtils
-          include ActionParser
-
+  ["        include ActionParser\n"]
   on_reduce = [
     nil,
               :_act_0,
@@ -252,9 +251,9 @@ class D4LexerExtension_prerulelist::NVAction < Depager::LALR::Action #:nodoc:all
   end
   
 
-module_eval <<-'.,.,118754107729449.,.,', 'lex.dr', 48
-  def _act_0 val
-    _lexactlist = *val 
+module_eval <<-'.,.,12099829229538.,.,', 'lex.dr', 48
+def _act_0 val
+    _lexactlist, = *val 
 
         g_parser.optinner << %{
           def lex
@@ -271,31 +270,28 @@ module_eval <<-'.,.,118754107729449.,.,', 'lex.dr', 48
           end
         }; #code
 
-  end
-
-.,.,118754107729449.,.,
+end
+.,.,12099829229538.,.,
       
-module_eval <<-'.,.,118754107760430.,.,', 'lex.dr', 66
-  def _act_1 val
-    _lexact = *val 
-     [ _lexact ] 
-
-  end
+module_eval <<-'.,.,12099829229930.,.,', 'lex.dr', 66
+def _act_1 val
+    _lexact, = *val 
+     _lexact 
 
-.,.,118754107760430.,.,
+end
+.,.,12099829229930.,.,
       
-module_eval <<-'.,.,118754107730115.,.,', 'lex.dr', 67
-  def _act_2 val
-    _lexactlist, _lexact = *val 
+module_eval <<-'.,.,120998292251446.,.,', 'lex.dr', 67
+def _act_2 val
+    _lexactlist, _lexact, = *val 
      _lexactlist << _lexact 
 
-  end
-
-.,.,118754107730115.,.,
+end
+.,.,120998292251446.,.,
       
-module_eval <<-'.,.,118754107747000.,.,', 'lex.dr', 71
-  def _act_3 val
-    _lexlist, _opt_noskip, _ACTION = *val 
+module_eval <<-'.,.,12099829229876.,.,', 'lex.dr', 71
+def _act_3 val
+    _lexlist, _opt_noskip, _ACTION, = *val 
 
         %{
           when #{_lexlist.join(', ')}
@@ -303,44 +299,39 @@ module_eval <<-'.,.,118754107747000.,.,', 'lex.dr', 71
             #{ _ACTION }
         }; #code
 
-  end
-
-.,.,118754107747000.,.,
+end
+.,.,12099829229876.,.,
       
-module_eval <<-'.,.,118754107727512.,.,', 'lex.dr', 80
-  def _act_4 val
+module_eval <<-'.,.,120998292261886.,.,', 'lex.dr', 80
+def _act_4 val
      false 
 
-  end
-
-.,.,118754107727512.,.,
+end
+.,.,120998292261886.,.,
       
-module_eval <<-'.,.,118754107710888.,.,', 'lex.dr', 81
-  def _act_5 val
-    _ = *val 
+module_eval <<-'.,.,120998292263869.,.,', 'lex.dr', 81
+def _act_5 val
+    _, = *val 
      true  
 
-  end
-
-.,.,118754107710888.,.,
+end
+.,.,120998292263869.,.,
       
-module_eval <<-'.,.,118754107743010.,.,', 'lex.dr', 84
-  def _act_6 val
-    _LEX = *val 
+module_eval <<-'.,.,120998292217015.,.,', 'lex.dr', 84
+def _act_6 val
+    _LEX, = *val 
      [ _LEX ] 
 
-  end
-
-.,.,118754107743010.,.,
+end
+.,.,120998292217015.,.,
       
-module_eval <<-'.,.,118754107718606.,.,', 'lex.dr', 85
-  def _act_7 val
-    _lexlist, _, _LEX = *val 
+module_eval <<-'.,.,120998292239616.,.,', 'lex.dr', 85
+def _act_7 val
+    _lexlist, _, _LEX, = *val 
      _lexlist << _LEX 
 
-  end
-
-.,.,118754107718606.,.,
+end
+.,.,120998292239616.,.,
       
 end