depager 0.2.3 → 0.3.0.b20160729

data/lib/depager/ruby/plugins/_rie_debug.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+require 'pp'
+class Depager::RieExtension
+  module Nodes
+    def self.defnode name, *args
+      code = ''; args.each_with_index{|a, x|
+        code << "def #{a};@_values[#{x}];end; def #{a}=(v);@_values[#{x}]=v;end;"
+      }; module_eval %{
+        class #{name}; attr_accessor :lineno, :_values; #{code}
+          def self.[] *args    ; self.new *args ; end
+          def initialize n, *as; @lineno, @_values = n, as; end
+          def inspect          ; "<#{name}:\#{@_values.inspect}>"; end
+          def pretty_print q   ; q.group(1, "<#{name}:", ">"){ q.pp @_values }; end
+        end
+      } # end of eval
+    end
+    defnode :N_THREAD,   :targets, :excepts
+    defnode :N_TRANSFER, :targets, :excepts
+    defnode :N_EXCEPT,   :let_or_ids
+    defnode :N_LET,      :atoc, :expr, :state
+    defnode :N_ACTION,   :expr
+    defnode :N_ATOC,     :sym_name, :attr_name, :rx
+
+    class N_ATOC
+      def inspect
+        name = sym_name == '$' ? '$'+$grammar.symname($grammar[rx].lhs) : sym_name
+        "<N_ATOC:#{[name, attr_name, rx].inspect}>"
+      end
+      def pretty_print q
+        name = sym_name == '$' ? '$'+$grammar.symname($grammar[rx].lhs) : sym_name rescue nil
+        q.group(1, "<N_ATOC:", ">"){ q.pp [name, attr_name, rx] }
+      end
+    end
+  end
+end

data/lib/depager/ruby/plugins/action.rb

@@ -1,43 +1,53 @@
-require 'depager/parser.rb'
-
-class ActionExtension #:nodoc:all
-  include Depager::ExtensionUtils
-  def initialize
-    @line0 = @line = @oldline = ''
-    @optouter = []
-    @on_reduce = []
-  end
-  
-  def modify_action_code code
-    return code, 0
-  end
-
-  def pre_rule_list
-    if g_parser.line0 =~ /^%ACTION\{\s*$/
-      while line = getline
-        break if line =~ /^%\}\s*$/
-        @optouter.push line
-      end
-      g_parser.update_context ''
-    end
-  end
-
-  def post_rhs
-    if g_parser.line =~ /\s*\{/
-      @line0, @line = g_parser.line0, g_parser.line
-      lineno = g_parser.lineno
-      code, d = modify_action_code(parse_action)
-      @optouter <<
-        gen_defm_code("_act_#{nrules} val", code, lineno, d)
-      g_parser.update_context @line
-      @on_reduce[nrules] = ":_act_#{nrules}"
-    end
-  end
-
-  def post_rule_list
-    g_parser.optouter <<
-      gen_action_decorator_code(
-        target_name, paramkey,
-        @on_reduce, @optouter, g_parser.mixin)
-  end
-end
+# -*- coding: utf-8 -*-
+require 'plugins/action.rb'
+
+class Depager::ActionExtension < Depager::Extension
+  def init_extension
+    @action_code = ''
+    @on_reduce = []
+  end
+
+  def term_extension
+    g_parser.outer_code <<
+      generate_action_decorator_code(@on_reduce, @action_code)
+  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 = modify_action_code(parse_block)
+      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
+
+  def modify_action_code code
+    let_code = ""
+    if g_parser.rhs_names.size > 0
+      let_code = g_parser.rhs_names.map do |name|
+        if name =~ /[a-zA-Z][a-zA-Z0-9_]*/
+          "_#{name}"
+        else
+          '_'
+        end
+      end
+      let_code = "    #{let_code.join(', ')}, = *val \n"
+    end
+    return let_code << code, 1
+  end
+end
+

data/lib/depager/ruby/plugins/ast.dr

@@ -1,269 +1,364 @@
-%defext ASTBuilderExtension
-%extend Lexer ('plugins/lex.rb')
-%extend NVAction ('plugins/nvaction.rb')
-%decorate @NVAction
-#%decorate ShiftReducePrinter ('plugins/srp.rb')
-%inner{
-  require 'plugins/_ast_tmpl'
-  attr_accessor :optouter, :on_reduce, :visitor
-  def init_parser
-    super
-    @visitor = Hash.new{|hash, key| hash[key] = []}
-    @optouter = []
-    @on_reduce = []
-    @output_file_name = nil
-  end
-  def post_rule_list
-    g_parser.optouter <<
-      gen_action_decorator_code(target_name, paramkey,
-                                @on_reduce, @optouter)
-  end
-
-  def modify_action_code code, nodes=[]
-    code = code.gsub(/\$\.([a-z_])/, 'node.\1')
-    code << %{
-      rescue
-        warn "raise at src:\#{node.lineno}/\#{node.class.name}"
-        raise
-    }
-  end
-  def gen_accept_code sym
-    return ''
-  end
-
-  attr_reader :output_file_name
-  def output_file_name= ofname
-    ofname = ofname.match(/'(.+)'/) ? $1 : ofname
-    @output_file_name = ofname
-  end
-%}
-%hook pre_rule_list /%AST\{\s*\Z/ skip
-%banner '%AST{ ... }'
-%%
-
-%LEX{
-  /\s+/, /#.*/            { }
-  /%\}\s*\Z/              { @line = $'; yield nil,nil }
-  'Node'                  { yield token(:NODE, $&) }
-  'Visitor'               { yield token(:VISITOR, $&) }
-  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(:ID, $&) }
-  '{' !                   { ln = lineno; yield token(:ACTION, parse_action, ln) }
-  /./                     { yield token($&, $&) }
-%}
-
-#begin-rule
-  start:
-      opt_defnode opt_defvis defnode_list
-      {
-        code = _opt_defnode
-        code << val[2] << %{
-          class Visitor
-            def visit node
-              node.accept(self)
-            end
-          #{master.visitor[nil].join}
-          end
-        };#code
-        master.visitor.each do |k, v|
-          next unless k
-          code << %{
-            class Visitor_#{k}
-            #{v.join}
-            end
-          };#code
-        end
-        if master.output_file_name
-          File.open(master.output_file_name, 'w') do |f|
-            f.write code
-          end
-          g_parser.optouter << %!require '#{master.output_file_name}'\n!
-        else
-          g_parser.optouter << code
-        end
-      }
-  ;
-  opt_defnode:
-      { "" }
-    | NODE opt_attr ACTION
-      {
-        ini = %{
-          def initialize
-            #{_ACTION.value}
-          end
-        };#code
-        ERB.new(master.class::TMPL_NODE_BASE).result(binding)
-      }
-  ;
-  opt_defvis:
-      { [] }
-    | VISITOR opt_action
-      {
-        _opt_action[nil] ||= Token['', 0]
-        _opt_action.each do |pass, act|
-          master.visitor[pass].unshift(
-            master.gen_meval_code(act.lineno, 0, act.value.to_s))
-        end
-      }
-  ;
-  defnode_list:
-      defnode              { _defnode }
-    | defnode_list defnode { _defnode_list << _defnode}
-  ;
-  defnode:
-      defnode_header opt_attr opt_action
-      {
-        name, args = _defnode_header
-        nodes, accept, attrs = [], '', _opt_attr
-        args.each do |i|
-          if i =~ /\-(.*)/
-            nodes.push $1
-            attrs.push $1
-          else
-            nodes.push i
-            accept << master.gen_accept_code(i)
-          end
-        end
-        _opt_action[nil] = Token['', 0] unless _opt_action[nil]
-        _opt_action.each do |pass, act|
-          vis_code = master.modify_action_code(act.value, nodes - attrs)
-          master.visitor[pass] <<
-            master.gen_defm_code("visit_Node_#{name} node",
-                                 vis_code, act.lineno)
-        end
-        ERB.new(master.class::TMPL_NODE).result(binding)
-      }
-  ;
-  defnode_header:
-      ID '(' ')'           { [_ID.value, []]}
-    | ID '(' fact_list ')' { [_ID.value, _fact_list] }
-  ;
-  opt_attr:                
-                           { [] }
-    | '[' ']'              { [] }
-    | '[' id_list ']'      { _id_list }
-  ;
-  fact_list:
-      fact                 { [_fact] }
-    | fact_list ',' fact   { _fact_list.push _fact }
-  ;
-  fact:
-      ID                   { _ID.value }
-    | '-' ID               { '-' + _ID.value }
-  ;
-  id_list:
-      ID                   { [ _ID.value ] }
-    | id_list ',' ID       { _id_list.push _ID.value }
-  ;
-  opt_action:   
-                           { {nil => Token['', 0]} }
-    | ACTION               { {nil => _ACTION} }
-    | pass_action_list
-      {
-        Hash[ *_pass_action_list.flatten ].merge({nil => Token['', 0]})
-      }
-  ;
-  pass_action_list:
-      pass_action                  { [ _pass_action ] }
-    | pass_action_list pass_action { _pass_action_list << _pass_action }
-  ;
-
-  pass_action:
-      '<' ID '>' ACTION    { [_ID.value, _ACTION]}
-  ;
-#end-rule
-%%
-%hook post_rhs /=>/ skip
-%banner '=>...'
-%prec{
-  left LL '@'
-%}
-%inner{
-  def do_default
-    n = master.nrules
-    master.optouter <<
-      master.gen_defm_code("_ast_#{n} val", "NilNode.new(basis.file.lineno)", lineno)
-    master.on_reduce[n] = ":_ast_#{n}"
-  end
-%}
-%%
-
-%LEX{
-  /[ \t]+/                { }
-  /\r?\n/               { yield nil, nil                 }
-  /<</                    { yield token(:LL, $&)          }
-  /%([a-zA-Z0-9_]+)((::[a-zA-Z0-9_]+)*)/
-                          { yield token(:CONST, $1+$2)    }
-  /%\((.+)\)%/            { yield token(:EMBED, $1)       }
-  'nil'                   { yield token(:NIL, $&)         }
-  'NilNode'               { yield token(:NILNODE, $&)     }
-  /[0-9]+/                { yield token(:NUMBER, $&.to_i) }
-  /:[a-zA-Z0-9_]+/        { yield token(:SYMBOL, $&)      }
-  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(:ID, $&)          }
-  /'(.+)'/                { yield token(:STR, $1)         }
-  /./                     { yield token($&, $&)           }
-%}
-#begin-rule
-  start: 
-      fnl
-      {
-        n = master.nrules
-        master.optouter <<
-          master.gen_defm_code("_ast_#{n} val", _fnl, basis.file.lineno)
-        master.on_reduce[n] = ":_ast_#{n}"
-      }
-  ;
-  node:
-      ID '(' ')'         { "Node_#{_ID.value}.new(basis.file.lineno)" }
-    | ID '(' fnlpair ')' 
-      {
-        if g_parser.rhs.size > 0
-          "Node_#{_ID.value}.new(val[0].lineno, #{_fnlpair.join(', ')})" 
-        else
-          "Node_#{_ID.value}.new(basis.file.lineno, #{_fnlpair.join(', ')})" 
-        end
-      }
-  ;
-  fnlpair:
-      fnl                { [_fnl] }
-    | fnlpair ',' fnl    { _fnlpair << _fnl }
-  ;
-  fnl:
-      fact               { _fact }
-    | node               { _node }
-    | list               { _list }
-  ;
-  fact:
-      ID opt_embed
-      {
-        unless i = g_parser.name_to_rhs_index(_ID.value)
-          warn "#{g_parser.lineno}: ?#{_ID.value}"
-          raise
-        end
-        "val[#{i}]#{val[1]}"
-      }
-    | CONST              { "Depager::Token[#{_CONST.value}]" }
-    | SYMBOL             { "Depager::Token[#{_SYMBOL.value}]" }
-    | STR                { "Depager::Token['#{_STR.value}']" }
-    | NILNODE            { "NilNode.new(basis.file.lineno)" }
-    | NUMBER             { "Depager::Token[#{_NUMBER.value}]" }
-    | NIL                { "nil" }
-  ;
-  opt_embed:
-                         { '' }
-    | EMBED              { _EMBED.value }
-  ;
-  list:
-      '['']'             { "NodeList.new(basis.file.lineno, [])" }
-    | '['fnlpair']'        
-      {
-        if g_parser.rhs.size > 0
-          "NodeList.new(val[0].lineno, [#{_fnlpair.join(', ')}])"
-        else
-          "NodeList.new(basis.file.lineno, #{_fnlpair.join(', ')})" 
-        end
-      }
-    | fnl-l LL fnl-r     { "#{_l}.push(#{_r})" }
-    | fnl-l '@' fnl-r    { "#{_l}.concat(#{_r})" }
-  ;
-#end-rule
-%%
+%defext Depager::ASTBuilderExtension
+%extend Depager::Lexer ('plugins/lex.rb')
+%extend Depager::Action ('plugins/action.rb')
+%decorate @Action
+#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
+%expanded_code_delimiter DEPAGER_EXPANDED_CODE
+%inner{
+  attr_accessor :action_code, :on_reduce, :visitors
+  def init_extension
+    @visitors = Hash.new{|hash, key| hash[key] = []}
+    @action_code = ''
+    @on_reduce = []
+    @output_file_name = nil
+  end
+  def term_extension
+    g_parser.outer_code <<
+      generate_action_decorator_code(@on_reduce, @action_code)
+  end
+
+  def modify_action_code code, nodes=[]
+    code = code.gsub(/\$\.([a-z_])/, 'node.\1')
+    code << %{
+      rescue
+        warn "raise at src:\#{node.lineno}/\#{node.class.name}"
+        raise
+    }
+  end
+
+  def gen_accept_code sym
+    return ''
+  end
+
+  def node_name name
+    name = name == '@List' ? "NodeList" : "Node_#{name}"
+    "#{target_namespace}::#{name}"
+  end
+
+  attr_reader :output_file_name
+  def output_file_name= name
+    name = name.match(/'(.+)'/) ? $1 : name
+    @output_file_name = name
+  end
+%}
+%hook pre_rule_list /%AST\{\s*\Z/ skip
+%banner '%AST{ ... }'
+%%
+
+%LEX{
+  /\s+/, /#.*/            { }
+  /%\}\s*\Z/              { @line = $'; yield nil,nil }
+  'Node'                  { yield token(:NODE, $&) }
+  'Visitor'               { yield token(:VISITOR, $&) }
+  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(:ID, $&) }
+  '{' !                   { lineno = file.lineno; yield token(:ACTION, parse_block, lineno) }
+  /./                     { yield token($&, $&) }
+%}
+
+#begin-rule
+  start:
+      opt_defnode opt_defvis defnode_list
+      {
+        code = "module #{target_namespace}\n"
+        code << _opt_defnode
+        code << val[2]
+        master.visitors.each do |name, body|
+          code << ERB.new(master.class::VISITOR_TEMPLATE, nil, '-').result(binding)
+        end
+        code << "end\n"
+        if master.output_file_name
+          File.open(master.output_file_name, 'w') do |f|
+            f.write code
+          end
+          g_parser.outer_code << %!require '#{master.output_file_name}'\n!
+        else
+          g_parser.outer_code << code
+        end
+      }
+  ;
+  opt_defnode:
+      { "" }
+    | NODE opt_attr ACTION
+      {
+        ini = %{
+          def initialize
+            #{_ACTION.value}
+          end
+        };#code
+        ERB.new(master.class::BASE_NODE_TEMPLATE, nil, '-').result(binding)
+      }
+  ;
+  opt_defvis:
+      { [] }
+    | VISITOR opt_action
+      {
+        _opt_action[nil] ||= Token.new('', 0)
+        _opt_action.each do |pass, act|
+          master.visitors[pass].unshift(
+            master.expand_inline_code(act.value.to_s, act.lineno))
+        end
+      }
+  ;
+  defnode_list:
+      defnode              { _defnode }
+    | defnode_list defnode { _defnode_list << _defnode}
+  ;
+  defnode:
+      defnode_header opt_attr opt_action
+      {
+        name, args = _defnode_header
+        nodes, accept, attrs = [], '', _opt_attr
+        args.each do |i|
+          if i =~ /\-(.*)/
+            nodes.push $1
+            attrs.push $1
+          else
+            nodes.push i
+            accept << master.gen_accept_code(i)
+          end
+        end
+        _opt_action[nil] = Token.new('', 0) unless _opt_action[nil]
+        _opt_action.each do |pass, act|
+          vis_code = master.modify_action_code(act.value, nodes - attrs)
+          master.visitors[pass] <<
+            master.expand_inline_code(vis_code, act.lineno, :wrap => "def visit_Node_#{name} node")
+        end
+        ERB.new(master.class::NODE_TEMPLATE, nil, '-').result(binding)
+      }
+  ;
+  defnode_header:
+      ID '(' ')'           { [_ID.value, []]}
+    | ID '(' fact_list ')' { [_ID.value, _fact_list] }
+  ;
+  opt_attr:
+                           { [] }
+    | '[' ']'              { [] }
+    | '[' id_list ']'      { _id_list }
+  ;
+  fact_list:
+      fact                 { [_fact] }
+    | fact_list ',' fact   { _fact_list.push _fact }
+  ;
+  fact:
+      ID                   { _ID.value }
+    | '-' ID               { '-' + _ID.value }
+  ;
+  id_list:
+      ID                   { [ _ID.value ] }
+    | id_list ',' ID       { _id_list.push _ID.value }
+  ;
+  opt_action:
+                           { {nil => Token.new('', 0)} }
+    | ACTION               { {nil => _ACTION} }
+    | pass_action_list
+      {
+        Hash[ *_pass_action_list.flatten ].merge({nil => Token.new('', 0)})
+      }
+  ;
+  pass_action_list:
+      pass_action                  { [ _pass_action ] }
+    | pass_action_list pass_action { _pass_action_list << _pass_action }
+  ;
+
+  pass_action:
+      '<' ID '>' ACTION    { [_ID.value, _ACTION]}
+  ;
+#end-rule
+%%
+%hook post_rhs /=>/ skip
+%banner '=>...'
+%prec{
+  left LL '@'
+%}
+%inner{
+  def do_default
+    n = g_parser.rules.size-1
+    master.action_code << %{
+      def _ast_#{n} val
+        NilNode.new(basis.file.lineno)
+      end
+    }.unindent #code
+    master.on_reduce[n] = ":_ast_#{n}"
+  end
+%}
+%%
+
+%LEX{
+  /[ \t]+/                { }
+  /\r?\n/               { yield nil, nil                 }
+  /<</                    { yield token(:LL, $&)          }
+  /%([a-zA-Z0-9_]+)((::[a-zA-Z0-9_]+)*)/
+                          { yield token(:CONST, $1+$2)    }
+  /%\((.+)\)%/            { yield token(:EMBED, $1)       }
+  'nil'                   { yield token(:NIL, $&)         }
+  'NilNode'               { yield token(:NILNODE, $&)     }
+  /[0-9]+/                { yield token(:NUMBER, $&.to_i) }
+  /:[a-zA-Z0-9_]+/        { yield token(:SYMBOL, $&)      }
+  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(:ID, $&)          }
+  /'(.+)'/                { yield token(:STR, $1)         }
+  /./                     { yield token($&, $&)           }
+%}
+#begin-rule
+  start:
+      fnl
+      {
+        n = g_parser.rules.size-1
+        master.action_code <<
+          master.expand_inline_code(_fnl, basis.file.lineno, :wrap => "def _ast_#{n} val")
+        master.on_reduce[n] = ":_ast_#{n}"
+      }
+  ;
+  node:
+      ID '(' ')'         { "#{master.node_name _ID.value}.new(basis.file.lineno)" }
+    | ID '(' fnlpair ')'
+      {
+        if g_parser.rhs.size > 0
+          "#{master.node_name _ID.value}.new(val[0].lineno, #{_fnlpair.join(', ')})"
+        else
+          "#{master.node_name _ID.value}.new(basis.file.lineno, #{_fnlpair.join(', ')})"
+        end
+      }
+  ;
+  fnlpair:
+      fnl                { [_fnl] }
+    | fnlpair ',' fnl    { _fnlpair << _fnl }
+  ;
+  fnl:
+      fact               { _fact }
+    | node               { _node }
+    | list               { _list }
+  ;
+  fact:
+      ID opt_embed
+      {
+        unless i = g_parser.name_to_rhs_index(_ID.value)
+          warn "#{g_parser.lineno}: ?#{_ID.value}"
+          raise
+        end
+        "val[#{i}]#{val[1]}"
+      }
+    | CONST              { "Depager::Token.new(#{_CONST.value})" }
+    | SYMBOL             { "Depager::Token.new(#{_SYMBOL.value})" }
+    | STR                { "Depager::Token.new('#{_STR.value}')" }
+    | NILNODE            { "NilNode.new(basis.file.lineno)" }
+    | NUMBER             { "Depager::Token.new(#{_NUMBER.value})" }
+    | NIL                { "nil" }
+  ;
+  opt_embed:
+                         { '' }
+    | EMBED              { _EMBED.value }
+  ;
+  list:
+      '['']'             { "#{master.node_name '@List'}.new(basis.file.lineno, [])" }
+    | '['fnlpair']'
+      {
+        if g_parser.rhs.size > 0
+          "#{master.node_name '@List'}.new(val[0].lineno, [#{_fnlpair.join(', ')}])"
+        else
+          "#{master.node_name '@List'}.new(basis.file.lineno, #{_fnlpair.join(', ')})"
+        end
+      }
+    | fnl-l LL fnl-r     { "#{_l}.push(#{_r})" }
+    | fnl-l '@' fnl-r    { "#{_l}.concat(#{_r})" }
+  ;
+#end-rule
+%%
+%%
+
+class Depager::ASTBuilderExtension
+  BASE_NODE_TEMPLATE = <<-'EOS'
+    class Node
+      attr_accessor :lineno
+      attr_accessor <%= _opt_attr.map{|i| ":#{i}" }.join(', ') %>
+      <%= ini %>
+
+      def self.[] lineno, *args
+        self.new lineno, *args
+      end
+
+      def accept v
+      end
+    end
+
+    class NodeList < Node
+      attr_accessor :lineno
+      def initialize(lineno, lst=[])
+        @lineno = lineno
+        @lst = lst.to_a.select{|i| ! i.is_a?(NilNode)}
+      end
+
+      <%- _opt_attr.each do |i| -%>
+      def all_<%= i %>
+        @lst.map{|i| i.<%= i %>}
+      end
+      <%- end -%>
+
+      def size
+        @lst.size
+      end
+      alias length size
+
+      def push(i)
+        @lst.push i unless i.is_a? NilNode
+        self
+      end
+
+      def concat(i)
+        @lst.concat i
+        self
+      end
+
+      def to_ary()
+        @lst
+      end
+
+      alias to_a to_ary
+      alias list to_ary
+
+      def accept(v)
+        @lst.each{|i| i.accept(v) }
+      end
+    end
+
+    class NilNode
+      attr_accessor :lineno
+      attr_accessor <%= _opt_attr.map{|i| ":#{i}" }.join(', ') %>
+
+      def initialize(lineno, *args)
+        @lineno = lineno
+      end
+
+      def accept v
+      end
+    end
+  EOS
+
+  NODE_TEMPLATE = <<-'EOS'
+    class Node_<%= name %> < Node
+      attr_accessor <%= nodes.map{|i| ":#{i}" }.join(', ') %>
+      attr_accessor <%= attrs.map{|i| ":#{i}" }.join(', ') %>
+
+      def initialize <%= nodes.unshift('lineno').join(', ') %>
+        super()
+        @lineno = lineno
+        <%= nodes.inject(''){|r,i| r << "    @#{i} = #{i}\n"} %>
+      end
+
+      def accept v
+        warn @lineno.to_s+':'+self.class.to_s if $DEBUG
+        <%= accept %>
+        v.visit_Node_<%= name %>(self)
+        self
+      end
+    end
+  EOS
+
+  VISITOR_TEMPLATE = <<-'EOS'
+    class Visitor<%= name ? '_' + name : '' %>
+      def visit node
+        node.accept(self)
+      end
+      <%= body.join %>
+    end # Visitor<%= name ? '_' + name : '' %>
+  EOS
+end