depager 0.1.9

data/data/depager/sample/sample_calc/calc.astl.action.dr

@@ -0,0 +1,66 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend ASTBuilderLazy ('depager/astl.rb')
+%extend Action ('depager/action.rb')
+%decorate @ASTBuilderLazy
+%decorate @Action
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%mixin Depager
+%%
+
+%LEX{
+  /\s+/, /\#.*/, /\n/  { }
+  /[1-9][0-9]*/        { yield _Token(:NUM, $&.to_i) }
+  /./                  { yield _Token($&, $&) }
+%}
+
+%AST{
+  Node [value]     { @value = nil }
+  Visitor          { }
+  add(left, right) { ~value = visit(~left).value + visit(~right).value }
+  sub(left, right) { ~value = visit(~left).value - visit(~right).value }
+  mul(left, right) { ~value = visit(~left).value * visit(~right).value }
+  div(left, right) { ~value = visit(~left).value / visit(~right).value }
+  literal(-n)      { ~value = ~n.value }
+%}
+
+#begin-rule
+  expr :
+      expr '+' term
+      => add(expr, term)
+      { val[0] + val[2] }
+    | expr '-' term
+      => sub(expr, term)
+      { val[0] - val[2] }
+    | term
+      => term
+      { val[0] }
+  ;
+  term :
+      term '*' fact
+      => mul(term, fact)
+      { val[0] * val[2] }
+    | term '/' fact
+      => div(term, fact)
+      { val[0] / val[2] }
+    | fact
+      => fact
+      { val[0] }
+  ;
+  fact :
+      NUM
+      => literal(NUM)
+      { val[0].value }
+    | '(' expr ')'
+      => expr
+      { val[1].value }
+  ;
+#end-rule
+%%
+require 'pp'
+parser = createDecoratedTinyCalc()
+t, r = parser.yyparse(STDIN)
+v = Visitor.new
+pp r
+pp t.accept(v).value
+pp t

data/data/depager/sample/sample_calc/calc.astl.dr

@@ -0,0 +1,55 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend ASTBuilderLazy ('depager/astl.rb')
+%decorate @ASTBuilderLazy
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield _Token(:NUM, $&.to_i) }
+  /./           { yield _Token($&, $&) }
+%}
+
+%AST{
+  Node [value]     { @value = nil }
+  Visitor          { }
+  add(left, right) { ~value = visit(~left).value + visit(~right).value }
+  sub(left, right) { ~value = visit(~left).value - visit(~right).value }
+  mul(left, right) { ~value = visit(~left).value * visit(~right).value }
+  div(left, right) { ~value = visit(~left).value / visit(~right).value }
+  literal(-n)      { ~value = ~n.value }
+%}
+
+#begin-rule
+  expr :
+      expr '+' term
+      => add(expr, term)
+    | expr '-' term
+      => sub(expr, term)
+    | term
+      => term
+  ;
+  term :
+      term '*' fact
+      => mul(term, fact)
+    | term '/' fact
+      => div(term, fact)
+    | fact
+      => fact
+  ;
+  fact :
+      NUM
+      => literal(NUM)
+    | '(' expr ')'
+      => expr
+  ;
+#end-rule
+%%
+require 'pp'
+parser = createDecoratedTinyCalc()
+t, = parser.yyparse(STDIN)
+v = Visitor.new
+pp t.accept(v).value
+pp t
+

data/data/depager/sample/sample_calc/calc.atree.dr

@@ -0,0 +1,43 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend ATreeBuilder ('depager/atree.rb')
+%decorate @ATreeBuilder
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%mixin Depager
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield _Token(:NUM, $&.to_i) }
+  /./           { yield _Token($&, $&) }
+%}
+
+#begin-rule
+   expr :
+      expr '+' term
+      => add(expr, term)
+    | expr '-' term
+      => sub(expr, term)
+    | term
+      => term
+  ;
+  term :
+      term '*' fact
+      => mul(term, fact)
+    | term '/' fact
+      => div(term, fact)
+    | fact
+      => fact
+  ;
+  fact :
+      NUM
+      => literal(NUM)
+    | '(' expr ')'
+      => expr
+  ;
+#end-rule
+%%
+require 'pp'
+parser = createDecoratedTinyCalc
+r, = parser.yyparse(STDIN)
+pp r

data/data/depager/sample/sample_calc/calc.cst.dr

@@ -0,0 +1,45 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend CSTBuilder ('depager/cst.rb')
+%decorate @CSTBuilder
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield _Token(:NUM, $&.to_i) }
+  /./           { yield _Token($&, $&) }
+%}
+
+%CST{
+  Node {
+    attr_accessor :value
+    def initialize
+      @value = nil
+    end
+  }
+%}
+
+#begin-rule
+  expr :
+      expr '+' term { ~value = ~expr.value + ~term.value }
+    | expr '-' term { ~value = ~expr.value + ~term.value }
+    | term          { ~value = ~term.value }
+  ;
+  term :
+      term '*' fact { ~value = ~term.value * ~fact.value }
+    | term '/' fact { ~value = ~term.value / ~fact.value }
+    | fact          { ~value = ~fact.value }
+  ;
+  fact :
+      NUM           { ~value = ~num.value }
+    | '(' expr ')'  { ~value = ~expr }
+  ;
+#end-rule
+%%
+require 'pp'
+parser = createDecoratedTinyCalc
+r, = parser.yyparse(STDIN)
+v = Visitor.new
+r.accept(v)
+pp r
+puts r.value

data/data/depager/sample/sample_calc/calc.dr

@@ -0,0 +1,43 @@
+%class TinyCalc
+%inner{
+  def lex
+    until @file.eof?
+      @line = @file.gets
+      until @line.empty? do
+        case @line
+        when /\A\s+/, /\A\#.*/, /\A\n/
+          #skip blank and comment
+        when /\A[0-9]+/
+          yield :NUM, $&
+        when /\A./
+          yield $&, $&
+        else
+          raise RuntimeError, "must not happen #{line}"
+        end
+        @line = $'
+      end
+    end
+    yield nil, nil
+  end
+%}
+%%
+
+#begin-rule
+  expr :
+      expr '+' term
+    | expr '-' term
+    | term
+  ;
+  term :
+      term '*' fact
+    | term '/' fact
+    | fact
+  ;
+  fact :
+      NUM
+    | '(' expr ')'
+  ;
+#end-rule
+%%
+parser = TinyCalc.new()
+parser.yyparse(STDIN)

data/data/depager/sample/sample_calc/calc.lex.dr

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

data/data/depager/sample/sample_calc/calc.nvaction.dr

@@ -0,0 +1,33 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend NVAction ('depager/nvaction.rb')
+%decorate @NVAction
+#%decorate ShiftReducePrinter ('depager/srp.rb')   
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield _Token(:NUM, $&.to_i) }
+  /./           { yield _Token($&, $&) }
+%}
+
+#begin-rule
+  expr :
+      expr '+' term { _expr + _term }
+    | expr '-' term { _expr - _term }
+    | term          { _term }
+  ;
+  term :
+      term '*' fact { _term * _fact }
+    | term '/' fact { _term / _fact }
+    | fact          { _fact }
+  ;
+  fact :
+      NUM           { _NUM.value }
+    | '(' expr ')'  { _expr }
+  ;
+#end-rule
+%%
+parser = createDecoratedTinyCalc
+r, = parser.yyparse(STDIN)
+puts r

data/data/depager/sample/sample_calc/calc_prec.nvaction.dr

@@ -0,0 +1,31 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend NVAction ('depager/nvaction.rb')
+%decorate @NVAction
+#%decorate ShiftReducePrinter ('depager/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.yyparse(STDIN)
+puts r

data/data/depager/sample/slex_test/slextest1.dr

@@ -0,0 +1,37 @@
+%class StatefulLexerTest1
+%extend StatefulLexer ('depager/slex.rb')
+%extend NVAction ('depager/nvaction.rb')
+%decorate @NVAction
+%decorate @StatefulLexer
+#%decorate ShiftReducePrinter ('depager/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
+%%
+=begin
+  stmt:
+      TYPEDEF [>:TNMODE] TYPENAME ';' [>:START] 
+       { warn 'TYPEDEF:'+val[2] }
+    | ID ';'
+       { warn 'ID:'+val[0] }
+  ;
+=end
+p = createDecoratedStatefulLexerTest1
+p.yyparse(STDIN)

data/data/depager/sample/slex_test/slextest2.dr

@@ -0,0 +1,33 @@
+%class StatefulLexerTest2
+%extend StatefulLexer ('depager/slex.rb')
+%extend Action ('depager/action.rb')
+%decorate @Action
+%decorate @StatefulLexer
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%%
+%LEX{
+  <START>
+  /[ \t]+/ { }
+  /\n/     { yield :EOL, $& }
+  /\w+/    { yield :ID, $& }
+  /./      { yield $&, $& }
+  <LCONT : START>
+  /\r?\n/     { }
+%}
+
+#begin-rule
+  stmts:
+    | stmts expr EOL
+      { warn "<EOL>:#{@lexstate}" }
+  ;
+  expr:
+      expr '+' [>:LCONT] fact
+    | fact
+  ;
+  fact:
+      ID  [>:START]
+  ;
+#end-rule
+%%
+p = createDecoratedStatefulLexerTest2
+p.yyparse(STDIN)

data/lib/depager.rb

@@ -0,0 +1,608 @@
+require 'erb'
+require "depager/lr.rb"
+require "depager/parser.rb"
+require "depager/utils.rb"
+
+module Depager
+  Tmpldir = "#{File.dirname(__FILE__)}/depager/template"
+  #
+  # file manager 
+  #
+  class FileManager
+    def initialize f=nil
+      @file = f
+    end
+    def file= f
+      @file = f
+    end
+    def eof?
+      @file.eof?
+    end
+    # get file name
+    def fname
+      File.basename @file.path
+    end
+    # get file path
+    def path
+      @file.path
+    end
+    # get current line no
+    def lineno
+      @file.lineno
+    end
+
+    # get next line
+    def getline
+      @file.gets
+    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*::\s*(\S+)\s*$/
+          @target_name = $1
+          @generator = Object.const_get("#{$2}Generator").new(self)
+          break
+        when /^%class\s*(.*?)\s*$/
+          @target_name = $1
+          @generator = SingleLALRParserGenerator.new(self)
+          break
+        when /^%defext\s*(.*?)\s*$/
+          @target_name = $1
+          @generator = ExtensionLALRParserGenerator.new(self)
+          break
+        else
+          error_exit "%class not found."
+        end
+      end
+      @generator.parse_decl
+    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
+    def files
+      @d_parser.files
+    end
+    alias file files
+    alias f files
+
+    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
+      preRuleList
+      parse_rulelist
+      postRuleList
+      unless @token.tag == nil
+        error_exit "syntax error(grammar). "<<
+          "unexpected '#{@token.tag}' expect '%%'"
+      end
+    end
+    def parse_rulelist
+      preRule
+      parse_rule
+      postRule
+      if @token.tag == :NT
+        parse_rulelist
+      end
+    end
+    def parse_rule
+      if @token[0] == :NT
+        @r = @token.value
+        gettoken
+        postLhs
+
+        unless  @token.tag == ':'
+          error_exit "syntax error(grammar). "<<
+            "unexpected '#{@token.tag}' expecting ':'"
+        end
+        gettoken
+
+        @nrhs = 0
+        preRhsList
+        parse_rhslist
+        postRhsList
+
+        unless @token.tag == ';'
+          error_exit "syntax error(grammar). " <<
+            "unexpected '#{@token[0]}' expecting ';'"
+        end
+        gettoken
+      end
+    end
+    def parse_rhslist
+      @rhs = []; @rhsni = {}; @prec = nil
+      @optval = Array.new(@nparam)
+      preRhs
+      parse_syms
+      @g.push Rule[@r, @rhs, @prec]
+      postRhs
+      @nrhs += 1
+
+      if @token.tag == '|'
+        gettoken
+        parse_rhslist
+      end
+    end
+    def parse_syms
+      if @token.tag == :NT || @token.tag == :T
+        @rhs.push @token.value
+        @rhsni[@token.name] = @rhs.size - 1
+
+        gettoken
+
+        postSymbol
+        parse_syms
+      end
+    end
+
+    public
+    def gettoken
+      while !@line.empty? || !eof?
+        getline if @line.empty?
+        @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
+            raise RuntimeError, "must not happen #{line}"
+          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 preRuleList
+      @prerulelist.each{|o, m| o.send m}
+    end
+    def postRuleList
+      @postrulelist.each{|o, m| o.send m}
+    end
+    def preRule
+      @prerule.each{|o, m| o.send m}
+    end
+    def postRule
+      @postrule.each{|o, m| o.send m}
+    end
+    def postLhs
+      @postlhs.each{|o, m| o.send(m)}
+    end
+    def preRhsList
+      @prerhslist.each{|o, m| o.send m}
+    end
+    def postRhsList
+      @postrhslist.each{|o, m| o.send m}
+    end
+    def preRhs
+      @prerhs.each{|o, m| o.send(m)}
+    end
+    def postRhs
+      @postrhs.each{|o, m| o.send(m)}
+    end
+    def postSymbol
+      @postsymbol.each{|o, m| o.send(m)}
+    end
+
+    public
+    # 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
+      isym = @nonterms[sym] = @nonterms.size
+      @i2s[isym] = sym
+      return isym
+    end
+
+    # get rhs index by name
+    # name :: name
+    def name_to_rhs_index name
+      @rhsni[name]
+    end
+    alias n2ri name_to_rhs_index
+
+    # lhs value
+    def lhs
+      @r
+    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 :prerulelist, :postrulelist, :prerule, :postrule
+    attr_accessor :postlhs, :prerhslist, :postrhslist
+    attr_accessor :prerhs, :postrhs, :postsymbol
+    attr_reader   :d_parser, :target_name, :table
+
+    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
+    # make grammar object
+    # precs:: prec infos
+    def make_grammar precs
+      ts = @nonterms.size - 1
+      @terms.each{|k,v| @terms[k] = ts - v}
+      @g[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
+      @g.each do |rl|
+        rl.r.each_with_index{|i, x| rl.r[x] = ts - i if i < 0}
+        rl.prec &&= @precs[@terms[rl.prec]]
+      end
+    end
+    alias mkg make_grammar
+
+    # initialize hook
+    def init_hook
+      @prerulelist = []
+      @postrulelist = []
+
+      @prerule = []
+      @postrule = []
+
+      @postlhs = []
+
+      @postrhslist = []
+      @prerhslist = []
+
+      @prerhs = []
+      @postrhs = []
+
+      @postsymbol = []
+    end
+
+    public
+    # extend paser
+    # ext:: extension name
+    def extend_paser ext
+      init_hook
+      ext.each do |f,m|
+        require f if f
+        Object.const_get("#{m}Extension").new.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 = [])
+      @line = @line0 = ''
+      @oldline = nil
+      @target_name = target_name
+      @mixin = mixin
+
+      parse_grammar
+      make_grammar precs
+      @table = LALRTable.new(G.new(@g, @terms, @nonterms, @precs))
+    end
+  end
+
+  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
+    attr_accessor :optouter, :optinner, :optmain
+    attr_accessor :basis_name, :deco, :req
+    def initialize d_parser
+      @d_parser = d_parser
+      @basis_name = nil
+
+      @deco = []
+      @req = []
+      @ext = []
+
+      @optinner = []
+      @optouter = []
+      @optmain = []
+      @precs = []
+      @mixin = []
+
+      @tmpldir = Generator::Tmpldir+'/'
+    end
+
+    def parse_prec
+      precs = []
+      until files.eof?
+        case line = files.getline
+        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 /^%extend\s+(.*?)\s*$/
+        # not implemented yet
+        warning "'%extend E' is not implemented yet. " <<
+          "use '%extend Ext (filename)' instead.", lineno
+      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 /^%outer\s*\{\s*$/
+        # obsolete
+        warning "'%optouter' is obsolete."
+        @optouter.push parse_block
+      when /^%main\s*\{\s*$/
+        # obsolete
+        warning "'%optmain' is obsolete."
+        @optmain.push parse_block
+      when /^%prec\s*\{\s*$/
+        @precs = parse_prec
+      else
+        warning "syntax error(declaration).\n> #{line}"
+      end
+    end
+  end
+
+  class SimpleGenerator < Generator
+    Tmplfile = 'simple.erb'
+    def initialize d_parser
+      super
+    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
+  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,
+
+        "prerule" => nil,
+        "postrule" => nil,
+
+        "postlhs" => nil,
+
+        "postrhslist" => nil,
+        "prerhslist" => nil,
+
+        "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)
+        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
+          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("#{tmpldir}/extension_lalr_slave.erb")).result(binding)
+    end
+    def out_master_code
+      ERB.new(File.read("#{tmpldir}/extension_lalr_master.erb")).result(binding)
+    end
+  end
+end