depager 0.2.3 → 0.3.0.b20160729

data/examples/c89/test.c89

@@ -1,10 +1,10 @@
-/*
-  comment
-*/
-int fact(int n)
-{
-    if (n == 1)
-        return 1;
-    else
-        return n * fact(n - 1);
-}
+/*
+  comment
+*/
+int fact(int n)
+{
+    if (n == 1)
+        return 1;
+    else
+        return n * fact(n - 1);
+}

data/examples/extension/astdf.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+require 'plugins/ast.rb'
+
+module Examples ; end
+
+class Examples::ASTBuilderDepthFirstExtension < Depager::ASTBuilderExtension #:nodoc:all
+  def gen_accept_code sym
+    "        @#{sym}.accept(v)\n"
+  end
+end

data/examples/extension/atree.dr

@@ -0,0 +1,55 @@
+%defext Examples::ATreeBuilderExtension
+%extend Depager::Action ('plugins/action.rb')
+%extend Depager::Lexer ('plugins/lex.rb')
+%decorate @Action
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%expanded_code_delimiter DEPAGER_EXPANDED_CODE
+%inner{
+  attr_accessor :action_code, :on_reduce
+  def init_extension
+    @action_code = ''
+    @on_reduce = []
+  end
+  def term_extension
+    g_parser.outer_code <<
+      generate_action_decorator_code(@on_reduce, @action_code)
+  end
+%}
+%hook post_rhs
+%banner '=>...'
+%%
+%LEX{
+  /[ \t]+/                { }
+  /\r?\n/                 { yield nil, nil }
+  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(:ID, $&) }
+  /'(.+)'/                { yield token(:STR, $1) }
+  /::/                    { yield token(:CC, $&) }
+  /=>/                    { yield token(:EG, $&) }
+  /./                     { yield token($&, $&) }
+%}
+
+#begin-rule
+  start:
+      EG ast
+      {
+        n = g_parser.rules.size-1
+        master.action_code <<
+          master.expand_inline_code(_ast, _EG.lineno, :wrap => "def _atree_#{n} val")
+        master.on_reduce[n] = ":_atree_#{n}"
+      }
+  ;
+  ast:
+      ID '(' ')'           { "[:#{_ID.value}]" }
+    | ID '(' fact_list ')' { "[:#{_ID.value}, #{_fact_list.join(',')}]" }
+    | ID                   { "val[#{g_parser.name_to_rhs_index(_ID.value)}]" }
+  ;
+  fact_list:
+      fact                 { [ _fact ] }
+    | fact_list ',' fact   { _fact_list.push _fact }
+  ;
+  fact:
+      ID                   { "val[#{g_parser.name_to_rhs_index(_ID.value)}]" }
+    | STR                  { "'#{_STR.value}'" }
+  ;
+#end-rule
+%%

data/examples/{sample_calc → extension}/calc.atree.dr

@@ -1,43 +1,42 @@
-%class TinyCalc
-%extend Lexer ('plugins/lex.rb')
-%extend ATreeBuilder ('plugins/atree.rb')
-%decorate @ATreeBuilder
-#%decorate ShiftReducePrinter ('plugins/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.parse(STDIN)
-pp r
+%class TinyCalc::Parser
+%extend Depager::Lexer ('plugins/lex.rb')
+%extend Examples::ATreeBuilder ('./atree.rb')
+%decorate @ATreeBuilder
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%%
+
+%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 = TinyCalc.create_decorated_parser()
+t, = parser.parse(STDIN)
+pp t

data/examples/extension/calc.simple_action.dr

@@ -0,0 +1,33 @@
+%class TinyCalc::Parser
+%extend Depager::Lexer ('plugins/lex.rb')
+%extend Examples::SimpleAction ('./simple_action.rb')
+%decorate @SimpleAction
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield token(:NUM, $&.to_i) }
+  /./           { yield token($&, $&) }
+%}
+
+#begin-rule
+  expr :
+      expr '+' term { val[0] + val[2] }
+    | expr '-' term { val[0] - val[2] }
+    | term          { val[0] }
+  ;
+  term :
+      term '*' fact { val[0] * val[2] }
+    | term '/' fact { val[0] / val[2] }
+    | fact          { val[0] }
+  ;
+  fact :
+      NUM           { val[0].value }
+    | '(' expr ')'  { val[1] }
+  ;
+#end-rule
+%%
+parser = TinyCalc.create_decorated_parser
+r, = parser.parse(STDIN)
+puts r

data/examples/extension/paction.dr

@@ -1,15 +1,16 @@
-%defext PseudoActionExtension
-%extend Lexer ('plugins/lex.rb')
-%extend Action ('plugins/action.rb')
-%decorate @Action
-#%decorate ShiftReducePrinter ('plugins/srp.rb')
-%hook postrhs
-%%
-%LEX{
-  /\s/ { }
-  /./  { yield $&, $&, @lineno }
-%}
- start:
-   '{' '}' { warn 'HIT' }
- ;
-%%
+%defext Examples::PseudoActionExtension
+%extend Depager::Lexer ('plugins/lex.rb')
+%extend Depager::Action ('plugins/action.rb')
+%decorate @Action
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%hook post_rhs
+%%
+%LEX{
+  /\s+/ { }
+  /\{/  { yield $&, $&, @lineno }
+  /\}/  { yield $&, $&, @lineno ; yield nil, nil }
+%}
+ start:
+   '{' '}' { warn 'HIT' }
+ ;
+%%

data/examples/extension/pactiontest.dr

@@ -1,14 +1,14 @@
-%class PseudoActionTest
-%extend PseudoAction ('paction.rb')
-%%
-#begin-rule
-  expr:
-      expr '+' fact { }
-  ;
-  fact:
-      ID { }
-  ;
-#end-rule
-%%
-p = PseudoActionTest.new()
-#p.parse(STDIN)
+%class PseudoActionTest::Parser
+%extend Examples::PseudoAction ('./paction.rb')
+%%
+#begin-rule
+  expr:
+      expr '+' fact { }
+  ;
+  fact:
+      ID { }
+  ;
+#end-rule
+%%
+p = PseudoActionTest.new()
+#p.parse(STDIN)

data/examples/extension/simple_action.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+require 'depager/parser.rb'
+
+module Examples ; end
+
+class Examples::SimpleActionExtension < Depager::Extension #:nodoc:all
+  def init_extension
+    @line0 = @line = @oldline = ''
+    @action_code = ''
+    @on_reduce = []
+  end
+
+  def term_extension
+    g_parser.outer_code <<
+      generate_action_decorator_code(@on_reduce, @action_code)
+  end
+
+  def modify_action_code code
+    return code, 0
+  end
+
+  def pre_rule_list
+    if g_parser.original_line =~ /^%ACTION\{\s*$/
+      while line = file.gets
+        break if line =~ /^%\}\s*$/
+        @action_code << line
+      end
+      g_parser.update_context ''
+    end
+  end
+
+  def post_rhs
+    if g_parser.line =~ /\s*\{/
+      @original_line, @line = g_parser.original_line, g_parser.line
+      lineno = g_parser.file.lineno
+      code, d = parse_block, 1
+      n = g_parser.rules.size - 1
+      @action_code <<
+        expand_inline_code(code, lineno, :wrap => "def _act_#{n} val", :delta => d)
+      g_parser.update_context @line
+      @on_reduce[n] = ":_act_#{n}"
+    end
+  end
+end

data/examples/pl0d/pl0ds.dr

@@ -1,334 +1,337 @@
-%class PL0d
-%extend Lexer ('plugins/lex.rb')
-%extend ASTBuilder ('plugins/ast.rb')
-%decorate @ASTBuilder
-#%decorate ShiftReducePrinter ('plugins/srp.rb')
-%%
-%LEX{
-  /\s+/     { }
-  ':='      { yield token(:COLOEQ, $&)    }
-  '<>'      { yield token(:NOTEQ, $&)     }
-  '<='      { yield token(:LE, $&)        }
-  '>='      { yield token(:GE, $&)        }
-  '='       { yield token(:EQ, $&)        }
-  '<'       { yield token(:LT, $&)        }
-  '>'       { yield token(:GT, $&)        }
-  'const'   { yield token(:CONST, $&)     }
-  'var'     { yield token(:VAR, $&)       }
-  'function'{ yield token(:FUNCTION, $&)  }
-  'begin'   { yield token(:BEGINN, $&)    }
-  'end'     { yield token(:END, $&)       }
-  'if'      { yield token(:IF, $&)        }
-  'then'    { yield token(:THEN, $&)      }
-  'while'   { yield token(:WHILE, $&)     }
-  'do'      { yield token(:DO, $&)        }
-  'return'  { yield token(:RETURN, $&)    }
-  'writeln' { yield token(:WRITELN, $&)   }
-  'write'   { yield token(:WRITE, $&)     }
-  'odd'     { yield token(:ODD, $&)       }
-  /[a-zA-Z][a-zA-Z0-9_]*/
-            { yield token(:IDENT, $&)       }
-  /[0-9]+/  { yield token(:NUMBER, $&.to_i) }
-  /./       { yield token($&, $&)           }
-%}
-
-%AST{
-  Node [value] { @value = nil }
-  Visitor
-  {
-    STEntry = Struct.new(:kind, :narg, :value)
-    def initialize
-      @global = {
-        '+'  => STEntry.new(:FUNC, 2, proc{|a| a[0] + a[1] }),
-        '-'  => STEntry.new(:FUNC, 2, proc{|a| a[0] - a[1] }),
-        '*'  => STEntry.new(:FUNC, 2, proc{|a| a[0] * a[1] }),
-        '/'  => STEntry.new(:FUNC, 2, proc{|a| a[0] / a[1] }),
-        '='  => STEntry.new(:FUNC, 2, proc{|a| a[0] == a[1] ? 1 : 0}),
-        '<>' => STEntry.new(:FUNC, 2, proc{|a| a[0] != a[1] ? 1 : 0}),
-        '<'  => STEntry.new(:FUNC, 2, proc{|a| a[0] <  a[1] ? 1 : 0}),
-        '>'  => STEntry.new(:FUNC, 2, proc{|a| a[0] >  a[1] ? 1 : 0}),
-        '<=' => STEntry.new(:FUNC, 2, proc{|a| a[0] <= a[1] ? 1 : 0}),
-        '>=' => STEntry.new(:FUNC, 2, proc{|a| a[0] >= a[1] ? 1 : 0}),
-        'odd'=> STEntry.new(:FUNC, 1, proc{|a| a[0] & 1 }),
-
-        'write'   => STEntry.new(:FUNC, 1, proc{|a| print "#{a[0]} "; 1}),
-        'writeln' => STEntry.new(:FUNC, 0, proc{|a| puts ''; 1}),
-      }
-      @env = [@global]
-    end
-    def lookup name
-      @env.reverse_each{|s| return s[name] if s[name]}
-      return nil
-    end
-    def dump_env n = 2
-      n = @env.size if n > @env.size
-      e = @env[n..-1].map{|i| Hash[* i.map{|k, v| [k, v.value]}.flatten ] }
-      warn e.pretty_inspect
-    end
-  }
-  program(block)
-  {
-    visit($.block)
-  }
-  block(decls, stmt)
-  {
-    @env.push({})
-    visit($.decls)
-    visit($.stmt)
-    @env.pop
-  }
-  var_decl(-idents)
-  {
-    $.idents.to_a.each do |ident|
-      if @env.last[ident.value]
-        warn "'#{ident.value}' already exist."; exit
-      else
-        @env.last[ident.value] = STEntry.new(:VAR, 0, 0)
-      end
-    end
-  }
-  const_decl(const_inits)
-  {
-    visit($.const_inits)
-  }
-  const_init(-ident, -number)
-  {
-    if @env.last[$.ident.value]
-      warn "'#{$.ident.value}' already exist."; exit
-    else
-      @env.last[$.ident.value] = STEntry.new(:CONST, 0, $.number.value)
-    end
-  }
-  func_decl(-ident, -params, -block)
-  {
-    if @env[0][$.ident.value]
-      warn "'#{$.ident.value}' already exist."; exit
-    end
-    body = proc do |args|
-      value = 0
-      n = @env.size
-      @env.push({})
-      value = catch(:return) do
-        @env.last['return'] = STEntry.new(:VAR, 0, :return)
-        $.params.to_a.each_with_index do |a, x|
-          @env.last[a.value] = STEntry.new(:VAR, 0, args[x])
-        end
-        visit($.block)
-      end
-      @env = @env[0, n]
-      value
-    end
-    @env.last[$.ident.value] = STEntry.new(:FUNC, $.params.size, body)
-  }
-  nop_stmt(-nop)
-  {
-  }
-  assign_stmt(-ident, expr)
-  {
-    if ent = lookup($.ident.value)
-      unless ent.kind == :VAR
-        warn "'#{$.ident.value}' not var."; exit
-      end
-      ent.value = visit($.expr).value
-    else
-      warn @env.pretty_inspect
-      warn "'#{$.ident.value}' not found."; exit
-    end
-  }
-  begin_stmt(stmt, stmts)
-  {
-    visit($.stmt)
-    visit($.stmts)
-  }
-  if_stmt(cond, stmt)
-  {
-    if visit($.cond).value != 0
-      visit($.stmt)
-    end
-  }
-  while_stmt(cond, stmt)
-  {
-    while visit($.cond).value != 0
-      visit($.stmt)
-    end
-  }
-  return_stmt(expr)
-  {
-    ent = nil
-    @env.reverse_each{|s| break if ent = s['return'] }
-    unless ent
-      warn "'return' not in func."; exit
-    end
-    throw :return, visit($.expr).value
-  }
-  apply(-ident, -args)
-  {
-    ent = nil
-    @env.reverse_each{|s| break if ent = s[$.ident.value] }
-    unless ent
-      warn "'#{$.ident.value}' not found."; exit
-    end
-    unless ent.kind == :FUNC
-      warn "'#{$.ident.value}' not func."; exit
-    end
-
-    args = $.args.to_a.map{|a| visit(a).value } 
-    # warn "#{'  '*(@env.size-2)}|#{$.ident.value} : #{args.inspect}"
-    unless ent.narg == args.size
-      warn "#{ent.narg} #{args.size} #{args.inspect}"
-      warn "'#{$.ident.value}' unmatch args."; exit
-    end
-    $.value = ent.value.call(args)
-    # warn "#{'  '*(@env.size-2)}|-> #{$.value} @ #{$.ident.value}"
-  }
-  refv(-ident)
-  {
-    unless ent = lookup($.ident.value)
-      warn "'#{$.ident.value}' not found."; exit
-    end
-    if ent.kind == :VAR || ent.kind == :CONST
-      $.value = ent.value
-    else
-      warn "'#{$.ident.value}' not var."; exit
-    end
-  }
-  number(-n)
-  {
-    $.value = $.n.value
-  }
-%}
-#begin-rule
-  program:
-      block '.'
-      => program(block)
-  ;
-
-  block:
-      opt_decl_list statement
-      => block(opt_decl_list, statement)
-  ;
-
-  opt_decl_list:
-      => []
-    | opt_decl_list decl
-      => opt_decl_list << decl
-  ;
-
-  decl:
-      CONST const_init_list ';'
-      => const_decl(const_init_list)
-    | VAR ident_list ';'
-      => var_decl(ident_list)
-    | FUNCTION IDENT '(' ')' block ';'
-      => func_decl(IDENT, [], block)
-    | FUNCTION IDENT '(' ident_list ')' block ';'
-      => func_decl(IDENT, ident_list, block)
-  ;
-
-  const_init_list:
-      const_init
-      => [ const_init ]
-    | const_init_list ',' const_init
-      => const_init_list << const_init
-  ;
-
-  const_init:
-      IDENT EQ NUMBER
-      => const_init(IDENT, NUMBER)    
-  ;
-
-  ident_list: 
-      IDENT
-      => [ IDENT ]
-    | ident_list ',' IDENT
-      => ident_list << IDENT
-  ;
-
-  statement:
-      => nop_stmt([])
-    | IDENT COLOEQ expression
-      => assign_stmt(IDENT, expression)
-    | BEGINN statement opt_state_list END
-      => begin_stmt(statement, opt_state_list)
-    | IF condition THEN statement
-      => if_stmt(condition, statement)
-    | WHILE condition DO statement
-      => while_stmt(condition, statement)
-    | RETURN expression
-      => return_stmt(expression)
-    | WRITE expression
-      => apply('write', [expression])
-    | WRITELN
-      => apply('writeln', [])
-  ;
-
-  opt_state_list:
-      => []
-    | opt_state_list ';' statement
-      => opt_state_list << statement
-  ;
-
-  condition:
-      ODD expression
-      => apply('odd', [expression])
-    | expression-e0 EQ expression-e1
-      => apply('=', [e0, e1])
-    | expression-e0 NOTEQ expression-e1
-      => apply('<>', [e0, e1])
-    | expression-e0 LT expression-e1
-      => apply('<', [e0, e1])
-    | expression-e0 GT expression-e1
-      => apply('>', [e0, e1])
-    | expression-e0 LE expression-e1
-      => apply('<=', [e0, e1])
-    | expression-e0 GE expression-e1
-      => apply('>=', [e0, e1])
-  ;
-
-  expression:
-      expression '+' term
-      => apply('+', [expression, term])
-    | expression '-' term
-      => apply('-', [expression, term])
-    | term
-      => term
-    | '-' term
-      => apply('UMINUS', [term])
-  ;
-
-  term:
-      term '*' factor
-      => apply('*', [term, factor])
-    | term '/' factor
-      => apply('/', [term, factor])
-    | factor
-      => factor
-  ;
-
-  factor:
-      IDENT
-      => refv(IDENT)
-    | NUMBER
-      => number(NUMBER)
-    | IDENT '(' ')'
-      => apply(IDENT, [])
-    | IDENT '(' exp_list ')'
-      => apply(IDENT, exp_list)
-    | '(' expression ')'
-      => expression
-  ;
-
-  exp_list: 
-      expression
-      => [ expression ]
-    | exp_list ',' expression
-      => exp_list << expression
-  ;
-#end-rule
-%%
-require 'pp'
-psr = createDecoratedPL0d
-t, = psr.parse(STDIN)
-# pp t
-v = Visitor.new
-t.accept(v)
+%class PL0d::Parser
+%extend Depager::Lexer ('plugins/lex.rb')
+%extend Depager::ASTBuilder ('plugins/ast.rb')
+%decorate @ASTBuilder
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%inner{
+  KEYWORDS = {
+    'const'    => :CONST,
+    'var'      => :VAR,
+    'function' => :FUNCTION,
+    'begin'    => :BEGINN,
+    'end'      => :END,
+    'if'       => :IF,
+    'then'     => :THEN,
+    'while'    => :WHILE,
+    'do'       => :DO,
+    'return'   => :RETURN,
+    'writeln'  => :WRITELN,
+    'write'    => :WRITE,
+    'odd'      => :ODD,
+  }
+%}
+%%
+%LEX{
+  /\s+/                   { }
+  ':='                    { yield token(:COLOEQ, $&) }
+  '<>'                    { yield token(:NOTEQ, $&) }
+  '<='                    { yield token(:LE, $&) }
+  '>='                    { yield token(:GE, $&) }
+  '='                     { yield token(:EQ, $&) }
+  '<'                     { yield token(:LT, $&) }
+  '>'                     { yield token(:GT, $&) }
+  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(KEYWORDS[$&] || :IDENT, $&) }
+  /[0-9]+/                { yield token(:NUMBER, $&.to_i) }
+  /./                     { yield token($&, $&)           }
+%}
+
+%AST{
+  Node [value] { @value = nil }
+  Visitor
+  {
+    STEntry = Struct.new(:kind, :narg, :value)
+    def initialize
+      @global = {
+        '+'  => STEntry.new(:FUNC, 2, proc{|a| a[0] + a[1] }),
+        '-'  => STEntry.new(:FUNC, 2, proc{|a| a[0] - a[1] }),
+        '*'  => STEntry.new(:FUNC, 2, proc{|a| a[0] * a[1] }),
+        '/'  => STEntry.new(:FUNC, 2, proc{|a| a[0] / a[1] }),
+        '='  => STEntry.new(:FUNC, 2, proc{|a| a[0] == a[1] ? 1 : 0}),
+        '<>' => STEntry.new(:FUNC, 2, proc{|a| a[0] != a[1] ? 1 : 0}),
+        '<'  => STEntry.new(:FUNC, 2, proc{|a| a[0] <  a[1] ? 1 : 0}),
+        '>'  => STEntry.new(:FUNC, 2, proc{|a| a[0] >  a[1] ? 1 : 0}),
+        '<=' => STEntry.new(:FUNC, 2, proc{|a| a[0] <= a[1] ? 1 : 0}),
+        '>=' => STEntry.new(:FUNC, 2, proc{|a| a[0] >= a[1] ? 1 : 0}),
+        'odd'=> STEntry.new(:FUNC, 1, proc{|a| a[0] & 1 }),
+
+        'write'   => STEntry.new(:FUNC, 1, proc{|a| print "#{a[0]} "; 1}),
+        'writeln' => STEntry.new(:FUNC, 0, proc{|a| puts ''; 1}),
+      }
+      @env = [@global]
+    end
+    def lookup name
+      @env.reverse_each{|s| return s[name] if s[name]}
+      return nil
+    end
+    def dump_env n = 2
+      n = @env.size if n > @env.size
+      e = @env[n..-1].map{|i| Hash[* i.map{|k, v| [k, v.value]}.flatten ] }
+      warn e.pretty_inspect
+    end
+  }
+  program(block)
+  {
+    visit($.block)
+  }
+  block(decls, stmt)
+  {
+    @env.push({})
+    visit($.decls)
+    visit($.stmt)
+    @env.pop
+  }
+  var_decl(-idents)
+  {
+    $.idents.to_a.each do |ident|
+      if @env.last[ident.value]
+        warn "'#{ident.value}' already exist."; exit
+      else
+        @env.last[ident.value] = STEntry.new(:VAR, 0, 0)
+      end
+    end
+  }
+  const_decl(const_inits)
+  {
+    visit($.const_inits)
+  }
+  const_init(-ident, -number)
+  {
+    if @env.last[$.ident.value]
+      warn "'#{$.ident.value}' already exist."; exit
+    else
+      @env.last[$.ident.value] = STEntry.new(:CONST, 0, $.number.value)
+    end
+  }
+  func_decl(-ident, -params, -block)
+  {
+    if @env[0][$.ident.value]
+      warn "'#{$.ident.value}' already exist."; exit
+    end
+    body = proc do |args|
+      value = 0
+      n = @env.size
+      @env.push({})
+      value = catch(:return) do
+        @env.last['return'] = STEntry.new(:VAR, 0, :return)
+        $.params.to_a.each_with_index do |a, x|
+          @env.last[a.value] = STEntry.new(:VAR, 0, args[x])
+        end
+        visit($.block)
+      end
+      @env = @env[0, n]
+      value
+    end
+    @env.last[$.ident.value] = STEntry.new(:FUNC, $.params.size, body)
+  }
+  nop_stmt(-nop)
+  {
+  }
+  assign_stmt(-ident, expr)
+  {
+    if ent = lookup($.ident.value)
+      unless ent.kind == :VAR
+        warn "'#{$.ident.value}' not var."; exit
+      end
+      ent.value = visit($.expr).value
+    else
+      warn @env.pretty_inspect
+      warn "'#{$.ident.value}' not found."; exit
+    end
+  }
+  begin_stmt(stmt, stmts)
+  {
+    visit($.stmt)
+    visit($.stmts)
+  }
+  if_stmt(cond, stmt)
+  {
+    if visit($.cond).value != 0
+      visit($.stmt)
+    end
+  }
+  while_stmt(cond, stmt)
+  {
+    while visit($.cond).value != 0
+      visit($.stmt)
+    end
+  }
+  return_stmt(expr)
+  {
+    ent = nil
+    @env.reverse_each{|s| break if ent = s['return'] }
+    unless ent
+      warn "'return' not in func."; exit
+    end
+    throw :return, visit($.expr).value
+  }
+  apply(-ident, -args)
+  {
+    ent = nil
+    @env.reverse_each{|s| break if ent = s[$.ident.value] }
+    unless ent
+      warn "'#{$.ident.value}' not found."; exit
+    end
+    unless ent.kind == :FUNC
+      warn "'#{$.ident.value}' not func."; exit
+    end
+
+    args = $.args.to_a.map{|a| visit(a).value } 
+    # warn "#{'  '*(@env.size-2)}|#{$.ident.value} : #{args.inspect}"
+    unless ent.narg == args.size
+      warn "#{ent.narg} #{args.size} #{args.inspect}"
+      warn "'#{$.ident.value}' unmatch args."; exit
+    end
+    $.value = ent.value.call(args)
+    # warn "#{'  '*(@env.size-2)}|-> #{$.value} @ #{$.ident.value}"
+  }
+  refv(-ident)
+  {
+    unless ent = lookup($.ident.value)
+      warn "'#{$.ident.value}' not found."; exit
+    end
+    if ent.kind == :VAR || ent.kind == :CONST
+      $.value = ent.value
+    else
+      warn "'#{$.ident.value}' not var."; exit
+    end
+  }
+  number(-n)
+  {
+    $.value = $.n.value
+  }
+%}
+#begin-rule
+  program:
+      block '.'
+      => program(block)
+  ;
+
+  block:
+      opt_decl_list statement
+      => block(opt_decl_list, statement)
+  ;
+
+  opt_decl_list:
+      => []
+    | opt_decl_list decl
+      => opt_decl_list << decl
+  ;
+
+  decl:
+      CONST const_init_list ';'
+      => const_decl(const_init_list)
+    | VAR ident_list ';'
+      => var_decl(ident_list)
+    | FUNCTION IDENT '(' ')' block ';'
+      => func_decl(IDENT, [], block)
+    | FUNCTION IDENT '(' ident_list ')' block ';'
+      => func_decl(IDENT, ident_list, block)
+  ;
+
+  const_init_list:
+      const_init
+      => [ const_init ]
+    | const_init_list ',' const_init
+      => const_init_list << const_init
+  ;
+
+  const_init:
+      IDENT EQ NUMBER
+      => const_init(IDENT, NUMBER)    
+  ;
+
+  ident_list: 
+      IDENT
+      => [ IDENT ]
+    | ident_list ',' IDENT
+      => ident_list << IDENT
+  ;
+
+  statement:
+      => nop_stmt([])
+    | IDENT COLOEQ expression
+      => assign_stmt(IDENT, expression)
+    | BEGINN statement opt_state_list END
+      => begin_stmt(statement, opt_state_list)
+    | IF condition THEN statement
+      => if_stmt(condition, statement)
+    | WHILE condition DO statement
+      => while_stmt(condition, statement)
+    | RETURN expression
+      => return_stmt(expression)
+    | WRITE expression
+      => apply('write', [expression])
+    | WRITELN
+      => apply('writeln', [])
+  ;
+
+  opt_state_list:
+      => []
+    | opt_state_list ';' statement
+      => opt_state_list << statement
+  ;
+
+  condition:
+      ODD expression
+      => apply('odd', [expression])
+    | expression-e0 EQ expression-e1
+      => apply('=', [e0, e1])
+    | expression-e0 NOTEQ expression-e1
+      => apply('<>', [e0, e1])
+    | expression-e0 LT expression-e1
+      => apply('<', [e0, e1])
+    | expression-e0 GT expression-e1
+      => apply('>', [e0, e1])
+    | expression-e0 LE expression-e1
+      => apply('<=', [e0, e1])
+    | expression-e0 GE expression-e1
+      => apply('>=', [e0, e1])
+  ;
+
+  expression:
+      expression '+' term
+      => apply('+', [expression, term])
+    | expression '-' term
+      => apply('-', [expression, term])
+    | term
+      => term
+    | '-' term
+      => apply('UMINUS', [term])
+  ;
+
+  term:
+      term '*' factor
+      => apply('*', [term, factor])
+    | term '/' factor
+      => apply('/', [term, factor])
+    | factor
+      => factor
+  ;
+
+  factor:
+      IDENT
+      => refv(IDENT)
+    | NUMBER
+      => number(NUMBER)
+    | IDENT '(' ')'
+      => apply(IDENT, [])
+    | IDENT '(' exp_list ')'
+      => apply(IDENT, exp_list)
+    | '(' expression ')'
+      => expression
+  ;
+
+  exp_list: 
+      expression
+      => [ expression ]
+    | exp_list ',' expression
+      => exp_list << expression
+  ;
+#end-rule
+%%
+require 'pp'
+psr = PL0d.create_decorated_parser
+t, = psr.parse(STDIN)
+# pp t
+v = PL0d::Visitor.new
+t.accept(v)