depager 0.2.3 → 0.3.0.b20250423

data/lib/depager/plugins/ast.dr

@@ -0,0 +1,367 @@
+%defext Depager::ASTBuilderExtension
+%extend Depager::Lexer ('depager/plugins/lex.rb')
+%extend Depager::Action ('depager/plugins/action.rb')
+%decorate @Action
+#%decorate Depager::LALR::ShiftReducePrinter ('depager/plugins/srp.rb')
+%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 << <<-CODE
+      rescue
+        warn "raise at src:\#{node.lineno}/\#{node.class.name}"
+        raise
+    CODE
+  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 = <<-CODE
+          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 << <<~CODE
+      def _ast_#{n} val
+        NilNode.new(basis.file.lineno)
+      end
+    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 = <<-'CODE'
+    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
+  CODE
+
+  NODE_TEMPLATE = <<-'CODE'
+    class Node_<%= name %> < Node
+      attr_accessor <%= nodes.map{|i| ":#{i}" }.join(', ') %>
+      attr_accessor <%= attrs.map{|i| ":#{i}" }.join(', ') %>
+
+      def initialize <%= ['lineno', *nodes].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
+
+      def attributes
+        { <%= (nodes + attrs).uniq.map{|i| "#{i}: #{i}" }.join(', ') %>, lineno: lineno }
+      end
+    end
+  CODE
+
+  VISITOR_TEMPLATE = <<-'CODE'
+    class Visitor<%= name ? '_' + name : '' %>
+      def visit node
+        node.accept(self)
+      end
+      <%= body.join %>
+    end # Visitor<%= name ? '_' + name : '' %>
+  CODE
+end