depager 0.1.9 → 0.2.0

data/examples/slex_test/test.divreg

@@ -0,0 +1 @@
+/aaa/ / /bbb/

data/examples/slex_test/test.ljoin

@@ -0,0 +1,3 @@
+x +
+y +
+z

data/lib/depager.rb

@@ -1,10 +1,11 @@
 require 'erb'
-require "depager/lr.rb"
 require "depager/parser.rb"
+require "depager/grammar.rb"
 require "depager/utils.rb"
 
 module Depager
-  Tmpldir = "#{File.dirname(__FILE__)}/depager/template"
+  Tmpldir = File.expand_path "#{File.dirname(__FILE__)}/depager/template"
+
   #
   # file manager 
   #
@@ -60,17 +61,23 @@ module Depager
         case line = files.getline
         when /^\s*(#.*)?$/
           #skip space and comment.
-        when /^%class\s*(\S+)\s*::\s*(\S+)\s*$/
+        when /^%class\s+(\S+)\s+based_on\s+(\S+)\s+\(\s*'(.+)'\s*\)\s*$/
           @target_name = $1
-          @generator = Object.const_get("#{$2}Generator").new(self)
+          require $3
+          ns = $2.split(/::/)
+          ge = ns.pop
+          m = ns.inject(Object){|c,name| c.const_get(name) }
+          @generator = m.const_get("#{ge}Generator").new(self)
           break
-        when /^%class\s*(.*?)\s*$/
+        when /^%class\s+(\S+)\s*$/
+          require 'depager/lr.rb'
           @target_name = $1
-          @generator = SingleLALRParserGenerator.new(self)
+          @generator = LALR::SingleParserGenerator.new(self)
           break
-        when /^%defext\s*(.*?)\s*$/
+        when /^%defext\s+(\S+)\s*$/
+          require 'depager/lr.rb'
           @target_name = $1
-          @generator = ExtensionLALRParserGenerator.new(self)
+          @generator = LALR::ExtensionParserGenerator.new(self)
           break
         else
           error_exit "%class not found."
@@ -78,6 +85,9 @@ module Depager
       end
       @generator.parse_decl
     end
+    def parsing_method
+      @generator.parsing_method
+    end
     def error_exit msg, lineno=nil
       lineno ||= files.lineno
       warn "#{files.path}:#{lineno}: #{msg}"
@@ -126,7 +136,8 @@ module Depager
     end
     def parse_rule
       if @token[0] == :NT
-        @r = @token.value
+        @lhs = @token.value
+
         gettoken
         postLhs
 
@@ -153,7 +164,7 @@ module Depager
       @optval = Array.new(@nparam)
       preRhs
       parse_syms
-      @g.push Rule[@r, @rhs, @prec]
+      add_rule(@lhs, @rhs, @prec)
       postRhs
       @nrhs += 1
 
@@ -164,9 +175,7 @@ module Depager
     end
     def parse_syms
       if @token.tag == :NT || @token.tag == :T
-        @rhs.push @token.value
-        @rhsni[@token.name] = @rhs.size - 1
-
+        rhs_insert_sym(-1, @token.value, @token.name)
         gettoken
 
         postSymbol
@@ -266,11 +275,22 @@ module Depager
     # add nonterm
     # sym:: symbol
     def add_nonterm sym
+      sym = sym.to_s.intern
       isym = @nonterms[sym] = @nonterms.size
       @i2s[isym] = sym
       return isym
     end
 
+    #
+    # add rule
+    # 
+    def add_rule lhs, rhs, prec=nil
+      @lhs_syms[lhs] = true
+      rule = @parsing_method::Rule[lhs, rhs, prec]
+      @g.push rule
+      return rule
+    end
+
     # get rhs index by name
     # name :: name
     def name_to_rhs_index name
@@ -278,41 +298,60 @@ module Depager
     end
     alias n2ri name_to_rhs_index
 
-    # lhs value
-    def lhs
-      @r
+    # insert sym into rhs
+    def rhs_insert_sym pos, token_value, token_name
+      if pos < 0
+        @rhs.push token_value
+        @rhsni[token_name] = @rhs.size - 1
+        @rhs_syms[token_value] = true
+      else
+        @rhsni.each{|k, v| @rhsni[k] += 1 if v >= pos }
+        @rhs.insert(pos, token_value)
+        @rhsni[token_name] = pos
+        @rhs_syms[token_value] = true
+      end
     end
 
     attr_accessor :g, :terms, :nonterms, :precs
     attr_accessor :line, :line0, :oldline, :token
     attr_accessor :optouter, :optinner, :optmain, :mixin
-    attr_accessor :nparams, :rhs, :nrhs, :rhsni, :nparam, :r, :nrules
+    attr_accessor :nparams, :lhs, :rhs, :nrhs, :rhsni, :nparam, :nrules
     attr_accessor :prerulelist, :postrulelist, :prerule, :postrule
     attr_accessor :postlhs, :prerhslist, :postrhslist
     attr_accessor :prerhs, :postrhs, :postsymbol
-    attr_reader   :d_parser, :target_name, :table
+    attr_reader   :d_parser, :target_name, :table, :parsing_method
 
     def initialize d_parser
       @yydebug = true
       @d_parser = d_parser
 
-      @i2s = {}
-
-      @g = [Rule[0 , [1]]]
-      @terms = { nil => -1, false => -2 }
-      @nonterms = {'$start' => 0}
-
       @optinner = []
       @optouter = []
       @optmain = []
-
       @nparams = {}
       @nparam = 1
-      
       init_hook
     end
 
     private
+    # check grammar
+    def check_grammar
+      lhs_warns = []
+      @lhs_syms.each do |s, _|
+        lhs_warns << s if s != 1 and !@rhs_syms[s]
+      end
+      rhs_warns = []
+      @rhs_syms.each do |s, _|
+        rhs_warns << s if s > 0 and !@lhs_syms[s]
+      end
+      lhs_warns.uniq.each do |s|
+        warning "the lhs '#{@i2s[s]}' is not used"
+      end
+      rhs_warns.uniq.each do |s|
+        warning "the symbol '#{@i2s[s]}' is undefined"
+      end
+    end
+
     # make grammar object
     # precs:: prec infos
     def make_grammar precs
@@ -356,6 +395,15 @@ module Depager
       @postsymbol = []
     end
 
+    def init_grammar
+      @g = [@parsing_method::Rule[0 , [1]]]
+      @terms = { nil => -1, false => -2 }
+      @nonterms = {'$start' => 0}
+      @i2s = {}
+      @rhs_syms = {}
+      @lhs_syms = {}
+    end
+
     public
     # extend paser
     # ext:: extension name
@@ -378,18 +426,29 @@ module Depager
     # mixin:: mixin modules
     # precs:: prec infos
     # return:: LALRTable
-    def parse(target_name = nil, mixin = [], precs = [])
+    def parse(target_name = nil, mixin = [], precs = [], pm=nil)
       @line = @line0 = ''
       @oldline = nil
       @target_name = target_name
       @mixin = mixin
+      @parsing_method = pm || @d_parser.generator.parsing_method
 
+      init_grammar
       parse_grammar
+      check_grammar
       make_grammar precs
-      @table = LALRTable.new(G.new(@g, @terms, @nonterms, @precs))
+      @table = @parsing_method::Table.new(
+        @parsing_method::Grammar.new(@g, @terms, @nonterms, @precs))
+      @table.check_table @d_parser
+      @table
     end
   end
 
+  #
+  # generators
+  #
+
+  # Generator base
   class Generator
     include FileUtils
     def files
@@ -403,11 +462,12 @@ module Depager
     def tmplf
       self.class::Tmplfile
     end
-    attr_reader   :d_parser
+    attr_reader   :d_parser, :parsing_method
     attr_accessor :optouter, :optinner, :optmain
     attr_accessor :basis_name, :deco, :req
     def initialize d_parser
       @d_parser = d_parser
+      @parsing_method = nil
       @basis_name = nil
 
       @deco = []
@@ -488,121 +548,128 @@ module Depager
     end
   end
 
-  class SimpleGenerator < Generator
-    Tmplfile = 'simple.erb'
-    def initialize d_parser
-      super
+
+  module Simple
+    class G
+      def initialize *args
+      end
     end
-    def out_code g_parser
-      ERB.new(File.read("#{tmpldir}/#{tmplf}")).result(binding)
+    class Table
+      def initialize *args
+      end
     end
-    def parse_decl
-      until eof?
-        line = getline
-        case line
-        when /^%%\s*$/
-          g_parser = GrammarParser.new(@d_parser)
-          g_parser.extend_paser @ext
-          g_parser.parse(@d_parser.target_name, @mixin, @precs)
-          @optmain.push parse_block
-          return out_code(g_parser)
-        else
-          parse_common(line)
+    class SingleGenerator < Generator
+      Tmplfile = 'simple.erb'
+      def initialize d_parser
+        super
+        @parsing_method = Simple
+      end
+      def out_code g_parser
+        ERB.new(File.read("#{tmpldir}/#{tmplf}")).result(binding)
+      end
+      def parse_decl
+        until eof?
+          line = getline
+          case line
+          when /^%%\s*$/
+            g_parser = GrammarParser.new(@d_parser)
+            g_parser.extend_paser @ext
+            g_parser.parse(@d_parser.target_name, @mixin, @precs)
+            @optmain.push parse_block
+            return out_code(g_parser)
+          else
+            parse_common(line)
+          end
         end
+        return nil
       end
-      return nil
     end
-  end
 
-  class SingleLALRParserGenerator < SimpleGenerator
-    Tmplfile = 'single_lalr_parser.erb'
-    def initialize d_parser
-      super
-      @basis_name = @d_parser.target_name + '.new()'
-    end
-  end
-
-  class ExtensionLALRParserGenerator < Generator
-    attr_accessor :regs, :paramkey
-    def initialize d_parser
-      super
-      @basis_name = 'self'
-      @paramkey = nil
-      @regs = {
-        "prerulelist" => nil,
-        "postrulelist" => nil,
+    class ExtensionGenerator < Generator
+      TmplfileMaster = '**NOTHING**'
+      TmplfileSlave = '**NOTHING**'
+      attr_accessor :regs, :paramkey
+      def initialize d_parser
+        super
+        @parsing_method = Simple
+        @basis_name = 'self'
+        @paramkey = nil
+        @regs = {
+          "prerulelist" => nil,
+          "postrulelist" => nil,
 
-        "prerule" => nil,
-        "postrule" => nil,
+          "prerule" => nil,
+          "postrule" => nil,
 
-        "postlhs" => nil,
+          "postlhs" => nil,
 
-        "postrhslist" => nil,
-        "prerhslist" => nil,
+          "postrhslist" => nil,
+          "prerhslist" => nil,
 
-        "prerhs" => nil,
-        "postrhs" => nil,
-      }    
-    end
+          "prerhs" => nil,
+          "postrhs" => nil,
+        }    
+      end
 
-    def parse_decl
-      until eof?
-        line = getline
-        case line
-        when /^%hook\s*(.*?)\s*$/
-          hs = $1
-          mtsk = if hs =~ /\/(([^\/\\]+|\\.)*)\/\s*(skip)?$/
-                   hs = $`
-                   [$1, $3 ? true : false]
-                 end
-          hook = hs.split(' ')
-          hookname = hook.join('_')
-          hook.each{|i| @regs[i] = [i, "#{@d_parser.target_name}_#{hookname}"]}
-          @optouter.push(parse_hook(hookname, mtsk))
-        when /^%param\s*(.*)\s*$/
-          @paramkey = $1
-        else
-          parse_common(line)
+      def parse_decl
+        until eof?
+          line = getline
+          case line
+          when /^%hook\s*(.*?)\s*$/
+            hs = $1
+            mtsk = if hs =~ /\/(([^\/\\]+|\\.)*)\/\s*(skip)?$/
+                     hs = $`
+                     [$1, $3 ? true : false]
+                   end
+            hook = hs.split(' ')
+            hookname = hook.join('_')
+            hook.each{|i| @regs[i] = [i, "#{@d_parser.target_name}_#{hookname}"]}
+            @optouter.push(parse_hook(hookname, mtsk))
+          when /^%param\s*(.*)\s*$/
+            @paramkey = $1
+          else
+            parse_common(line)
+          end
         end
+        return out_master_code
       end
-      return out_master_code
-    end
 
-    def parse_hook hookname, mtsk
-      inner = ''
-      precs = []
-      banner = nil
-      mixin = [].concat(@mixin)
-      target_name = "#{@d_parser.target_name}_#{hookname}"
-      until eof?
-        line = getline
-        case line
-        when /^%banner\s*'(([^'\\]+|\\.)*)'\s*$/
-          banner = $1
-        when /^%inner\s*\{\s*$/
-          inner = parse_block
-        when /^%mixin\s*(.+?)\s*(\((.+)\)\s*)?$/
-          mixin.push $1
-          @req.push $3 if $3
-        when /^%prec\s*(.*?)\s*$/
-          precs = parse_prec
-        when /^%%\s*$/
-          g_parser = GrammarParser.new(@d_parser)
-          g_parser.extend_paser @ext
-          g_parser.parse(target_name, mixin, precs)
-          g_parser.optinner.push inner
-          return out_slave_code(g_parser, mixin, mtsk, banner)
-        else
-          warning "syntax error(declaration).\n> #{line}", lineno
+      def parse_hook hookname, mtsk
+        inner = ''
+        precs = []
+        banner = nil
+        mixin = [].concat(@mixin)
+        target_name = "#{@d_parser.target_name}_#{hookname}"
+        until eof?
+          line = getline
+          case line
+          when /^%banner\s*'(([^'\\]+|\\.)*)'\s*$/
+            banner = $1
+          when /^%inner\s*\{\s*$/
+            inner = parse_block
+          when /^%mixin\s*(.+?)\s*(\((.+)\)\s*)?$/
+            mixin.push $1
+            @req.push $3 if $3
+          when /^%prec\s*(.*?)\s*$/
+            precs = parse_prec
+          when /^%%\s*$/
+            g_parser = GrammarParser.new(@d_parser)
+            g_parser.extend_paser @ext
+            g_parser.parse(target_name, mixin, precs)
+            g_parser.optinner.push inner
+            return out_slave_code(g_parser, mixin, mtsk, banner)
+          else
+            warning "syntax error(declaration).\n> #{line}", lineno
+          end
         end
       end
-    end
 
-    def out_slave_code g_parser, mixin, mtsk, banner
-      ERB.new(File.read("#{tmpldir}/extension_lalr_slave.erb")).result(binding)
-    end
-    def out_master_code
-      ERB.new(File.read("#{tmpldir}/extension_lalr_master.erb")).result(binding)
+      def out_slave_code g_parser, mixin, mtsk, banner
+        ERB.new(File.read(self.class::TmplfileSlave)).result(binding)
+      end
+      def out_master_code
+        ERB.new(File.read(self.class::TmplfileMaster)).result(binding)
+      end
     end
   end
 end