debug 1.4.0 → 1.9.2

data/TODO.md

@@ -2,22 +2,22 @@
 
 ## Basic functionality
 
-* Support Ractors
-* Signal (SIGINT) trap handling 
+* Support Fibers and Ractors
 
 ## UI
 
+* Multi-line support
 * Completion for Ruby's code
 * Interactive breakpoint setting
 * Interactive record & play debugging
 * irb integration
-* Web browser integrated UI
-* History file
 
 ## Debug command
 
-* Breakpoints
-    * Lightweight pending method break points with Ruby 3.1 feature (TP:method_added)
 * Watch points
-    * Lightweight watchpoints for instance variables with Ruby 3.1 features (TP:ivar_set)
-* Faster `next`/`finish` command by specifying target code.
+    * Lightweight watchpoints for instance variables with Ruby 3.3 features (TP:ivar_set)
+* Alias
+
+## Debug port
+
+* Debug port for monitoring

data/debug.gemspec

@@ -7,24 +7,26 @@ Gem::Specification.new do |spec|
   spec.email         = ["ko1@atdot.net"]
 
   spec.summary       = %q{Debugging functionality for Ruby}
-  spec.description   = %q{Debugging functionality for Ruby. This is completely rewritten debug.rb which was contained by the encient Ruby versions.}
+  spec.description   = %q{Debugging functionality for Ruby. This is completely rewritten debug.rb which was contained by the ancient Ruby versions.}
   spec.homepage      = "https://github.com/ruby/debug"
   spec.licenses      = ["Ruby", "BSD-2-Clause"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
   end
   spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions    = ['ext/debug/extconf.rb']
 
-  spec.add_dependency "irb", ">= 1.3.6" # for its color_printer class, which was added after 1.3
-  spec.add_dependency "reline", ">= 0.2.7"
+  spec.add_dependency "irb", "~> 1.10" # for irb:debug integration
+  spec.add_dependency "reline", ">= 0.3.8"
 end

data/exe/rdbg

@@ -3,22 +3,41 @@
 require_relative '../lib/debug/config'
 config = DEBUGGER__::Config::parse_argv(ARGV)
 
-case config[:mode]
+# mode is not an actual configuration option
+# it's only used to carry the result of parse_argv here
+case config.delete(:mode)
 when :start
   require 'rbconfig'
 
   libpath = File.join(File.expand_path(File.dirname(__dir__)), 'lib/debug')
-  start_mode = config[:remote] ? "open" : 'start'
+  start_mode = config[:open] ? "open" : 'start'
   cmd = config[:command] ? ARGV.shift : (ENV['RUBY'] || RbConfig.ruby)
 
+  if defined?($:.resolve_feature_path)
+    begin
+      _, sopath = $:.resolve_feature_path('debug/debug.so')
+    rescue LoadError
+      # raises LoadError before 3.1 (2.7 and 3.0)
+    else
+      sopath = File.dirname(File.dirname(sopath)) if sopath
+    end
+  else
+    # `$:.resolve_feature_path` is not defined in 2.6 or earlier.
+    so = "debug/debug.#{RbConfig::CONFIG['DLEXT']}"
+    sopath = $:.find {|dir| File.exist?(File.join(dir, so))}
+  end
+  added = "-r #{libpath}/#{start_mode}"
+  added = "-I #{sopath} #{added}" if sopath
+  rubyopt = ENV['RUBYOPT']
   env = ::DEBUGGER__::Config.config_to_env_hash(config)
-  env['RUBYOPT'] = "-r #{libpath}/#{start_mode}"
+  env['RUBY_DEBUG_ADDED_RUBYOPT'] = added
+  env['RUBYOPT'] = "#{rubyopt} #{added}"
 
   exec(env, cmd, *ARGV)
 
 when :attach
   require_relative "../lib/debug/client"
-  ::DEBUGGER__::CONFIG.update config
+  ::DEBUGGER__::CONFIG.set_config(**config)
 
   begin
     if ARGV.empty? && config[:port]

data/ext/debug/debug.c

@@ -8,13 +8,13 @@ static VALUE rb_mDebugger;
 
 // iseq
 typedef struct rb_iseq_struct rb_iseq_t;
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
 VALUE rb_iseq_realpath(const rb_iseq_t *iseq);
 
 static VALUE
 iseq_realpath(VALUE iseqw)
 {
-    rb_iseq_t *iseq = DATA_PTR(iseqw);
-    return rb_iseq_realpath(iseq);
+    return rb_iseq_realpath(rb_iseqw_to_iseq(iseqw));
 }
 
 static VALUE rb_cFrameInfo;
@@ -62,21 +62,34 @@ di_body(const rb_debug_inspector_t *dc, void *ptr)
     long i;
 
     for (i=1; i<len; i++) {
-        VALUE loc, e;
+        VALUE e;
         VALUE iseq = rb_debug_inspector_frame_iseq_get(dc, i);
+        VALUE loc = RARRAY_AREF(locs, i);
+        VALUE path;
 
         if (!NIL_P(iseq)) {
-            VALUE path = iseq_realpath(iseq);
-            if (!NIL_P(path) && !NIL_P(skip_path_prefix) && str_start_with(path, skip_path_prefix)) continue;
+            path = iseq_realpath(iseq);
+        }
+        else {
+            // C frame
+            path = rb_funcall(loc, rb_intern("path"), 0);
+        }
+
+        if (!NIL_P(path) && !NIL_P(skip_path_prefix) && str_start_with(path, skip_path_prefix)) {
+            continue;
         }
 
-        loc = RARRAY_AREF(locs, i);
         e = di_entry(loc,
                      rb_debug_inspector_frame_self_get(dc, i),
                      rb_debug_inspector_frame_binding_get(dc, i),
                      iseq,
                      rb_debug_inspector_frame_class_get(dc, i),
-                     INT2FIX(len - i));
+#ifdef RB_DEBUG_INSPECTOR_FRAME_DEPTH
+                     rb_debug_inspector_frame_depth(dc, i)
+#else
+                     INT2FIX(len - i)
+#endif
+                     );
         rb_ary_push(ary, e);
     }
 
@@ -89,6 +102,13 @@ capture_frames(VALUE self, VALUE skip_path_prefix)
     return rb_debug_inspector_open(di_body, (void *)skip_path_prefix);
 }
 
+#ifdef RB_DEBUG_INSPECTOR_FRAME_DEPTH
+static VALUE
+frame_depth(VALUE self)
+{
+    return rb_debug_inspector_current_depth();
+}
+#else
 static VALUE
 frame_depth(VALUE self)
 {
@@ -96,33 +116,89 @@ frame_depth(VALUE self)
     VALUE bt = rb_make_backtrace();
     return INT2FIX(RARRAY_LEN(bt));
 }
+#endif
+
+
+// iseq
+
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
+
+#ifdef HAVE_RB_ISEQ_TYPE
+VALUE rb_iseq_type(const rb_iseq_t *);
+
+static VALUE
+iseq_type(VALUE iseqw)
+{
+    const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
+    return rb_iseq_type(iseq);
+}
+#endif
 
-static void
-method_added_tracker(VALUE tpval, void *ptr)
+#ifdef HAVE_RB_ISEQ_PARAMETERS
+VALUE rb_iseq_parameters(const rb_iseq_t *, int is_proc);
+
+static VALUE
+iseq_parameters_symbols(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 rb_iseq_t *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 rb_iseq_t *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
+
+static VALUE
+iseq_first_line(VALUE iseqw)
+{
+    const rb_iseq_t *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 rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
+    int line;
+    rb_iseq_code_location(iseq, NULL, NULL, &line, NULL);
+    return INT2NUM(line);
 }
+#endif
 
+#ifdef HAVE_RB_ISEQ
 void Init_iseq_collector(void);
+#endif
 
 void
 Init_debug(void)
 {
+#ifdef HAVE_RB_ISEQ
+    VALUE rb_mRubyVM = rb_const_get(rb_cObject, rb_intern("RubyVM"));
+    VALUE rb_cISeq = rb_const_get(rb_mRubyVM, rb_intern("InstructionSequence"));
+#endif
     rb_mDebugger = rb_const_get(rb_cObject, rb_intern("DEBUGGER__"));
     rb_cFrameInfo = rb_const_get(rb_mDebugger, rb_intern("FrameInfo"));
 
@@ -132,7 +208,21 @@ 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
+
+#ifdef HAVE_RB_ISEQ
     Init_iseq_collector();
+#endif
 }

data/ext/debug/extconf.rb

@@ -1,4 +1,27 @@
 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'
+  $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/ext/debug/iseq_collector.c

@@ -1,5 +1,6 @@
 #include <ruby/ruby.h>
 
+#ifdef HAVE_RB_ISEQ
 VALUE rb_iseqw_new(VALUE v);
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),
@@ -89,3 +90,4 @@ Init_iseq_collector(void)
     rb_define_singleton_method(rb_mObjSpace, "each_iseq", each_iseq, 0);
     rb_define_singleton_method(rb_mObjSpace, "count_iseq", count_iseq, 0);
 }
+#endif

data/lib/debug/abbrev_command.rb

@@ -0,0 +1,77 @@
+
+module DEBUGGER__
+  class AbbrevCommand
+    class TrieNode
+      def initialize
+        @children = {}
+        @types = {} # set
+      end
+
+      def append c, type
+        trie = (@children[c] ||= TrieNode.new)
+        trie.add_type type
+      end
+
+      def [](c)
+        @children[c]
+      end
+
+      def add_type type
+        @types[type] = true
+        self
+      end
+
+      def types
+        @types.keys
+      end
+
+      def type
+        if @types.size == 1
+          @types.keys.first
+        else
+          nil
+        end
+      end
+
+      def candidates
+        @children.map{|c, n|
+          ss = n.candidates
+          ss.empty? ? c :
+          ss.map{|s|
+            c+s
+          }
+        }.flatten
+      end
+    end
+
+    # config: { type: [commands...], ... }
+    def initialize config
+      @trie = TrieNode.new
+      build config
+    end
+
+    private def build config
+      config.each do |type, commands|
+        commands.each do |command|
+          trie = @trie
+          command.each_char do |c|
+            trie = trie.append(c, type)
+          end
+        end
+      end
+    end
+
+    def search str, if_none = nil
+      trie = @trie
+      str.each_char do |c|
+        if trie = trie[c]
+          return trie.type if trie.type
+        else
+          return if_none
+        end
+      end
+      yield trie.candidates.map{|s| str + s} if block_given?
+      if_none
+    end
+  end
+end