depager 0.2.3 → 0.3.0.b20250423

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

@@ -1,269 +0,0 @@
-%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
-%%