debug 1.4.0 → 1.6.1

data/ext/debug/debug.c

@@ -97,32 +97,82 @@ frame_depth(VALUE self)
     return INT2FIX(RARRAY_LEN(bt));
 }
 
-static void
-method_added_tracker(VALUE tpval, void *ptr)
+// iseq
+
+const struct rb_iseq *rb_iseqw_to_iseq(VALUE iseqw);
+
+#ifdef HAVE_RB_ISEQ_TYPE
+VALUE rb_iseq_type(const struct rb_iseq *);
+
+static VALUE
+iseq_type(VALUE iseqw)
 {
-    rb_trace_arg_t *arg = rb_tracearg_from_tracepoint(tpval);
-    VALUE mid = rb_tracearg_callee_id(arg);
-
-    if (RB_UNLIKELY(mid == ID2SYM(rb_intern("method_added")) ||
-                    mid == ID2SYM(rb_intern("singleton_method_added")))) {
-        VALUE args[] = {
-            tpval,
-        };
-        rb_funcallv(rb_mDebugger, rb_intern("method_added"), 1, args);
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    return rb_iseq_type(iseq);
+}
+#endif
+
+#ifdef HAVE_RB_ISEQ_PARAMETERS
+VALUE rb_iseq_parameters(const struct rb_iseq *, int is_proc);
+
+static VALUE
+iseq_parameters_symbols(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    VALUE params = rb_iseq_parameters(iseq, 0);
+    VALUE ary = rb_ary_new();
+
+    static VALUE sym_ast, sym_astast, sym_amp;
+
+    if (sym_ast == 0) {
+        sym_ast = ID2SYM(rb_intern("*"));
+        sym_astast = ID2SYM(rb_intern("**"));
+        sym_amp = ID2SYM(rb_intern("&"));
     }
+
+    for (long i=0; i<RARRAY_LEN(params); i++) {
+        VALUE e = RARRAY_AREF(params, i);
+        if (RARRAY_LEN(e) == 2) {
+            VALUE sym = RARRAY_AREF(e, 1);
+            if (sym != sym_ast &&
+                sym != sym_astast &&
+                sym != sym_amp) rb_ary_push(ary, RARRAY_AREF(e, 1));
+        }
+    }
+
+    return ary;
+}
+#endif
+
+#ifdef HAVE_RB_ISEQ_CODE_LOCATION
+void rb_iseq_code_location(const struct rb_iseq *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
+
+static VALUE
+iseq_first_line(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    int line;
+    rb_iseq_code_location(iseq, &line, NULL, NULL, NULL);
+    return INT2NUM(line);
 }
 
 static VALUE
-create_method_added_tracker(VALUE self)
+iseq_last_line(VALUE iseqw)
 {
-    return rb_tracepoint_new(0, RUBY_EVENT_CALL, method_added_tracker, NULL);
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    int line;
+    rb_iseq_code_location(iseq, NULL, NULL, &line, NULL);
+    return INT2NUM(line);
 }
+#endif
 
 void Init_iseq_collector(void);
 
 void
 Init_debug(void)
 {
+    VALUE rb_mRubyVM = rb_const_get(rb_cObject, rb_intern("RubyVM"));
+    VALUE rb_cISeq = rb_const_get(rb_mRubyVM, rb_intern("InstructionSequence"));
     rb_mDebugger = rb_const_get(rb_cObject, rb_intern("DEBUGGER__"));
     rb_cFrameInfo = rb_const_get(rb_mDebugger, rb_intern("FrameInfo"));
 
@@ -132,7 +182,19 @@ Init_debug(void)
     rb_gc_register_mark_object(rb_cFrameInfo);
     rb_define_singleton_method(rb_mDebugger, "capture_frames", capture_frames, 1);
     rb_define_singleton_method(rb_mDebugger, "frame_depth", frame_depth, 0);
-    rb_define_singleton_method(rb_mDebugger, "create_method_added_tracker", create_method_added_tracker, 0);
     rb_define_const(rb_mDebugger, "SO_VERSION", rb_str_new2(RUBY_DEBUG_VERSION));
+
+    // iseq
+#ifdef HAVE_RB_ISEQ_TYPE
+    rb_define_method(rb_cISeq, "type", iseq_type, 0);
+#endif
+#ifdef HAVE_RB_ISEQ_PARAMETERS
+    rb_define_method(rb_cISeq, "parameters_symbols", iseq_parameters_symbols, 0);
+#endif
+#ifdef HAVE_RB_ISEQ_CODE_LOCATION
+    rb_define_method(rb_cISeq, "first_line", iseq_first_line, 0);
+    rb_define_method(rb_cISeq, "last_line", iseq_last_line, 0);
+#endif
+
     Init_iseq_collector();
 }

data/ext/debug/extconf.rb

@@ -1,4 +1,26 @@
 require 'mkmf'
 require_relative '../../lib/debug/version'
 File.write("debug_version.h", "#define RUBY_DEBUG_VERSION \"#{DEBUGGER__::VERSION}\"\n")
+$distcleanfiles << "debug_version.h"
+
+if defined? RubyVM
+  $defs << '-DHAVE_RB_ISEQ_PARAMETERS'
+  $defs << '-DHAVE_RB_ISEQ_CODE_LOCATION'
+
+  if RUBY_VERSION >= '3.1.0'
+    $defs << '-DHAVE_RB_ISEQ_TYPE'
+  end
+else
+  # not on MRI
+
+  have_func "rb_iseq_parameters(NULL, 0)",
+             [["VALUE rb_iseq_parameters(void *, int is_proc);"]]
+
+  have_func "rb_iseq_code_location(NULL, NULL, NULL, NULL, NULL)",
+            [["void rb_iseq_code_location(void *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);"]]
+  # from Ruby 3.1
+  have_func "rb_iseq_type(NULL)",
+            [["VALUE rb_iseq_type(void *);"]]
+end
+
 create_makefile 'debug/debug'

data/lib/debug/breakpoint.rb

@@ -8,9 +8,13 @@ module DEBUGGER__
 
     attr_reader :key
 
-    def initialize do_enable = true
+    def initialize cond, command, path, do_enable: true
       @deleted = false
 
+      @cond = cond
+      @command = command
+      @path = path
+
       setup
       enable if do_enable
     end
@@ -82,8 +86,11 @@ module DEBUGGER__
     end
 
     def skip_path?(path)
-      if @path
+      case @path
+      when Regexp
         !path.match?(@path)
+      when String
+        !path.include?(@path)
       else
         super
       end
@@ -108,7 +115,7 @@ module DEBUGGER__
       @oneshot = oneshot
       @key = [:iseq, @iseq.path, @iseq.first_lineno].freeze
 
-      super()
+      super(nil, nil, nil)
     end
 
     def setup
@@ -124,25 +131,30 @@ module DEBUGGER__
   end
 
   class LineBreakpoint < Breakpoint
-    attr_reader :path, :line, :iseq
+    attr_reader :path, :line, :iseq, :cond, :oneshot, :hook_call, :command
 
-    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil
-      @path = path
+    def self.copy bp, root_iseq
+      nbp = LineBreakpoint.new bp.path, bp.line,
+                               cond: bp.cond, oneshot: bp.oneshot, hook_call: bp.hook_call,
+                               command: bp.command, skip_activate: true
+      nbp.try_activate root_iseq
+      nbp
+    end
+
+    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil, skip_activate: false
       @line = line
-      @cond = cond
       @oneshot = oneshot
       @hook_call = hook_call
-      @command = command
       @pending = false
 
       @iseq = nil
       @type = nil
 
-      @key = [@path, @line].freeze
+      @key = [path, @line].freeze
 
-      super()
+      super(cond, command, path)
 
-      try_activate
+      try_activate unless skip_activate
       @pending = !@iseq
     end
 
@@ -202,7 +214,7 @@ module DEBUGGER__
       when events.include?(:RUBY_EVENT_END)
         activate(iseq, :end, line)
       else
-        # not actiavated
+        # not activated
       end
     end
 
@@ -212,42 +224,56 @@ module DEBUGGER__
 
     NearestISeq = Struct.new(:iseq, :line, :events)
 
-    def try_activate
-      nearest = nil # NearestISeq
-
-      ObjectSpace.each_iseq{|iseq|
-        if (iseq.absolute_path || iseq.path) == self.path &&
-            iseq.first_lineno <= self.line &&
-            iseq.type != :ensure # ensure iseq is copied (duplicated)
+    def iterate_iseq root_iseq
+      if root_iseq
+        is = [root_iseq]
+        while iseq = is.pop
+          yield iseq
+          iseq.each_child do |child_iseq|
+            is << child_iseq
+          end
+        end
+      else
+        ObjectSpace.each_iseq do |iseq|
+          if DEBUGGER__.compare_path((iseq.absolute_path || iseq.path), self.path) &&
+             iseq.first_lineno <= self.line &&
+             iseq.type != :ensure # ensure iseq is copied (duplicated)
+            yield iseq
+          end
+        end
+      end
+    end
 
-          iseq.traceable_lines_norec(line_events = {})
-          lines = line_events.keys.sort
+    def try_activate root_iseq = nil
+      nearest = nil # NearestISeq
+      iterate_iseq root_iseq do |iseq|
+        iseq.traceable_lines_norec(line_events = {})
+        lines = line_events.keys.sort
 
-          if !lines.empty? && lines.last >= line
-            nline = lines.bsearch{|l| line <= l}
-            events = line_events[nline]
+        if !lines.empty? && lines.last >= line
+          nline = lines.bsearch{|l| line <= l}
+          events = line_events[nline]
 
-            next if events == [:RUBY_EVENT_B_CALL]
+          next if events == [:RUBY_EVENT_B_CALL]
 
-            if @hook_call &&
-               events.include?(:RUBY_EVENT_CALL) &&
-               self.line == iseq.first_lineno
-              nline = iseq.first_lineno
-            end
+          if @hook_call &&
+            events.include?(:RUBY_EVENT_CALL) &&
+            self.line == iseq.first_lineno
+            nline = iseq.first_lineno
+          end
 
-            if !nearest || ((line - nline).abs < (line - nearest.line).abs)
-              nearest = NearestISeq.new(iseq, nline, events)
-            else
-              if @hook_call && nearest.iseq.first_lineno <= iseq.first_lineno
-                if (nearest.line > line && !nearest.events.include?(:RUBY_EVENT_CALL)) ||
-                   (events.include?(:RUBY_EVENT_CALL))
-                  nearest = NearestISeq.new(iseq, nline, events)
-                end
+          if !nearest || ((line - nline).abs < (line - nearest.line).abs)
+            nearest = NearestISeq.new(iseq, nline, events)
+          else
+            if @hook_call && nearest.iseq.first_lineno <= iseq.first_lineno
+              if (nearest.line > line && !nearest.events.include?(:RUBY_EVENT_CALL)) ||
+                (events.include?(:RUBY_EVENT_CALL))
+                nearest = NearestISeq.new(iseq, nline, events)
               end
             end
           end
         end
-      }
+      end
 
       if nearest
         activate_exact nearest.iseq, nearest.events, nearest.line
@@ -277,11 +303,7 @@ module DEBUGGER__
       @key = [:catch, @pat].freeze
       @last_exc = nil
 
-      @cond = cond
-      @command = command
-      @path = path
-
-      super()
+      super(cond, command, path)
     end
 
     def setup
@@ -314,29 +336,41 @@ module DEBUGGER__
   end
 
   class CheckBreakpoint < Breakpoint
-    def initialize expr, path
-      @expr = expr.freeze
-      @key = [:check, @expr].freeze
-      @path = path
+    def initialize cond:, command: nil, path: nil
+      @key = [:check, cond].freeze
 
-      super()
+      super(cond, command, path)
     end
 
     def setup
       @tp = TracePoint.new(:line){|tp|
-        next if tp.path.start_with? __dir__
-        next if tp.path.start_with? '<internal:'
+        next if SESSION.in_subsession? # TODO: Ractor support
         next if ThreadClient.current.management?
         next if skip_path?(tp.path)
 
-        if safe_eval tp.binding, @expr
+        if need_suspend? safe_eval(tp.binding, @cond)
           suspend
         end
       }
     end
 
+    private def need_suspend? cond_result
+      map = ThreadClient.current.check_bp_fulfillment_map
+      if cond_result
+        if map[self]
+          false
+        else
+          map[self] = true
+        end
+      else
+        map[self] = false
+      end
+    end
+
     def to_s
-      "#{generate_label("Check")} #{@expr}"
+      s = "#{generate_label("Check")}"
+      s += super
+      s
     end
   end
 
@@ -348,10 +382,7 @@ module DEBUGGER__
 
       @current = current
 
-      @cond = cond
-      @command = command
-      @path = path
-      super()
+      super(cond, command, path)
     end
 
     def watch_eval(tp)
@@ -374,9 +405,6 @@ module DEBUGGER__
 
     def setup
       @tp = TracePoint.new(:line, :return, :b_return){|tp|
-        next if tp.path.start_with? __dir__
-        next if tp.path.start_with? '<internal:'
-
         watch_eval(tp)
       }
     end
@@ -393,7 +421,7 @@ module DEBUGGER__
   end
 
   class MethodBreakpoint < Breakpoint
-    attr_reader :sig_method_name, :method
+    attr_reader :sig_method_name, :method, :klass
 
     def initialize b, klass_name, op, method_name, cond: nil, command: nil, path: nil
       @sig_klass_name = klass_name
@@ -404,13 +432,10 @@ module DEBUGGER__
 
       @klass = nil
       @method = nil
-      @cond = cond
       @cond_class = nil
-      @command = command
-      @path = path
       @key = "#{klass_name}#{op}#{method_name}".freeze
 
-      super(false)
+      super(cond, command, path, do_enable: false)
     end
 
     def setup
@@ -419,7 +444,6 @@ module DEBUGGER__
         next if @cond_class && !tp.self.kind_of?(@cond_class)
 
         caller_location = caller_locations(2, 1).first.to_s
-        next if caller_location.start_with?(__dir__)
         next if skip_path?(caller_location)
 
         suspend

data/lib/debug/client.rb

@@ -18,6 +18,10 @@ module DEBUGGER__
         case name
         when 'gen-sockpath'
           puts DEBUGGER__.create_unix_domain_socket_name
+        when 'gen-portpath'
+          port_path = File.join(DEBUGGER__.unix_domain_socket_dir, 'tcp_port')
+          File.unlink port_path if File.exist?(port_path)
+          puts port_path
         when 'list-socks'
           cleanup_unix_domain_sockets
           puts list_connections
@@ -76,7 +80,7 @@ module DEBUGGER__
 
       def cleanup_unix_domain_sockets
         Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*') do |file|
-          if /(\d+)$/ =~ file
+          if File.socket?(file) && (/-(\d+)-\d+$/ =~ file || /-(\d+)$/ =~ file)
             begin
               Process.kill(0, $1.to_i)
             rescue Errno::EPERM
@@ -88,7 +92,9 @@ module DEBUGGER__
       end
 
       def list_connections
-        Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
+        Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*').find_all do |path|
+          File.socket?(path)
+        end
       end
     end
 
@@ -115,7 +121,10 @@ module DEBUGGER__
       @width = IO.console_size[1]
       @width = 80 if @width == 0
 
-      send "version: #{VERSION} width: #{@width} cookie: #{CONFIG[:cookie]}"
+      send "version: #{VERSION} " +
+           "width: #{@width} " +
+           "cookie: #{CONFIG[:cookie] || '-'} " +
+           "nonstop: #{CONFIG[:nonstop] ? 'true' : 'false'}"
     end
 
     def deactivate
@@ -167,6 +176,8 @@ module DEBUGGER__
     end
 
     def connect
+      pre_commands = (CONFIG[:commands] || '').split(';;')
+
       trap(:SIGINT){
         send "pause"
       }
@@ -175,7 +186,7 @@ module DEBUGGER__
         trap(:SIGWINCH){
           @width = IO.console_size[1]
         }
-      rescue ArgumentError => e
+      rescue ArgumentError
         @width = 80
       end
 
@@ -193,7 +204,12 @@ module DEBUGGER__
           prev_trap = trap(:SIGINT, 'DEFAULT')
 
           begin
-            line = readline
+            if pre_commands.empty?
+              line = readline
+            else
+              line = pre_commands.shift
+              puts "(rdbg:remote:command) #{line}"
+            end
           rescue Interrupt
             retry
           ensure

data/lib/debug/config.rb

@@ -7,46 +7,50 @@ module DEBUGGER__
     ERROR:   2,
     WARN:    3,
     INFO:    4,
+    DEBUG:   5
   }.freeze
 
   CONFIG_SET = {
     # UI setting
-    log_level:      ['RUBY_DEBUG_LOG_LEVEL',      "UI: Log level same as Logger (default: WARN)",                   :loglevel],
-    show_src_lines: ['RUBY_DEBUG_SHOW_SRC_LINES', "UI: Show n lines source code on breakpoint (default: 10 lines)", :int],
-    show_frames:    ['RUBY_DEBUG_SHOW_FRAMES',    "UI: Show n frames on breakpoint (default: 2 frames)",            :int],
-    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shorten PATH (like $(Gem)/foo.rb)",                      :bool],
-    no_color:       ['RUBY_DEBUG_NO_COLOR',       "UI: Do not use colorize (default: false)",                       :bool],
-    no_sigint_hook: ['RUBY_DEBUG_NO_SIGINT_HOOK', "UI: Do not suspend on SIGINT (default: false)",                  :bool],
-    no_reline:      ['RUBY_DEBUG_NO_RELINE',      "UI: Do not use Reline library (default: false)",                 :bool],
+    log_level:      ['RUBY_DEBUG_LOG_LEVEL',      "UI: Log level same as Logger",               :loglevel, "WARN"],
+    show_src_lines: ['RUBY_DEBUG_SHOW_SRC_LINES', "UI: Show n lines source code on breakpoint", :int, "10"],
+    show_frames:    ['RUBY_DEBUG_SHOW_FRAMES',    "UI: Show n frames on breakpoint",            :int, "2"],
+    use_short_path: ['RUBY_DEBUG_USE_SHORT_PATH', "UI: Show shorten PATH (like $(Gem)/foo.rb)", :bool, "false"],
+    no_color:       ['RUBY_DEBUG_NO_COLOR',       "UI: Do not use colorize",                    :bool, "false"],
+    no_sigint_hook: ['RUBY_DEBUG_NO_SIGINT_HOOK', "UI: Do not suspend on SIGINT",               :bool, "false"],
+    no_reline:      ['RUBY_DEBUG_NO_RELINE',      "UI: Do not use Reline library",              :bool, "false"],
+    no_hint:        ['RUBY_DEBUG_NO_HINT',        "UI: Do not show the hint on the REPL",       :bool, "false"],
 
     # control setting
-    skip_path:      ['RUBY_DEBUG_SKIP_PATH',      "CONTROL: Skip showing/entering frames for given paths (default: [])", :path],
-    skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "CONTROL: Skip on no source code lines (default: false)",              :bool],
-    keep_alloc_site:['RUBY_DEBUG_KEEP_ALLOC_SITE',"CONTROL: Keep allocation site and p, pp shows it (default: false)",   :bool],
-    postmortem:     ['RUBY_DEBUG_POSTMORTEM',     "CONTROL: Enable postmortem debug (default: false)",                   :bool],
-    fork_mode:      ['RUBY_DEBUG_FORK_MODE',      "CONTROL: Control which process activates a debugger after fork (both/parent/child) (default: both)", :forkmode],
-    sigdump_sig:    ['RUBY_DEBUG_SIGDUMP_SIG',    "CONTROL: Sigdump signal (default: disabled)"],
+    skip_path:      ['RUBY_DEBUG_SKIP_PATH',      "CONTROL: Skip showing/entering frames for given paths", :path],
+    skip_nosrc:     ['RUBY_DEBUG_SKIP_NOSRC',     "CONTROL: Skip on no source code lines",              :bool, "false"],
+    keep_alloc_site:['RUBY_DEBUG_KEEP_ALLOC_SITE',"CONTROL: Keep allocation site and p, pp shows it",   :bool, "false"],
+    postmortem:     ['RUBY_DEBUG_POSTMORTEM',     "CONTROL: Enable postmortem debug",                   :bool, "false"],
+    fork_mode:      ['RUBY_DEBUG_FORK_MODE',      "CONTROL: Control which process activates a debugger after fork (both/parent/child)", :forkmode, "both"],
+    sigdump_sig:    ['RUBY_DEBUG_SIGDUMP_SIG',    "CONTROL: Sigdump signal", :bool, "false"],
 
     # boot setting
-    nonstop:        ['RUBY_DEBUG_NONSTOP',     "BOOT: Nonstop mode",                                                :bool],
-    stop_at_load:   ['RUBY_DEBUG_STOP_AT_LOAD',"BOOT: Stop at just loading location",                               :bool],
+    nonstop:        ['RUBY_DEBUG_NONSTOP',     "BOOT: Nonstop mode",                                                :bool, "false"],
+    stop_at_load:   ['RUBY_DEBUG_STOP_AT_LOAD',"BOOT: Stop at just loading location",                               :bool, "false"],
     init_script:    ['RUBY_DEBUG_INIT_SCRIPT', "BOOT: debug command script path loaded at first stop"],
     commands:       ['RUBY_DEBUG_COMMANDS',    "BOOT: debug commands invoked at first stop. commands should be separated by ';;'"],
-    no_rc:          ['RUBY_DEBUG_NO_RC',       "BOOT: ignore loading ~/.rdbgrc(.rb)",                               :bool],
-    history_file:   ['RUBY_DEBUG_HISTORY_FILE',"BOOT: history file (default: ~/.rdbg_history)"],
-    save_history:   ['RUBY_DEBUG_SAVE_HISTORY',"BOOT: maximum save history lines (default: 10,000)"],
+    no_rc:          ['RUBY_DEBUG_NO_RC',       "BOOT: ignore loading ~/.rdbgrc(.rb)",                               :bool, "false"],
+    history_file:   ['RUBY_DEBUG_HISTORY_FILE',"BOOT: history file",               :string, "~/.rdbg_history"],
+    save_history:   ['RUBY_DEBUG_SAVE_HISTORY',"BOOT: maximum save history lines", :int, "10000"],
 
     # remote setting
     port:           ['RUBY_DEBUG_PORT',         "REMOTE: TCP/IP remote debugging: port"],
-    host:           ['RUBY_DEBUG_HOST',         "REMOTE: TCP/IP remote debugging: host (localhost if not given)"],
+    host:           ['RUBY_DEBUG_HOST',         "REMOTE: TCP/IP remote debugging: host", :string, "127.0.0.1"],
     sock_path:      ['RUBY_DEBUG_SOCK_PATH',    "REMOTE: UNIX Domain Socket remote debugging: socket path"],
     sock_dir:       ['RUBY_DEBUG_SOCK_DIR',     "REMOTE: UNIX Domain Socket remote debugging: socket directory"],
+    local_fs_map:   ['RUBY_DEBUG_LOCAL_FS_MAP', "REMOTE: Specify local fs map", :path_map],
+    skip_bp:        ['RUBY_DEBUG_SKIP_BP',      "REMOTE: Skip breakpoints if no clients are attached", :bool, 'false'],
     cookie:         ['RUBY_DEBUG_COOKIE',       "REMOTE: Cookie for negotiation"],
     open_frontend:  ['RUBY_DEBUG_OPEN_FRONTEND',"REMOTE: frontend used by open command (vscode, chrome, default: rdbg)."],
     chrome_path:    ['RUBY_DEBUG_CHROME_PATH',  "REMOTE: Platform dependent path of Chrome (For more information, See [here](https://github.com/ruby/debug/pull/334/files#diff-5fc3d0a901379a95bc111b86cf0090b03f857edfd0b99a0c1537e26735698453R55-R64))"],
 
     # obsolete
-    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "OBSOLETE: Keep debugging parent process on fork (default: false)",     :bool],
+    parent_on_fork: ['RUBY_DEBUG_PARENT_ON_FORK', "OBSOLETE: Keep debugging parent process on fork",     :bool, "false"],
   }.freeze
 
   CONFIG_MAP = CONFIG_SET.map{|k, (ev, _)| [k, ev]}.to_h.freeze
@@ -59,11 +63,23 @@ module DEBUGGER__
     end
 
     def initialize argv
+      @skip_all = false
+
       if self.class.config
         raise 'Can not make multiple configurations in one process'
       end
 
-      update self.class.parse_argv(argv)
+      config = self.class.parse_argv(argv)
+
+      # apply defaults
+      CONFIG_SET.each do |k, config_detail|
+        unless config.key?(k)
+          default_value = config_detail[3]
+          config[k] = parse_config_value(k, default_value)
+        end
+      end
+
+      update config
     end
 
     def inspect
@@ -78,6 +94,14 @@ module DEBUGGER__
       set_config(key => val)
     end
 
+    def skip_all
+      @skip_all = true
+    end
+
+    def skip?
+      @skip_all
+    end
+
     def set_config(**kw)
       conf = config.dup
       kw.each{|k, v|
@@ -114,11 +138,13 @@ module DEBUGGER__
       self.class.instance_variable_set(:@config, conf.freeze)
 
       # Post process
-      if_updated old_conf, conf, :keep_alloc_site do |_, new|
+      if_updated old_conf, conf, :keep_alloc_site do |old, new|
         if new
           require 'objspace'
           ObjectSpace.trace_object_allocations_start
-        else
+        end
+
+        if old && !new
           ObjectSpace.trace_object_allocations_stop
         end
       end
@@ -215,6 +241,8 @@ module DEBUGGER__
             e
           end
         }
+      when :path_map
+        valstr.split(',').map{|e| e.split(':')}
       else
         valstr
       end
@@ -223,6 +251,7 @@ module DEBUGGER__
     def self.parse_argv argv
       config = {
         mode: :start,
+        no_color: (nc = ENV['NO_COLOR']) && !nc.empty?,
       }
       CONFIG_MAP.each{|key, evname|
         if val = ENV[evname]
@@ -361,6 +390,8 @@ module DEBUGGER__
           case CONFIG_SET[key][2]
           when :path
             valstr = config[key].map{|e| e.kind_of?(Regexp) ? e.inspect : e}.join(':')
+          when :path_map
+            valstr = config[key].map{|e| e.join(':')}.join(',')
           else
             valstr = config[key].to_s
           end
@@ -428,7 +459,7 @@ module DEBUGGER__
   end
 
   def self.create_unix_domain_socket_name_prefix(base_dir = unix_domain_socket_dir)
-    user = ENV['USER'] || 'ruby-debug'
+    user = ENV['USER'] || 'UnknownUser'
     File.join(base_dir, "ruby-debug-#{user}")
   end