docspring 3.0.0 → 3.1.0

data/vendor/bundle/ruby/3.3.0/gems/debug-1.10.0/lib/debug/thread_client.rb

@@ -0,0 +1,1455 @@
+# frozen_string_literal: true
+
+require 'objspace'
+require 'pp'
+
+require_relative 'color'
+
+class ::Thread
+  attr_accessor :debug_thread_client
+end
+
+module DEBUGGER__
+  M_INSTANCE_VARIABLES = method(:instance_variables).unbind
+  M_INSTANCE_VARIABLE_GET = method(:instance_variable_get).unbind
+  M_CLASS = method(:class).unbind
+  M_SINGLETON_CLASS = method(:singleton_class).unbind
+  M_KIND_OF_P = method(:kind_of?).unbind
+  M_RESPOND_TO_P = method(:respond_to?).unbind
+  M_METHOD = method(:method).unbind
+  M_OBJECT_ID = method(:object_id).unbind
+  M_NAME = method(:name).unbind
+
+  module SkipPathHelper
+    def skip_path?(path)
+      !path ||
+      DEBUGGER__.skip? ||
+      ThreadClient.current.management? ||
+      skip_internal_path?(path) ||
+      skip_config_skip_path?(path)
+    end
+
+    def skip_config_skip_path?(path)
+      (skip_paths = CONFIG[:skip_path]) && skip_paths.any?{|skip_path| path.match?(skip_path)}
+    end
+
+    def skip_internal_path?(path)
+      path.start_with?(__dir__) || path.delete_prefix('!eval:').start_with?('<internal:')
+    end
+
+    def skip_location?(loc)
+      loc_path = loc.absolute_path || "!eval:#{loc.path}"
+      skip_path?(loc_path)
+    end
+  end
+
+  module GlobalVariablesHelper
+    SKIP_GLOBAL_LIST = %i[$= $KCODE $-K $SAFE $FILENAME].freeze
+    def safe_global_variables
+      global_variables.reject{|name| SKIP_GLOBAL_LIST.include? name }
+    end
+  end
+
+  class ThreadClient
+    def self.current
+      Thread.current.debug_thread_client ||= SESSION.get_thread_client
+    end
+
+    include Color
+    include SkipPathHelper
+    include GlobalVariablesHelper
+
+    attr_reader :thread, :id, :recorder, :check_bp_fulfillment_map
+
+    def location
+      current_frame&.location
+    end
+
+    def assemble_arguments(args)
+      args.map do |arg|
+        "#{colorize_cyan(arg[:name])}=#{arg[:value]}"
+      end.join(", ")
+    end
+
+    def default_frame_formatter frame
+      call_identifier_str =
+        case frame.frame_type
+        when :block
+          level, block_loc = frame.block_identifier
+          args = frame.parameters_info
+
+          if !args.empty?
+            args_str = " {|#{assemble_arguments(args)}|}"
+          end
+
+          "#{colorize_blue("block")}#{args_str} in #{colorize_blue(block_loc + level)}"
+        when :method
+          ci = frame.method_identifier
+          args = frame.parameters_info
+
+          if !args.empty?
+            args_str = "(#{assemble_arguments(args)})"
+          end
+
+          "#{colorize_blue(ci)}#{args_str}"
+        when :c
+          colorize_blue(frame.c_identifier)
+        when :other
+          colorize_blue(frame.other_identifier)
+        end
+
+      location_str = colorize(frame.location_str, [:GREEN])
+      result = "#{call_identifier_str} at #{location_str}"
+
+      if return_str = frame.return_str
+        result += " #=> #{colorize_magenta(return_str)}"
+      end
+
+      result
+    end
+
+    def initialize id, q_evt, q_cmd, thr = Thread.current
+      @is_management = false
+      @id = id
+      @thread = thr
+      @target_frames = nil
+      @q_evt = q_evt
+      @q_cmd = q_cmd
+      @step_tp = nil
+      @output = []
+      @frame_formatter = method(:default_frame_formatter)
+      @var_map = {} # { thread_local_var_id => obj } for DAP
+      @obj_map = {} # { object_id => obj } for CDP
+      @recorder = nil
+      @mode = :waiting
+      @current_frame_index = 0
+      # every thread should maintain its own CheckBreakpoint fulfillment state
+      @check_bp_fulfillment_map = {} # { check_bp => boolean }
+      set_mode :running
+      thr.instance_variable_set(:@__thread_client_id, id)
+
+      ::DEBUGGER__.info("Thread \##{@id} is created.")
+    end
+
+    def deactivate
+      @step_tp.disable if @step_tp
+    end
+
+    def management?
+      @is_management
+    end
+
+    def mark_as_management
+      @is_management = true
+    end
+
+    def set_mode mode
+      debug_mode(@mode, mode)
+      # STDERR.puts "#{@mode} => #{mode} @ #{caller.inspect}"
+      # pp caller
+
+      # mode transition check
+      case mode
+      when :running
+        raise "#{mode} is given, but #{mode}" unless self.waiting?
+      when :waiting
+        # TODO: there is waiting -> waiting
+        # raise "#{mode} is given, but #{mode}" unless self.running?
+      else
+        raise "unknown mode: #{mode}"
+      end
+
+      # DEBUGGER__.warn "#{@mode} => #{mode} @ #{self.inspect}"
+      @mode = mode
+    end
+
+    def running?
+      @mode == :running
+    end
+
+    def waiting?
+      @mode == :waiting
+    end
+
+    def name
+      "##{@id} #{@thread.name || @thread.backtrace.last}"
+    end
+
+    def close
+      @q_cmd.close
+    end
+
+    def inspect
+      if bt = @thread.backtrace
+        "#<DBG:TC #{self.id}:#{@mode}@#{bt[-1]}>"
+      else # bt can be nil
+        "#<DBG:TC #{self.id}:#{@mode}>"
+      end
+    end
+
+    def to_s
+      str = "(#{@thread.name || @thread.status})@#{current_frame&.location || @thread.to_s}"
+      str += " (not under control)" unless self.waiting?
+      str
+    end
+
+    def puts str = ''
+      if @recorder&.replaying?
+        prefix = colorize_dim("[replay] ")
+      end
+      case str
+      when nil
+        @output << "\n"
+      when Array
+        str.each{|s| puts s}
+      else
+        @output << "#{prefix}#{str.chomp}\n"
+      end
+    end
+
+    def << req
+      debug_cmd(req)
+      @q_cmd << req
+    end
+
+    def generate_info
+      return unless current_frame
+
+      { location: current_frame.location_str, line: current_frame.location.lineno }
+    end
+
+    def event! ev, *args
+      debug_event(ev, args)
+      @q_evt << [self, @output, ev, generate_info, *args]
+      @output = []
+    end
+
+    ## events
+
+    def wait_reply event_arg
+      return if management?
+
+      set_mode :waiting
+
+      event!(*event_arg)
+      wait_next_action
+    end
+
+    def on_load iseq, eval_src
+      wait_reply [:load, iseq, eval_src]
+    end
+
+    def on_init name
+      wait_reply [:init, name]
+    end
+
+    def on_trace trace_id, msg
+      wait_reply [:trace, trace_id, msg]
+    end
+
+    def on_breakpoint tp, bp
+      suspend tp.event, tp, bp: bp
+    end
+
+    def on_trap sig
+      if waiting?
+        # raise Interrupt
+      else
+        suspend :trap, sig: sig
+      end
+    end
+
+    def on_pause
+      suspend :pause
+    end
+
+    def suspend event, tp = nil, bp: nil, sig: nil, postmortem_frames: nil, replay_frames: nil, postmortem_exc: nil
+      return if management?
+      debug_suspend(event)
+
+      @current_frame_index = 0
+
+      case
+      when postmortem_frames
+        @target_frames = postmortem_frames
+        @postmortem = true
+      when replay_frames
+        @target_frames = replay_frames
+      else
+        @target_frames = DEBUGGER__.capture_frames(__dir__)
+      end
+
+      cf = @target_frames.first
+      if cf
+        case event
+        when :return, :b_return, :c_return
+          cf.has_return_value = true
+          cf.return_value = tp.return_value
+        end
+
+        if CatchBreakpoint === bp
+          cf.has_raised_exception = true
+          cf.raised_exception = bp.last_exc
+        end
+
+        if postmortem_exc
+          cf.has_raised_exception = true
+          cf.raised_exception = postmortem_exc
+        end
+      end
+
+      if event != :pause
+        unless bp&.skip_src
+          show_src
+          show_frames CONFIG[:show_frames]
+        end
+
+        set_mode :waiting
+
+        if bp
+          event! :suspend, :breakpoint, bp.key
+        elsif sig
+          event! :suspend, :trap, sig
+        else
+          event! :suspend, event
+        end
+      else
+        set_mode :waiting
+      end
+
+      wait_next_action
+    end
+
+    def replay_suspend
+      # @recorder.current_position
+      suspend :replay, replay_frames: @recorder.current_frame
+    end
+
+    ## control all
+
+    begin
+      TracePoint.new(:raise){}.enable(target_thread: Thread.current)
+      SUPPORT_TARGET_THREAD = true
+    rescue ArgumentError
+      SUPPORT_TARGET_THREAD = false
+    end
+
+    def step_tp iter, events = [:line, :b_return, :return]
+      @step_tp.disable if @step_tp
+
+      thread = Thread.current
+      subsession_id = SESSION.subsession_id
+
+      if SUPPORT_TARGET_THREAD
+        @step_tp = TracePoint.new(*events){|tp|
+          if SESSION.stop_stepping? tp.path, tp.lineno, subsession_id
+            tp.disable
+            next
+          end
+          next if !yield(tp)
+          next if tp.path.start_with?(__dir__)
+          next if tp.path.start_with?('<internal:trace_point>')
+          next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
+          loc = caller_locations(1, 1).first
+          next if skip_location?(loc)
+          next if iter && (iter -= 1) > 0
+
+          tp.disable
+          suspend tp.event, tp
+        }
+        @step_tp.enable(target_thread: thread)
+      else
+        @step_tp = TracePoint.new(*events){|tp|
+          next if thread != Thread.current
+          if SESSION.stop_stepping? tp.path, tp.lineno, subsession_id
+            tp.disable
+            next
+          end
+          next if !yield(tp)
+          next if tp.path.start_with?(__dir__)
+          next if tp.path.start_with?('<internal:trace_point>')
+          next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
+          loc = caller_locations(1, 1).first
+          next if skip_location?(loc)
+          next if iter && (iter -= 1) > 0
+
+          tp.disable
+          suspend tp.event, tp
+        }
+        @step_tp.enable
+      end
+    end
+
+    ## cmd helpers
+
+    if TracePoint.respond_to? :allow_reentry
+      def tp_allow_reentry
+        TracePoint.allow_reentry do
+          yield
+        end
+      rescue RuntimeError => e
+        # on the postmortem mode, it is not stopped in TracePoint
+        if e.message == 'No need to allow reentrance.'
+          yield
+        else
+          raise
+        end
+      end
+    else
+      def tp_allow_reentry
+        yield
+      end
+    end
+
+    def frame_eval_core src, b, binding_location: false
+      saved_target_frames = @target_frames
+      saved_current_frame_index = @current_frame_index
+
+      if b
+        file, lineno = b.source_location
+
+        tp_allow_reentry do
+          if binding_location
+            b.eval(src, file, lineno)
+          else
+            b.eval(src, "(rdbg)/#{file}")
+          end
+        end
+      else
+        frame_self = current_frame.self
+
+        tp_allow_reentry do
+          frame_self.instance_eval(src)
+        end
+      end
+    ensure
+      @target_frames = saved_target_frames
+      @current_frame_index = saved_current_frame_index
+    end
+
+    SPECIAL_LOCAL_VARS = [
+      [:raised_exception, "_raised"],
+      [:return_value,     "_return"],
+    ]
+
+    def frame_eval src, re_raise: false, binding_location: false
+      @success_last_eval = false
+
+      b = current_frame&.eval_binding || TOPLEVEL_BINDING
+
+      special_local_variables current_frame do |name, var|
+        b.local_variable_set(name, var) if /\%/ !~ name
+      end
+
+      result = frame_eval_core(src, b, binding_location: binding_location)
+
+      @success_last_eval = true
+      result
+
+    rescue SystemExit
+      raise
+    rescue Exception => e
+      return yield(e) if block_given?
+
+      puts "eval error: #{e}"
+
+      e.backtrace_locations&.each do |loc|
+        break if loc.path == __FILE__
+        puts "  #{loc}"
+      end
+      raise if re_raise
+    end
+
+    def get_src(frame,
+                max_lines:,
+                start_line: nil,
+                end_line: nil,
+                dir: +1)
+      if file_lines = frame.file_lines
+        frame_line = frame.location.lineno - 1
+
+        if CONFIG[:no_lineno]
+          lines = file_lines
+        else
+          lines = file_lines.map.with_index do |e, i|
+            cur = i == frame_line ? '=>' : '  '
+            line = colorize_dim('%4d|' % (i+1))
+            "#{cur}#{line} #{e}"
+          end
+        end
+
+        unless start_line
+          if frame.show_line
+            if dir > 0
+              start_line = frame.show_line
+            else
+              end_line = frame.show_line - max_lines
+              start_line = [end_line - max_lines, 0].max
+            end
+          else
+            start_line = [frame_line - max_lines/2, 0].max
+          end
+        end
+
+        unless end_line
+          end_line = [start_line + max_lines, lines.size].min
+        end
+
+        if start_line != end_line && max_lines
+          [start_line, end_line, lines]
+        end
+      else # no file lines
+        nil
+      end
+    rescue Exception => e
+      p e
+      pp e.backtrace
+      exit!
+    end
+
+    def show_src(frame_index: @current_frame_index, update_line: false, ignore_show_line: false, max_lines: CONFIG[:show_src_lines], **options)
+      if frame = get_frame(frame_index)
+        begin
+          if ignore_show_line
+            prev_show_line = frame.show_line
+            frame.show_line = nil
+          end
+
+          start_line, end_line, lines = *get_src(frame, max_lines: max_lines, **options)
+
+          if start_line
+            if update_line
+              frame.show_line = end_line
+            end
+
+            puts "[#{start_line+1}, #{end_line}] in #{frame.pretty_path}" if !update_line && max_lines != 1
+            puts lines[start_line...end_line]
+          else
+            puts "# No sourcefile available for #{frame.path}"
+          end
+        ensure
+          frame.show_line = prev_show_line if prev_show_line
+        end
+      end
+    end
+
+    def current_frame
+      get_frame(@current_frame_index)
+    end
+
+    def get_frame(index)
+      if @target_frames
+        @target_frames[index]
+      else
+        nil
+      end
+    end
+
+    def collect_locals(frame)
+      locals = []
+
+      if s = frame&.self
+        locals << ["%self", s]
+      end
+      special_local_variables frame do |name, val|
+        locals << [name, val]
+      end
+
+      if vars = frame&.local_variables
+        vars.each{|var, val|
+          locals << [var, val]
+        }
+      end
+
+      locals
+    end
+
+    ## cmd: show
+
+    def special_local_variables frame
+      SPECIAL_LOCAL_VARS.each do |mid, name|
+        next unless frame&.send("has_#{mid}")
+        name = name.sub('_', '%') if frame.eval_binding.local_variable_defined?(name)
+        yield name, frame.send(mid)
+      end
+    end
+
+    def show_locals pat
+      collect_locals(current_frame).each do |var, val|
+        puts_variable_info(var, val, pat)
+      end
+    end
+
+    def show_ivars pat, expr = nil
+      if expr && !expr.empty?
+        _self = frame_eval(expr);
+      elsif _self = current_frame&.self
+      else
+        _self = nil
+      end
+
+      if _self
+        M_INSTANCE_VARIABLES.bind_call(_self).sort.each{|iv|
+          value = M_INSTANCE_VARIABLE_GET.bind_call(_self, iv)
+          puts_variable_info iv, value, pat
+        }
+      end
+    end
+
+    def iter_consts c, names = {}
+      c.constants(false).sort.each{|name|
+        next if names.has_key? name
+        names[name] = nil
+        begin
+          value = c.const_get(name)
+        rescue Exception => e
+          value = e
+        end
+        yield name, value
+      }
+    end
+
+    def get_consts expr = nil, only_self: false, &block
+      if expr && !expr.empty?
+        begin
+          _self = frame_eval(expr, re_raise: true)
+        rescue Exception
+          # ignore
+        else
+          if M_KIND_OF_P.bind_call(_self, Module)
+            iter_consts _self, &block
+            return
+          else
+            puts "#{_self.inspect} (by #{expr}) is not a Module."
+          end
+        end
+      elsif _self = current_frame&.self
+        cs = {}
+        if M_KIND_OF_P.bind_call(_self, Module)
+          cs[_self] = :self
+        else
+          _self = M_CLASS.bind_call(_self)
+          cs[_self] = :self unless only_self
+        end
+
+        unless only_self
+          _self.ancestors.each{|c| break if c == Object; cs[c] = :ancestors}
+          if b = current_frame&.binding
+            b.eval('::Module.nesting').each{|c| cs[c] = :nesting unless cs.has_key? c}
+          end
+        end
+
+        names = {}
+
+        cs.each{|c, _|
+          iter_consts c, names, &block
+        }
+      end
+    end
+
+    def show_consts pat, expr = nil, only_self: false
+      get_consts expr, only_self: only_self do |name, value|
+        puts_variable_info name, value, pat
+      end
+    end
+
+    def show_globals pat
+      safe_global_variables.sort.each{|name|
+        next if SKIP_GLOBAL_LIST.include? name
+
+        value = eval(name.to_s)
+        puts_variable_info name, value, pat
+      }
+    end
+
+    def puts_variable_info label, obj, pat
+      return if pat && pat !~ label
+
+      begin
+        inspected = DEBUGGER__.safe_inspect(obj)
+      rescue Exception => e
+        inspected = e.inspect
+      end
+      mono_info = "#{label} = #{inspected}"
+
+      w = SESSION::width
+
+      if mono_info.length >= w
+        maximum_value_width = w - "#{label} = ".length
+        valstr = truncate(inspected, width: maximum_value_width)
+      else
+        valstr = colored_inspect(obj, width: 2 ** 30)
+        valstr = inspected if valstr.lines.size > 1
+      end
+
+      info = "#{colorize_cyan(label)} = #{valstr}"
+
+      puts info
+    end
+
+    def truncate(string, width:)
+      if string.start_with?("#<")
+        string[0 .. (width-5)] + '...>'
+      else
+        string[0 .. (width-4)] + '...'
+      end
+    end
+
+    ### cmd: show edit
+
+    def show_by_editor path = nil
+      unless path
+        if current_frame
+          path = current_frame.path
+        else
+          return # can't get path
+        end
+      end
+
+      if File.exist?(path)
+        if editor = (ENV['RUBY_DEBUG_EDITOR'] || ENV['EDITOR'])
+          puts "command: #{editor}"
+          puts "   path: #{path}"
+          require 'shellwords'
+          system(*Shellwords.split(editor), path)
+        else
+          puts "can not find editor setting: ENV['RUBY_DEBUG_EDITOR'] or ENV['EDITOR']"
+        end
+      else
+        puts "Can not find file: #{path}"
+      end
+    end
+
+    ### cmd: show frames
+
+    def show_frames max = nil, pattern = nil
+      if @target_frames && (max ||= @target_frames.size) > 0
+        frames = []
+        @target_frames.each_with_index{|f, i|
+          # we need to use FrameInfo#matchable_location because #location_str is for display
+          # and it may change based on configs (e.g. use_short_path)
+          next if pattern && !(f.name.match?(pattern) || f.matchable_location.match?(pattern))
+          # avoid using skip_path? because we still want to display internal frames
+          next if skip_config_skip_path?(f.matchable_location)
+
+          frames << [i, f]
+        }
+
+        size = frames.size
+        max.times{|i|
+          break unless frames[i]
+          index, frame = frames[i]
+          puts frame_str(index, frame: frame)
+        }
+        puts "  # and #{size - max} frames (use `bt' command for all frames)" if max < size
+      end
+    end
+
+    def show_frame i=0
+      puts frame_str(i)
+    end
+
+    def frame_str(i, frame: @target_frames[i])
+      cur_str = (@current_frame_index == i ? '=>' : '  ')
+      prefix = "#{cur_str}##{i}"
+      frame_string = @frame_formatter.call(frame)
+      "#{prefix}\t#{frame_string}"
+    end
+
+    ### cmd: show outline
+
+    def show_outline expr
+      begin
+        obj = frame_eval(expr, re_raise: true)
+      rescue Exception
+        # ignore
+      else
+        o = Output.new(@output)
+
+        locals = current_frame&.local_variables
+
+        klass = M_CLASS.bind_call(obj)
+        klass = obj if Class == klass || Module == klass
+
+        o.dump("constants", obj.constants) if M_RESPOND_TO_P.bind_call(obj, :constants)
+        outline_method(o, klass, obj)
+        o.dump("instance variables", M_INSTANCE_VARIABLES.bind_call(obj))
+        o.dump("class variables", klass.class_variables)
+        o.dump("locals", locals.keys) if locals
+      end
+    end
+
+    def outline_method(o, klass, obj)
+      begin
+        singleton_class = M_SINGLETON_CLASS.bind_call(obj)
+      rescue TypeError
+        singleton_class = nil
+      end
+
+      maps = class_method_map((singleton_class || klass).ancestors)
+      maps.each do |mod, methods|
+        name = mod == singleton_class ? "#{klass}.methods" : "#{mod}#methods"
+        o.dump(name, methods)
+      end
+    end
+
+    def class_method_map(classes)
+      dumped = Array.new
+      classes.reject { |mod| mod >= Object }.map do |mod|
+        methods = mod.public_instance_methods(false).select do |m|
+          dumped.push(m) unless dumped.include?(m)
+        end
+        [mod, methods]
+      end.reverse
+    end
+
+    ## cmd: breakpoint
+
+    # TODO: support non-ASCII Constant name
+    def constant_name? name
+      case name
+      when /\A::\b/
+        constant_name? $~.post_match
+      when /\A[A-Z]\w*/
+        post = $~.post_match
+        if post.empty?
+          true
+        else
+          constant_name? post
+        end
+      else
+        false
+      end
+    end
+
+    def make_breakpoint args
+      case args.first
+      when :method
+        klass_name, op, method_name, cond, cmd, path = args[1..]
+        bp = MethodBreakpoint.new(current_frame&.eval_binding || TOPLEVEL_BINDING, klass_name, op, method_name, cond: cond, command: cmd, path: path)
+        begin
+          bp.enable
+        rescue NameError => e
+          if bp.klass
+            puts "Unknown method name: \"#{e.name}\""
+          else
+            # klass_name can not be evaluated
+            if constant_name? klass_name
+              puts "Unknown constant name: \"#{e.name}\""
+            else
+              # only Class name is allowed
+              puts "Not a constant name: \"#{klass_name}\""
+              bp = nil
+            end
+          end
+
+          Session.activate_method_added_trackers if bp
+        rescue Exception => e
+          puts e.inspect
+          bp = nil
+        end
+
+        bp
+      when :watch
+        ivar, object, result, cond, command, path = args[1..]
+        WatchIVarBreakpoint.new(ivar, object, result, cond: cond, command: command, path: path)
+      else
+        raise "unknown breakpoint: #{args}"
+      end
+    end
+
+    class SuspendReplay < Exception
+    end
+
+    if ::Fiber.respond_to?(:blocking)
+      private def fiber_blocking
+        ::Fiber.blocking{yield}
+      end
+    else
+      private def fiber_blocking
+        yield
+      end
+    end
+
+    def wait_next_action
+      fiber_blocking{wait_next_action_}
+    rescue SuspendReplay
+      replay_suspend
+    end
+
+    def wait_next_action_
+      # assertions
+      raise "@mode is #{@mode}" if !waiting?
+
+      unless SESSION.active?
+        pp caller
+        set_mode :running
+        return
+      end
+
+      while true
+        begin
+          set_mode :waiting if !waiting?
+          cmds = @q_cmd.pop
+          # pp [self, cmds: cmds]
+
+          break unless cmds
+        ensure
+          set_mode :running
+        end
+
+        cmd, *args = *cmds
+
+        case cmd
+        when :continue
+          break
+
+        when :step
+          step_type = args[0]
+          iter = args[1]
+
+          case step_type
+          when :in
+            iter = iter || 1
+            if @recorder&.replaying?
+              @recorder.step_forward iter
+              raise SuspendReplay
+            else
+              step_tp iter do
+                true
+              end
+              break
+            end
+
+          when :next
+            frame = @target_frames.first
+            path = frame.location.absolute_path || "!eval:#{frame.path}"
+            line = frame.location.lineno
+            label = frame.location.base_label
+
+            if frame.iseq
+              frame.iseq.traceable_lines_norec(lines = {})
+              next_line = lines.keys.bsearch{|e| e > line}
+              if !next_line && (last_line = frame.iseq.last_line) > line
+                next_line = last_line
+              end
+            end
+
+            depth = @target_frames.first.frame_depth
+
+            step_tp iter do |tp|
+              loc = caller_locations(2, 1).first
+              loc_path = loc.absolute_path || "!eval:#{loc.path}"
+              loc_label = loc.base_label
+              loc_depth = DEBUGGER__.frame_depth - 3
+
+              case
+              when loc_depth == depth && loc_label == label
+                true
+              when loc_depth < depth
+                # lower stack depth
+                true
+              when (next_line &&
+                    loc_path == path &&
+                    (loc_lineno = loc.lineno) > line &&
+                    loc_lineno <= next_line)
+                # different frame (maybe block) but the line is before next_line
+                true
+              end
+            end
+            break
+
+          when :finish
+            finish_frames = (iter || 1) - 1
+            frame = @target_frames.first
+            goal_depth = frame.frame_depth - finish_frames - (frame.has_return_value ? 1 : 0)
+
+            step_tp nil, [:return, :b_return] do
+              DEBUGGER__.frame_depth - 3 <= goal_depth ? true : false
+            end
+            break
+
+          when :until
+            location = iter&.strip
+            frame = @target_frames.first
+            depth = frame.frame_depth - (frame.has_return_value ? 1 : 0)
+            target_location_label = frame.location.base_label
+
+            case location
+            when nil, /\A(?:(.+):)?(\d+)\z/
+              no_loc = !location
+              file = $1 || frame.location.path
+              line = ($2 ||  frame.location.lineno + 1).to_i
+
+              step_tp nil, [:line, :return] do |tp|
+                if tp.event == :line
+                  next false if no_loc && depth < DEBUGGER__.frame_depth - 3
+                  next false unless tp.path.end_with?(file)
+                  next false unless tp.lineno >= line
+                  true
+                else
+                  true if depth >= DEBUGGER__.frame_depth - 3 &&
+                          caller_locations(2, 1).first.base_label == target_location_label
+                          # TODO: imcomplete condition
+                end
+              end
+            else
+              pat = location
+              if /\A\/(.+)\/\z/ =~ pat
+                pat = Regexp.new($1)
+              end
+
+              step_tp nil, [:call, :c_call, :return] do |tp|
+                case tp.event
+                when :call, :c_call
+                  true if pat === tp.callee_id.to_s
+                else # :return, :b_return
+                  true if depth >= DEBUGGER__.frame_depth - 3 &&
+                          caller_locations(2, 1).first.base_label == target_location_label
+                          # TODO: imcomplete condition
+                end
+              end
+            end
+
+            break
+
+          when :back
+            iter = iter || 1
+            if @recorder&.can_step_back?
+              unless @recorder.backup_frames
+                @recorder.backup_frames = @target_frames
+              end
+              @recorder.step_back iter
+              raise SuspendReplay
+            else
+              puts "Can not step back more."
+              event! :result, nil
+            end
+
+          when :reset
+            if @recorder&.replaying?
+              @recorder.step_reset
+              raise SuspendReplay
+            end
+
+          else
+            raise "unknown: #{type}"
+          end
+
+        when :eval
+          eval_type, eval_src = *args
+
+          result_type = nil
+
+          case eval_type
+          when :p
+            result = frame_eval(eval_src)
+            puts "=> " + color_pp(result, 2 ** 30)
+            if alloc_path = ObjectSpace.allocation_sourcefile(result)
+              puts "allocated at #{alloc_path}:#{ObjectSpace.allocation_sourceline(result)}"
+            end
+          when :pp
+            result = frame_eval(eval_src)
+            puts color_pp(result, SESSION.width)
+            if alloc_path = ObjectSpace.allocation_sourcefile(result)
+              puts "allocated at #{alloc_path}:#{ObjectSpace.allocation_sourceline(result)}"
+            end
+          when :call
+            result = frame_eval(eval_src)
+          when :display, :try_display
+            failed_results = []
+            eval_src.each_with_index{|src, i|
+              result = frame_eval(src){|e|
+                failed_results << [i, e.message]
+                "<error: #{e.message}>"
+              }
+              puts "#{i}: #{src} = #{result}"
+            }
+
+            result_type = eval_type
+            result = failed_results
+          else
+            raise "unknown error option: #{args.inspect}"
+          end
+
+          event! :result, result_type, result
+        when :frame
+          type, arg = *args
+          case type
+          when :up
+            if @current_frame_index + 1 < @target_frames.size
+              @current_frame_index += 1
+              show_src max_lines: 1
+              show_frame(@current_frame_index)
+            end
+          when :down
+            if @current_frame_index > 0
+              @current_frame_index -= 1
+              show_src max_lines: 1
+              show_frame(@current_frame_index)
+            end
+          when :set
+            if arg
+              index = arg.to_i
+              if index >= 0 && index < @target_frames.size
+                @current_frame_index = index
+              else
+                puts "out of frame index: #{index}"
+              end
+            end
+            show_src max_lines: 1
+            show_frame(@current_frame_index)
+          else
+            raise "unsupported frame operation: #{arg.inspect}"
+          end
+
+          event! :result, nil
+
+        when :show
+          type = args.shift
+
+          case type
+          when :backtrace
+            max_lines, pattern = *args
+            show_frames max_lines, pattern
+
+          when :list
+            show_src(update_line: true, **(args.first || {}))
+
+          when :whereami
+            show_src ignore_show_line: true
+            show_frames CONFIG[:show_frames]
+
+          when :edit
+            show_by_editor(args.first)
+
+          when :default
+            pat = args.shift
+            show_locals pat
+            show_ivars  pat
+            show_consts pat, only_self: true
+
+          when :locals
+            pat = args.shift
+            show_locals pat
+
+          when :ivars
+            pat = args.shift
+            expr = args.shift
+            show_ivars pat, expr
+
+          when :consts
+            pat = args.shift
+            expr = args.shift
+            show_consts pat, expr
+
+          when :globals
+            pat = args.shift
+            show_globals pat
+
+          when :outline
+            show_outline args.first || 'self'
+
+          else
+            raise "unknown show param: " + [type, *args].inspect
+          end
+
+          event! :result, nil
+
+        when :breakpoint
+          case args[0]
+          when :method
+            bp = make_breakpoint args
+            event! :result, :method_breakpoint, bp
+          when :watch
+            ivar, cond, command, path = args[1..]
+            result = frame_eval(ivar)
+
+            if @success_last_eval
+              object =
+                if b = current_frame.binding
+                  b.receiver
+                else
+                  current_frame.self
+                end
+              bp = make_breakpoint [:watch, ivar, object, result, cond, command, path]
+              event! :result, :watch_breakpoint, bp
+            else
+              event! :result, nil
+            end
+          end
+
+        when :trace
+          case args.shift
+          when :object
+            begin
+              obj = frame_eval args.shift, re_raise: true
+              opt = args.shift
+              obj_inspect = DEBUGGER__.safe_inspect(obj)
+
+              width = 50
+
+              if obj_inspect.length >= width
+                obj_inspect = truncate(obj_inspect, width: width)
+              end
+
+              event! :result, :trace_pass, M_OBJECT_ID.bind_call(obj), obj_inspect, opt
+            rescue => e
+              puts e.message
+              event! :result, nil
+            end
+          else
+            raise "unreachable"
+          end
+
+        when :record
+          case args[0]
+          when nil
+            # ok
+          when :on
+            # enable recording
+            if !@recorder
+              @recorder = Recorder.new
+            end
+            @recorder.enable
+          when :off
+            if @recorder&.enabled?
+              @recorder.disable
+            end
+          else
+            raise "unknown: #{args.inspect}"
+          end
+
+          if @recorder&.enabled?
+            puts "Recorder for #{Thread.current}: on (#{@recorder.log.size} records)"
+          else
+            puts "Recorder for #{Thread.current}: off"
+          end
+          event! :result, nil
+
+        when :quit
+          sleep # wait for SystemExit
+        when :dap
+          process_dap args
+        when :cdp
+          process_cdp args
+        else
+          raise [cmd, *args].inspect
+        end
+      end
+
+    rescue SuspendReplay, SystemExit, Interrupt
+      raise
+    rescue Exception => e
+      STDERR.puts e.cause.inspect
+      STDERR.puts e.inspect
+      Thread.list.each{|th|
+        STDERR.puts "@@@ #{th}"
+        th.backtrace.each{|b|
+          STDERR.puts " > #{b}"
+        }
+      }
+      p ["DEBUGGER Exception: #{__FILE__}:#{__LINE__}", e, e.backtrace]
+      raise
+    ensure
+      @returning = false
+    end
+
+    def debug_event(ev, args)
+      DEBUGGER__.debug{
+        args = args.map { |arg| DEBUGGER__.safe_inspect(arg) }
+        "#{inspect} sends Event { type: #{ev.inspect}, args: #{args} } to Session"
+      }
+    end
+
+    def debug_mode(old_mode, new_mode)
+      DEBUGGER__.debug{
+        "#{inspect} changes mode (#{old_mode} -> #{new_mode})"
+      }
+    end
+
+    def debug_cmd(cmds)
+      DEBUGGER__.debug{
+        cmd, *args = *cmds
+        args = args.map { |arg| DEBUGGER__.safe_inspect(arg) }
+        "#{inspect} receives Cmd { type: #{cmd.inspect}, args: #{args} } from Session"
+      }
+    end
+
+    def debug_suspend(event)
+      DEBUGGER__.debug{
+        "#{inspect} is suspended for #{event.inspect}"
+      }
+    end
+
+    class Recorder
+      attr_reader :log, :index
+      attr_accessor :backup_frames
+
+      include SkipPathHelper
+
+      def initialize
+        @log = []
+        @index = 0
+        @backup_frames = nil
+        thread = Thread.current
+
+        @tp_recorder ||= TracePoint.new(:line){|tp|
+          next unless Thread.current == thread
+          # can't be replaced by skip_location
+          next if skip_internal_path?(tp.path)
+          loc = caller_locations(1, 1).first
+          next if skip_location?(loc)
+
+          frames = DEBUGGER__.capture_frames(__dir__)
+          frames.each{|frame|
+            if b = frame.binding
+              frame.binding = nil
+              frame._local_variables = b.local_variables.map{|name|
+                [name, b.local_variable_get(name)]
+              }.to_h
+              frame._callee = b.eval('__callee__')
+            end
+          }
+          append(frames)
+        }
+      end
+
+      def append frames
+        @log << frames
+      end
+
+      def enable
+        unless @tp_recorder.enabled?
+          @log.clear
+          @tp_recorder.enable
+        end
+      end
+
+      def disable
+        if @tp_recorder.enabled?
+          @log.clear
+          @tp_recorder.disable
+        end
+      end
+
+      def enabled?
+        @tp_recorder.enabled?
+      end
+
+      def step_back iter
+        @index += iter
+        if @index > @log.size
+          @index = @log.size
+        end
+      end
+
+      def step_forward iter
+        @index -= iter
+        if @index < 0
+          @index = 0
+        end
+      end
+
+      def step_reset
+        @index = 0
+        @backup_frames = nil
+      end
+
+      def replaying?
+        @index > 0
+      end
+
+      def can_step_back?
+        log.size > @index
+      end
+
+      def log_index
+        @log.size - @index
+      end
+
+      def current_frame
+        if @index == 0
+          f = @backup_frames
+          @backup_frames = nil
+          f
+        else
+          frames = @log[log_index]
+          frames
+        end
+      end
+
+      # for debugging
+      def current_position
+        puts "INDEX: #{@index}"
+        li = log_index
+        @log.each_with_index{|frame, i|
+          loc = frame.first&.location
+          prefix = i == li ? "=> " : '   '
+          puts "#{prefix} #{loc}"
+        }
+      end
+    end
+
+    # copied from irb
+    class Output
+      include Color
+
+      MARGIN = "  "
+
+      def initialize(output)
+        @output = output
+        @line_width = screen_width - MARGIN.length # right padding
+      end
+
+      def dump(name, strs)
+        strs = strs.sort
+        return if strs.empty?
+
+        line = "#{colorize_blue(name)}: "
+
+        # Attempt a single line
+        if fits_on_line?(strs, cols: strs.size, offset: "#{name}: ".length)
+          line += strs.join(MARGIN)
+          @output << line
+          return
+        end
+
+        # Multi-line
+        @output << line
+
+        # Dump with the largest # of columns that fits on a line
+        cols = strs.size
+        until fits_on_line?(strs, cols: cols, offset: MARGIN.length) || cols == 1
+          cols -= 1
+        end
+        widths = col_widths(strs, cols: cols)
+        strs.each_slice(cols) do |ss|
+          @output << ss.map.with_index { |s, i| "#{MARGIN}%-#{widths[i]}s" % s }.join
+        end
+      end
+
+      private
+
+      def fits_on_line?(strs, cols:, offset: 0)
+        width = col_widths(strs, cols: cols).sum + MARGIN.length * (cols - 1)
+        width <= @line_width - offset
+      end
+
+      def col_widths(strs, cols:)
+        cols.times.map do |col|
+          (col...strs.size).step(cols).map do |i|
+            strs[i].length
+          end.max
+        end
+      end
+
+      def screen_width
+        SESSION.width
+      rescue Errno::EINVAL # in `winsize': Invalid argument - <STDIN>
+        80
+      end
+    end
+    private_constant :Output
+  end
+end