depager 0.2.3 → 0.3.0.b20250423

data/lib/depager.rb

@@ -1,670 +1,572 @@
-require 'erb'
-require "depager/parser.rb"
-require "depager/grammar.rb"
-require "depager/utils.rb"
-
-module Depager
-  LIBDIR  = File.expand_path "#{File.dirname(__FILE__)}/depager/ruby"
-  Tmpldir = "#{LIBDIR}/templates"
-  $LOAD_PATH.unshift LIBDIR
-
-  #
-  # file manager 
-  #
-  class FileManager
-    def initialize f=nil
-      @files = []
-      @files << f if f
-    end
-    def __file= f
-      # @file = f
-    end
-    def eof?
-      ceof = current.eof?
-      if !ceof 
-        ceof
-      elsif @files.size == 1
-        ceof
-      else
-        @files.pop
-        self.eof?
-      end
-    end
-    # get file name
-    def fname
-      File.basename current.path
-    end
-    # get file path
-    def path
-      current.path
-    end
-    # get current line no
-    def lineno
-      current.lineno
-    end
-    # add file to files
-    def add_file f
-      @files << f
-    end
-    #current file
-    def current
-      @files.last
-    end
-
-    # get next line
-    def getline
-      current.gets unless eof?
-    end
-    alias gets getline
-  end
-
-  #
-  # = declaration part parser
-  #
-  class DeclParser
-    attr_accessor :target_name, :g_parser, :generator
-    def initialize
-    end
-    def parse(file, fname=nil)
-      @files = FileManager.new(file)
-      @target_name = nil
-      
-      parse_decl
-    end
-    def files
-      @files
-    end
-    alias file files
-    def parse_decl
-      until files.eof?
-        case line = files.getline
-        when /^\s*(#.*)?$/
-          #skip space and comment.
-        when /^%class\s+(\S+)\s+based_on\s+(\S+)(\s+\(\s*'(.+)'\s*\))?\s*$/
-          @target_name = $1
-          require $4 if $4
-          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+)\s*$/
-          require 'depager/lr.rb'
-          @target_name = $1
-          @generator = LALR::SingleParserGenerator.new(self)
-          break
-        when /^%defext\s+(\S+)\s*$/
-          require 'depager/lr.rb'
-          @target_name = $1
-          @generator = LALR::ExtensionParserGenerator.new(self)
-          break
-        else
-          error_exit "%class not found."
-        end
-      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}"
-      exit 1
-    end
-    def warning msg, lineno=nil
-      lineno ||= files.lineno
-      warn "#{files.path}:#{lineno}: warning: #{msg}"
-    end
-  end
-
-  #
-  # = grammar part parser
-  #
-  class GrammarParser
-    include FileUtils
-
-    HOOK_KEYS = [
-      :pre_rule_list, :post_rule_list,
-      :pre_rule, :post_rule,
-      :post_lhs,
-      :post_rhs_list, :pre_rhs_list,
-      :pre_rhs, :post_rhs, :post_symbol
-    ] #:nodoc:
-    def self.hook_name? s
-      HOOK_KEYS.include? s.to_sym
-    end
-
-    def files
-      @d_parser.files
-    end
-
-    private
-    GToken = Struct.new(:tag, :value, :name, :lineno)
-    def _GToken tag, value, name=nil
-      @token = GToken[tag, value, name, lineno]
-      return @token
-    end
-    def parse_grammar
-      gettoken
-      do_hook :pre_rule_list
-      parse_rulelist
-      do_hook :post_rule_list
-      unless @token.tag == nil
-        error_exit "syntax error(grammar). "<<
-          "unexpected '#{@token.tag}' expect '%%'"
-      end
-    end
-    def parse_rulelist
-      do_hook :pre_rule
-      parse_rule
-      do_hook :post_rule
-      if @token.tag == :NT
-        parse_rulelist
-      end
-    end
-    def parse_rule
-      if @token[0] == :NT
-        @lhs = @token.value
-
-        gettoken
-        do_hook :post_lhs
-
-        unless  @token.tag == ':'
-          error_exit "syntax error(grammar). "<<
-            "unexpected '#{@token.tag}' expecting ':'"
-        end
-        gettoken
-
-        @nrhs = 0
-        do_hook :pre_rhs_list
-        parse_rhslist
-        do_hook :post_rhs_list
-
-        unless @token.tag == ';'
-          error_exit "syntax error(grammar). " <<
-            "unexpected '#{@token.tag}' expecting ';'"
-        end
-        gettoken
-      end
-    end
-    def parse_rhslist
-      @rhs = []; @rhsni = {}; @prec = nil
-      @optval = Array.new(@nparam)
-      do_hook :pre_rhs
-      parse_syms
-      add_rule(@lhs, @rhs, @prec)
-      do_hook :post_rhs
-      @nrhs += 1
-
-      if @token.tag == '|'
-        gettoken
-        parse_rhslist
-      end
-    end
-    def parse_syms
-      if @token.tag == :NT || @token.tag == :T
-        rhs_insert_sym(-1, @token.value, @token.name)
-        gettoken
-
-        do_hook :post_symbol
-        parse_syms
-      end
-    end
-
-    def gettoken
-      while !@line.empty? || !eof?
-        if @line.empty?
-          getline 
-          if @line =~ /^%include\s+'(.+?)'\s*$/
-            files.add_file File.open($1)
-            @line = ''
-          end
-        end
-        @oldline = @line
-        tag = s = name = val = nil
-        until @line.empty? do
-          case @line
-          when /^\s+/, /^\#.*/ ;
-            # skip
-          when /^=([a-zA-Z]+)/
-            @prec = s = $1.intern
-            val = @terms[s] ||= - (@terms.size + 1)
-          when /^([a-z][a-z0-9_]*)(-([a-z][_a-z0-9]*))?/
-            tag = :NT
-            s = $1.intern
-            name = $3 ? $3 : $1
-            val = @nonterms[s] ||= @nonterms.size
-          when /^([A-Z][A-Z0-9_]*)(-([a-z][_a-z0-9]*))?/
-            tag = :T
-            s = $1.intern
-            name = $3 ? $3 : $1
-            val = @terms[s] ||=  - (@terms.size + 1)
-          when /^'(.+?)'/
-            tag = :T
-            name = s = $1
-            val = @terms[s] ||=  - (@terms.size + 1)
-          when /^%%/
-            return _GToken(nil, nil)
-          when /^([:;|])/
-            tag = $&
-            val = $&
-          else
-            return _GToken(:UNKNOWN, @line[0].chr)
-          end
-          @oldline = @line; @line = $'
-          @i2s[val] ||= s if val && s
-          return _GToken(tag, val, name) if tag
-        end
-      end
-      return _GToken(nil, nil)
-    end
-
-    private
-    def do_hook hook
-      @hooks[hook].each{|o, m| o.send m}
-    end
-
-    public
-    # update line and get token
-    def update_context line
-      @line = line
-      gettoken
-    end
-
-    # get number of param
-    def getnparam a = nil
-      return nil unless a
-      return @nparams[a] if @nparams[a]
-      @nparam += 1
-      @nparams[a] = @nparam
-    end
-
-    def int_to_sym n
-      @i2s[n]
-    end
-    alias i2s int_to_sym
-
-    # 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]
-      @rules.push rule
-      return rule
-    end
-
-    # get rhs index by name
-    # name :: name
-    def name_to_rhs_index name
-      @rhsni[name]
-    end
-    alias n2ri name_to_rhs_index
-
-    # 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 :rules, :terms, :nonterms, :precs, :table
-    attr_accessor :line, :line0, :oldline, :token
-    attr_accessor :optouter, :optinner, :optmain, :mixin
-    attr_accessor :nparams, :lhs, :rhs, :nrhs, :rhsni, :nparam, :nrules
-    attr_reader   :d_parser, :target_name, :parsing_method, :hooks
-
-    def initialize d_parser
-      @yydebug = true
-      @d_parser = d_parser
-
-      @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
-      ts = @nonterms.size - 1
-      @terms.each{|k,v| @terms[k] = ts - v}
-      # @grammar[0].act = Array.new(@nparam-1)
-
-      @precs = {}
-      precs.each_with_index do |p, x|
-        p[1].each do |i|
-          if @terms[i]
-            @precs[@terms[i]] = [p[0], x]
-          else
-            error_exit "prec error '#{i}'."
-          end
-        end
-      end
-      @rules.each do |rule|
-        rule.rhs.each_with_index{|i, x| rule.rhs[x] = ts - i if i < 0}
-        rule.prec &&= @precs[@terms[rule.prec]]
-      end
-    end
-    alias mkg make_grammar
-
-    # initialize hook
-    def init_hook
-      @hooks = HOOK_KEYS.inject({}){|r,i| r[i]=[]; r }
-    end
-
-    def init_grammar
-      @rules = [@parsing_method::Rule[0 , [1]]]
-      @terms = { nil => -1, false => -2 }
-      @nonterms = {'$start' => 0}
-      @i2s = {}
-      @rhs_syms = {}
-      @lhs_syms = {}
-    end
-
-    public
-    # extend paser
-    # extentions:: array of [name, paht]
-    # options::    hash of options
-    def extend_paser extentions, options
-      init_hook
-      extentions.each do |f,m|
-        require f if f
-        e = Object.const_get("#{m}Extension").new
-        options[m] and options[m].each do |k,v|
-          begin
-            e.send("#{k}=", v)
-          rescue NoMethodError
-            warning "no such a option '#{m}.#{k}'."            
-          end
-        end
-        e.send(:__regext__, self)
-      end
-    end
-
-    # get next line
-    def getline
-      @line0 = @line = files.getline
-    end
-
-    # parse and make LALR(1) table
-    # file::  input file object
-    # target_name:: class name
-    # mixin:: mixin modules
-    # precs:: prec infos
-    # return:: LALRTable
-    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 = @parsing_method::Table.new(
-        @parsing_method::Grammar.new(@rules, @terms, @nonterms, @precs))
-      @table.check_table @d_parser
-      @table
-    end
-  end
-
-  #
-  # generators
-  #
-
-  # Generator base
-  class Generator
-    include FileUtils
-    def files
-      @d_parser.files
-    end
-    Tmpldir = Depager::Tmpldir
-    Tmplfile = "**NOTHING**"
-    def tmpldir
-      Generator::Tmpldir
-    end
-    def tmplf
-      self.class::Tmplfile
-    end
-    attr_reader   :d_parser, :parsing_method
-    attr_accessor :optouter, :optinner, :optmain
-    attr_accessor :basis_name, :deco, :req, :options
-    def initialize d_parser
-      @d_parser = d_parser
-      @parsing_method = nil
-      @basis_name = nil
-
-      @deco = []
-      @req = []
-      @ext = []
-      @options = {}
-
-      @optinner = []
-      @optouter = []
-      @optmain = []
-      @precs = []
-      @mixin = []
-
-      @dr_option = {}
-
-      @tmpldir = Generator::Tmpldir+'/'
-    end
-
-    def parse_prec
-      precs = []
-      until files.eof?
-        case line = files.getline
-        when /^\s*$/, /^\s*#.*$/
-          # skip
-        when /^\s*(left|right|nonassoc)\s+(.*)$/
-          dir = $1.upcase.intern
-          syms = $2.split.map{|i| (i =~ /'(.+?)'/) ? $1 : i.intern}
-          precs.push [dir, syms]
-        when /^%\}\s*$/
-          break
-        else
-          error_exit "syntax error(prec).\n> #{line}"
-        end
-      end
-      return precs
-    end
-
-    def parse_block
-      val = ''
-      until eof?
-        line = getline
-        break if line =~ /^%\}/ 
-        val.concat line
-      end
-      return val
-    end
-
-    def parse_common line
-      case line
-      when /^\s*(#.*)?$/
-        #skip space and comment.
-      when /^%decorate\s+(.*?)\s*\((.*)\)\s*$/
-        @deco.push $1
-        @req.push $2
-      when /^%decorate\s+(.*?)\s*$/
-        @deco.push $1
-      when /^%extend\s+(.*?)\s*\(\s*'(.*)'\s*\)\s*$/
-        @ext.push [$2.strip, $1] unless @ext.find{|i| i[1] == $1}
-      when /^%option\s+(\w+).(\w+)\s+(.*)\s*$/
-        if $1 == 'Generator'
-          @dr_option[$2] = $3
-        else
-          @options[$1] ||= []
-          @options[$1] << [$2, $3]
-        end
-      when /^%require\s+'(.+?)'\s*$/
-        @req.push "'#{$1}'"
-      when /^%mixin\s+(\S+)\s*(\((.+)\)\s*)?$/
-        @mixin.push $1
-        @req.push $3 if $3
-      when /^%inner\s*\{\s*$/
-        @optinner.push parse_block
-      when /^%prec\s*\{\s*$/
-        @precs = parse_prec
-      else
-        warning "syntax error(declaration).\n> #{line}"
-      end
-    end
-  end
-
-
-  module Simple
-    Grammar = Depager::ParsingMethod::Grammar
-    Rule    = Depager::ParsingMethod::Rule
-    class Table
-      def initialize *args
-      end
-      def check_table *args
-        true
-      end
-    end
-    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, @options
-            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
-    end
-
-    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 = { }
-      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 do |i| i = i.to_sym
-              raise unless GrammarParser.hook_name? i
-              @regs[i] = "#{@d_parser.target_name}_#{hookname}"
-            end
-            @optouter.push(parse_hook(hookname, mtsk))
-          when /^%param\s*(.*)\s*$/
-            @paramkey = $1
-          else
-            parse_common(line)
-          end
-        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, @options
-            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
-
-      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
+require "erb"
+require "depager/parser"
+require "depager/grammar"
+require "depager/utils"
+
+module Depager
+  def self.configuration
+    @configuration ||= {}
+  end
+
+  def self.debug_mode?(flag = "")
+    value = configuration[:debug] or return false
+    !!value.match(/#{flag}/)
+  end
+
+  def self.verbose_mode?
+    configuration[:verbose]
+  end
+
+  class DeclarationPartParser
+    include Depager::Utils::CommonMethods
+
+    attr_reader :file, :target_namespace, :target_name, :g_parser, :generator
+
+    def parse(file)
+      @file = file
+      @g_parser = GrammarPartParser.new(self)
+
+      until file.eof?
+        case file.gets
+        when /^\s*(#.*)?$/
+          # skip space and comment.
+        when /^%class\s+(\S+)(\s+based_on\s+(\S+)(\s+\(\s*'(.+)'\s*\))?)?\s*$/
+          @target_name = $1
+          if $2
+            require $5 if $5
+            nesting = $3.split("::").tap { |it| it[-1] = "#{it[-1]}Generator" }
+            generator_class = nesting.inject(Object) { |c, name| c.const_get(name) }
+          else
+            require "depager/lr"
+            generator_class = LALR::ParserGenerator
+          end
+
+          if @target_name =~ /(.+)::([^:]+)/
+            @target_namespace = $1
+            @target_name = $2
+          else
+            error_exit "Namespace required"
+          end
+
+          @generator = generator_class.new(self)
+          break
+        when /^%defext\s+(\S+)\s*$/
+          require "depager/lr"
+
+          @target_namespace = $1
+          @target_name = "Master"
+
+          @generator = LALR::ExtensionGenerator.new(self)
+          break
+        else
+          error_exit "%class not found."
+        end
+      end
+      @generator.parse
+    end
+
+    def parsing_method
+      @generator.parsing_method
+    end
+  end
+
+  class GrammarPartParser
+    include Depager::Utils::CommonMethods
+
+    Token = Struct.new(:tag, :value, :name, :lineno)
+
+    HOOK_KEYS = %i[
+      pre_rule_list post_rule_list
+      pre_rule post_rule
+      post_lhs
+      post_rhs_list pre_rhs_list
+      pre_rhs post_rhs
+      post_symbol
+    ].freeze # :nodoc:
+
+    attr_accessor :rules, :terms, :nonterms, :precs, :table, :lhs, :rhs, :nrhs, :rhs_names, :nrules, :line,
+                  :original_line, :old_line, :token, :outer_code, :inner_code, :mixins
+    attr_reader   :d_parser, :target_namespace, :target_name, :hooks
+
+    def initialize(d_parser)
+      @d_parser = d_parser
+    end
+
+    # parse and make LALR(1) table
+    def parse(full_target_name, precs = [], extensions = [], options = {})
+      @original_line = @old_line = @line = ""
+      @inner_code    = ""
+      @outer_code    = ""
+
+      full_target_name.match(/::([^:]+)$/) or raise
+      @target_namespace = $`
+      @target_name = $1
+
+      extend_parser(extensions, options)
+      init_grammar
+      parse_grammar
+      check_grammar
+      make_grammar precs
+
+      grammar = d_parser.parsing_method::Grammar.new(@rules, @terms, @nonterms, @precs)
+      @table  = d_parser.parsing_method::Table.new(grammar)
+      @table.check_table d_parser
+      @extensions.each { |o| o.send :term_extension }
+      @table
+    end
+
+    def hook_name?(s)
+      HOOK_KEYS.include? s.to_sym
+    end
+
+    def update_context(line)
+      @line = line
+      scan_token
+    end
+
+    def int_to_sym(n)
+      @int_to_sym[n]
+    end
+
+    def lhs_name
+      int_to_sym(lhs)
+    end
+
+    def add_nonterm(sym)
+      sym = sym.to_s.intern
+      isym = @nonterms[sym] = @nonterms.size
+      @int_to_sym[isym] = sym
+      isym
+    end
+
+    def add_rule(lhs, rhs, prec = nil, rhs_names = nil)
+      @lhs_syms[lhs] = true
+      rule = d_parser.parsing_method::Rule[lhs, rhs, prec, rhs_names]
+      @rules.push rule
+      rule
+    end
+
+    def name_to_rhs_index(name)
+      @rhs_names.index(name)
+    end
+
+    def insert_sym_to_rhs(pos, token_value, token_name)
+      if pos < 0
+        @rhs.push token_value
+        @rhs_names[@rhs.size - 1] = token_name
+      else
+        @rhs.insert(pos, token_value)
+        @rhs_names.insert(pos, token_name)
+      end
+      @rhs_syms[token_value] = true
+    end
+
+    private
+
+    def parse_grammar
+      scan_token
+      do_hook :pre_rule_list
+      parse_rulelist
+      do_hook :post_rule_list
+      return if @token.tag.nil?
+
+      error_exit "syntax error(grammar). unexpected '#{@token.tag}' expect '%%'"
+    end
+
+    def parse_rulelist
+      do_hook :pre_rule
+      parse_rule
+      do_hook :post_rule
+      return unless @token.tag == :NT
+
+      parse_rulelist
+    end
+
+    def parse_rule
+      return unless @token[0] == :NT
+
+      @lhs = @token.value
+
+      scan_token
+      do_hook :post_lhs
+
+      error_exit "syntax error(grammar). unexpected '#{@token.tag}' expecting ':'" unless @token.tag == ":"
+      scan_token
+
+      @nrhs = 0
+      do_hook :pre_rhs_list
+      parse_rhslist
+      do_hook :post_rhs_list
+
+      error_exit "syntax error(grammar). unexpected '#{@token.tag}' expecting ';'" unless @token.tag == ";"
+      scan_token
+    end
+
+    def parse_rhslist
+      @rhs = []
+      @rhs_names = []
+      @prec = nil
+      do_hook :pre_rhs
+      parse_syms
+      add_rule(@lhs, @rhs, @prec, @rhs_names)
+      do_hook :post_rhs
+      @nrhs += 1
+
+      return unless @token.tag == "|"
+
+      scan_token
+      parse_rhslist
+    end
+
+    def parse_syms
+      return unless @token.tag == :NT || @token.tag == :T
+
+      insert_sym_to_rhs(-1, @token.value, @token.name)
+      scan_token
+
+      do_hook :post_symbol
+      parse_syms
+    end
+
+    def make_token(tag, value, name = nil)
+      @token = Token.new(tag, value, name, file.lineno)
+    end
+
+    def scan_token
+      while !@line.empty? || !file.eof?
+        @original_line = @old_line = @line = file.gets if @line.empty?
+
+        tag = s = name = val = nil
+        until @line.empty?
+          case @line
+          when /^\s+/, /^\#.*/
+            # skip
+          when /^=([a-zA-Z]+)/
+            @prec = s = $1.intern
+            val = @terms[s] ||= - (@terms.size + 1)
+          when /^([a-z][a-z0-9_]*)(-([a-z][_a-z0-9]*))?/
+            tag = :NT
+            s = $1.intern
+            name = $3 || $1
+            val = @nonterms[s] ||= @nonterms.size
+          when /^([A-Z][A-Z0-9_]*)(-([a-z][_a-z0-9]*))?/
+            tag = :T
+            s = $1.intern
+            name = $3 || $1
+            val = @terms[s] ||= - (@terms.size + 1)
+          when /^'(.+?)'/
+            tag = :T
+            name = s = $1
+            val = @terms[s] ||= - (@terms.size + 1)
+          when /^%%/
+            return make_token(nil, nil)
+          when /^([:;|])/
+            tag = $&
+            val = $&
+          else
+            return make_token(:UNKNOWN, @line[0].chr)
+          end
+          @old_line = @line
+          @line = $'
+          @int_to_sym[val] ||= s if val && s
+          return make_token(tag, val, name) if tag
+        end
+      end
+      make_token(nil, nil)
+    end
+
+    def extend_parser(extensions, options)
+      init_hook
+      @extensions = []
+      extensions.each do |f, m|
+        if f&.match(%r{^\./})
+          require File.expand_path(f, File.dirname(file.path))
+        elsif f
+          require f
+        end
+
+        nesting   = m.split("::").tap { |it| it[-1] = "#{it[-1]}Extension" }
+        extension = nesting.inject(Object) { |c, name| c.const_get(name) }.new
+        options[m]&.each do |k, v|
+          extension.send(:"#{k}=", v)
+        rescue NoMethodError
+          warning "no such a option '#{m}.#{k}'."
+        end
+        @extensions << extension
+        extension.extension_registered self
+        extension.init_extension
+      end
+    end
+
+    def init_grammar
+      @rules      = [d_parser.parsing_method::Rule[0, [1]]]
+      @terms      = { nil => -1, false => -2 }
+      @nonterms   = { "$start" => 0 }
+      @int_to_sym = {}
+      @rhs_syms   = {}
+      @lhs_syms   = {}
+    end
+
+    def make_grammar(precs)
+      ts = @nonterms.size - 1
+      @terms.each { |k, v| @terms[k] = ts - v }
+
+      @precs = {}
+      precs.each_with_index do |p, x|
+        p[1].each do |i|
+          if @terms[i]
+            @precs[@terms[i]] = [p[0], x]
+          else
+            error_exit "prec error '#{i}'."
+          end
+        end
+      end
+      @rules.each do |rule|
+        rule.rhs.each_with_index { |i, x| rule.rhs[x] = ts - i if i < 0 }
+        rule.prec &&= @precs[@terms[rule.prec]]
+      end
+    end
+
+    def check_grammar
+      lhs_warns = []
+      @lhs_syms.each_key do |s|
+        lhs_warns << s if (s != 1) && !@rhs_syms[s]
+      end
+      rhs_warns = []
+      @rhs_syms.each_key do |s|
+        rhs_warns << s if (s > 0) && !@lhs_syms[s]
+      end
+      lhs_warns.uniq.each do |s|
+        warning "the lhs '#{@int_to_sym[s]}' is not used"
+      end
+      rhs_warns.uniq.each do |s|
+        warning "the symbol '#{@int_to_sym[s]}' is undefined"
+      end
+    end
+
+    def init_hook
+      @hooks = HOOK_KEYS.each_with_object({}) do |i, r|
+        r[i] = []
+      end
+    end
+
+    def do_hook(hook)
+      @hooks[hook].each { |o, m| o.send m }
+    end
+  end
+
+  class Generator
+    include Depager::Utils::CommonMethods
+
+    TEMPLATES_DIR = File.expand_path("depager/ruby/templates", __dir__)
+
+    attr_reader   :d_parser, :g_parser, :parsing_method
+    attr_accessor :outer_code, :inner_code, :setup_code, :decorators, :requirements, :options
+
+    def initialize(d_parser)
+      @d_parser = d_parser
+      @g_parser = d_parser.g_parser
+      @parsing_method = nil
+
+      @options      = {}
+      @decorators   = []
+      @requirements = []
+      @extensions   = []
+      @inner_code   = ""
+      @outer_code   = ""
+      @setup_code   = ""
+      @precs        = []
+      @mixins       = []
+    end
+
+    def generate_code(template)
+      ERB.new(template || "", trim_mode: "-").result(binding)
+    end
+
+    def parse_prec
+      precs = []
+      until file.eof?
+        case line = file.gets
+        when /^\s*$/, /^\s*#.*$/
+          # skip
+        when /^\s*(left|right|nonassoc)\s+(.*)$/
+          dir = $1.upcase.intern
+          syms = $2.split.map { |i| i =~ /'(.+?)'/ ? $1 : i.intern }
+          precs.push [dir, syms]
+        when /^%\}\s*$/
+          break
+        else
+          error_exit "syntax error(prec).\n> #{line}"
+        end
+      end
+      precs
+    end
+
+    def parse_block(raw: false)
+      lineno = file.lineno
+      val = ""
+      until file.eof?
+        line = file.gets
+        break if /^%\}/.match?(line)
+
+        val.concat line
+      end
+      return val if raw
+
+      delimiter = expanded_code_delimiter
+      <<~EXPANDED_CODE
+        module_eval <<'#{delimiter}', '#{file.path}', #{lineno + 1}
+        #{val}
+        #{delimiter}
+      EXPANDED_CODE
+    end
+
+    def parse_common(line)
+      case line
+      when /^\s*(#.*)?$/
+        # skip space and comment.
+      when /^%decorate\s+(.*?)\s*\((.*)\)\s*$/
+        @decorators.push $1
+        @requirements.push $2
+      when /^%decorate\s+(.*?)\s*$/
+        @decorators.push $1
+      when /^%extend\s+(.*?)\s*\(\s*'(.*)'\s*\)\s*$/
+        @extensions.push [$2.strip, $1] unless @extensions.find { |i| i[1] == $1 }
+      when /^%option\s+([\w:]+).(\w+)\s+(.*)\s*$/
+        if $1 == "Generator"
+          Depager.configuration[$2.to_sym] = $3
+        else
+          @options[$1] ||= []
+          @options[$1] << [$2, $3]
+        end
+      when /^%require\s+'(.+?)'\s*$/
+        @requirements.push "'#{$1}'"
+      when /^%mixin\s+(\S+)\s*(\((.+)\)\s*)?$/
+        @mixins.push $1
+        @requirements.push $3 if $3
+      when /^%inner\s*\{\s*$/
+        @inner_code << parse_block
+      when /^%prec\s*\{\s*$/
+        @precs = parse_prec
+      when /^%expanded_code_delimiter\s+(\S+)\s*$/
+        Depager.configuration[:expanded_code_delimiter] = $1
+      when /^%abort_behavior\s+(pending\s+)?(.*)$/
+        @inner_code << "    def do_abort_driver; end\n" if $1
+        @inner_code << "    def abort_driver; #{$2}; end\n" unless $2.strip.empty?
+      else
+        warning "syntax error(declaration).\n> #{line}"
+      end
+    end
+  end
+
+  class ParserGenerator < Generator
+    def parse
+      until file.eof?
+        line = file.gets
+        case line
+        when /^%%\s*$/
+          g_parser.parse(@d_parser.full_target_name, @precs, @extensions, @options)
+          @outer_code << parse_block(raw: true)
+          return generate_code parser_code_template
+        when /^%setup((\s*{\s*)|(\s.*))$/
+          @setup_code << ($2 ? parse_block : $3.lstrip)
+        else
+          parse_common(line)
+        end
+      end
+      nil
+    end
+
+    def parser_code_template; end
+  end
+
+  class ExtensionGenerator < Generator
+    attr_accessor :slaves
+
+    def initialize(d_parser)
+      super
+      @slaves = {}
+    end
+
+    def parse
+      until file.eof?
+        line = file.gets
+        case line
+        when %r{^%hook\s+([\w \t]+?)(/((?:[^/\\]+|\\.)+)/(\s+skip)?)?\s*$}
+          hooks = $1.split
+          @banner = hooks.join(",")
+          @do_parse_re   = $3
+          @do_parse_skip = $4
+
+          parts = hooks.map do |i|
+            error_exit "Unknown hook: #{i}" unless g_parser.hook_name? i
+            i.split("_").map(&:capitalize).join
+          end
+          target_name = "#{d_parser.target_namespace}::#{parts.join}#{slaves.size}::Parser"
+          @slaves[target_name] = hooks
+          @outer_code << parse_hook(target_name)
+        when /^%%\s*$/
+          @outer_code << parse_block(raw: true)
+        else
+          parse_common(line)
+        end
+      end
+      generate_code master_code_template
+    end
+
+    def parse_hook(target_name)
+      inner = ""
+      precs = []
+      @slave_mixins = @mixins.dup
+      until file.eof?
+        line = file.gets
+        case line
+        when /^%banner\s*'(([^'\\]+|\\.)*)'\s*$/
+          @banner = $1
+        when /^%inner\s*\{\s*$/
+          inner = parse_block
+        when /^%mixin\s*(.+?)\s*(\((.+)\)\s*)?$/
+          @slave_mixins << $1
+          @requirements.push $3 if $3
+        when /^%prec\s*(.*?)\s*$/
+          precs = parse_prec
+        when /^%%\s*$/
+          g_parser.parse(target_name, precs, @extensions, @options)
+          g_parser.inner_code << inner
+          return generate_code slave_code_template
+        else
+          warning "syntax error(declaration).\n> #{line}", file.lineno
+        end
+      end
+    end
+
+    def slave_code_template; end
+
+    def master_code_template; end
+  end
+
+  class Extension
+    include Depager::Utils::CommonMethods
+    include Depager::Utils::CodeGeneratorMethods
+
+    attr_reader :d_parser, :g_parser
+
+    def init_extension; end
+
+    def term_extension; end
+
+    def extension_registered(g_parser)
+      @g_parser = g_parser
+      @d_parser = g_parser.d_parser
+
+      methods.sort.each do |m|
+        m = m.to_sym
+        g_parser.hooks[m].push [self, m] if g_parser.hook_name? m
+      end
+    end
+
+    def decorator_name
+      self.class.name.split("::").last.sub(/Extension$/, "")
+    end
+  end
+end