depager 0.2.3 → 0.3.0.b20160729

data/examples/sample_calc/calc.lex.dr

@@ -1,29 +1,29 @@
-%class TinyCalc
-%extend Lexer ('plugins/lex.rb')
-%%
-
-%LEX{
-  /\s+/, /\#.*/, /\n/  { }
-  /[1-9][0-9]*/        { yield token(:NUM, $&.to_i) }
-  /./                  { yield token($&, $&) }
-%}
-
-#begin-rule
-  expr :
-      expr '+' term
-    | expr '-' term
-    | term
-  ;
-  term :
-      term '*' fact
-    | term '/' fact
-    | fact
-  ;
-  fact :
-      NUM
-    | '(' expr ')'
-  ;
-#end-rule
-%%
-parser = TinyCalc.new()
-parser.parse(STDIN)
+%class TinyCalc::Parser
+%extend Depager::Lexer ('plugins/lex.rb')
+%%
+
+%LEX{
+  /\s+/, /\#.*/, /\n/  { }
+  /[1-9][0-9]*/        { yield token(:NUM, $&.to_i) }
+  /./                  { yield token($&, $&) }
+%}
+
+#begin-rule
+  expr :
+      expr '+' term
+    | expr '-' term
+    | term
+  ;
+  term :
+      term '*' fact
+    | term '/' fact
+    | fact
+  ;
+  fact :
+      NUM
+    | '(' expr ')'
+  ;
+#end-rule
+%%
+parser = TinyCalc.create_decorated_parser()
+parser.parse(STDIN)

data/examples/sample_calc/{calc_prec.nvaction.dr → calc_prec.action.dr}

@@ -1,31 +1,31 @@
-%class TinyCalc
-%extend Lexer ('plugins/lex.rb')
-%extend NVAction ('plugins/nvaction.rb')
-%decorate @NVAction
-#%decorate ShiftReducePrinter ('plugins/srp.rb')
-%prec{
-  left '*' '/'
-  left '+' '-'
-%}
-%%
-
-%LEX{
-  /\s+/, /\#.*/ { }
-  /[1-9][0-9]*/ { yield token(:NUM, $&.to_i) }
-  /./           { yield token($&, $&) }
-%}
-
-#begin-rule
-  expr : 
-      expr-left '+' expr-right { _left + _right }
-    | expr-left '-' expr-right { _left - _right }
-    | expr-left '*' expr-right { _left * _right }
-    | expr-left '/' expr-right { _left / _right }
-    | '(' expr ')'  { _expr }
-    | NUM           { _NUM.value }
-  ;
-#end-rule
-%%
-parser = createDecoratedTinyCalc
-r, = parser.parse(STDIN)
-puts r
+%class TinyCalc::Parser
+%extend Depager::Lexer ('plugins/lex.rb')
+%extend Depager::Action ('plugins/action.rb')
+%decorate @Action
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%prec{
+  left '*' '/'
+  left '+' '-'
+%}
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield token(:NUM, $&.to_i) }
+  /./           { yield token($&, $&) }
+%}
+
+#begin-rule
+  expr : 
+      expr-left '+' expr-right { _left + _right }
+    | expr-left '-' expr-right { _left - _right }
+    | expr-left '*' expr-right { _left * _right }
+    | expr-left '/' expr-right { _left / _right }
+    | '(' expr ')'  { _expr }
+    | NUM           { _NUM.value }
+  ;
+#end-rule
+%%
+parser = TinyCalc.create_decorated_parser
+r, = parser.parse(STDIN)
+puts r

data/examples/slex_test/divreg.slex.dr

@@ -1,29 +1,29 @@
-%class StatefulLexerTest1
-%extend StatefulLexer ('plugins/slex.rb')
-%extend NVAction ('plugins/nvaction.rb')
-%decorate @NVAction
-%decorate @StatefulLexer
-#%decorate ShiftReducePrinter ('plugins/srp.rb')
-%%
-%LEX{
-  <START>
-  /\s+/                   { }
-  /\/(([^\/\\]+|\\.)*)\// { yield token(:REGEXP, $&) }
-  /./                     { yield token($&, $&) }
-  <OPMODE : START>
-  '/'                     { yield token($&, $&) }
-%}
-
-#begin-rule
-  expr:
-      expr '/' [>:START ?] fact
-    | fact
-  ;
-  fact:
-      REGEXP [>:OPMODE ?]
-       { warn "REGEXP: #{_REGEXP.value}" }
-  ;
-#end-rule
-%%
-p = createDecoratedStatefulLexerTest1
-p.parse(STDIN)
+%class StatefulLexerTest1::Parser
+%extend Depager::StatefulLexer ('plugins/slex.rb')
+%extend Depager::Action ('plugins/action.rb')
+%decorate @Action
+%decorate @StatefulLexer
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%%
+%LEX{
+  <START>
+  /\s+/                   { }
+  /\/(([^\/\\]+|\\.)*)\// { yield token(:REGEXP, $&) }
+  /./                     { yield token($&, $&) }
+  <OPMODE : START>
+  '/'                     { yield token($&, $&) }
+%}
+
+#begin-rule
+  expr:
+      expr '/' [>:START ?] fact
+    | fact
+  ;
+  fact:
+      REGEXP [>:OPMODE ?]
+       { warn "REGEXP: #{_REGEXP.value}" }
+  ;
+#end-rule
+%%
+p = StatefulLexerTest1.create_decorated_parser
+p.parse(STDIN)

data/examples/slex_test/ljoin.slex.dr

@@ -1,36 +1,36 @@
-%class StatefulLexerTest2
-%extend StatefulLexer ('plugins/slex.rb')
-%extend NVAction ('plugins/nvaction.rb')
-%decorate @NVAction
-%decorate @StatefulLexer
-#%decorate ShiftReducePrinter ('plugins/srp.rb')
-%%
-%LEX{
-  <START>
-  /[ \t]+/ { }
-  /\n/     { yield token(:EOL, $&) }
-  /\w+/    { yield token(:ID,  $&) }
-  /./      { yield token($&,   $&) }
-  <LCONT : START>
-  /\r?\n/  { }
-%}
-
-#begin-rule
-  stmts:
-    | stmts expr EOL
-      { warn "#{_expr} <EOL>:#{@lexstate}" }
-  ;
-  expr:
-      expr '+' [>:LCONT] fact
-      { "#{_expr} + #{_fact}" }
-    | fact
-      { _fact }
-  ;
-  fact:
-      ID  [>:START]
-      { _ID.value }
-  ;
-#end-rule
-%%
-p = createDecoratedStatefulLexerTest2
-p.parse(STDIN)
+%class StatefulLexerTest2::Parser
+%extend Depager::StatefulLexer ('plugins/slex.rb')
+%extend Depager::Action ('plugins/action.rb')
+%decorate @Action
+%decorate @StatefulLexer
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%%
+%LEX{
+  <START>
+  /[ \t]+/ { }
+  /\r?\n/  { yield token(:EOL, $&) }
+  /\w+/    { yield token(:ID,  $&) }
+  /./      { yield token($&,   $&) }
+  <LCONT : START>
+  /\r?\n/  { }
+%}
+
+#begin-rule
+  stmts:
+    | stmts expr EOL
+      { warn "#{_expr} <EOL>:#{@lexstate}" }
+  ;
+  expr:
+      expr '+' [>:LCONT] fact
+      { "#{_expr} + #{_fact}" }
+    | fact
+      { _fact }
+  ;
+  fact:
+      ID  [>:START]
+      { _ID.value }
+  ;
+#end-rule
+%%
+p = StatefulLexerTest2.create_decorated_parser
+p.parse(STDIN)

data/examples/slex_test/test.divreg

@@ -1 +1 @@
-/aaa/ / /bbb/
+/aaa/ / /bbb/

data/examples/slex_test/test.ljoin

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

data/lib/depager.rb

@@ -1,670 +1,582 @@
-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
+# -*- coding: utf-8 -*-
+require 'erb'
+require "depager/parser.rb"
+require "depager/grammar.rb"
+require "depager/utils.rb"
+
+module Depager
+  def self.configuration
+    @flags ||= {}
+  end
+
+  def self.debug_mode? flag = ''
+    value = configuration[:debug] or return false
+    !! value.match(/#{flag.to_s}/)
+  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 line = 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.rb'
+            generator_class = LALR::ParserGenerator
+          end
+
+          if @target_name.match('(.+)::([^:]+)')
+            @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.rb'
+
+          @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 = [
+      :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:
+
+    attr_accessor :rules, :terms, :nonterms, :precs, :table
+    attr_accessor :lhs, :rhs, :nrhs, :rhs_names, :nrules
+    attr_accessor :line, :original_line, :old_line, :token
+    attr_accessor :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_paser(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
+      get_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
+      return isym
+    end
+
+    def add_rule lhs, rhs, prec = nil, rhs_names = nil
+      @lhs_syms[lhs] = true
+      rule = @parsing_method::Rule[lhs, rhs, prec, rhs_names]
+      @rules.push rule
+      return 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
+        @rhs_syms[token_value] = true
+      else
+        @rhs.insert(pos, token_value)
+        @rhs_names.insert(pos, token_name)
+        @rhs_syms[token_value] = true
+      end
+    end
+
+    private
+    def parse_grammar
+      get_token
+      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
+
+        get_token
+        do_hook :post_lhs
+
+        unless  @token.tag == ':'
+          error_exit "syntax error(grammar). unexpected '#{@token.tag}' expecting ':'"
+        end
+        get_token
+
+        @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
+        get_token
+      end
+    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
+
+      if @token.tag == '|'
+        get_token
+        parse_rhslist
+      end
+    end
+
+    def parse_syms
+      if @token.tag == :NT || @token.tag == :T
+        insert_sym_to_rhs(-1, @token.value, @token.name)
+        get_token
+
+        do_hook :post_symbol
+        parse_syms
+      end
+    end
+
+    def make_token tag, value, name = nil
+      @token = Token.new(tag, value, name, file.lineno)
+    end
+
+    def get_token
+      while !@line.empty? || !file.eof?
+        @original_line = @old_line = @line = file.gets if @line.empty?
+
+        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 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
+      return make_token(nil, nil)
+    end
+
+    def extend_paser extensions, options
+      init_hook
+      @extensions = []
+      extensions.each do |f, m|
+        if f && 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] and options[m].each do |k, v|
+          begin
+            e.send("#{k}=", v)
+          rescue NoMethodError
+            warning "no such a option '#{m}.#{k}'."
+          end
+        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 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 '#{@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.inject({}){|r, i| r[i] = []; r }
+    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', __FILE__)
+
+    attr_reader   :d_parser, :g_parser, :parsing_method
+    attr_accessor :outer_code, :inner_code
+    attr_accessor :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   = ''
+      @precs        = []
+      @mixins       = []
+    end
+
+    def generate_code template
+      ERB.new(template || '', nil, '-').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
+      return precs
+    end
+
+    def parse_block raw = false
+      lineno, val = self.file.lineno, ''
+      until file.eof?
+        line = file.gets
+        break if line =~ /^%\}/
+        val.concat line
+      end
+      return val if raw
+
+      delimiter = Depager.configuration[:expanded_code_delimiter] ||
+        ".,.,#{Time.now.to_i}#{rand(0xffff)}.,.,"
+      return "module_eval <<'#{delimiter}', '#{file.path}', #{lineno + 1}\n" <<
+        "#{val.gsub('\\', '\\\\')}\n" <<
+        "#{delimiter}\n"
+    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
+      else
+        warning "syntax error(declaration).\n> #{line}"
+      end
+    end
+  end
+
+  class ParserGenerator < Generator
+    def initialize d_parser
+      super
+    end
+
+    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(true)
+          return generate_code parser_code_template
+        else
+          parse_common(line)
+        end
+      end
+      return 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 /^%hook\s+([\w \t]+?)(\/((?:[^\/\\]+|\\.)+)\/(\s+skip)?)?\s*$/
+          hooks = $1.split(' ')
+          @banner = hooks.join(',')
+          @do_parse_re   = $3
+          @do_parse_skip = $4
+
+          target_name = "#{d_parser.target_namespace}::Slave_#{ hooks.join('__') }::Parser"
+          hooks.each do |i| i = i.to_sym
+            error_exit "Unknown hook: #{i}" unless g_parser.hook_name? i
+            @slaves[i] = target_name
+          end
+          @outer_code << parse_hook(target_name)
+        when /^%%\s*$/
+          @outer_code << parse_block(true)
+        else
+          parse_common(line)
+        end
+      end
+      return 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
+
+      self.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
+
+class String
+  def unindent
+    indent = match(/\n(\s+)/) ? $1 : ''
+    gsub(/^#{indent}/m, '')
+  end
+end