debug 1.3.3 → 1.5.0

data/lib/debug/session.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+return if ENV['RUBY_DEBUG_ENABLE'] == '0'
+
 # skip to load debugger for bundle exec
 
 if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
   trace_var(:$0) do |file|
     trace_var(:$0, nil)
-    if /-r (#{__dir__}\S+)/ =~ ENV['RUBYOPT']
+    if /-r (#{Regexp.escape(__dir__)}\S+)/ =~ ENV['RUBYOPT']
       lib = $1
       $LOADED_FEATURES.delete_if{|path| path.start_with?(__dir__)}
       ENV['RUBY_DEBUG_INITIAL_SUSPEND_PATH'] = file
@@ -29,7 +31,7 @@ $LOADED_FEATURES << 'debug.rb'
 $LOADED_FEATURES << File.expand_path(File.join(__dir__, '..', 'debug.rb'))
 require 'debug' # invalidate the $LOADED_FEATURE cache
 
-require 'json' if ENV['RUBY_DEBUG_TEST_MODE']
+require 'json' if ENV['RUBY_DEBUG_TEST_UI'] == 'terminal'
 
 class RubyVM::InstructionSequence
   def traceable_lines_norec lines
@@ -54,23 +56,22 @@ class RubyVM::InstructionSequence
 
   def type
     self.to_a[9]
-  end
+  end unless method_defined?(:type)
 
-  def argc
-    self.to_a[4][:arg_size]
-  end
-
-  def locals
-    self.to_a[10]
-  end
+  def parameters_symbols
+    ary = self.to_a
+    argc = ary[4][:arg_size]
+    locals = ary.to_a[10]
+    locals[0...argc]
+  end unless method_defined?(:parameters_symbols)
 
   def last_line
     self.to_a[4][:code_location][2]
-  end
+  end unless method_defined?(:last_line)
 
   def first_line
     self.to_a[4][:code_location][0]
-  end
+  end unless method_defined?(:first_line)
 end
 
 module DEBUGGER__
@@ -80,8 +81,10 @@ module DEBUGGER__
   class Session
     attr_reader :intercepted_sigint_cmd, :process_group
 
-    def initialize ui
-      @ui = ui
+    include Color
+
+    def initialize
+      @ui = nil
       @sr = SourceRepository.new
       @bps = {} # bp.key => bp
                 #   [file, line] => LineBreakpoint
@@ -99,17 +102,17 @@ module DEBUGGER__
       @preset_command = nil
       @postmortem_hook = nil
       @postmortem = false
-      @thread_stopper = nil
       @intercept_trap_sigint = false
       @intercepted_sigint_cmd = 'DEFAULT'
       @process_group = ProcessGroup.new
-      @subsession = nil
+      @subsession_stack = []
 
-      @frame_map = {} # {id => [threadId, frame_depth]} for DAP
+      @frame_map = {} # for DAP: {id => [threadId, frame_depth]} and CDP: {id => frame_depth}
       @var_map   = {1 => [:globals], } # {id => ...} for DAP
       @src_map   = {} # {id => src}
 
-      @script_paths = [File.absolute_path($0)] # for CDP
+      @scr_id_map = {} # for CDP
+      @obj_map = {} # { object_id => ... } for CDP
 
       @tp_thread_begin = nil
       @tp_load_script = TracePoint.new(:script_compiled){|tp|
@@ -117,8 +120,7 @@ module DEBUGGER__
       }
       @tp_load_script.enable
 
-      activate
-
+      @thread_stopper = thread_stopper
       self.postmortem = CONFIG[:postmortem]
     end
 
@@ -130,15 +132,13 @@ module DEBUGGER__
       @bps.has_key? [file, line]
     end
 
-    def activate on_fork: false
+    def activate ui = nil, on_fork: false
+      @ui = ui if ui
+
       @tp_thread_begin&.disable
       @tp_thread_begin = nil
 
-      if on_fork
-        @ui.activate self, on_fork: true
-      else
-        @ui.activate self, on_fork: false
-      end
+      @ui.activate self, on_fork: on_fork
 
       q = Queue.new
       @session_server = Thread.new do
@@ -147,15 +147,15 @@ module DEBUGGER__
 
         # Thread management
         setup_threads
-        thc = thread_client Thread.current
-        thc.is_management
+        thc = get_thread_client Thread.current
+        thc.mark_as_management
 
-        if @ui.respond_to?(:reader_thread) && thc = thread_client(@ui.reader_thread)
-          thc.is_management
+        if @ui.respond_to?(:reader_thread) && thc = get_thread_client(@ui.reader_thread)
+          thc.mark_as_management
         end
 
         @tp_thread_begin = TracePoint.new(:thread_begin) do |tp|
-          thread_client
+          get_thread_client
         end
         @tp_thread_begin.enable
 
@@ -168,12 +168,12 @@ module DEBUGGER__
     end
 
     def deactivate
-      thread_client.deactivate
-      @thread_stopper.disable if @thread_stopper
+      get_thread_client.deactivate
+      @thread_stopper.disable
       @tp_load_script.disable
       @tp_thread_begin.disable
-      @bps.each{|k, bp| bp.disable}
-      @th_clients.each{|th, thc| thc.close}
+      @bps.each_value{|bp| bp.disable}
+      @th_clients.each_value{|thc| thc.close}
       @tracers.values.each{|t| t.disable}
       @q_evt.close
       @ui&.deactivate
@@ -211,6 +211,7 @@ module DEBUGGER__
         q << true
 
       when :init
+        enter_subsession
         wait_command_loop tc
 
       when :load
@@ -233,12 +234,13 @@ module DEBUGGER__
         case ev_args.first
         when :breakpoint
           bp, i = bp_index ev_args[1]
+          clean_bps unless bp
           @ui.event :suspend_bp, i, bp, tc.id
         when :trap
           @ui.event :suspend_trap, sig = ev_args[1], tc.id
 
           if sig == :SIGINT && (@intercepted_sigint_cmd.kind_of?(Proc) || @intercepted_sigint_cmd.kind_of?(String))
-            @ui.puts "#{@intercepted_sigint_cmd.inspect} is registerred as SIGINT handler."
+            @ui.puts "#{@intercepted_sigint_cmd.inspect} is registered as SIGINT handler."
             @ui.puts "`sigint` command execute it."
           end
         else
@@ -252,7 +254,7 @@ module DEBUGGER__
         end
 
       when :result
-        raise "[BUG] not in subsession" unless @subsession
+        raise "[BUG] not in subsession" if @subsession_stack.empty?
 
         case ev_args.first
         when :try_display
@@ -364,7 +366,7 @@ module DEBUGGER__
           @ui.puts "(rdbg:#{@preset_command.source}) #{line}"
         end
       else
-        @ui.puts "INTERNAL_INFO: #{JSON.generate(@internal_info)}" if ENV['RUBY_DEBUG_TEST_MODE']
+        @ui.puts "INTERNAL_INFO: #{JSON.generate(@internal_info)}" if ENV['RUBY_DEBUG_TEST_UI'] == 'terminal'
         line = @ui.readline prompt
       end
 
@@ -418,10 +420,15 @@ module DEBUGGER__
       # * `fin[ish]`
       #   * Finish this frame. Resume the program until the current frame is finished.
       # * `fin[ish] <n>`
-      #   * Finish frames, same as `step <n>`.
+      #   * Finish `<n>`th frames.
       when 'fin', 'finish'
         cancel_auto_continue
         check_postmortem
+
+        if arg&.to_i == 0
+          raise 'finish command with 0 does not make sense.'
+        end
+
         step_command :finish, arg
 
       # * `c[ontinue]`
@@ -447,7 +454,7 @@ module DEBUGGER__
         leave_subsession nil
 
       # * `kill`
-      #   * Stop the debuggee process with `Kernal#exit!`.
+      #   * Stop the debuggee process with `Kernel#exit!`.
       when 'kill'
         if ask 'Really kill?'
           exit! (arg || 1).to_i
@@ -461,7 +468,7 @@ module DEBUGGER__
         exit! (arg || 1).to_i
 
       # * `sigint`
-      #   * Execute SIGINT handler registerred by the debuggee.
+      #   * Execute SIGINT handler registered by the debuggee.
       #   * Note that this command should be used just after stop by `SIGINT`.
       when 'sigint'
         begin
@@ -500,6 +507,8 @@ module DEBUGGER__
       #   * break and run `<command>` before stopping.
       # * `b[reak] ... do: <command>`
       #   * break and run `<command>`, and continue.
+      # * `b[reak] ... path: <path>`
+      #   * break if the path matches to `<path>`. `<path>` can be a regexp with `/regexp/`.
       # * `b[reak] if: <expr>`
       #   * break if: `<expr>` is true at any lines.
       #   * Note that this feature is super slow.
@@ -526,7 +535,7 @@ module DEBUGGER__
         require 'json'
 
         h = Hash.new{|h, k| h[k] = []}
-        @bps.each{|key, bp|
+        @bps.each_value{|bp|
           if LineBreakpoint === bp
             h[bp.path] << {lnum: bp.line}
           end
@@ -548,6 +557,14 @@ module DEBUGGER__
 
       # * `catch <Error>`
       #   * Set breakpoint on raising `<Error>`.
+      # * `catch ... if: <expr>`
+      #   * stops only if `<expr>` is true as well.
+      # * `catch ... pre: <command>`
+      #   * runs `<command>` before stopping.
+      # * `catch ... do: <command>`
+      #   * stops and run `<command>`, and continue.
+      # * `catch ... path: <path>`
+      #   * stops if the exception is raised from a `<path>`. `<path>` can be a regexp with `/regexp/`.
       when 'catch'
         check_postmortem
 
@@ -562,11 +579,19 @@ module DEBUGGER__
       # * `watch @ivar`
       #   * Stop the execution when the result of current scope's `@ivar` is changed.
       #   * Note that this feature is super slow.
+      # * `watch ... if: <expr>`
+      #   * stops only if `<expr>` is true as well.
+      # * `watch ... pre: <command>`
+      #   * runs `<command>` before stopping.
+      # * `watch ... do: <command>`
+      #   * stops and run `<command>`, and continue.
+      # * `watch ... path: <path>`
+      #   * stops if the path matches `<path>`. `<path>` can be a regexp with `/regexp/`.
       when 'wat', 'watch'
         check_postmortem
 
         if arg && arg.match?(/\A@\w+/)
-          @tc << [:breakpoint, :watch, arg]
+          repl_add_watch_breakpoint(arg)
         else
           show_bps
           return :retry
@@ -671,8 +696,8 @@ module DEBUGGER__
       #   * Show information about accessible constants except toplevel constants.
       # * `i[nfo] g[lobal[s]]`
       #   * Show information about global variables
-      # * `i[nfo] ... </pattern/>`
-      #   * Filter the output with `</pattern/>`.
+      # * `i[nfo] ... /regexp/`
+      #   * Filter the output with `/regexp/`.
       # * `i[nfo] th[read[s]]`
       #   * Show all threads (same as `th[read]`).
       when 'i', 'info'
@@ -806,8 +831,8 @@ module DEBUGGER__
       #   * Add an exception tracer. It indicates raising exceptions.
       # * `trace object <expr>`
       #   * Add an object tracer. It indicates that an object by `<expr>` is passed as a parameter or a receiver on method call.
-      # * `trace ... </pattern/>`
-      #   * Indicates only matched events to `</pattern/>` (RegExp).
+      # * `trace ... /regexp/`
+      #   * Indicates only matched events to `/regexp/`.
       # * `trace ... into: <file>`
       #   * Save trace information into: `<file>`.
       # * `trace off <num>`
@@ -902,7 +927,7 @@ module DEBUGGER__
         when nil, 'list', 'l'
           thread_list
         when /(\d+)/
-          thread_switch $1.to_i
+          switch_thread $1.to_i
         else
           @ui.puts "unknown thread command: #{arg}"
         end
@@ -950,7 +975,7 @@ module DEBUGGER__
       when 'open'
         case arg&.downcase
         when '', nil
-          repl_open_unix
+          repl_open
         when 'vscode'
           repl_open_vscode
         when /\A(.+):(\d+)\z/
@@ -975,11 +1000,7 @@ module DEBUGGER__
       # * `h[elp] <command>`
       #   * Show help for the given command.
       when 'h', 'help', '?'
-        if arg
-          show_help arg
-        else
-          @ui.puts DEBUGGER__.help
-        end
+        show_help arg
         return :retry
 
       ### END
@@ -1016,8 +1037,8 @@ module DEBUGGER__
     def repl_open_setup
       @tp_thread_begin.disable
       @ui.activate self
-      if @ui.respond_to?(:reader_thread) && thc = thread_client(@ui.reader_thread)
-        thc.is_management
+      if @ui.respond_to?(:reader_thread) && thc = get_thread_client(@ui.reader_thread)
+        thc.mark_as_management
       end
       @tp_thread_begin.enable
     end
@@ -1027,14 +1048,14 @@ module DEBUGGER__
       repl_open_setup
     end
 
-    def repl_open_unix
-      DEBUGGER__.open_unix nonstop: true
+    def repl_open
+      DEBUGGER__.open nonstop: true
       repl_open_setup
     end
 
     def repl_open_vscode
       CONFIG[:open_frontend] = 'vscode'
-      repl_open_unix
+      repl_open
     end
 
     def step_command type, arg
@@ -1131,16 +1152,50 @@ module DEBUGGER__
       end
     end
 
-    def show_help arg
-      DEBUGGER__.helps.each{|cat, cs|
-        cs.each{|ws, desc|
-          if ws.include? arg
-            @ui.puts desc
-            return
+    def show_help arg = nil
+      instructions = (DEBUGGER__.commands.keys + DEBUGGER__.commands.values).uniq
+      print_instructions = proc do |desc|
+        desc.split("\n").each do |line|
+          next if line.start_with?(" ") # workaround for step back
+          formatted_line = line.gsub(/[\[\]\*]/, "").strip
+          instructions.each do |inst|
+            if formatted_line.start_with?("`#{inst}")
+              desc.sub!(line, colorize(line, [:CYAN, :BOLD]))
+            end
+          end
+        end
+        @ui.puts desc
+      end
+
+      print_category = proc do |cat|
+        @ui.puts "\n"
+        @ui.puts colorize("### #{cat}", [:GREEN, :BOLD])
+        @ui.puts "\n"
+      end
+
+      DEBUGGER__.helps.each { |cat, cs|
+        # categories
+        if arg.nil?
+          print_category.call(cat)
+        else
+          cs.each { |ws, _|
+            if ws.include?(arg)
+              print_category.call(cat)
+              break
+            end
+          }
+        end
+
+        # instructions
+        cs.each { |ws, desc|
+          if arg.nil? || ws.include?(arg)
+            print_instructions.call(desc.dup)
+            return if arg
           end
         }
       }
-      @ui.puts "not found: #{arg}"
+
+      @ui.puts "not found: #{arg}" if arg
     end
 
     def ask msg, default = 'Y'
@@ -1195,6 +1250,12 @@ module DEBUGGER__
       }
     end
 
+    def clean_bps
+      @bps.delete_if{|_k, bp|
+        bp.deleted?
+      }
+    end
+
     def add_bp bp
       # don't repeat commands that add breakpoints
       @repl_prev_line = nil
@@ -1225,7 +1286,7 @@ module DEBUGGER__
       end
     end
 
-    BREAK_KEYWORDS = %w(if: do: pre:).freeze
+    BREAK_KEYWORDS = %w(if: do: pre: path:).freeze
 
     def parse_break arg
       mode = :sig
@@ -1238,13 +1299,20 @@ module DEBUGGER__
         end
       }
       expr.default_proc = nil
-      expr.transform_values{|v| v.join(' ')}
+      expr = expr.transform_values{|v| v.join(' ')}
+
+      if (path = expr[:path]) && path =~ /\A\/(.*)\/\z/
+        expr[:path] = Regexp.compile($1)
+      end
+
+      expr
     end
 
     def repl_add_breakpoint arg
       expr = parse_break arg.strip
       cond = expr[:if]
       cmd = ['break', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+      path = expr[:path]
 
       case expr[:sig]
       when /\A(\d+)\z/
@@ -1252,10 +1320,10 @@ module DEBUGGER__
       when /\A(.+)[:\s+](\d+)\z/
         add_line_breakpoint $1, $2.to_i, cond: cond, command: cmd
       when /\A(.+)([\.\#])(.+)\z/
-        @tc << [:breakpoint, :method, $1, $2, $3, cond, cmd]
+        @tc << [:breakpoint, :method, $1, $2, $3, cond, cmd, path]
         return :noretry
       when nil
-        add_check_breakpoint cond
+        add_check_breakpoint cond, path, cmd
       else
         @ui.puts "Unknown breakpoint format: #{arg}"
         @ui.puts
@@ -1267,18 +1335,28 @@ module DEBUGGER__
       expr = parse_break arg.strip
       cond = expr[:if]
       cmd = ['catch', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+      path = expr[:path]
 
-      bp = CatchBreakpoint.new(expr[:sig], cond: cond, command: cmd)
+      bp = CatchBreakpoint.new(expr[:sig], cond: cond, command: cmd, path: path)
       add_bp bp
     end
 
+    def repl_add_watch_breakpoint arg
+      expr = parse_break arg.strip
+      cond = expr[:if]
+      cmd = ['watch', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+      path = Regexp.compile(expr[:path]) if expr[:path]
+
+      @tc << [:breakpoint, :watch, expr[:sig], cond, cmd, path]
+    end
+
     def add_catch_breakpoint pat
       bp = CatchBreakpoint.new(pat)
       add_bp bp
     end
 
-    def add_check_breakpoint expr
-      bp = CheckBreakpoint.new(expr)
+    def add_check_breakpoint cond, path, command
+      bp = CheckBreakpoint.new(cond: cond, path: path, command: command)
       add_bp bp
     end
 
@@ -1291,6 +1369,20 @@ module DEBUGGER__
       @ui.puts e.message
     end
 
+    def clear_line_breakpoints path
+      path = resolve_path(path)
+      @bps.delete_if do |k, bp|
+        if (Array === k) && DEBUGGER__.compare_path(k.first, path)
+          bp.delete
+        end
+      end
+    end
+
+    def add_iseq_breakpoint iseq, **kw
+      bp = ISeqBreakpoint.new(iseq, [:line], **kw)
+      add_bp bp
+    end
+
     # tracers
 
     def add_tracer tracer
@@ -1344,7 +1436,7 @@ module DEBUGGER__
       thcs
     end
 
-    def thread_switch n
+    def switch_thread n
       thcs, _unmanaged_ths = update_thread_list
 
       if tc = thcs[n]
@@ -1365,7 +1457,7 @@ module DEBUGGER__
         if tc = prev_clients[th]
           @th_clients[th] = tc
         else
-          thread_client_create(th)
+          create_thread_client(th)
         end
       }
     end
@@ -1374,17 +1466,17 @@ module DEBUGGER__
       if @th_clients.has_key? th
         # TODO: NG?
       else
-        thread_client_create th
+        create_thread_client th
       end
     end
 
-    private def thread_client_create th
+    private def create_thread_client th
       # TODO: Ractor support
       raise "Only session_server can create thread_client" unless Thread.current == @session_server
       @th_clients[th] = ThreadClient.new((@tc_id += 1), @q_evt, Queue.new, th)
     end
 
-    private def ask_thread_client th = Thread.current
+    private def ask_thread_client th
       # TODO: Ractor support
       q2 = Queue.new
       # tc, output, ev, @internal_info, *ev_args = evt
@@ -1395,30 +1487,18 @@ module DEBUGGER__
     end
 
     # can be called by other threads
-    def thread_client th = Thread.current
+    def get_thread_client th = Thread.current
       if @th_clients.has_key? th
         @th_clients[th]
       else
         if Thread.current == @session_server
-          thread_client_create th
+          create_thread_client th
         else
           ask_thread_client th
         end
       end
     end
 
-    private def thread_stopper
-      @thread_stopper ||= TracePoint.new(:line) do
-        # run on each thread
-        tc = ThreadClient.current
-        next if tc.management?
-        next unless tc.running?
-        next if tc == @tc
-
-        tc.on_pause
-      end
-    end
-
     private def running_thread_clients_count
       @th_clients.count{|th, tc|
         next if tc.management?
@@ -1435,15 +1515,27 @@ module DEBUGGER__
       }.compact
     end
 
+    private def thread_stopper
+      TracePoint.new(:line) do
+        # run on each thread
+        tc = ThreadClient.current
+        next if tc.management?
+        next unless tc.running?
+        next if tc == @tc
+
+        tc.on_pause
+      end
+    end
+
     private def stop_all_threads
       return if running_thread_clients_count == 0
 
-      stopper = thread_stopper
+      stopper = @thread_stopper
       stopper.enable unless stopper.enabled?
     end
 
     private def restart_all_threads
-      stopper = thread_stopper
+      stopper = @thread_stopper
       stopper.disable if stopper.enabled?
 
       waiting_thread_clients.each{|tc|
@@ -1453,27 +1545,38 @@ module DEBUGGER__
     end
 
     private def enter_subsession
-      raise "already in subsession" if @subsession
-      @subsession = true
-      stop_all_threads
-      @process_group.lock
-      DEBUGGER__.info "enter_subsession"
+      if !@subsession_stack.empty?
+        DEBUGGER__.info "Enter subsession (nested #{@subsession_stack.size})"
+      else
+        DEBUGGER__.info "Enter subsession"
+        stop_all_threads
+        @process_group.lock
+      end
+
+      @subsession_stack << true
     end
 
     private def leave_subsession type
-      DEBUGGER__.info "leave_subsession"
-      @process_group.unlock
-      restart_all_threads
+      raise '[BUG] leave_subsession: not entered' if @subsession_stack.empty?
+      @subsession_stack.pop
+
+      if @subsession_stack.empty?
+        DEBUGGER__.info "Leave subsession"
+        @process_group.unlock
+        restart_all_threads
+      else
+        DEBUGGER__.info "Leave subsession (nested #{@subsession_stack.size})"
+      end
+
       @tc << type if type
       @tc = nil
-      @subsession = false
     rescue Exception => e
-      STDERR.puts [e, e.backtrace].inspect
+      STDERR.puts PP.pp([e, e.backtrace], ''.dup)
       raise
     end
 
     def in_subsession?
-      @subsession
+      !@subsession_stack.empty?
     end
 
     ## event
@@ -1487,7 +1590,7 @@ module DEBUGGER__
       end
 
       pending_line_breakpoints.each do |_key, bp|
-        if bp.path == (iseq.absolute_path || iseq.path)
+        if DEBUGGER__.compare_path(bp.path, (iseq.absolute_path || iseq.path))
           bp.try_activate
         end
       end
@@ -1550,7 +1653,7 @@ module DEBUGGER__
 
       frames = exc.instance_variable_get(:@__debugger_postmortem_frames)
       @postmortem = true
-      ThreadClient.current.suspend :postmortem, postmortem_frames: frames
+      ThreadClient.current.suspend :postmortem, postmortem_frames: frames, postmortem_exc: exc
     ensure
       @postmortem = false
     end
@@ -1810,6 +1913,9 @@ module DEBUGGER__
         puts "\nStop by #{args.first}"
       end
     end
+
+    def flush
+    end
   end
 
   # manual configuration methods
@@ -1822,11 +1928,11 @@ module DEBUGGER__
     ::DEBUGGER__::SESSION.add_catch_breakpoint pat
   end
 
-  # String for requring location
+  # String for requiring location
   # nil for -r
   def self.require_location
     locs = caller_locations
-    dir_prefix = /#{__dir__}/
+    dir_prefix = /#{Regexp.escape(__dir__)}/
 
     locs.each do |loc|
       case loc.absolute_path
@@ -1846,7 +1952,7 @@ module DEBUGGER__
 
     unless defined? SESSION
       require_relative 'local'
-      initialize_session UI_LocalConsole.new
+      initialize_session{ UI_LocalConsole.new }
     end
 
     setup_initial_suspend unless nonstop
@@ -1854,8 +1960,9 @@ module DEBUGGER__
 
   def self.open host: nil, port: CONFIG[:port], sock_path: nil, sock_dir: nil, nonstop: false, **kw
     CONFIG.set_config(**kw)
+    require_relative 'server'
 
-    if port || CONFIG[:open_frontend] == 'chrome'
+    if port || CONFIG[:open_frontend] == 'chrome' || (!::Addrinfo.respond_to?(:unix))
       open_tcp host: host, port: (port || 0), nonstop: nonstop
     else
       open_unix sock_path: sock_path, sock_dir: sock_dir, nonstop: nonstop
@@ -1869,7 +1976,7 @@ module DEBUGGER__
     if defined? SESSION
       SESSION.reset_ui UI_TcpServer.new(host: host, port: port)
     else
-      initialize_session UI_TcpServer.new(host: host, port: port)
+      initialize_session{ UI_TcpServer.new(host: host, port: port) }
     end
 
     setup_initial_suspend unless nonstop
@@ -1882,7 +1989,7 @@ module DEBUGGER__
     if defined? SESSION
       SESSION.reset_ui UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
     else
-      initialize_session UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path)
+      initialize_session{ UI_UnixDomainServer.new(sock_dir: sock_dir, sock_path: sock_path) }
     end
 
     setup_initial_suspend unless nonstop
@@ -1909,9 +2016,10 @@ module DEBUGGER__
   end
 
   class << self
-    define_method :initialize_session do |ui|
+    define_method :initialize_session do |&init_ui|
       DEBUGGER__.info "Session start (pid: #{Process.pid})"
-      ::DEBUGGER__.const_set(:SESSION, Session.new(ui))
+      ::DEBUGGER__.const_set(:SESSION, Session.new)
+      SESSION.activate init_ui.call
       load_rc
     end
   end
@@ -1960,13 +2068,17 @@ module DEBUGGER__
   METHOD_ADDED_TRACKER = self.create_method_added_tracker
 
   SHORT_INSPECT_LENGTH = 40
-  def self.short_inspect obj, use_short = true
+
+  def self.safe_inspect obj, max_length: SHORT_INSPECT_LENGTH, short: false
     str = obj.inspect
-    if use_short && str.length > SHORT_INSPECT_LENGTH
-      str[0...SHORT_INSPECT_LENGTH] + '...'
+
+    if short && str.length > max_length
+      str[0...max_length] + '...'
     else
       str
     end
+  rescue Exception => e
+    str = "<#inspect raises #{e.inspect}>"
   end
 
   def self.warn msg
@@ -2000,10 +2112,72 @@ module DEBUGGER__
     end
   end
 
+  def self.step_in &b
+    if defined?(SESSION) && SESSION.active?
+      SESSION.add_iseq_breakpoint RubyVM::InstructionSequence.of(b), oneshot: true
+    end
+
+    yield
+  end
+
+  if File.identical?(__FILE__.upcase, __FILE__.downcase)
+    # For case insensitive file system (like Windows)
+    # Note that this check is not enough because case sensitive/insensitive is
+    # depend on the file system. So this check is only roughly estimation.
+
+    def self.compare_path(a, b)
+      a.downcase == b.downcase
+    end
+  else
+    def self.compare_path(a, b)
+      a == b
+    end
+  end
+
   module ForkInterceptor
-    def fork(&given_block)
-      return super unless defined?(SESSION) && SESSION.active?
+    if Process.respond_to? :_fork
+      def _fork
+        return yield unless defined?(SESSION) && SESSION.active?
+
+        parent_hook, child_hook = __fork_setup_for_debugger
+
+        super.tap do |pid|
+          if pid != 0
+            # after fork: parent
+            parent_hook.call pid
+          else
+            # after fork: child
+            child_hook.call
+          end
+        end
+      end
+    else
+      def fork(&given_block)
+        return yield unless defined?(SESSION) && SESSION.active?
+        parent_hook, child_hook = __fork_setup_for_debugger
+
+        if given_block
+          new_block = proc {
+            # after fork: child
+            child_hook.call
+            given_block.call
+          }
+          super(&new_block).tap{|pid| parent_hook.call(pid)}
+        else
+          super.tap do |pid|
+            if pid
+              # after fork: parent
+              parent_hook.call pid
+            else
+              # after fork: child
+              child_hook.call
+            end
+          end
+        end
+      end
+    end
 
+    private def __fork_setup_for_debugger
       unless fork_mode = CONFIG[:fork_mode]
         if CONFIG[:parent_on_fork]
           fork_mode = :parent
@@ -2050,26 +2224,7 @@ module DEBUGGER__
         }
       end
 
-      if given_block
-        new_block = proc {
-          # after fork: child
-          child_hook.call
-          given_block.call
-        }
-        pid = super(&new_block)
-        parent_hook.call(pid)
-        pid
-      else
-        if pid = super
-          # after fork: parent
-          parent_hook.call pid
-        else
-          # after fork: child
-          child_hook.call
-        end
-
-        pid
-      end
+      return parent_hook, child_hook
     end
   end
 
@@ -2086,28 +2241,46 @@ module DEBUGGER__
     end
   end
 
-  if RUBY_VERSION >= '3.0.0'
+  if Process.respond_to? :_fork
+    module ::Process
+      class << self
+        prepend ForkInterceptor
+      end
+    end
+
+    # trap
     module ::Kernel
-      prepend ForkInterceptor
       prepend TrapInterceptor
     end
+    module ::Signal
+      class << self
+        prepend TrapInterceptor
+      end
+    end
   else
-    class ::Object
-      include ForkInterceptor
-      include TrapInterceptor
+    if RUBY_VERSION >= '3.0.0'
+      module ::Kernel
+        prepend ForkInterceptor
+        prepend TrapInterceptor
+      end
+    else
+      class ::Object
+        include ForkInterceptor
+        include TrapInterceptor
+      end
     end
-  end
 
-  module ::Kernel
-    class << self
-      prepend ForkInterceptor
-      prepend TrapInterceptor
+    module ::Kernel
+      class << self
+        prepend ForkInterceptor
+        prepend TrapInterceptor
+      end
     end
-  end
 
-  module ::Process
-    class << self
-      prepend ForkInterceptor
+    module ::Process
+      class << self
+        prepend ForkInterceptor
+      end
     end
   end