depager 0.2.3 → 0.3.0.b20250423

data/lib/depager/{ruby/plugins → plugins}/cst.dr

@@ -1,180 +1,174 @@
-%defext CSTBuilderExtension
-%extend Lexer ('plugins/lex.rb')
-%extend NVAction ('plugins/nvaction.rb')
-%decorate @NVAction
-#%decorate ShiftReducePrinter ('plugins/srp.rb')
-%inner{
-  attr_accessor :optouter, :nodes_code
-  def init_parser
-    super
-    @n = 0
-    @visitor_code = []
-    @nodes_code = []
-    @optouter = []
-    @on_reduce = []
-  end
-  def modify_action_code code
-    code.gsub(/~([a-z_])/, 'node.\1')
-  end
-  def post_rhs
-    code, lineno = '', g_parser.lineno
-    if g_parser.line =~ /\s*\{/
-      @line0, @line = g_parser.line0, g_parser.line
-      code = parse_action
-      
-      g_parser.update_context @line
-    end
-
-    node_name = "#{lhs_name}_#{nrhs}"
-    accept = ""
-    nodes = g_parser.rhs.map do |i| 
-      x = g_parser.int_to_sym(i)
-      if x.class == String
-        "tx#{x.unpack("H*")[0]}"
-      else
-        x = x.to_s
-        accept << "#{x}.accept(v); " if x =~ /\A[a-z_]+\Z/
-        x.downcase
-      end
-    end
-    attrc = nodes.map{|i| ":#{i}" }.join(', ')
-    inic  = nodes.map{|i| "@#{i} = #{i}"}.join('; ')
-    @nodes_code << %{
-      class Node_#{node_name} < Node_#{lhs_name}
-        attr_accessor #{attrc}
-        def initialize #{nodes.join(', ')}
-          super()
-          #{inic}
-        end
-        def accept v
-          #{accept}
-          v.visit_Node_#{node_name}(self)
-        end
-      end
-    }; #code
-
-    @visitor_code <<
-      gen_defm_code("visit_Node_#{node_name} node",
-                    modify_action_code(code), lineno)
-
-    args  = nodes.inject([]){|r, i| r << "val[#{r.size}]"}
-    code = "Node_#{node_name}.new(#{args.join(', ')})"
-    @optouter << 
-      gen_defm_code("_cst_#{nrules} val", code, lineno)
-
-    @on_reduce[nrules] = ":_cst_#{nrules}"
-  end
-  def post_rule_list
-    code = unindent %{
-      class Node
-        def accept
-        end
-      end
-    }; #code
-    g_parser.optouter << code
-
-    code = unindent %{
-      class Visitor
-      $$!!@ CST @!!$$
-      end
-    }; #code
-    g_parser.optouter <<
-      code.sub!('$$!!@ CST @!!$$', @visitor_code.join) <<
-      unindent(@nodes_code) <<
-      gen_action_decorator_code(target_name, paramkey,
-                                @on_reduce, @optouter)
-  end
-%}
-%hook pre_rule_list /%CST\{\s*\Z/ skip
-%banner '%CST{ ... }'
-%%
-
-%LEX{
-  /\s+/, /#.*/            { }
-  /%\}\s*\Z/              { yield nil,nil }
-  'Node'                  { yield token(:NODE, $&) }
-  '{' !                   { ln = lineno; yield token(:ACTION, parse_action, ln) }
-%}
-
-#begin-rule
-  start:
-      opt_node opt_visitor
-      {
-        code = %{
-          class Node
-            $$!!@ NODE @!!$$
-          end
-          class Visitor
-            $$!!@ VISITOR @!!$$
-          end
-        }; #code
-        master.nodes_code <<
-          code.sub!('$$!!@ NODE @!!$$', _opt_node) \
-              .sub!('$$!!@ VISITOR @!!$$', _opt_visitor)
-      }
-  ;
-  opt_node:           
-                      { '' }
-    | NODE ACTION     { _ACTION.value }
-  ;
-  opt_visitor:        
-                      { '' }
-    | VISITOR ACTION  { _ACTION.value }
-  ;
-#end-rule
-%%
-%hook post_lhs /\[/ skip
-%banner '[ ... ]'
-%inner{
-  def do_default
-    master.nodes_code << %{
-      class Node_#{master.lhs_name} < Node
-        def initialize
-          super()
-        end
-      end
-    }; #code
-  end
-%}
-%%
-
-%LEX{
-  /\A\s+/              { } #skip blank
-  /""/,/''/,/[0-9]+/,
-  /\{\s*\}/,/\[\s*\]/,
-  /nil/                { yield token(:LIT, $&) }
-  /\A[a-z][a-z_]*/     { yield token(:ID, $&)  }
-  /\A(.)/              { yield token($&, $&)   }
-%}
-
-#begin-rule
-  start:
-      '[' pair ']'
-      {
-        args = []; code = ''
-        _pair.each do |id, lit|
-          args <<  id
-          code << "#{id} = #{lit}; " if lit
-        end
-        attrc = args.map{|i| ":#{i}"}.join(', ')
-        master.nodes_code << %{
-          class Node_#{master.lhs_name} < Node
-            attr_accessor #{attrc}
-            def initialize
-              super()
-              #{code}
-            end
-          end
-        }; #code
-      }
-  ;
-  pair:
-      expr          { [ _expr ] }
-    | pair ',' expr { _pair << _expr }
-  ;
-  expr:
-      ID            { [ _ID.value, nil] }
-    | ID '=' LIT    { [ _ID.value, _LIT.value ] }
-  ;
-#end-rule
-%%
+%defext Depager::CSTBuilderExtension
+%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, :nodes_code, :visitor_code
+  def init_extension
+    @n = 0
+    @visitor_code = ''
+    @nodes_code   = ''
+    @action_code   = ''
+    @on_reduce    = []
+  end
+
+  def modify_action_code code
+    code.gsub(/\$\.([a-z_])/, 'node.\1')
+  end
+
+  def post_rhs
+    code, lineno = '', g_parser.file.lineno
+    if g_parser.line =~ /\s*\{/
+      @original_line, @line = g_parser.original_line, g_parser.line
+      code = parse_block
+
+      g_parser.update_context @line
+    end
+
+    node_name = "#{g_parser.lhs_name}_#{g_parser.nrhs}"
+    accept = ""
+    nodes = g_parser.rhs.map do |i|
+      x = g_parser.int_to_sym(i)
+      if x.class == String
+        "tx#{x.unpack("H*")[0]}"
+      else
+        x = x.to_s
+        accept << "#{x}.accept(v); " if x =~ /\A[a-z_]+\Z/
+        x.downcase
+      end
+    end
+    attrc = nodes.map{|i| ":#{i}" }.join(', ')
+    inic  = nodes.map{|i| "@#{i} = #{i}"}.join('; ')
+    @nodes_code << <<-CODE
+      class Node_#{node_name} < Node_#{g_parser.lhs_name}
+        attr_accessor #{attrc}
+        def initialize #{nodes.join(', ')}
+          super()
+          #{inic}
+        end
+        def accept v
+          #{accept}
+          v.visit_Node_#{node_name}(self)
+        end
+        def children
+          [#{nodes.join(', ')}]
+        end
+      end
+    CODE
+
+    @visitor_code <<
+      expand_inline_code(modify_action_code(code), lineno, :wrap => "def visit_Node_#{node_name} node")
+
+    args  = nodes.inject([]){|r, i| r << "val[#{r.size}]"}
+    code = "#{target_namespace}::Node_#{node_name}.new(#{args.join(', ')})"
+    n = g_parser.rules.size-1
+    @action_code <<
+      expand_inline_code(code, lineno, :wrap => "def _cst_#{n} val")
+
+    @on_reduce[n] = ":_cst_#{n}"
+  end
+
+  def term_extension
+    g_parser.outer_code << "module #{target_namespace}\n"
+    g_parser.outer_code << @nodes_code
+    g_parser.outer_code << <<-CODE
+      class Visitor
+      #{@visitor_code}
+      end
+    CODE
+    g_parser.outer_code << "end\n"
+    g_parser.outer_code << generate_action_decorator_code(@on_reduce, @action_code)
+  end
+%}
+%hook pre_rule_list /%CST\{\s*\Z/ skip
+%banner '%CST{ ... }'
+%%
+
+%LEX{
+  /\s+/, /#.*/            { }
+  /%\}\s*\Z/              { yield nil,nil }
+  'Node'                  { yield token(:NODE, $&) }
+  'Visitor'               { yield token(:VISITOR, $&) }
+  '{' !                   { lineno = file.lineno; yield token(:ACTION, parse_block, lineno) }
+%}
+
+#begin-rule
+  start:
+      opt_node opt_visitor
+      {
+        master.nodes_code << <<-CODE
+          class Node
+            def accept
+            end
+          #{_opt_node}
+          end
+        CODE
+        master.visitor_code << _opt_visitor
+      }
+  ;
+  opt_node:
+                      { '' }
+    | NODE ACTION     { _ACTION.value }
+  ;
+  opt_visitor:
+                      { '' }
+    | VISITOR ACTION  { _ACTION.value }
+  ;
+#end-rule
+%%
+%hook post_lhs /\[/ skip
+%banner '[ ... ]'
+%inner{
+  def do_default
+    master.nodes_code << <<-CODE
+      class Node_#{g_parser.lhs_name} < Node
+        def initialize
+          super()
+        end
+      end
+    CODE
+  end
+%}
+%%
+
+%LEX{
+  /\A\s+/              { } #skip blank
+  /""/,/''/,/[0-9]+/,
+  /\{\s*\}/,/\[\s*\]/,
+  /nil/                { yield token(:LIT, $&) }
+  /\A[a-z][a-z_]*/     { yield token(:ID, $&)  }
+  /\A(.)/              { yield token($&, $&)   }
+%}
+
+#begin-rule
+  start:
+      '[' pair ']'
+      {
+        args = []; code = ''
+        _pair.each do |id, lit|
+          args <<  id
+          code << "#{id} = #{lit}; " if lit
+        end
+        attrc = args.map{|i| ":#{i}"}.join(', ')
+        master.nodes_code << <<-CODE
+          class Node_#{g_parser.lhs_name} < Node
+            attr_accessor #{attrc}
+            def initialize
+              super
+              #{code}
+            end
+          end
+        CODE
+      }
+  ;
+  pair:
+      expr          { [ _expr ] }
+    | pair ',' expr { _pair << _expr }
+  ;
+  expr:
+      ID            { [ _ID.value, nil] }
+    | ID '=' LIT    { [ _ID.value, _LIT.value ] }
+  ;
+#end-rule
+%%