depager 0.3.0.b20160729 → 0.3.0.b20250423

data/lib/depager/parser.rb

@@ -1,12 +1,17 @@
-# -*- coding: utf-8 -*-
-lib = File.expand_path("../ruby", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "forwardable"
 
 module Depager
+  def self.path_of(io)
+    return "-" if io == $stdin
+    return "<#{io.class}>" unless io.respond_to?(:path) # StringIO
+
+    io.path
+  end
+
   class Token
     attr_accessor :value, :lineno, :filename
 
-    def initialize value, lineno=nil, filename=nil
+    def initialize(value, lineno = nil, filename = nil)
       @value = value
       @lineno = lineno
       @filename = filename
@@ -33,23 +38,7 @@ module Depager
     class Parser
       ACC = 0x03ffffff
 
-      attr_reader :action_table, :defred_table, :defred_after_shift_table
-      attr_reader :goto_table, :reduce_table
-      attr_reader :int_to_term, :term_to_int, :nonterm_to_int, :int_to_nonterm
-
-      def initialize
-        @reduce_table,
-        @action_table,
-        @defred_table,
-        @defred_after_shift_table,
-        @goto_table,
-        @term_to_int,
-        @int_to_term,
-        @nonterm_to_int,
-        @int_to_nonterm = basis.class::Tables
-      end
-
-      def parse f, line = ''
+      def parse(f, line = "")
         basis.__send__ :internal_initialize, f, line, [0, nil]
 
         do_hook :before_parse
@@ -62,52 +51,42 @@ module Depager
         stack[1][2..basis.parser_size]
       end
 
-      def accept
-      end
+      def lex; end
+      def accept; end
+      def error; end
+      def shift; end
+      def reduce; end
 
-      def error
-      end
-
-      def shift
-      end
-
-      def reduce
-      end
-
-      def stack
-        basis.stack
-      end
-
-      def lookahead
-        basis.lookahead
-      end
-
-      def action_value
-        basis.action_value
-      end
+      def reduce_table; end
+      def action_table; end
+      def defred_table; end
+      def defred_after_shift_table; end
+      def goto_table; end
+      def term_to_int; end
+      def int_to_term; end
+      def nonterm_to_int; end
+      def int_to_nonterm; end
 
       protected
-      def lex &block
-        basis.lex &block
-      end
 
       def driver
-        while true
+        loop do
           basis.action_value = action_table[stack.last][lookahead[0]] || defred_table[stack.last]
 
-          if action_value == nil
+          if action_value.nil?
             error
-            exit 1
+            basis.do_abort_driver
           elsif action_value == ACC
-            if int_to_term[lookahead[0]] == nil
+            if int_to_term[lookahead[0]].nil?
               accept
+              return true
             else
               error
+              basis.do_abort_driver
             end
-            return true
           elsif action_value > 0
             shift
-            while v = defred_after_shift_table[stack.last]
+            while (v = defred_after_shift_table[stack.last])
               basis.action_value = v
               reduce
             end
@@ -118,10 +97,10 @@ module Depager
         end
       end
 
-      def do_hook hook
+      def do_hook(hook)
         if @basis == self
           send hook
-        elsif hook.to_s.match(/^before_/)
+        elsif /^before_/.match?(hook.to_s)
           send hook
           @inside.do_hook hook
         else
@@ -131,45 +110,47 @@ module Depager
       end
 
       private
-      def before_parse
-      end
 
-      def after_parse
-      end
+      def before_parse; end
+      def after_parse; end
     end
 
     class Basis < Parser
-      attr_reader   :basis, :file, :line, :parser_size
+      attr_reader :basis, :file, :line, :parser_size
       attr_accessor :lookahead, :action_value, :stack
 
       def initialize
+        super
+
         @basis = self
         @parser_size = 1
-        super()
       end
 
       def banner
         self.class.name
       end
 
-      def get_decorator_index
+      def next_decorator_index
         @parser_size += 1
       end
 
-      def accept
-      end
+      def accept; end
 
       def error
-        path = file.respond_to?(:path) ? file.path : '-'
+        path = Depager.path_of(file)
         exp  = []
         action_table[stack.last].each_with_index do |i, x|
           exp << int_to_term[x] if i
         end
-        la  = lookahead[1].value rescue lookahead[1]
+        la = begin
+          lookahead[1].value
+        rescue StandardError
+          lookahead[1]
+        end
         la  = (int_to_term[lookahead[0]] || la).inspect
-        exp = exp.map{|i| i ? i.inspect : '$' }.join(', ')
+        exp = exp.map { |i| i ? i.inspect : "$" }.join(", ")
         warn "#{path}:#{file.lineno}: syntax error(#{banner}), unexpected #{la}, expecting #{exp}."
-        warn @stack.pretty_inspect if Depager.debug_mode?
+        warn @stack.pretty_inspect if Depager.respond_to?(:debug_mode?) && Depager.debug_mode?
       end
 
       def shift
@@ -178,31 +159,50 @@ module Depager
 
       def reduce
         r, x = reduce_table[-action_value]
-        (x * 2).times{ stack.pop }
+        (x * 2).times { stack.pop }
         v = goto_table[stack.last][r]
         stack << [r, :NT] << v
       end
 
+      def do_abort_driver
+        abort_driver
+      end
+
+      def abort_driver
+        exit 1
+      end
+
       private
-      def internal_initialize file, line, lookahead
-        @stack, @action_value, @file, @line, @lookahead =
-          [0], nil, file, line, lookahead
+
+      def internal_initialize(file, line, lookahead)
+        @stack = [0]
+        @action_value = nil
+        @file = file
+        @line = line
+        @lookahead = lookahead
       end
 
-      def token sym, value = nil, lineno = nil
+      def token(sym, value = nil, lineno = nil)
         lineno ||= file.lineno
-        path     = file.respond_to?(:path) ? file.path : '-'
-        return sym, Depager::Token.new(value, lineno, path)
+        path     = file.respond_to?(:path) ? file.path : "-"
+        [sym, Depager::Token.new(value, lineno, path)]
       end
     end
 
     class AdvancedParser < Parser
+      extend Forwardable
+      delegate %i[
+        lookahead action_value stack lex abort_driver
+        reduce_table action_table defred_table defred_after_shift_table goto_table
+        term_to_int int_to_term nonterm_to_int int_to_nonterm
+      ] => :@basis
+
       attr_reader :basis, :decorator_index
 
-      def initialize inside
+      def initialize(inside)
         @inside          = inside
         @basis           = inside.basis
-        @decorator_index = @basis.get_decorator_index
+        @decorator_index = @basis.next_decorator_index
         super()
       end
 
@@ -231,49 +231,36 @@ module Depager
       end
 
       private
-      def before_accept
-      end
 
-      def after_accept
-      end
-
-      def before_error
-      end
-
-      def after_error
-      end
-
-      def before_shift
-      end
-
-      def after_shift
-      end
-
-      def before_reduce
-      end
-
-      def after_reduce
-      end
+      def before_accept; end
+      def after_accept; end
+      def before_error; end
+      def after_error; end
+      def before_shift; end
+      def after_shift; end
+      def before_reduce; end
+      def after_reduce; end
     end
 
     class Action < AdvancedParser
-      def initialize inside
-        super inside
+      def on_reduce; end
+
+      def initialize(inside)
+        super
         @_arguments = []
-        @on_reduce, = self.class::Tables
       end
 
       def before_reduce
         @_arguments = []
         n = reduce_table[-action_value][1]
         n.times do |i|
-          v = stack[stack.size - 2 * (i + 1)]
+          v = stack[stack.size - (2 * (i + 1))]
           @_arguments[n - i - 1] = v[1] == :NT ? v[decorator_index] : v[1]
         end
       end
 
       def after_reduce
-        method = @on_reduce[-action_value]
+        method = on_reduce[-action_value]
         result = method ? send(method, @_arguments) : nil
         stack[stack.size - 2][decorator_index] = result
       end

data/lib/depager/plugins/_rie_debug.rb

@@ -0,0 +1,63 @@
+class Depager::RieExtension
+  module DebugHelper
+    def inspect
+      "<#{node_name}:#{node_values.inspect}>"
+    end
+
+    def pretty_print(q)
+      q.group(1, "<#{node_name}:", ">") { q.pp node_values }
+    end
+
+    def node_name
+      self.class.name.split("::").last
+    end
+
+    def node_values
+      to_h.tap { _1.delete(:lineno) }
+    end
+  end
+
+  module Nodes
+    N_THREAD.class_eval do
+      include DebugHelper
+    end
+
+    N_TRANSFER.class_eval do
+      include DebugHelper
+    end
+
+    N_EXCEPT.class_eval do
+      include DebugHelper
+    end
+
+    N_LET.class_eval do
+      include DebugHelper
+    end
+
+    N_ACTION.class_eval do
+      include DebugHelper
+    end
+
+    N_ATOC.class_eval do
+      include DebugHelper
+
+      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 = begin
+          sym_name == "$" ? "$#{grammar.symname(grammar[rx].lhs)}" : sym_name
+        rescue StandardError
+          nil
+        end
+        q.group(1, "<N_ATOC:", ">") { q.pp [name, attr_name, rx] }
+      end
+
+      def grammar
+        $grammar # rubocop: disable Style/GlobalVars
+      end
+    end
+  end
+end

data/lib/depager/plugins/action.rb

@@ -0,0 +1,47 @@
+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
+    return unless /^%ACTION\{\s*$/.match?(g_parser.original_line)
+
+    while (line = file.gets)
+      break if /^%\}\s*$/.match?(line)
+
+      @action_code << line
+    end
+    g_parser.update_context ""
+  end
+
+  def post_rhs
+    return unless /\s*\{/.match?(g_parser.line)
+
+    @original_line = g_parser.original_line
+    @line = g_parser.line
+    lineno = g_parser.file.lineno
+    code = modify_action_code(parse_block)
+    n = g_parser.rules.size - 1
+    @action_code <<
+      expand_inline_code(code, lineno, wrap: "def _act_#{n} val", delta: 1)
+    g_parser.update_context @line
+    @on_reduce[n] = ":_act_#{n}"
+  end
+
+  def modify_action_code(code)
+    let_code = "    # empty rule\n"
+    unless g_parser.rhs_names.empty?
+      vars = g_parser.rhs_names.map do |i|
+        /[a-zA-Z][a-zA-Z0-9_]*/.match?(i) ? "_#{i}" : "_"
+      end
+      let_code = "    #{vars.join(', ')}, = *val\n"
+    end
+    let_code << code
+  end
+end

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

@@ -1,9 +1,8 @@
 %defext Depager::ASTBuilderExtension
-%extend Depager::Lexer ('plugins/lex.rb')
-%extend Depager::Action ('plugins/action.rb')
+%extend Depager::Lexer ('depager/plugins/lex.rb')
+%extend Depager::Action ('depager/plugins/action.rb')
 %decorate @Action
-#%decorate Depager::LALR::ShiftReducePrinter ('plugins/srp.rb')
-%expanded_code_delimiter DEPAGER_EXPANDED_CODE
+#%decorate Depager::LALR::ShiftReducePrinter ('depager/plugins/srp.rb')
 %inner{
   attr_accessor :action_code, :on_reduce, :visitors
   def init_extension
@@ -19,11 +18,11 @@
 
   def modify_action_code code, nodes=[]
     code = code.gsub(/\$\.([a-z_])/, 'node.\1')
-    code << %{
+    code << <<-CODE
       rescue
         warn "raise at src:\#{node.lineno}/\#{node.class.name}"
         raise
-    }
+    CODE
   end
 
   def gen_accept_code sym
@@ -80,11 +79,11 @@
       { "" }
     | NODE opt_attr ACTION
       {
-        ini = %{
+        ini = <<-CODE
           def initialize
             #{_ACTION.value}
           end
-        };#code
+        CODE
         ERB.new(master.class::BASE_NODE_TEMPLATE, nil, '-').result(binding)
       }
   ;
@@ -173,11 +172,11 @@
 %inner{
   def do_default
     n = g_parser.rules.size-1
-    master.action_code << %{
+    master.action_code << <<~CODE
       def _ast_#{n} val
         NilNode.new(basis.file.lineno)
       end
-    }.unindent #code
+    CODE
     master.on_reduce[n] = ":_ast_#{n}"
   end
 %}
@@ -266,7 +265,7 @@
 %%
 
 class Depager::ASTBuilderExtension
-  BASE_NODE_TEMPLATE = <<-'EOS'
+  BASE_NODE_TEMPLATE = <<-'CODE'
     class Node
       attr_accessor :lineno
       attr_accessor <%= _opt_attr.map{|i| ":#{i}" }.join(', ') %>
@@ -331,14 +330,14 @@ class Depager::ASTBuilderExtension
       def accept v
       end
     end
-  EOS
+  CODE
 
-  NODE_TEMPLATE = <<-'EOS'
+  NODE_TEMPLATE = <<-'CODE'
     class Node_<%= name %> < Node
       attr_accessor <%= nodes.map{|i| ":#{i}" }.join(', ') %>
       attr_accessor <%= attrs.map{|i| ":#{i}" }.join(', ') %>
 
-      def initialize <%= nodes.unshift('lineno').join(', ') %>
+      def initialize <%= ['lineno', *nodes].join(', ') %>
         super()
         @lineno = lineno
         <%= nodes.inject(''){|r,i| r << "    @#{i} = #{i}\n"} %>
@@ -350,15 +349,19 @@ class Depager::ASTBuilderExtension
         v.visit_Node_<%= name %>(self)
         self
       end
+
+      def attributes
+        { <%= (nodes + attrs).uniq.map{|i| "#{i}: #{i}" }.join(', ') %>, lineno: lineno }
+      end
     end
-  EOS
+  CODE
 
-  VISITOR_TEMPLATE = <<-'EOS'
+  VISITOR_TEMPLATE = <<-'CODE'
     class Visitor<%= name ? '_' + name : '' %>
       def visit node
         node.accept(self)
       end
       <%= body.join %>
     end # Visitor<%= name ? '_' + name : '' %>
-  EOS
+  CODE
 end