depager 0.2.3 → 0.3.0.b20250423

data/lib/depager/parser.rb

@@ -1,277 +1,269 @@
-module Depager; end
-#
-# Token
-# 
-class Depager::Token
-  def self.[] *args
-    self.new(*args)
-  end
-  attr_accessor :value, :lineno, :filename
-  def initialize value, lineno=nil, filename=nil
-    @value = value
-    @lineno = lineno
-    @filename = filename
-  end
-  def [](n)
-    case n
-    when 0 ; @value
-    when 1 ; @lineno
-    when 2 ; @filename
-    else   ; nil
-    end
-  end
-  def to_s
-    "#{@value.inspect}:#{@lineno}@#{@filename}"
-  end
-  def inspect
-    "#<#{self.class.name}:0x#{object_id.to_s(16)}" <<
-      " #{@value.inspect}:#{@lineno}@#{@filename}>"
-  end
-end
-
-# LALR runtime
-module Depager::LALR
-  # = Parser runtime
-  # == Stack
-  # s::  state
-  # la:: look ahead
-  # v::  value
-  #                                stack top->
-  #   [0, [la0, v0], s0, [la1, v1], s1, .....]
-  #
-  class Parser
-    ACC = 0x03ffffff
-
-    # parse method
-    def parse f
-      @basis.file = f
-      @basis.la = [0, nil]
-      @basis.lex do |sym, val|
-        @basis.la = [@basis.t2i[sym] || @basis.t2i[false], val]
-        break if driver
-      end
-      @basis.stack[1][2..(@basis.params.size+1)]
-    end
-
-    protected
-    # driver method
-    def driver
-      while true
-        @basis.val = @basis.action_table[@basis.stack.last][@basis.la[0]]
-        @basis.val ||= @basis.defred_table[@basis.stack.last]
-        
-        if @basis.val == nil
-          #warn "#{@basis.stack}#{@basis.la[0]}"
-          error
-          exit 1
-        elsif @basis.val == ACC
-          if @i2t[@basis.la[0]] == nil
-            accept
-          else
-            error          
-          end
-          return true
-        elsif @basis.val > 0
-          shift
-          while val = @basis.defred_after_shift_table[@basis.stack.last]
-            @basis.val = val
-            reduce
-          end
-          return false
-        else
-          reduce
-        end
-      end
-    end
-
-    def enable?(act, sym)
-      case act
-      when :shift
-        la = @basis.t2i[sym] || @basis.t2i[false]
-        val = @basis.action_table[@basis.stack.last][la]
-      else
-      end
-    end
-
-    def enables(act, sym)
-      case act
-      when :shift
-        la = @basis.t2i[sym] || @basis.t2i[false]
-        res = []
-        @basis.action_table.each_with_index{|i, x|
-          i[la] and res.push(x)
-        }
-        return res
-      else
-      end
-    end
-
-    # template methods
-    def init_parser ; end
-    def lex ; end
-    def accept ; end
-    def error  ; end
-    def shift  ; end
-    def reduce ; end
-  end
-
-  class Basis < Parser
-    attr_accessor :state, :stack, :laq, :la, :val, :basis, :params
-    attr_accessor :file, :oldline, :lineno, :line, :line0
-    attr_reader :action_table, :defred_table, :defred_after_shift_table
-    attr_reader :goto_table, :reduce_table
-    attr_reader :i2t, :t2i, :nt2i, :i2nt
-
-    private
-    def __init_parser__
-      @state = 0
-      @stack = [@state]
-      @laq = []
-      @la = nil
-      @val = nil
-      @line0 = @line = ''
-    end
-
-    def initialize
-      __init_parser__
-      @file = nil
-      @basis = self
-      @reduce_table, @params, @action_table,
-        @defred_table, @defred_after_shift_table, @goto_table,
-        @t2i, @i2t, @nt2i, @i2nt = self.class::Tables
-    end
-
-    def token sym, val=nil, lineno=nil
-      lineno ||= file.lineno
-      return sym, Depager::Token[val, lineno, file.path]
-    end
-
-    public
-    def banner
-      self.class.name
-    end
-
-    def getline
-      @file.gets unless @file.eof?
-    end
-
-    def accept
-      #warn "acc."
-    end
-    def error
-      fname = @file.respond_to?(:path) ? @file.path : '-'
-      exp = []
-      @action_table[@stack.last].each_with_index do |i, x|
-        exp << @i2t[x] if i
-      end
-      la  = @la[1].value rescue @la[1]
-      la  = (@i2t[@la[0]] || la).inspect
-      exp = exp.map{|i| i ? i.inspect : '$' }.join(', ')
-      warn "#{fname}:#{@file.lineno}: syntax error(#{self.banner}), " <<
-        "unexpected #{la}, expecting #{exp}."
-      warn @stack.pretty_inspect if $MP_DEBUG
-    end
-    def shift
-      @stack.push(@la).push(@val)
-    end
-    def reduce
-      (@reduce_table[-@val][1] * 2).times{@stack.pop}
-      r = @reduce_table[-@val][0]
-      cs = @goto_table[@stack.last][r]
-      @stack.push([r, :NT]).push(cs)
-    end
-  end
-
-  #
-  # Decorator Base class
-  #
-  class AdvancedParser < Parser
-    attr_reader :basis
-    attr_reader :action_table, :goto_table, :reduce_table
-    attr_reader :i2t, :t2i, :nt2i, :i2nt
-    def initialize inside, paramkey = nil
-      @inside = inside
-      @basis = @inside.basis
-      @reduce_table, @params, @action_table, @defred_table, @goto_table, 
-        @t2i, @i2t, @nt2i, @i2nt = @basis.class::Tables
-      @nparam = @params[paramkey]
-    end
-
-    protected
-    def _state
-      @basis.state
-    end
-    def _stack
-      @basis.stack
-    end
-    def _lookaheadque
-      @basis.laq
-    end
-    def _lookahead
-      @basis.la
-    end
-    def _actvalue
-      @basis.val
-    end
-
-    def accept
-      before_accept
-      @inside.accept
-      after_accept
-    end
-    def error
-      before_error
-      @inside.error
-      after_error
-    end
-    def shift
-      before_shift
-      @inside.shift
-      after_shift
-    end
-    def reduce
-      before_reduce
-      @inside.reduce
-      after_reduce
-    end
-
-    # template methods
-    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
-
-  #
-  # Action Decorator Base class
-  #
-  class Action < AdvancedParser
-    def initialize inside, nparamkey=nil
-      super inside, nparamkey
-      @_yy_val_ = []
-    end
-    def before_reduce
-      @_yy_val_ = []
-      n = @reduce_table[-_actvalue][1]
-      n.times do |i|
-        x = _stack[_stack.size-2*(i+1)]
-        @_yy_val_[n-i-1] = x[1] == :NT ? x[@nparam] : x[1]
-      end
-    end
-    def after_reduce
-      mes = @on_reduce[-_actvalue]
-      r = mes ? self.send(mes, @_yy_val_) : nil
-      _stack[_stack.size-2][@nparam] = r
-    end
-  end
-end
-
-class IO
-  def path
-    self.to_s
-  end
-end
+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)
+      @value = value
+      @lineno = lineno
+      @filename = filename
+    end
+
+    def to_s
+      "#{@value.inspect}:#{@lineno}@#{@filename}"
+    end
+
+    def inspect
+      "<#{@value.inspect}:#{@lineno}>"
+    end
+  end
+
+  module LALR
+    # = Parser runtime
+    # == Stack
+    # s::  state
+    # la:: look ahead
+    # v::  value
+    #                                stack top->
+    #   [0, [la0, v0], s0, [la1, v1], s1, .....]
+    #
+    class Parser
+      ACC = 0x03ffffff
+
+      def parse(f, line = "")
+        basis.__send__ :internal_initialize, f, line, [0, nil]
+
+        do_hook :before_parse
+        lex do |sym, val|
+          basis.lookahead = [term_to_int[sym] || term_to_int[false], val]
+          break if driver
+        end
+        do_hook :after_parse
+
+        stack[1][2..basis.parser_size]
+      end
+
+      def lex; end
+      def accept; end
+      def error; end
+      def shift; end
+      def reduce; 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 driver
+        loop do
+          basis.action_value = action_table[stack.last][lookahead[0]] || defred_table[stack.last]
+
+          if action_value.nil?
+            error
+            basis.do_abort_driver
+          elsif action_value == ACC
+            if int_to_term[lookahead[0]].nil?
+              accept
+              return true
+            else
+              error
+              basis.do_abort_driver
+            end
+          elsif action_value > 0
+            shift
+            while (v = defred_after_shift_table[stack.last])
+              basis.action_value = v
+              reduce
+            end
+            return false
+          else
+            reduce
+          end
+        end
+      end
+
+      def do_hook(hook)
+        if @basis == self
+          send hook
+        elsif /^before_/.match?(hook.to_s)
+          send hook
+          @inside.do_hook hook
+        else
+          @inside.do_hook hook
+          send hook
+        end
+      end
+
+      private
+
+      def before_parse; end
+      def after_parse; end
+    end
+
+    class Basis < Parser
+      attr_reader :basis, :file, :line, :parser_size
+      attr_accessor :lookahead, :action_value, :stack
+
+      def initialize
+        super
+
+        @basis = self
+        @parser_size = 1
+      end
+
+      def banner
+        self.class.name
+      end
+
+      def next_decorator_index
+        @parser_size += 1
+      end
+
+      def accept; end
+
+      def error
+        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 = 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(", ")
+        warn "#{path}:#{file.lineno}: syntax error(#{banner}), unexpected #{la}, expecting #{exp}."
+        warn @stack.pretty_inspect if Depager.respond_to?(:debug_mode?) && Depager.debug_mode?
+      end
+
+      def shift
+        stack << lookahead << action_value
+      end
+
+      def reduce
+        r, x = reduce_table[-action_value]
+        (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 = [0]
+        @action_value = nil
+        @file = file
+        @line = line
+        @lookahead = lookahead
+      end
+
+      def token(sym, value = nil, lineno = nil)
+        lineno ||= file.lineno
+        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)
+        @inside          = inside
+        @basis           = inside.basis
+        @decorator_index = @basis.next_decorator_index
+        super()
+      end
+
+      def accept
+        before_accept
+        @inside.accept
+        after_accept
+      end
+
+      def error
+        before_error
+        @inside.error
+        after_error
+      end
+
+      def shift
+        before_shift
+        @inside.shift
+        after_shift
+      end
+
+      def reduce
+        before_reduce
+        @inside.reduce
+        after_reduce
+      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
+    end
+
+    class Action < AdvancedParser
+      def on_reduce; end
+
+      def initialize(inside)
+        super
+        @_arguments = []
+      end
+
+      def before_reduce
+        @_arguments = []
+        n = reduce_table[-action_value][1]
+        n.times do |i|
+          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]
+        result = method ? send(method, @_arguments) : nil
+        stack[stack.size - 2][decorator_index] = result
+      end
+    end
+  end
+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