debug 1.4.0 → 1.9.2

data/lib/debug/session.rb

@@ -7,7 +7,7 @@ return if ENV['RUBY_DEBUG_ENABLE'] == '0'
 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
@@ -19,6 +19,15 @@ if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
   return
 end
 
+# restore RUBYOPT
+if (added_opt = ENV['RUBY_DEBUG_ADDED_RUBYOPT']) &&
+   (rubyopt = ENV['RUBYOPT']) &&
+   rubyopt.end_with?(added_opt)
+
+  ENV['RUBYOPT'] = rubyopt.delete_suffix(added_opt)
+  ENV['RUBY_DEBUG_ADDED_RUBYOPT'] = nil
+end
+
 require_relative 'frame_info'
 require_relative 'config'
 require_relative 'thread_client'
@@ -31,7 +40,8 @@ $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'
+require 'pp'
 
 class RubyVM::InstructionSequence
   def traceable_lines_norec lines
@@ -56,34 +66,37 @@ 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
+  end unless method_defined?(:first_line)
+end if defined?(RubyVM::InstructionSequence)
 
 module DEBUGGER__
-  PresetCommand = Struct.new(:commands, :source, :auto_continue)
+  PresetCommands = Struct.new(:commands, :source, :auto_continue)
+  SessionCommand = Struct.new(:block, :repeat, :unsafe, :cancel_auto_continue, :postmortem)
+
   class PostmortemError < RuntimeError; end
 
   class Session
-    attr_reader :intercepted_sigint_cmd, :process_group
+    attr_reader :intercepted_sigint_cmd, :process_group, :subsession_id
 
-    def initialize ui
-      @ui = ui
+    include Color
+
+    def initialize
+      @ui = nil
       @sr = SourceRepository.new
       @bps = {} # bp.key => bp
                 #   [file, line] => LineBreakpoint
@@ -104,48 +117,69 @@ module DEBUGGER__
       @intercept_trap_sigint = false
       @intercepted_sigint_cmd = 'DEFAULT'
       @process_group = ProcessGroup.new
-      @subsession = nil
+      @subsession_stack = []
+      @subsession_id = 0
 
       @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_thread_end = nil
+
+      @commands = {}
+      @unsafe_context = false
+
+      @has_keep_script_lines = defined?(RubyVM.keep_script_lines)
+
       @tp_load_script = TracePoint.new(:script_compiled){|tp|
-        ThreadClient.current.on_load tp.instruction_sequence, tp.eval_script
+        eval_script = tp.eval_script unless @has_keep_script_lines
+        ThreadClient.current.on_load tp.instruction_sequence, eval_script
       }
       @tp_load_script.enable
 
       @thread_stopper = thread_stopper
-
-      activate
-
       self.postmortem = CONFIG[:postmortem]
+
+      register_default_command
     end
 
     def active?
       !@q_evt.closed?
     end
 
-    def break_at? file, line
-      @bps.has_key? [file, line]
+    def remote?
+      @ui.remote?
     end
 
-    def activate on_fork: false
-      @tp_thread_begin&.disable
-      @tp_thread_begin = nil
-
-      if on_fork
-        @ui.activate self, on_fork: true
+    def stop_stepping? file, line, subsession_id = nil
+      if @bps.has_key? [file, line]
+        true
+      elsif subsession_id && @subsession_id != subsession_id
+        true
       else
-        @ui.activate self, on_fork: false
+        false
       end
+    end
+
+    def activate ui = nil, on_fork: false
+      @ui = ui if ui
+
+      @tp_thread_begin&.disable
+      @tp_thread_end&.disable
+      @tp_thread_begin = nil
+      @tp_thread_end = nil
+      @ui.activate self, on_fork: on_fork
 
       q = Queue.new
+      first_q = Queue.new
       @session_server = Thread.new do
+        # make sure `@session_server` is assigned
+        first_q.pop; first_q = nil
+
         Thread.current.name = 'DEBUGGER__::SESSION@server'
         Thread.current.abort_on_exception = true
 
@@ -163,12 +197,24 @@ module DEBUGGER__
         end
         @tp_thread_begin.enable
 
+        @tp_thread_end = TracePoint.new(:thread_end) do |tp|
+          @th_clients.delete(Thread.current)
+        end
+        @tp_thread_end.enable
+
         # session start
         q << true
         session_server_main
       end
+      first_q << :ok
 
       q.pop
+
+      # For activating irb:rdbg with startup config like `RUBY_DEBUG_IRB_CONSOLE=1`
+      # Because in that case the `Config#if_updated` callback would not be triggered
+      if CONFIG[:irb_console] && !CONFIG[:open]
+        activate_irb_integration
+      end
     end
 
     def deactivate
@@ -176,6 +222,7 @@ module DEBUGGER__
       @thread_stopper.disable
       @tp_load_script.disable
       @tp_thread_begin.disable
+      @tp_thread_end.disable
       @bps.each_value{|bp| bp.disable}
       @th_clients.each_value{|thc| thc.close}
       @tracers.values.each{|t| t.disable}
@@ -187,6 +234,16 @@ module DEBUGGER__
     def reset_ui ui
       @ui.deactivate
       @ui = ui
+
+      # activate new ui
+      @tp_thread_begin.disable
+      @tp_thread_end.disable
+      @ui.activate self
+      if @ui.respond_to?(:reader_thread) && thc = get_thread_client(@ui.reader_thread)
+        thc.mark_as_management
+      end
+      @tp_thread_begin.enable
+      @tp_thread_end.enable
     end
 
     def pop_event
@@ -201,63 +258,81 @@ module DEBUGGER__
       deactivate
     end
 
+    def request_tc(req)
+      @tc << req
+    end
+
+    def request_tc_with_restarted_threads(req)
+      restart_all_threads
+      request_tc(req)
+    end
+
+    def request_eval type, src
+      request_tc_with_restarted_threads [:eval, type, src]
+    end
+
     def process_event evt
       # variable `@internal_info` is only used for test
       tc, output, ev, @internal_info, *ev_args = evt
-      output.each{|str| @ui.puts str} if ev != :suspend
 
-      case ev
+      output.each{|str| @ui.puts str} if ev != :suspend
 
-      when :thread_begin # special event, tc is nil
+      # special event, tc is nil
+      # and we don't want to set @tc to the newly created thread's ThreadClient
+      if ev == :thread_begin
         th = ev_args.shift
         q = ev_args.shift
         on_thread_begin th
         q << true
 
-      when :init
-        wait_command_loop tc
+        return
+      end
 
+      @tc = tc
+
+      case ev
+      when :init
+        enter_subsession
+        wait_command_loop
       when :load
         iseq, src = ev_args
         on_load iseq, src
-        @ui.event :load
-        tc << :continue
+        request_tc :continue
 
       when :trace
         trace_id, msg = ev_args
         if t = @tracers.values.find{|t| t.object_id == trace_id}
           t.puts msg
         end
-        tc << :continue
+        request_tc :continue
 
       when :suspend
         enter_subsession if ev_args.first != :replay
-        output.each{|str| @ui.puts str}
+        output.each{|str| @ui.puts str} unless @ui.ignore_output_on_suspend?
 
         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
+          @ui.event :suspend_bp, i, bp, @tc.id
         when :trap
-          @ui.event :suspend_trap, sig = ev_args[1], tc.id
+          @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 registered as SIGINT handler."
             @ui.puts "`sigint` command execute it."
           end
         else
-          @ui.event :suspended, tc.id
+          @ui.event :suspended, @tc.id
         end
 
         if @displays.empty?
-          wait_command_loop tc
+          wait_command_loop
         else
-          tc << [:eval, :display, @displays]
+          request_eval :display, @displays
         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
@@ -269,6 +344,7 @@ module DEBUGGER__
             end
           end
 
+          stop_all_threads
         when :method_breakpoint, :watch_breakpoint
           bp = ev_args[1]
           if bp
@@ -282,18 +358,16 @@ module DEBUGGER__
           obj_inspect = ev_args[2]
           opt = ev_args[3]
           add_tracer ObjectTracer.new(@ui, obj_id, obj_inspect, **opt)
+          stop_all_threads
         else
-          # ignore
+          stop_all_threads
         end
 
-        wait_command_loop tc
+        wait_command_loop
 
-      when :dap_result
-        dap_event ev_args # server.rb
-        wait_command_loop tc
-      when :cdp_result
-        cdp_event ev_args
-        wait_command_loop tc
+      when :protocol_result
+        process_protocol_result ev_args
+        wait_command_loop
       end
     end
 
@@ -308,7 +382,7 @@ module DEBUGGER__
       if @preset_command && !@preset_command.commands.empty?
         @preset_command.commands += cs
       else
-        @preset_command = PresetCommand.new(cs, name, continue)
+        @preset_command = PresetCommands.new(cs, name, continue)
       end
 
       ThreadClient.current.on_init name if kick
@@ -326,9 +400,7 @@ module DEBUGGER__
       "DEBUGGER__::SESSION"
     end
 
-    def wait_command_loop tc
-      @tc = tc
-
+    def wait_command_loop
       loop do
         case wait_command
         when :retry
@@ -369,7 +441,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
 
@@ -383,97 +455,121 @@ module DEBUGGER__
       end
     end
 
-    def process_command line
-      if line.empty?
-        if @repl_prev_line
-          line = @repl_prev_line
-        else
-          return :retry
-        end
-      else
-        @repl_prev_line = line
-      end
-
-      /([^\s]+)(?:\s+(.+))?/ =~ line
-      cmd, arg = $1, $2
+    private def register_command *names,
+                                 repeat: false, unsafe: true, cancel_auto_continue: false, postmortem: true,
+                                 &b
+      cmd = SessionCommand.new(b, repeat, unsafe, cancel_auto_continue, postmortem)
 
-      # p cmd: [cmd, *arg]
+      names.each{|name|
+        @commands[name] = cmd
+      }
+    end
 
-      case cmd
+    def register_default_command
       ### Control flow
 
       # * `s[tep]`
       #   * Step in. Resume the program until next breakable point.
       # * `s[tep] <n>`
       #   * Step in, resume the program at `<n>`th breakable point.
-      when 's', 'step'
-        cancel_auto_continue
-        check_postmortem
+      register_command 's', 'step',
+                       repeat: true,
+                       cancel_auto_continue: true,
+                       postmortem: false do |arg|
         step_command :in, arg
+      end
 
       # * `n[ext]`
       #   * Step over. Resume the program until next line.
       # * `n[ext] <n>`
       #   * Step over, same as `step <n>`.
-      when 'n', 'next'
-        cancel_auto_continue
-        check_postmortem
+      register_command 'n', 'next',
+                       repeat: true,
+                       cancel_auto_continue: true,
+                       postmortem: false do |arg|
         step_command :next, arg
+      end
 
       # * `fin[ish]`
       #   * Finish this frame. Resume the program until the current frame is finished.
       # * `fin[ish] <n>`
       #   * Finish `<n>`th frames.
-      when 'fin', 'finish'
-        cancel_auto_continue
-        check_postmortem
-
+      register_command 'fin', 'finish',
+                       repeat: true,
+                       cancel_auto_continue: true,
+                       postmortem: false do |arg|
         if arg&.to_i == 0
           raise 'finish command with 0 does not make sense.'
         end
 
         step_command :finish, arg
+      end
 
-      # * `c[ontinue]`
+      # * `u[ntil]`
+      #   * Similar to `next` command, but only stop later lines or the end of the current frame.
+      #   * Similar to gdb's `advance` command.
+      # * `u[ntil] <[file:]line>`
+      #   * Run til the program reaches given location or the end of the current frame.
+      # * `u[ntil] <name>`
+      #   * Run til the program invokes a method `<name>`. `<name>` can be a regexp with `/name/`.
+      register_command 'u', 'until',
+                       repeat: true,
+                       cancel_auto_continue: true,
+                       postmortem: false do |arg|
+
+        step_command :until, arg
+      end
+
+      # * `c` or `cont` or `continue`
       #   * Resume the program.
-      when 'c', 'continue'
-        cancel_auto_continue
+      register_command 'c', 'cont', 'continue',
+                       repeat: true,
+                       cancel_auto_continue: true do |arg|
         leave_subsession :continue
+      end
 
       # * `q[uit]` or `Ctrl-D`
       #   * Finish debugger (with the debuggee process on non-remote debugging).
-      when 'q', 'quit'
+      register_command 'q', 'quit' do |arg|
         if ask 'Really quit?'
-          @ui.quit arg.to_i
+          @ui.quit arg.to_i do
+            request_tc :quit
+          end
           leave_subsession :continue
         else
-          return :retry
+          next :retry
         end
+      end
 
       # * `q[uit]!`
       #   * Same as q[uit] but without the confirmation prompt.
-      when 'q!', 'quit!'
-        @ui.quit arg.to_i
-        leave_subsession nil
+      register_command 'q!', 'quit!', unsafe: false do |arg|
+        @ui.quit arg.to_i do
+          request_tc :quit
+        end
+        leave_subsession :continue
+      end
 
       # * `kill`
       #   * Stop the debuggee process with `Kernel#exit!`.
-      when 'kill'
+      register_command 'kill' do |arg|
         if ask 'Really kill?'
           exit! (arg || 1).to_i
         else
-          return :retry
+          next :retry
         end
+      end
 
       # * `kill!`
       #   * Same as kill but without the confirmation prompt.
-      when 'kill!'
+      register_command 'kill!', unsafe: false do |arg|
         exit! (arg || 1).to_i
+      end
 
       # * `sigint`
       #   * Execute SIGINT handler registered by the debuggee.
       #   * Note that this command should be used just after stop by `SIGINT`.
-      when 'sigint'
+      register_command 'sigint' do
         begin
           case cmd = @intercepted_sigint_cmd
           when nil, 'IGNORE', :IGNORE, 'DEFAULT', :DEFAULT
@@ -489,8 +585,9 @@ module DEBUGGER__
         rescue Exception => e
           @ui.puts "Exception: #{e}"
           @ui.puts e.backtrace.map{|line| "  #{e}"}
-          return :retry
+          next :retry
         end
+      end
 
       ### Breakpoint
 
@@ -510,53 +607,26 @@ module DEBUGGER__
       #   * break and run `<command>` before stopping.
       # * `b[reak] ... do: <command>`
       #   * break and run `<command>`, and continue.
-      # * `b[reak] ... path: <path_regexp>`
-      #   * break if the triggering event's path matches <path_regexp>.
+      # * `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.
-      when 'b', 'break'
-        check_postmortem
-
+      register_command 'b', 'break', postmortem: false, unsafe: false do |arg|
         if arg == nil
           show_bps
-          return :retry
+          next :retry
         else
           case bp = repl_add_breakpoint(arg)
           when :noretry
           when nil
-            return :retry
+            next :retry
           else
             show_bps bp
-            return :retry
+            next :retry
           end
         end
-
-      # skip
-      when 'bv'
-        check_postmortem
-        require 'json'
-
-        h = Hash.new{|h, k| h[k] = []}
-        @bps.each_value{|bp|
-          if LineBreakpoint === bp
-            h[bp.path] << {lnum: bp.line}
-          end
-        }
-        if h.empty?
-          # TODO: clean?
-        else
-          open(".rdb_breakpoints.json", 'w'){|f| JSON.dump(h, f)}
-        end
-
-        vimsrc = File.join(__dir__, 'bp.vim')
-        system("vim -R -S #{vimsrc} #{@tc.location.path}")
-
-        if File.exist?(".rdb_breakpoints.json")
-          pp JSON.load(File.read(".rdb_breakpoints.json"))
-        end
-
-        return :retry
+      end
 
       # * `catch <Error>`
       #   * Set breakpoint on raising `<Error>`.
@@ -566,18 +636,18 @@ module DEBUGGER__
       #   * runs `<command>` before stopping.
       # * `catch ... do: <command>`
       #   * stops and run `<command>`, and continue.
-      # * `catch ... path: <path_regexp>`
-      #   * stops if the exception is raised from a path that matches <path_regexp>.
-      when 'catch'
-        check_postmortem
-
+      # * `catch ... path: <path>`
+      #   * stops if the exception is raised from a `<path>`. `<path>` can be a regexp with `/regexp/`.
+      register_command 'catch', postmortem: false, unsafe: false do |arg|
         if arg
           bp = repl_add_catch_breakpoint arg
           show_bps bp if bp
         else
           show_bps
         end
-        return :retry
+
+        :retry
+      end
 
       # * `watch @ivar`
       #   * Stop the execution when the result of current scope's `@ivar` is changed.
@@ -588,26 +658,22 @@ module DEBUGGER__
       #   * runs `<command>` before stopping.
       # * `watch ... do: <command>`
       #   * stops and run `<command>`, and continue.
-      # * `watch ... path: <path_regexp>`
-      #   * stops if the triggering event's path matches <path_regexp>.
-      when 'wat', 'watch'
-        check_postmortem
-
+      # * `watch ... path: <path>`
+      #   * stops if the path matches `<path>`. `<path>` can be a regexp with `/regexp/`.
+      register_command 'wat', 'watch', postmortem: false, unsafe: false do |arg|
         if arg && arg.match?(/\A@\w+/)
           repl_add_watch_breakpoint(arg)
         else
           show_bps
-          return :retry
+          :retry
         end
+      end
 
       # * `del[ete]`
       #   * delete all breakpoints.
       # * `del[ete] <bpnum>`
       #   * delete specified breakpoint.
-      when 'del', 'delete'
-        check_postmortem
-
-        bp =
+      register_command 'del', 'delete', postmortem: false, unsafe: false do |arg|
         case arg
         when nil
           show_bps
@@ -615,12 +681,13 @@ module DEBUGGER__
             delete_bp
           end
         when /\d+/
-          delete_bp arg.to_i
+          bp = delete_bp arg.to_i
         else
           nil
         end
         @ui.puts "deleted: \##{bp[0]} #{bp[1]}" if bp
-        return :retry
+        :retry
+      end
 
       ### Information
 
@@ -632,19 +699,20 @@ module DEBUGGER__
       #   * Only shows frames with method name or location info that matches `/regexp/`.
       # * `bt <num> /regexp/` or `backtrace <num> /regexp/`
       #   * Only shows first `<num>` frames with method name or location info that matches `/regexp/`.
-      when 'bt', 'backtrace'
+      register_command 'bt', 'backtrace', unsafe: false do |arg|
         case arg
         when /\A(\d+)\z/
-          @tc << [:show, :backtrace, arg.to_i, nil]
+          request_tc_with_restarted_threads [:show, :backtrace, arg.to_i, nil]
         when /\A\/(.*)\/\z/
           pattern = $1
-          @tc << [:show, :backtrace, nil, Regexp.compile(pattern)]
+          request_tc_with_restarted_threads [:show, :backtrace, nil, Regexp.compile(pattern)]
         when /\A(\d+)\s+\/(.*)\/\z/
           max, pattern = $1, $2
-          @tc << [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
+          request_tc_with_restarted_threads [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
         else
-          @tc << [:show, :backtrace, nil, nil]
+          request_tc_with_restarted_threads [:show, :backtrace, nil, nil]
         end
+      end
 
       # * `l[ist]`
       #   * Show current frame's source code.
@@ -653,57 +721,75 @@ module DEBUGGER__
       #   * Show predecessor lines as opposed to the `list` command.
       # * `l[ist] <start>` or `l[ist] <start>-<end>`
       #   * Show current frame's source code from the line <start> to <end> if given.
-      when 'l', 'list'
+      register_command 'l', 'list', repeat: true, unsafe: false do |arg|
         case arg ? arg.strip : nil
         when /\A(\d+)\z/
-          @tc << [:show, :list, {start_line: arg.to_i - 1}]
+          request_tc [:show, :list, {start_line: arg.to_i - 1}]
         when /\A-\z/
-          @tc << [:show, :list, {dir: -1}]
+          request_tc [:show, :list, {dir: -1}]
         when /\A(\d+)-(\d+)\z/
-          @tc << [:show, :list, {start_line: $1.to_i - 1, end_line: $2.to_i}]
+          request_tc [:show, :list, {start_line: $1.to_i - 1, end_line: $2.to_i}]
         when nil
-          @tc << [:show, :list]
+          request_tc [:show, :list]
         else
           @ui.puts "Can not handle list argument: #{arg}"
-          return :retry
+          :retry
         end
+      end
+
+      # * `whereami`
+      #   * Show the current frame with source code.
+      register_command 'whereami', unsafe: false do
+        request_tc [:show, :whereami]
+      end
 
       # * `edit`
       #   * Open the current file on the editor (use `EDITOR` environment variable).
       #   * Note that edited file will not be reloaded.
       # * `edit <file>`
       #   * Open <file> on the editor.
-      when 'edit'
+      register_command 'edit' do |arg|
         if @ui.remote?
           @ui.puts "not supported on the remote console."
-          return :retry
+          next :retry
         end
 
         begin
           arg = resolve_path(arg) if arg
         rescue Errno::ENOENT
           @ui.puts "not found: #{arg}"
-          return :retry
+          next :retry
         end
 
-        @tc << [:show, :edit, arg]
+        request_tc [:show, :edit, arg]
+      end
+
+      info_subcommands = nil
+      info_subcommands_abbrev = nil
 
       # * `i[nfo]`
-      #    * Show information about current frame (local/instance variables and defined constants).
-      # * `i[nfo] l[ocal[s]]`
+      #   * Show information about current frame (local/instance variables and defined constants).
+      # * `i[nfo]` <subcommand>
+      #   * `info` has the following sub-commands.
+      #   * Sub-commands can be specified with few letters which is unambiguous, like `l` for 'locals'.
+      # * `i[nfo] l or locals or local_variables`
       #   * Show information about the current frame (local variables)
-      #   * It includes `self` as `%self` and a return value as `%return`.
-      # * `i[nfo] i[var[s]]` or `i[nfo] instance`
+      #   * It includes `self` as `%self` and a return value as `_return`.
+      # * `i[nfo] i or ivars or instance_variables`
       #   * Show information about instance variables about `self`.
-      # * `i[nfo] c[onst[s]]` or `i[nfo] constant[s]`
+      #   * `info ivars <expr>` shows the instance variables of the result of `<expr>`.
+      # * `i[nfo] c or consts or constants`
       #   * Show information about accessible constants except toplevel constants.
-      # * `i[nfo] g[lobal[s]]`
+      #   * `info consts <expr>` shows the constants of a class/module of the result of `<expr>`
+      # * `i[nfo] g or globals or global_variables`
       #   * Show information about global variables
-      # * `i[nfo] ... </pattern/>`
-      #   * Filter the output with `</pattern/>`.
-      # * `i[nfo] th[read[s]]`
+      # * `i[nfo] th or threads`
       #   * Show all threads (same as `th[read]`).
-      when 'i', 'info'
+      # * `i[nfo] b or breakpoints or w or watchpoints`
+      #   * Show all breakpoints and watchpoints.
+      # * `i[nfo] ... /regexp/`
+      #   * Filter the output with `/regexp/`.
+      register_command 'i', 'info', unsafe: false do |arg|
         if /\/(.+)\/\z/ =~ arg
           pat = Regexp.compile($1)
           sub = $~.pre_match.strip
@@ -711,63 +797,98 @@ module DEBUGGER__
           sub = arg
         end
 
+        if /\A(.+?)\b(.+)/ =~ sub
+          sub = $1
+          opt = $2.strip
+          opt = nil if opt.empty?
+        end
+
+        if sub && !info_subcommands
+          info_subcommands = {
+            locals: %w[ locals local_variables ],
+            ivars:  %w[ ivars instance_variables ],
+            consts: %w[ consts constants ],
+            globals:%w[ globals global_variables ],
+            threads:%w[ threads ],
+            breaks: %w[ breakpoints ],
+            watchs: %w[ watchpoints ],
+          }
+
+          require_relative 'abbrev_command'
+          info_subcommands_abbrev = AbbrevCommand.new(info_subcommands)
+        end
+
+        if sub
+          sub = info_subcommands_abbrev.search sub, :unknown do |candidates|
+            # note: unreached now
+            @ui.puts "Ambiguous command '#{sub}': #{candidates.join(' ')}"
+          end
+        end
+
         case sub
         when nil
-          @tc << [:show, :default, pat] # something useful
-        when 'l', /^locals?/
-          @tc << [:show, :locals, pat]
-        when 'i', /^ivars?/i, /^instance[_ ]variables?/i
-          @tc << [:show, :ivars, pat]
-        when 'c', /^consts?/i, /^constants?/i
-          @tc << [:show, :consts, pat]
-        when 'g', /^globals?/i, /^global[_ ]variables?/i
-          @tc << [:show, :globals, pat]
-        when 'th', /threads?/
+          request_tc_with_restarted_threads [:show, :default, pat] # something useful
+        when :locals
+          request_tc_with_restarted_threads [:show, :locals, pat]
+        when :ivars
+          request_tc_with_restarted_threads [:show, :ivars, pat, opt]
+        when :consts
+          request_tc_with_restarted_threads [:show, :consts, pat, opt]
+        when :globals
+          request_tc_with_restarted_threads [:show, :globals, pat]
+        when :threads
           thread_list
-          return :retry
+          :retry
+        when :breaks, :watchs
+          show_bps
+          :retry
         else
           @ui.puts "unrecognized argument for info command: #{arg}"
           show_help 'info'
-          return :retry
+          :retry
         end
+      end
 
       # * `o[utline]` or `ls`
       #   * Show you available methods, constants, local variables, and instance variables in the current scope.
       # * `o[utline] <expr>` or `ls <expr>`
       #   * Show you available methods and instance variables of the given object.
       #   * If the object is a class/module, it also lists its constants.
-      when 'outline', 'o', 'ls'
-        @tc << [:show, :outline, arg]
+      register_command 'outline', 'o', 'ls', unsafe: false do |arg|
+        request_tc_with_restarted_threads [:show, :outline, arg]
+      end
 
       # * `display`
       #   * Show display setting.
       # * `display <expr>`
       #   * Show the result of `<expr>` at every suspended timing.
-      when 'display'
+      register_command 'display', postmortem: false do |arg|
         if arg && !arg.empty?
           @displays << arg
-          @tc << [:eval, :try_display, @displays]
+          request_eval :try_display, @displays
         else
-          @tc << [:eval, :display, @displays]
+          request_eval :display, @displays
         end
+      end
 
       # * `undisplay`
       #   * Remove all display settings.
       # * `undisplay <displaynum>`
       #   * Remove a specified display setting.
-      when 'undisplay'
+      register_command 'undisplay', postmortem: false, unsafe: false do |arg|
         case arg
         when /(\d+)/
           if @displays[n = $1.to_i]
             @displays.delete_at n
           end
-          @tc << [:eval, :display, @displays]
+          request_eval :display, @displays
         when nil
           if ask "clear all?", 'N'
             @displays.clear
           end
-          return :retry
+          :retry
         end
+      end
 
       ### Frame control
 
@@ -775,53 +896,59 @@ module DEBUGGER__
       #   * Show the current frame.
       # * `f[rame] <framenum>`
       #   * Specify a current frame. Evaluation are run on specified frame.
-      when 'frame', 'f'
-        @tc << [:frame, :set, arg]
+      register_command 'frame', 'f', unsafe: false do |arg|
+        request_tc [:frame, :set, arg]
+      end
 
       # * `up`
       #   * Specify the upper frame.
-      when 'up'
-        @tc << [:frame, :up]
+      register_command 'up', repeat: true, unsafe: false do |arg|
+        request_tc [:frame, :up]
+      end
 
       # * `down`
       #   * Specify the lower frame.
-      when 'down'
-        @tc << [:frame, :down]
+      register_command 'down', repeat: true, unsafe: false do |arg|
+        request_tc [:frame, :down]
+      end
 
       ### Evaluate
 
       # * `p <expr>`
       #   * Evaluate like `p <expr>` on the current frame.
-      when 'p'
-        @tc << [:eval, :p, arg.to_s]
+      register_command 'p' do |arg|
+        request_eval :p, arg.to_s
+      end
 
       # * `pp <expr>`
       #   * Evaluate like `pp <expr>` on the current frame.
-      when 'pp'
-        @tc << [:eval, :pp, arg.to_s]
+      register_command 'pp' do |arg|
+        request_eval :pp, arg.to_s
+      end
 
       # * `eval <expr>`
       #   * Evaluate `<expr>` on the current frame.
-      when 'eval', 'call'
+      register_command 'eval', 'call' do |arg|
         if arg == nil || arg.empty?
           show_help 'eval'
           @ui.puts "\nTo evaluate the variable `#{cmd}`, use `pp #{cmd}` instead."
-          return :retry
+          :retry
         else
-          @tc << [:eval, :call, arg]
+          request_eval :call, arg
         end
+      end
 
       # * `irb`
-      #   * Invoke `irb` on the current frame.
-      when 'irb'
+      #   * Activate and switch to `irb:rdbg` console
+      register_command 'irb' do |arg|
         if @ui.remote?
-          @ui.puts "not supported on the remote console."
-          return :retry
+          @ui.puts "\nIRB is not supported on the remote console."
+        else
+          config_set :irb_console, true
         end
-        @tc << [:eval, :irb]
 
-        # don't repeat irb command
-        @repl_prev_line = nil
+        :retry
+      end
 
       ### Trace
       # * `trace`
@@ -834,15 +961,15 @@ 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>`
       #   * Disable tracer specified by `<num>` (use `trace` command to check the numbers).
       # * `trace off [line|call|pass]`
       #   * Disable all tracers. If `<type>` is provided, disable specified type tracers.
-      when 'trace'
+      register_command 'trace', postmortem: false, unsafe: false do |arg|
         if (re = /\s+into:\s*(.+)/) =~ arg
           into = $1
           arg.sub!(re, '')
@@ -860,22 +987,22 @@ module DEBUGGER__
             @ui.puts "* \##{i} #{t}"
           }
           @ui.puts
-          return :retry
+          :retry
 
         when /\Aline\z/
           add_tracer LineTracer.new(@ui, pattern: pattern, into: into)
-          return :retry
+          :retry
 
         when /\Acall\z/
           add_tracer CallTracer.new(@ui, pattern: pattern, into: into)
-          return :retry
+          :retry
 
         when /\Aexception\z/
           add_tracer ExceptionTracer.new(@ui, pattern: pattern, into: into)
-          return :retry
+          :retry
 
         when /\Aobject\s+(.+)/
-          @tc << [:trace, :object, $1.strip, {pattern: pattern, into: into}]
+          request_tc_with_restarted_threads [:trace, :object, $1.strip, {pattern: pattern, into: into}]
 
         when /\Aoff\s+(\d+)\z/
           if t = @tracers.values[$1.to_i]
@@ -884,7 +1011,7 @@ module DEBUGGER__
           else
             @ui.puts "Unmatched: #{$1}"
           end
-          return :retry
+          :retry
 
         when /\Aoff(\s+(line|call|exception|object))?\z/
           @tracers.values.each{|t|
@@ -893,12 +1020,13 @@ module DEBUGGER__
               @ui.puts "Disable #{t.to_s}"
             end
           }
-          return :retry
+          :retry
 
         else
           @ui.puts "Unknown trace option: #{arg.inspect}"
-          return :retry
+          :retry
         end
+      end
 
       # Record
       # * `record`
@@ -910,14 +1038,15 @@ module DEBUGGER__
       #   * `s[tep]` does stepping forward with the last log.
       # * `step reset`
       #   * Stop replay .
-      when 'record'
+      register_command 'record', postmortem: false, unsafe: false do |arg|
         case arg
         when nil, 'on', 'off'
-          @tc << [:record, arg&.to_sym]
+          request_tc [:record, arg&.to_sym]
         else
           @ui.puts "unknown command: #{arg}"
-          return :retry
+          :retry
         end
+      end
 
       ### Thread control
 
@@ -925,7 +1054,7 @@ module DEBUGGER__
       #   * Show all threads.
       # * `th[read] <thnum>`
       #   * Switch thread specified by `<thnum>`.
-      when 'th', 'thread'
+      register_command 'th', 'thread', unsafe: false do |arg|
         case arg
         when nil, 'list', 'l'
           thread_list
@@ -934,7 +1063,8 @@ module DEBUGGER__
         else
           @ui.puts "unknown thread command: #{arg}"
         end
-        return :retry
+        :retry
+      end
 
       ### Configuration
       # * `config`
@@ -947,13 +1077,14 @@ module DEBUGGER__
       #   * Append `<val>` to `<name>` if it is an array.
       # * `config unset <name>`
       #   * Set <name> to default.
-      when 'config'
+      register_command 'config', unsafe: false do |arg|
         config_command arg
-        return :retry
+        :retry
+      end
 
       # * `source <file>`
       #   * Evaluate lines in `<file>` as debug commands.
-      when 'source'
+      register_command 'source' do |arg|
         if arg
           begin
             cmds = File.readlines(path = File.expand_path(arg))
@@ -964,7 +1095,8 @@ module DEBUGGER__
         else
           show_help 'source'
         end
-        return :retry
+        :retry
+      end
 
       # * `open`
       #   * open debuggee port on UNIX domain socket and wait for attaching.
@@ -975,26 +1107,28 @@ module DEBUGGER__
       #   * open debuggee port for VSCode and launch VSCode if available.
       # * `open chrome`
       #   * open debuggee port for Chrome and wait for attaching.
-      when 'open'
+      register_command 'open' do |arg|
         case arg&.downcase
         when '', nil
-          repl_open_unix
-        when 'vscode'
-          repl_open_vscode
-        when /\A(.+):(\d+)\z/
-          repl_open_tcp $1, $2.to_i
+          ::DEBUGGER__.open nonstop: true
         when /\A(\d+)z/
-          repl_open_tcp nil, $1.to_i
+          ::DEBUGGER__.open_tcp host: nil, port: $1.to_i, nonstop: true
+        when /\A(.+):(\d+)\z/
+          ::DEBUGGER__.open_tcp host: $1, port: $2.to_i, nonstop: true
         when 'tcp'
-          repl_open_tcp CONFIG[:host], (CONFIG[:port] || 0)
+          ::DEBUGGER__.open_tcp host: CONFIG[:host], port: (CONFIG[:port] || 0), nonstop: true
+        when 'vscode'
+          CONFIG[:open] = 'vscode'
+          ::DEBUGGER__.open nonstop: true
         when 'chrome', 'cdp'
-          CONFIG[:open_frontend] = 'chrome'
-          repl_open_tcp CONFIG[:host], (CONFIG[:port] || 0)
+          CONFIG[:open] = 'chrome'
+          ::DEBUGGER__.open_tcp host: CONFIG[:host], port: (CONFIG[:port] || 0), nonstop: true
         else
           raise "Unknown arg: #{arg}"
         end
 
-        return :retry
+        :retry
+      end
 
       ### Help
 
@@ -1002,30 +1136,38 @@ module DEBUGGER__
       #   * Show help for all commands.
       # * `h[elp] <command>`
       #   * Show help for the given command.
-      when 'h', 'help', '?'
-        if arg
-          show_help arg
+      register_command 'h', 'help', '?', unsafe: false do |arg|
+        show_help arg
+        :retry
+      end
+    end
+
+    def process_command line
+      if line.empty?
+        if @repl_prev_line
+          line = @repl_prev_line
         else
-          @ui.puts DEBUGGER__.help
+          return :retry
         end
-        return :retry
+      else
+        @repl_prev_line = line
+      end
 
-      ### END
+      /([^\s]+)(?:\s+(.+))?/ =~ line
+      cmd_name, cmd_arg = $1, $2
+
+      if cmd = @commands[cmd_name]
+        check_postmortem      if !cmd.postmortem
+        check_unsafe          if cmd.unsafe
+        cancel_auto_continue  if cmd.cancel_auto_continue
+        @repl_prev_line = nil if !cmd.repeat
+
+        cmd.block.call(cmd_arg)
       else
-        @tc << [:eval, :pp, line]
-=begin
         @repl_prev_line = nil
-        @ui.puts "unknown command: #{line}"
-        begin
-          require 'did_you_mean'
-          spell_checker = DidYouMean::SpellChecker.new(dictionary: DEBUGGER__.commands)
-          correction = spell_checker.correct(line.split(/\s/).first || '')
-          @ui.puts "Did you mean? #{correction.join(' or ')}" unless correction.empty?
-        rescue LoadError
-          # Don't use D
-        end
-        return :retry
-=end
+        check_unsafe
+
+        request_eval :pp, line
       end
 
     rescue Interrupt
@@ -1041,44 +1183,27 @@ module DEBUGGER__
       return :retry
     end
 
-    def repl_open_setup
-      @tp_thread_begin.disable
-      @ui.activate self
-      if @ui.respond_to?(:reader_thread) && thc = get_thread_client(@ui.reader_thread)
-        thc.mark_as_management
+    def step_command type, arg
+      if type == :until
+        leave_subsession [:step, type, arg]
+        return
       end
-      @tp_thread_begin.enable
-    end
 
-    def repl_open_tcp host, port, **kw
-      DEBUGGER__.open_tcp host: host, port: port, nonstop: true, **kw
-      repl_open_setup
-    end
-
-    def repl_open_unix
-      DEBUGGER__.open_unix nonstop: true
-      repl_open_setup
-    end
-
-    def repl_open_vscode
-      CONFIG[:open_frontend] = 'vscode'
-      repl_open_unix
-    end
-
-    def step_command type, arg
       case arg
       when nil, /\A\d+\z/
         if type == :in && @tc.recorder&.replaying?
-          @tc << [:step, type, arg&.to_i]
+          request_tc [:step, type, arg&.to_i]
         else
           leave_subsession [:step, type, arg&.to_i]
         end
-      when /\Aback\z/, /\Areset\z/
+      when /\A(back)\z/, /\A(back)\s+(\d+)\z/, /\A(reset)\z/
         if type != :in
           @ui.puts "only `step #{arg}` is supported."
           :retry
         else
-          @tc << [:step, arg.to_sym]
+          type = $1.to_sym
+          iter = $2&.to_i
+          request_tc [:step, type, iter]
         end
       else
         @ui.puts "Unknown option: #{arg}"
@@ -1088,11 +1213,18 @@ module DEBUGGER__
 
     def config_show key
       key = key.to_sym
-      if CONFIG_SET[key]
+      config_detail = CONFIG_SET[key]
+
+      if config_detail
         v = CONFIG[key]
-        kv = "#{key} = #{v.nil? ? '(default)' : v.inspect}"
-        desc = CONFIG_SET[key][1]
-        line = "%-30s \# %s" % [kv, desc]
+        kv = "#{key} = #{v.inspect}"
+        desc = config_detail[1]
+
+        if config_default = config_detail[3]
+          desc += " (default: #{config_default})"
+        end
+
+        line = "%-34s \# %s" % [kv, desc]
         if line.size > SESSION.width
           @ui.puts "\# #{desc}\n#{kv}"
         else
@@ -1142,7 +1274,7 @@ module DEBUGGER__
         config_set $1, $2, append: true
 
       when /\A\s*append\s+(\w+)\s+(.+)\z/
-        config_set $1, $2
+        config_set $1, $2, append: true
 
       when /\A(\w+)\z/
         config_show $1
@@ -1159,16 +1291,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'
@@ -1231,12 +1397,13 @@ module DEBUGGER__
 
     def add_bp bp
       # don't repeat commands that add breakpoints
-      @repl_prev_line = nil
-
       if @bps.has_key? bp.key
-        unless bp.duplicable?
+        if bp.duplicable?
+          bp
+        else
           @ui.puts "duplicated breakpoint: #{bp}"
           bp.disable
+          nil
         end
       else
         @bps[bp.key] = bp
@@ -1261,7 +1428,7 @@ module DEBUGGER__
 
     BREAK_KEYWORDS = %w(if: do: pre: path:).freeze
 
-    def parse_break arg
+    private def parse_break type, arg
       mode = :sig
       expr = Hash.new{|h, k| h[k] = []}
       arg.split(' ').each{|w|
@@ -1272,14 +1439,25 @@ 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
+
+      if expr[:do] || expr[:pre]
+        check_unsafe
+        expr[:cmd] = [type, expr[:pre], expr[:do]]
+      end
+
+      expr
     end
 
     def repl_add_breakpoint arg
-      expr = parse_break arg.strip
+      expr = parse_break 'break', arg.strip
       cond = expr[:if]
-      cmd = ['break', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
-      path = Regexp.compile(expr[:path]) if expr[:path]
+      cmd  = expr[:cmd]
+      path = expr[:path]
 
       case expr[:sig]
       when /\A(\d+)\z/
@@ -1287,10 +1465,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, path]
+        request_tc [:breakpoint, :method, $1, $2, $3, cond, cmd, path]
         return :noretry
       when nil
-        add_check_breakpoint cond, path
+        add_check_breakpoint cond, path, cmd
       else
         @ui.puts "Unknown breakpoint format: #{arg}"
         @ui.puts
@@ -1299,31 +1477,31 @@ module DEBUGGER__
     end
 
     def repl_add_catch_breakpoint arg
-      expr = parse_break arg.strip
+      expr = parse_break 'catch', arg.strip
       cond = expr[:if]
-      cmd = ['catch', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
-      path = Regexp.compile(expr[:path]) if expr[:path]
+      cmd  = expr[:cmd]
+      path = expr[:path]
 
       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
+      expr = parse_break 'watch', arg.strip
       cond = expr[:if]
-      cmd = ['watch', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+      cmd  = expr[:cmd]
       path = Regexp.compile(expr[:path]) if expr[:path]
 
-      @tc << [:breakpoint, :watch, expr[:sig], cond, cmd, path]
+      request_tc [:breakpoint, :watch, expr[:sig], cond, cmd, path]
     end
 
-    def add_catch_breakpoint pat
-      bp = CatchBreakpoint.new(pat)
+    def add_catch_breakpoint pat, cond: nil
+      bp = CatchBreakpoint.new(pat, cond: cond)
       add_bp bp
     end
 
-    def add_check_breakpoint expr, path
-      bp = CheckBreakpoint.new(expr, path)
+    def add_check_breakpoint cond, path, command
+      bp = CheckBreakpoint.new(cond: cond, path: path, command: command)
       add_bp bp
     end
 
@@ -1336,6 +1514,34 @@ module DEBUGGER__
       @ui.puts e.message
     end
 
+    def clear_breakpoints(&condition)
+      @bps.delete_if do |k, bp|
+        if condition.call(k, bp)
+          bp.delete
+          true
+        end
+      end
+    end
+
+    def clear_line_breakpoints path
+      path = resolve_path(path)
+      clear_breakpoints do |k, bp|
+        bp.is_a?(LineBreakpoint) && bp.path_is?(path)
+      end
+    rescue Errno::ENOENT
+      # just ignore
+    end
+
+    def clear_catch_breakpoints *exception_names
+      clear_breakpoints do |k, bp|
+        bp.is_a?(CatchBreakpoint) && exception_names.include?(k[1])
+      end
+    end
+
+    def clear_all_breakpoints
+      clear_breakpoints{true}
+    end
+
     def add_iseq_breakpoint iseq, **kw
       bp = ISeqBreakpoint.new(iseq, [:line], **kw)
       add_bp bp
@@ -1344,9 +1550,7 @@ module DEBUGGER__
     # tracers
 
     def add_tracer tracer
-      # don't repeat commands that add tracers
-      @repl_prev_line = nil
-      if @tracers.has_key? tracer.key
+      if @tracers[tracer.key]&.enabled?
         tracer.disable
         @ui.puts "Duplicated tracer: #{tracer}"
       else
@@ -1503,42 +1707,72 @@ 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"
+      @subsession_id += 1
+      if !@subsession_stack.empty?
+        DEBUGGER__.debug{ "Enter subsession (nested #{@subsession_stack.size})" }
+      else
+        DEBUGGER__.debug{ "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
-      @tc << type if type
+      raise '[BUG] leave_subsession: not entered' if @subsession_stack.empty?
+      @subsession_stack.pop
+
+      if @subsession_stack.empty?
+        DEBUGGER__.debug{ "Leave subsession" }
+        @process_group.unlock
+        restart_all_threads
+      else
+        DEBUGGER__.debug{ "Leave subsession (nested #{@subsession_stack.size})" }
+      end
+
+      request_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
 
     def on_load iseq, src
       DEBUGGER__.info "Load #{iseq.absolute_path || iseq.path}"
-      @sr.add iseq, src
-
-      pending_line_breakpoints = @bps.find_all do |key, bp|
-        LineBreakpoint === bp && !bp.iseq
-      end
 
-      pending_line_breakpoints.each do |_key, bp|
-        if bp.path == (iseq.absolute_path || iseq.path)
-          bp.try_activate
+      file_path, reloaded = @sr.add(iseq, src)
+      @ui.event :load, file_path, reloaded
+
+      # check breakpoints
+      if file_path
+        @bps.find_all do |_key, bp|
+          LineBreakpoint === bp && bp.path_is?(file_path) && (iseq.first_lineno..iseq.last_line).cover?(bp.line)
+        end.each do |_key, bp|
+          if !bp.iseq
+            bp.try_activate iseq
+          elsif reloaded
+            @bps.delete bp.key # to allow duplicate
+
+            # When we delete a breakpoint from the @bps hash, we also need to deactivate it or else its tracepoint event
+            # will continue to be enabled and we'll suspend on ghost breakpoints
+            bp.delete
+
+            nbp = LineBreakpoint.copy(bp, iseq)
+            add_bp nbp
+          end
+        end
+      else # !file_path => file_path is not existing
+        @bps.find_all do |_key, bp|
+          LineBreakpoint === bp && !bp.iseq && DEBUGGER__.compare_path(bp.path, (iseq.absolute_path || iseq.path))
+        end.each do |_key, bp|
+          bp.try_activate iseq
         end
       end
     end
@@ -1563,9 +1797,10 @@ module DEBUGGER__
 
     def method_added tp
       b = tp.binding
+
       if var_name = b.local_variables.first
         mid = b.local_variable_get(var_name)
-        unresolved = false
+        resolved = true
 
         @bps.each{|k, bp|
           case bp
@@ -1576,15 +1811,57 @@ module DEBUGGER__
               end
             end
 
-            unresolved = true unless bp.enabled?
+            resolved = false if !bp.enabled?
           end
         }
-        unless unresolved
-          METHOD_ADDED_TRACKER.disable
+
+        if resolved
+          Session.deactivate_method_added_trackers
+        end
+
+        case mid
+        when :method_added, :singleton_method_added
+          Session.create_method_added_tracker(tp.self, mid)
+          Session.activate_method_added_trackers unless resolved
         end
       end
     end
 
+    class ::Module
+      undef method_added
+      def method_added mid; end
+    end
+
+    class ::BasicObject
+      undef singleton_method_added
+      def singleton_method_added mid; end
+    end
+
+    def self.create_method_added_tracker mod, method_added_id, method_accessor = :method
+      m = mod.__send__(method_accessor, method_added_id)
+      METHOD_ADDED_TRACKERS[m] = TracePoint.new(:call) do |tp|
+        SESSION.method_added tp
+      end
+    end
+
+    def self.activate_method_added_trackers
+      METHOD_ADDED_TRACKERS.each do |m, tp|
+        tp.enable(target: m) unless tp.enabled?
+      rescue ArgumentError
+        DEBUGGER__.warn "Methods defined under #{m.owner} can not track by the debugger."
+      end
+    end
+
+    def self.deactivate_method_added_trackers
+      METHOD_ADDED_TRACKERS.each do |m, tp|
+        tp.disable if tp.enabled?
+      end
+    end
+
+    METHOD_ADDED_TRACKERS = Hash.new
+    create_method_added_tracker Module, :method_added, :instance_method
+    create_method_added_tracker BasicObject, :singleton_method_added, :instance_method
+
     def width
       @ui.width
     end
@@ -1595,6 +1872,18 @@ module DEBUGGER__
       end
     end
 
+    def check_unsafe
+      if @unsafe_context
+        raise RuntimeError, "#{@repl_prev_line.dump} is not allowed on unsafe context."
+      end
+    end
+
+    def activate_irb_integration
+      require_relative "irb_integration"
+      thc = get_thread_client(@session_server)
+      thc.activate_irb_integration
+    end
+
     def enter_postmortem_session exc
       return unless exc.instance_variable_defined? :@__debugger_postmortem_frames
 
@@ -1674,6 +1963,17 @@ module DEBUGGER__
       end
     end
 
+    def set_no_sigint_hook old, new
+      return unless old != new
+      return unless @ui.respond_to? :activate_sigint
+
+      if old # no -> yes
+        @ui.activate_sigint
+      else
+        @ui.deactivate_sigint
+      end
+    end
+
     def save_int_trap cmd
       prev, @intercepted_sigint_cmd = @intercepted_sigint_cmd, cmd
       prev
@@ -1717,6 +2017,13 @@ module DEBUGGER__
     def after_fork_parent
       @ui.after_fork_parent
     end
+
+    # experimental API
+    def extend_feature session: nil, thread_client: nil, ui: nil
+      Session.include session if session
+      ThreadClient.include thread_client if thread_client
+      @ui.extend ui if ui
+    end
   end
 
   class ProcessGroup
@@ -1765,9 +2072,11 @@ module DEBUGGER__
 
     def after_fork child: true
       if child || !@lock_file
-        @m = Mutex.new
-        @lock_level = 0
-        @lock_file = open(@lock_tempfile.path, 'w')
+        @m = Mutex.new unless @m
+        @m.synchronize do
+          @lock_level = 0
+          @lock_file = open(@lock_tempfile.path, 'w')
+        end
       end
     end
 
@@ -1776,7 +2085,7 @@ module DEBUGGER__
     end
 
     def locked?
-      # DEBUGGER__.info "locked? #{@lock_level}"
+      # DEBUGGER__.debug{ "locked? #{@lock_level}" }
       @lock_level > 0
     end
 
@@ -1860,6 +2169,13 @@ module DEBUGGER__
         puts "\nStop by #{args.first}"
       end
     end
+
+    def ignore_output_on_suspend?
+      false
+    end
+
+    def flush
+    end
   end
 
   # manual configuration methods
@@ -1876,12 +2192,13 @@ module DEBUGGER__
   # 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
       when dir_prefix
       when %r{rubygems/core_ext/kernel_require\.rb}
+      when %r{bundled_gems\.rb}
       else
         return loc if loc.absolute_path
       end
@@ -1894,18 +2211,22 @@ module DEBUGGER__
   def self.start nonstop: false, **kw
     CONFIG.set_config(**kw)
 
-    unless defined? SESSION
-      require_relative 'local'
-      initialize_session UI_LocalConsole.new
+    if CONFIG[:open]
+      open nonstop: nonstop, **kw
+    else
+      unless defined? SESSION
+        require_relative 'local'
+        initialize_session{ UI_LocalConsole.new }
+      end
+      setup_initial_suspend unless nonstop
     end
-
-    setup_initial_suspend unless nonstop
   end
 
   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] == '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
@@ -1919,7 +2240,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
@@ -1932,7 +2253,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
@@ -1959,13 +2280,26 @@ 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
 
+  # Exiting control
+
+  class << self
+    def skip_all
+      @skip_all = true
+    end
+
+    def skip?
+      @skip_all
+    end
+  end
+
   def self.load_rc
     [[File.expand_path('~/.rdbgrc'), true],
      [File.expand_path('~/.rdbgrc.rb'), true],
@@ -1993,34 +2327,53 @@ module DEBUGGER__
     end
   end
 
-  class ::Module
-    undef method_added
-    def method_added mid; end
-    def singleton_method_added mid; end
-  end
+  # Inspector
 
-  def self.method_added tp
-    begin
-      SESSION.method_added tp
-    rescue Exception => e
-      p e
+  SHORT_INSPECT_LENGTH = 40
+
+  class LimitedPP
+    def self.pp(obj, max=80)
+      out = self.new(max)
+      catch out do
+        PP.singleline_pp(obj, out)
+      end
+      out.buf
     end
-  end
 
-  METHOD_ADDED_TRACKER = self.create_method_added_tracker
+    attr_reader :buf
 
-  SHORT_INSPECT_LENGTH = 40
+    def initialize max
+      @max = max
+      @cnt = 0
+      @buf = String.new
+    end
 
-  def self.safe_inspect obj, max_length: SHORT_INSPECT_LENGTH, short: false
-    str = obj.inspect
+    def <<(other)
+      @buf << other
 
-    if short && str.length > max_length
-      str[0...max_length] + '...'
+      if @buf.size >= @max
+        @buf = @buf[0..@max] + '...'
+        throw self
+      end
+    end
+  end
+
+  def self.safe_inspect obj, max_length: SHORT_INSPECT_LENGTH, short: false
+    if short
+      LimitedPP.pp(obj, max_length)
+    else
+      obj.inspect
+    end
+  rescue NoMethodError => e
+    klass, oid = M_CLASS.bind_call(obj), M_OBJECT_ID.bind_call(obj)
+    if obj == (r = e.receiver)
+      "<\##{klass.name}#{oid} does not have \#inspect>"
     else
-      str
+      rklass, roid = M_CLASS.bind_call(r), M_OBJECT_ID.bind_call(r)
+      "<\##{klass.name}:#{roid} contains <\##{rklass}:#{roid} and it does not have #inspect>"
     end
   rescue Exception => e
-    str = "<#inspect raises #{e.inspect}>"
+    "<#inspect raises #{e.inspect}>"
   end
 
   def self.warn msg
@@ -2031,18 +2384,28 @@ module DEBUGGER__
     log :INFO, msg
   end
 
-  def self.log level, msg
-    @logfile = STDERR unless defined? @logfile
-
+  def self.check_loglevel level
     lv = LOG_LEVELS[level]
-    config_lv = LOG_LEVELS[CONFIG[:log_level] || :WARN]
+    config_lv = LOG_LEVELS[CONFIG[:log_level]]
+    lv <= config_lv
+  end
 
-    if defined? SESSION
-      pi = SESSION.process_info
-      process_info = pi ? "[#{pi}]" : nil
+  def self.debug(&b)
+    if check_loglevel :DEBUG
+      log :DEBUG, b.call
     end
+  end
+
+  def self.log level, msg
+    if check_loglevel level
+      @logfile = STDERR unless defined? @logfile
+      return if @logfile.closed?
+
+      if defined? SESSION
+        pi = SESSION.process_info
+        process_info = pi ? "[#{pi}]" : nil
+      end
 
-    if lv <= config_lv
       if level == :WARN
         # :WARN on debugger is general information
         @logfile.puts "DEBUGGER#{process_info}: #{msg}"
@@ -2062,17 +2425,85 @@ module DEBUGGER__
     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 super unless defined?(SESSION) && SESSION.active?
+
+        parent_hook, child_hook = __fork_setup_for_debugger
 
-      unless fork_mode = CONFIG[:fork_mode]
-        if CONFIG[:parent_on_fork]
-          fork_mode = :parent
+        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 super 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
-          fork_mode = :both
+          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
+
+    module DaemonInterceptor
+      def daemon(*args)
+        return super unless defined?(SESSION) && SESSION.active?
+
+        _, child_hook = __fork_setup_for_debugger(:child)
+
+        unless SESSION.remote?
+          DEBUGGER__.warn "Can't debug the code after Process.daemon locally. Use the remote debugging feature."
+        end
+
+        super.tap do
+          child_hook.call
         end
       end
+    end
+
+    private def __fork_setup_for_debugger fork_mode = nil
+      fork_mode ||= CONFIG[:fork_mode]
+
+      if fork_mode == :both && CONFIG[:parent_on_fork]
+        fork_mode = :parent
+      end
 
       parent_pid = Process.pid
 
@@ -2083,19 +2514,19 @@ module DEBUGGER__
           # Do nothing
         }
         child_hook = -> {
-          DEBUGGER__.warn "Detaching after fork from child process #{Process.pid}"
+          DEBUGGER__.info "Detaching after fork from child process #{Process.pid}"
           SESSION.deactivate
         }
       when :child
         SESSION.before_fork false
 
         parent_hook = -> child_pid {
-          DEBUGGER__.warn "Detaching after fork from parent process #{Process.pid}"
+          DEBUGGER__.info "Detaching after fork from parent process #{Process.pid}"
           SESSION.after_fork_parent
           SESSION.deactivate
         }
         child_hook = -> {
-          DEBUGGER__.warn "Attaching after process #{parent_pid} fork to child process #{Process.pid}"
+          DEBUGGER__.info "Attaching after process #{parent_pid} fork to child process #{Process.pid}"
           SESSION.activate on_fork: true
         }
       when :both
@@ -2106,38 +2537,29 @@ module DEBUGGER__
           SESSION.after_fork_parent
         }
         child_hook = -> {
-          DEBUGGER__.warn "Attaching after process #{parent_pid} fork to child process #{Process.pid}"
+          DEBUGGER__.info "Attaching after process #{parent_pid} fork to child process #{Process.pid}"
           SESSION.process_group.after_fork child: true
           SESSION.activate on_fork: true
         }
       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
 
   module TrapInterceptor
     def trap sig, *command, &command_proc
-      case sig&.to_sym
+      sym =
+        case sig
+        when String
+          sig.to_sym
+        when Integer
+          Signal.signame(sig)&.to_sym
+        else
+          sig
+        end
+
+      case sym
       when :INT, :SIGINT
         if defined?(SESSION) && SESSION.active? && SESSION.intercept_trap_sigint?
           return SESSION.save_int_trap(command.empty? ? command_proc : command.first)
@@ -2148,28 +2570,48 @@ module DEBUGGER__
     end
   end
 
-  if RUBY_VERSION >= '3.0.0'
+  if Process.respond_to? :_fork
+    module ::Process
+      class << self
+        prepend ForkInterceptor
+        prepend DaemonInterceptor
+      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
+        prepend DaemonInterceptor
+      end
     end
   end
 
@@ -2185,10 +2627,17 @@ module Kernel
     return if !defined?(::DEBUGGER__::SESSION) || !::DEBUGGER__::SESSION.active?
 
     if pre || (do_expr = binding.local_variable_get(:do))
-      cmds = ['binding.break', pre, do_expr]
+      cmds = ['#debugger', pre, do_expr]
     end
 
-    loc = caller_locations(up_level, 1).first; ::DEBUGGER__.add_line_breakpoint loc.path, loc.lineno + 1, oneshot: true, command: cmds
+    if ::DEBUGGER__::SESSION.in_subsession?
+      if cmds
+        commands = [*cmds[1], *cmds[2]].map{|c| c.split(';;').join("\n")}
+        ::DEBUGGER__::SESSION.add_preset_commands cmds[0], commands, kick: false, continue: false
+      end
+    else
+      loc = caller_locations(up_level, 1).first; ::DEBUGGER__.add_line_breakpoint loc.path, loc.lineno + 1, oneshot: true, command: cmds
+    end
     self
   end
 
@@ -2199,3 +2648,12 @@ class Binding
   alias break debugger
   alias b debugger
 end
+
+# for Ruby 2.6 compatibility
+unless method(:p).unbind.respond_to? :bind_call
+  class UnboundMethod
+    def bind_call(obj, *args)
+      self.bind(obj).call(*args)
+    end
+  end
+end