debug 1.4.0 → 1.9.2

data/lib/debug/thread_client.rb

@@ -5,32 +5,65 @@ 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].freeze
+    def safe_global_variables
+      global_variables.reject{|name| SKIP_GLOBAL_LIST.include? name }
+    end
+  end
+
   class ThreadClient
     def self.current
-      if thc = Thread.current[:DEBUGGER__ThreadClient]
-        thc
-      else
-        thc = SESSION.get_thread_client
-        Thread.current[:DEBUGGER__ThreadClient] = thc
-      end
+      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
 
-    attr_reader :location, :thread, :id, :recorder
+    def location
+      current_frame&.location
+    end
 
     def assemble_arguments(args)
       args.map do |arg|
@@ -42,7 +75,8 @@ module DEBUGGER__
       call_identifier_str =
         case frame.frame_type
         when :block
-          level, block_loc, args = frame.block_identifier
+          level, block_loc = frame.block_identifier
+          args = frame.parameters_info
 
           if !args.empty?
             args_str = " {|#{assemble_arguments(args)}|}"
@@ -50,7 +84,8 @@ module DEBUGGER__
 
           "#{colorize_blue("block")}#{args_str} in #{colorize_blue(block_loc + level)}"
         when :method
-          ci, args = frame.method_identifier
+          ci = frame.method_identifier
+          args = frame.parameters_info
 
           if !args.empty?
             args_str = "(#{assemble_arguments(args)})"
@@ -87,6 +122,9 @@ module DEBUGGER__
       @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)
 
@@ -106,6 +144,7 @@ module DEBUGGER__
     end
 
     def set_mode mode
+      debug_mode(@mode, mode)
       # STDERR.puts "#{@mode} => #{mode} @ #{caller.inspect}"
       # pp caller
 
@@ -149,14 +188,7 @@ module DEBUGGER__
     end
 
     def to_s
-      loc = current_frame&.location
-
-      if loc
-        str = "(#{@thread.name || @thread.status})@#{loc}"
-      else
-        str = "(#{@thread.name || @thread.status})@#{@thread.to_s}"
-      end
-
+      str = "(#{@thread.name || @thread.status})@#{current_frame&.location || @thread.to_s}"
       str += " (not under control)" unless self.waiting?
       str
     end
@@ -176,6 +208,7 @@ module DEBUGGER__
     end
 
     def << req
+      debug_cmd(req)
       @q_cmd << req
     end
 
@@ -186,6 +219,7 @@ module DEBUGGER__
     end
 
     def event! ev, *args
+      debug_event(ev, args)
       @q_evt << [self, @output, ev, generate_info, *args]
       @output = []
     end
@@ -231,6 +265,7 @@ module DEBUGGER__
 
     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
 
@@ -246,7 +281,6 @@ module DEBUGGER__
 
       cf = @target_frames.first
       if cf
-        @location = cf.location
         case event
         when :return, :b_return, :c_return
           cf.has_return_value = true
@@ -265,8 +299,10 @@ module DEBUGGER__
       end
 
       if event != :pause
-        show_src
-        show_frames CONFIG[:show_frames] || 2
+        unless bp&.skip_src
+          show_src
+          show_frames CONFIG[:show_frames]
+        end
 
         set_mode :waiting
 
@@ -302,11 +338,15 @@ module DEBUGGER__
       @step_tp.disable if @step_tp
 
       thread = Thread.current
+      subsession_id = SESSION.subsession_id
 
       if SUPPORT_TARGET_THREAD
         @step_tp = TracePoint.new(*events){|tp|
-          next if SESSION.break_at? tp.path, tp.lineno
-          next if !yield(tp.event)
+          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]
@@ -321,8 +361,11 @@ module DEBUGGER__
       else
         @step_tp = TracePoint.new(*events){|tp|
           next if thread != Thread.current
-          next if SESSION.break_at? tp.path, tp.lineno
-          next if !yield(tp.event)
+          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]
@@ -339,9 +382,49 @@ module DEBUGGER__
 
     ## cmd helpers
 
-    # this method is extracted to hide frame_eval's local variables from C method eval's binding
-    def instance_eval_for_cmethod frame_self, src
-      frame_self.instance_eval(src)
+    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 = [
@@ -349,25 +432,22 @@ module DEBUGGER__
       [:return_value,     "_return"],
     ]
 
-    def frame_eval src, re_raise: false
+    def frame_eval src, re_raise: false, binding_location: false
       @success_last_eval = false
 
-      b = current_frame.eval_binding
+      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 = if b
-                  f, _l = b.source_location
-                  b.eval(src, "(rdbg)/#{f}")
-                else
-                  frame_self = current_frame.self
-                  instance_eval_for_cmethod(frame_self, src)
-                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?
 
@@ -380,50 +460,46 @@ module DEBUGGER__
       raise if re_raise
     end
 
-    def show_src(frame_index: @current_frame_index,
-                 update_line: false,
-                 max_lines: CONFIG[:show_src_lines] || 10,
-                 start_line: nil,
-                 end_line: nil,
-                 dir: +1)
-      if @target_frames && frame = @target_frames[frame_index]
-        if file_lines = frame.file_lines
-          frame_line = frame.location.lineno - 1
+    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
+        unless start_line
+          if frame.show_line
+            if dir > 0
+              start_line = frame.show_line
             else
-              start_line = [frame_line - max_lines/2, 0].max
+              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 update_line
-            frame.show_line = end_line
-          end
+        unless end_line
+          end_line = [start_line + max_lines, lines.size].min
+        end
 
-          if start_line != end_line && max_lines
-            puts "[#{start_line+1}, #{end_line}] in #{frame.pretty_path}" if !update_line && max_lines != 1
-            puts lines[start_line ... end_line]
-          end
-        else # no file lines
-          puts "# No sourcefile available for #{frame.path}"
+        if start_line != end_line && max_lines
+          [start_line, end_line, lines]
         end
+      else # no file lines
+        nil
       end
     rescue Exception => e
       p e
@@ -431,14 +507,63 @@ module DEBUGGER__
       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[@current_frame_index]
+        @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
@@ -450,62 +575,86 @@ module DEBUGGER__
     end
 
     def show_locals pat
-      if s = current_frame&.self
-        puts_variable_info '%self', s, pat
-      end
-      special_local_variables current_frame do |name, val|
-        puts_variable_info name, val, pat
+      collect_locals(current_frame).each do |var, val|
+        puts_variable_info(var, val, pat)
       end
+    end
 
-      if vars = current_frame&.local_variables
-        vars.each{|var, val|
-          puts_variable_info var, val, pat
-        }
+    def show_ivars pat, expr = nil
+      if expr && !expr.empty?
+        _self = frame_eval(expr);
+      elsif _self = current_frame&.self
+      else
+        _self = nil
       end
-    end
 
-    def show_ivars pat
-      if s = current_frame&.self
-        s.instance_variables.sort.each{|iv|
-          value = s.instance_variable_get(iv)
+      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 show_consts pat, only_self: false
-      if s = current_frame&.self
+    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 s.kind_of? Module
-          cs[s] = :self
+        if M_KIND_OF_P.bind_call(_self, Module)
+          cs[_self] = :self
         else
-          s = s.class
-          cs[s] = :self unless only_self
+          _self = M_CLASS.bind_call(_self)
+          cs[_self] = :self unless only_self
         end
 
         unless only_self
-          s.ancestors.each{|c| break if c == Object; cs[c] = :ancestors}
+          _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}
+            b.eval('::Module.nesting').each{|c| cs[c] = :nesting unless cs.has_key? c}
           end
         end
 
         names = {}
 
         cs.each{|c, _|
-          c.constants(false).sort.each{|name|
-            next if names.has_key? name
-            names[name] = nil
-            value = c.const_get(name)
-            puts_variable_info name, value, pat
-          }
+          iter_consts c, names, &block
         }
       end
     end
 
-    SKIP_GLOBAL_LIST = %i[$= $KCODE $-K $SAFE].freeze
+    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
-      global_variables.sort.each{|name|
+      safe_global_variables.sort.each{|name|
         next if SKIP_GLOBAL_LIST.include? name
 
         value = eval(name.to_s)
@@ -517,7 +666,7 @@ module DEBUGGER__
       return if pat && pat !~ label
 
       begin
-        inspected = obj.inspect
+        inspected = DEBUGGER__.safe_inspect(obj)
       rescue Exception => e
         inspected = e.inspect
       end
@@ -526,28 +675,32 @@ module DEBUGGER__
       w = SESSION::width
 
       if mono_info.length >= w
-        info = truncate(mono_info, width: 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
-        info = "#{colorize_cyan(label)} = #{valstr}"
       end
 
+      info = "#{colorize_cyan(label)} = #{valstr}"
+
       puts info
     end
 
     def truncate(string, width:)
-      str = string[0 .. (width-4)] + '...'
-      str += ">" if str.start_with?("#<")
-      str
+      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 @target_frames && frame = @target_frames[@current_frame_index]
-          path = frame.path
+        if current_frame
+          path = current_frame.path
         else
           return # can't get path
         end
@@ -557,7 +710,8 @@ module DEBUGGER__
         if editor = (ENV['RUBY_DEBUG_EDITOR'] || ENV['EDITOR'])
           puts "command: #{editor}"
           puts "   path: #{path}"
-          system(editor, path)
+          require 'shellwords'
+          system(*Shellwords.split(editor), path)
         else
           puts "can not find editor setting: ENV['RUBY_DEBUG_EDITOR'] or ENV['EDITOR']"
         end
@@ -572,15 +726,11 @@ module DEBUGGER__
       if @target_frames && (max ||= @target_frames.size) > 0
         frames = []
         @target_frames.each_with_index{|f, i|
-          next if pattern && !(f.name.match?(pattern) || f.location_str.match?(pattern))
-          next if CONFIG[:skip_path] && CONFIG[:skip_path].any?{|pat|
-            case pat
-            when String
-              f.location_str.start_with?(pat)
-            when Regexp
-              f.location_str.match?(pat)
-            end
-          }
+          # 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]
         }
@@ -617,18 +767,25 @@ module DEBUGGER__
         o = Output.new(@output)
 
         locals = current_frame&.local_variables
-        klass  = (obj.class == Class || obj.class == Module ? obj : obj.class)
 
-        o.dump("constants", obj.constants) if obj.respond_to?(:constants)
+        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", obj.instance_variables)
+        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)
-      singleton_class = begin obj.singleton_class; rescue TypeError; nil end
+      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"
@@ -648,16 +805,48 @@ module DEBUGGER__
 
     ## 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, klass_name, op, method_name, cond: cond, command: cmd, path: path)
+        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.message
-          ::DEBUGGER__::METHOD_ADDED_TRACKER.enable
+          puts e.inspect
+          bp = nil
         end
 
         bp
@@ -672,8 +861,18 @@ module DEBUGGER__
     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
-      wait_next_action_
+      fiber_blocking{wait_next_action_}
     rescue SuspendReplay
       replay_suspend
     end
@@ -693,6 +892,7 @@ module DEBUGGER__
           set_mode :waiting if !waiting?
           cmds = @q_cmd.pop
           # pp [self, cmds: cmds]
+
           break unless cmds
         ensure
           set_mode :running
@@ -710,8 +910,9 @@ module DEBUGGER__
 
           case step_type
           when :in
+            iter = iter || 1
             if @recorder&.replaying?
-              @recorder.step_forward
+              @recorder.step_forward iter
               raise SuspendReplay
             else
               step_tp iter do
@@ -724,6 +925,7 @@ module DEBUGGER__
             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 = {})
@@ -735,35 +937,89 @@ module DEBUGGER__
 
             depth = @target_frames.first.frame_depth
 
-            step_tp iter do
+            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
 
-              # same stack depth
-              (DEBUGGER__.frame_depth - 3 <= depth) ||
-
-              # different frame
-              (next_line && loc_path == path &&
-               (loc_lineno = loc.lineno) > line &&
-               loc_lineno <= next_line)
+              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
-            goal_depth = @target_frames.first.frame_depth - finish_frames
+            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
+              @recorder.step_back iter
               raise SuspendReplay
             else
               puts "Can not step back more."
@@ -800,13 +1056,6 @@ module DEBUGGER__
             end
           when :call
             result = frame_eval(eval_src)
-          when :irb
-            begin
-              result = frame_eval('binding.irb')
-            ensure
-              # workaround: https://github.com/ruby/debug/issues/308
-              Reline.prompt_proc = nil if defined? Reline
-            end
           when :display, :try_display
             failed_results = []
             eval_src.each_with_index{|src, i|
@@ -853,6 +1102,7 @@ module DEBUGGER__
           else
             raise "unsupported frame operation: #{arg.inspect}"
           end
+
           event! :result, nil
 
         when :show
@@ -866,6 +1116,10 @@ module DEBUGGER__
           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)
 
@@ -881,11 +1135,13 @@ module DEBUGGER__
 
           when :ivars
             pat = args.shift
-            show_ivars pat
+            expr = args.shift
+            show_ivars pat, expr
 
           when :consts
             pat = args.shift
-            show_consts pat
+            expr = args.shift
+            show_consts pat, expr
 
           when :globals
             pat = args.shift
@@ -929,7 +1185,7 @@ module DEBUGGER__
             begin
               obj = frame_eval args.shift, re_raise: true
               opt = args.shift
-              obj_inspect = obj.inspect
+              obj_inspect = DEBUGGER__.safe_inspect(obj)
 
               width = 50
 
@@ -937,7 +1193,7 @@ module DEBUGGER__
                 obj_inspect = truncate(obj_inspect, width: width)
               end
 
-              event! :result, :trace_pass, obj.object_id, obj_inspect, opt
+              event! :result, :trace_pass, M_OBJECT_ID.bind_call(obj), obj_inspect, opt
             rescue => e
               puts e.message
               event! :result, nil
@@ -954,8 +1210,8 @@ module DEBUGGER__
             # enable recording
             if !@recorder
               @recorder = Recorder.new
-              @recorder.enable
             end
+            @recorder.enable
           when :off
             if @recorder&.enabled?
               @recorder.disable
@@ -971,6 +1227,8 @@ module DEBUGGER__
           end
           event! :result, nil
 
+        when :quit
+          sleep # wait for SystemExit
         when :dap
           process_dap args
         when :cdp
@@ -983,8 +1241,45 @@ module DEBUGGER__
     rescue SuspendReplay, SystemExit, Interrupt
       raise
     rescue Exception => e
-      pp ["DEBUGGER Exception: #{__FILE__}:#{__LINE__}", e, e.backtrace]
+      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
@@ -1001,8 +1296,8 @@ module DEBUGGER__
 
         @tp_recorder ||= TracePoint.new(:line){|tp|
           next unless Thread.current == thread
-          next if tp.path.start_with? __dir__
-          next if tp.path.start_with? '<internal:'
+          # 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)
 
@@ -1016,10 +1311,14 @@ module DEBUGGER__
               frame._callee = b.eval('__callee__')
             end
           }
-          @log << frames
+          append(frames)
         }
       end
 
+      def append frames
+        @log << frames
+      end
+
       def enable
         unless @tp_recorder.enabled?
           @log.clear
@@ -1038,12 +1337,18 @@ module DEBUGGER__
         @tp_recorder.enabled?
       end
 
-      def step_back
-        @index += 1
+      def step_back iter
+        @index += iter
+        if @index > @log.size
+          @index = @log.size
+        end
       end
 
-      def step_forward
-        @index -= 1
+      def step_forward iter
+        @index -= iter
+        if @index < 0
+          @index = 0
+        end
       end
 
       def step_reset