debugger2 1.0.0.beta1

data/ext/ruby_debug/ruby_debug.h

@@ -0,0 +1,151 @@
+#include <ruby.h>
+#include "ruby/debug.h"
+
+/* Context info */
+enum ctx_stop_reason {
+    CTX_STOP_NONE,
+    CTX_STOP_STEP,
+    CTX_STOP_BREAKPOINT,
+    CTX_STOP_CATCHPOINT
+};
+
+/* Context flags */
+#define CTX_FL_SUSPEND      (1<<1) /* suspend because another thread stopping */
+#define CTX_FL_TRACING      (1<<2) /* call at_tracing method */
+#define CTX_FL_SKIPPED      (1<<3) /* skip all debugger events */
+#define CTX_FL_IGNORE       (1<<4) /* this context belongs to ignored thread */
+#define CTX_FL_DEAD         (1<<5) /* this context belonged to died thraed */
+#define CTX_FL_WAS_RUNNING  (1<<6) /* previous thread state */
+#define CTX_FL_ENABLE_BKPT  (1<<7) /* can check breakpoint */
+#define CTX_FL_STEPPED      (1<<8)
+#define CTX_FL_FORCE_MOVE   (1<<9)
+#define CTX_FL_CATCHING     (1<<10)
+
+#if 0
+static inline const char *
+flag_name(int flag)
+{
+    switch (flag) {
+#define C(x) case x: return #x
+	C(CTX_FL_SUSPEND);
+	C(CTX_FL_TRACING);
+	C(CTX_FL_SKIPPED);
+	C(CTX_FL_IGNORE);
+	C(CTX_FL_DEAD);
+	C(CTX_FL_WAS_RUNNING);
+	C(CTX_FL_ENABLE_BKPT);
+	C(CTX_FL_STEPPED);
+	C(CTX_FL_FORCE_MOVE);
+	C(CTX_FL_CATCHING);
+      default:
+	return "unknown";
+    }
+}
+#define CTX_DUMP(set, f) fprintf(stderr, "[CTX %s:%d] %s %s\n", __FILE__, __LINE__, (set) ? "set" : "unset", flag_name(f))
+#else
+#define CTX_DUMP(set, f)
+#endif
+
+#define CTX_FL_TEST(c,f)  ((c)->flags & (f))
+#define CTX_FL_SET(c,f)   do { CTX_DUMP(1, f); (c)->flags |= (f); } while (0)
+#define CTX_FL_UNSET(c,f) do { CTX_DUMP(0, f);  (c)->flags &= ~(f); } while (0)
+
+typedef struct {
+    VALUE thread_id;
+    int thnum;
+    int flags;
+    int calced_stack_size;
+    enum ctx_stop_reason stop_reason;
+
+    /* control flow */
+    int stop_next;
+    int dest_frame;
+    int stop_line;
+    int stop_frame;
+
+    int thread_pause;
+
+    VALUE last_file;
+    VALUE last_line;
+
+    VALUE breakpoint;
+
+    /* [[loc, self, klass, binding, iseq], ...] */
+    VALUE inspected_frame;
+} debug_context_t;
+
+enum inspected_frame_type {
+    INSPECTED_FRAME_LOCATION,
+    INSPECTED_FRAME_SELF,
+    INSPECTED_FRAME_CLASS,
+    INSPECTED_FRAME_BIDING,
+    INSPECTED_FRAME_ISEQ,
+};
+
+/* variables in ruby_debug.c */
+extern VALUE mDebugger;
+extern VALUE rdebug_breakpoints;
+extern VALUE rdebug_catchpoints;
+extern VALUE rdebug_threads_tbl;
+
+#define IS_STARTED  (rdebug_threads_tbl != Qnil)
+static inline void
+debug_check_started()
+{
+    if (!IS_STARTED) {
+	rb_raise(rb_eRuntimeError, "Debugger.start is not called yet.");
+    }
+}
+
+static inline int
+classname_cmp(VALUE name, VALUE klass)
+{
+    VALUE mod_name;
+    VALUE class_name = (Qnil == name) ? rb_str_new2("main") : name;
+    if (klass == Qnil) return(0);
+    mod_name = rb_mod_name(klass);
+    return (mod_name != Qnil 
+	    && rb_str_cmp(class_name, mod_name) == 0);
+}
+
+/* Breakpoint information */
+enum bp_type {
+    BP_POS_TYPE,
+    BP_METHOD_TYPE
+};
+
+enum hit_condition {
+    HIT_COND_NONE,
+    HIT_COND_GE,
+    HIT_COND_EQ,
+    HIT_COND_MOD
+};
+
+typedef struct {
+    int   id;
+    enum bp_type type;
+    VALUE source;
+    union {
+	int line;
+	ID  mid;
+    } pos;
+    VALUE expr;
+    VALUE enabled;
+    int hit_count;
+    int hit_value;
+    enum hit_condition hit_condition;
+} debug_breakpoint_t;
+
+/* routines in breakpoint.c */
+extern int   check_breakpoint_expression(VALUE breakpoint, VALUE binding);
+extern int   check_breakpoint_hit_condition(VALUE breakpoint);
+extern VALUE check_breakpoints_by_method(debug_context_t *debug_context, VALUE klass, ID mid, VALUE self);
+extern VALUE check_breakpoints_by_pos(debug_context_t *debug_context, VALUE file, VALUE line);
+extern VALUE create_breakpoint_from_args(int argc, VALUE *argv, int id);
+extern VALUE context_breakpoint(VALUE self);
+extern VALUE context_set_breakpoint(int argc, VALUE *argv, VALUE self);
+extern VALUE rdebug_add_catchpoint(VALUE self, VALUE value);
+extern VALUE debug_catchpoints(VALUE self);
+extern VALUE rdebug_remove_breakpoint(VALUE self, VALUE id_value);
+
+extern void Init_breakpoint();

data/lib/debugger.rb

@@ -0,0 +1,5 @@
+module Debugger
+end
+
+require 'ruby-debug'
+require 'debugger/version'

data/lib/debugger/version.rb

@@ -0,0 +1,5 @@
+module Debugger
+  # TODO: remove version from C ext
+  send :remove_const, :VERSION if const_defined? :VERSION
+  VERSION = '1.0.0.beta1'
+end

data/lib/debugger2.rb

@@ -0,0 +1,6 @@
+p 'loading debugger2...'
+module Debugger
+end
+
+require 'ruby-debug'
+require 'debugger/version'

data/lib/ruby-debug-base.rb

@@ -0,0 +1,307 @@
+require 'ruby_debug.so'
+require 'linecache19'
+
+module Debugger
+
+  # Default options to Debugger.start
+  DEFAULT_START_SETTINGS = {
+    :init        => true,  # Set $0 and save ARGV?
+    :post_mortem => false, # post-mortem debugging on uncaught exception?
+    :tracing     => nil    # Debugger.tracing value. true/false resets,
+                           # nil keeps the prior value
+  } unless defined?(DEFAULT_START_SETTINGS)
+
+  class Context
+    def interrupt
+      self.stop_next = 1
+    end
+
+    alias __c_frame_binding frame_binding
+    def frame_binding(frame)
+      b = __c_frame_binding(frame)
+      return b if b
+      hbinding(frame)
+    end
+
+    private
+
+    def hbinding(frame)
+      hash = frame_locals(frame)
+      code = hash.keys.map{|k| "#{k} = hash['#{k}']" unless k=='self' }.compact.join(';') + ';binding'
+      if obj = frame_self(frame)
+        obj.instance_eval code
+      else
+        eval code, TOPLEVEL_BINDING
+      end
+    end
+
+    def handler
+      Debugger.handler or raise 'No interface loaded'
+    end
+
+    def at_breakpoint(breakpoint)
+      handler.at_breakpoint(self, breakpoint)
+    end
+
+    def at_catchpoint(excpt)
+      handler.at_catchpoint(self, excpt)
+    end
+
+    def at_tracing(file, line)
+      @tracing_started = File.identical?(file, Debugger::PROG_SCRIPT)
+      handler.at_tracing(self, file, line) if @tracing_started
+    end
+
+    def at_line(file, line)
+      handler.at_line(self, file, line)
+    end
+
+    def at_return(file, line)
+      handler.at_return(self, file, line)
+    end
+  end
+
+  @reload_source_on_change = false
+  @tracing_started = false
+
+  class << self
+    # interface modules provide +handler+ object
+    attr_accessor :handler
+
+    # if <tt>true</tt>, checks the modification time of source files and reloads if it was modified
+    attr_accessor :reload_source_on_change
+
+    attr_accessor :last_exception
+    Debugger.last_exception = nil
+
+    #
+    # Interrupts the current thread
+    #
+    def interrupt
+      current_context.interrupt
+    end
+
+    #
+    # Interrupts the last debugged thread
+    #
+    def interrupt_last
+      if context = last_context
+        return nil unless context.thread.alive?
+        context.interrupt
+      end
+      context
+    end
+
+    def source_reload
+      Object.send(:remove_const, "SCRIPT_LINES__") if Object.const_defined?("SCRIPT_LINES__")
+      Object.const_set("SCRIPT_LINES__", {})
+      LineCache::clear_file_cache
+    end
+
+    # Get line +line_number+ from file named +filename+. Return "\n"
+    # there was a problem. Leaking blanks are stripped off.
+    def line_at(filename, line_number) # :nodoc:
+      @reload_on_change=nil unless defined?(@reload_on_change)
+      line = LineCache::getline(filename, line_number, @reload_on_change)
+      return "\n" unless line
+      return "#{line.gsub(/^\s+/, '').chomp}\n"
+    end
+
+    #
+    # Activates the post-mortem mode. There are two ways of using it:
+    #
+    # == Global post-mortem mode
+    # By calling Debugger.post_mortem method without a block, you install
+    # at_exit hook that intercepts any unhandled by your script exceptions
+    # and enables post-mortem mode.
+    #
+    # == Local post-mortem mode
+    #
+    # If you know that a particular block of code raises an exception you can
+    # enable post-mortem mode by wrapping this block with Debugger.post_mortem, e.g.
+    #
+    #   def offender
+    #      raise 'error'
+    #   end
+    #   Debugger.post_mortem do
+    #      ...
+    #      offender
+    #      ...
+    #   end
+    def post_mortem
+      if block_given?
+        old_post_mortem = self.post_mortem?
+        begin
+          self.post_mortem = true
+          yield
+        rescue Exception => exp
+          handle_post_mortem(exp)
+          raise
+        ensure
+          self.post_mortem = old_post_mortem
+        end
+      else
+        return if post_mortem?
+        self.post_mortem = true
+        debug_at_exit do
+          handle_post_mortem($!) if $! && post_mortem?
+        end
+      end
+    end
+
+    def handle_post_mortem(exp)
+      return if !exp || !exp.__debug_context ||
+        exp.__debug_context.stack_size == 0
+      Debugger.suspend
+      orig_tracing = Debugger.tracing, Debugger.current_context.tracing
+      Debugger.tracing = Debugger.current_context.tracing = false
+      Debugger.last_exception = exp
+      handler.at_line(exp.__debug_context, exp.__debug_file, exp.__debug_line)
+    ensure
+      Debugger.tracing, Debugger.current_context.tracing = orig_tracing
+      Debugger.resume
+    end
+    # private :handle_post_mortem
+  end
+
+  class DebugThread # :nodoc:
+  end
+
+  class ThreadsTable # :nodoc:
+  end
+
+  # Debugger.start(options) -> bool
+  # Debugger.start(options) { ... } -> obj
+  #
+  # If it's called without a block it returns +true+, unless debugger
+  # was already started.  If a block is given, it starts debugger and
+  # yields to block. When the block is finished executing it stops
+  # the debugger with Debugger.stop method.
+  #
+  # If a block is given, it starts debugger and yields to block. When
+  # the block is finished executing it stops the debugger with
+  # Debugger.stop method. Inside the block you will probably want to
+  # have a call to Debugger.debugger. For example:
+  #
+  #     Debugger.start{debugger; foo}  # Stop inside of foo
+  #
+  # Also, ruby-debug only allows
+  # one invocation of debugger at a time; nested Debugger.start's
+  # have no effect and you can't use this inside the debugger itself.
+  #
+  # <i>Note that if you want to stop debugger, you must call
+  # Debugger.stop as many time as you called Debugger.start
+  # method.</i>
+  #
+  # +options+ is a hash used to set various debugging options.
+  # Set :init true if you want to save ARGV and some variables which
+  # make a debugger restart possible. Only the first time :init is set true
+  # will values get set. Since ARGV is saved, you should make sure
+  # it hasn't been changed before the (first) call.
+  # Set :post_mortem true if you want to enter post-mortem debugging
+  # on an uncaught exception. Once post-mortem debugging is set, it can't
+  # be unset.
+  def start(options={}, &block)
+    options = Debugger::DEFAULT_START_SETTINGS.merge(options)
+    if options[:init]
+      Debugger.const_set('ARGV', ARGV.clone) unless
+        defined? Debugger::ARGV
+      Debugger.const_set('PROG_SCRIPT', $0) unless
+        defined? Debugger::PROG_SCRIPT
+      Debugger.const_set('INITIAL_DIR', Dir.pwd) unless
+        defined? Debugger::INITIAL_DIR
+    end
+    Debugger.tracing = options[:tracing] unless options[:tracing].nil?
+    retval = Debugger.started? ? block && block.call(self) : Debugger.start_(&block)
+    if options[:post_mortem]
+      post_mortem
+    end
+    return retval
+  end
+  module_function :start
+end
+
+module Kernel
+
+  # Enters the debugger in the current thread after _steps_ line events occur.
+  # Before entering the debugger startup script is read.
+  #
+  # Setting _steps_ to 0 will cause a break in the debugger subroutine
+  # and not wait for a line event to occur. You will have to go "up 1"
+  # in order to be back in your debugged program rather than the
+  # debugger. Settings _steps_ to 0 could be useful you want to stop
+  # right after the last statement in some scope, because the next
+  # step will take you out of some scope.
+
+  # If a block is given (and the debugger hasn't been started, we run the
+  # block under the debugger. Alas, when a block is given, we can't support
+  # running the startup script or support the steps option. FIXME.
+  def debugger(steps = 1, &block)
+    if block
+      Debugger.start({}, &block)
+    else
+      Debugger.start unless Debugger.started?
+      Debugger.run_init_script(StringIO.new)
+      if 0 == steps
+        Debugger.current_context.stop_frame = 0
+      else
+        Debugger.current_context.stop_next = steps
+      end
+    end
+  end
+  alias breakpoint debugger unless respond_to?(:breakpoint)
+
+  #
+  # Returns a binding of n-th call frame
+  #
+  def binding_n(n = 0)
+    Debugger.skip do
+      if RUBY_VERSION < "1.9"
+        Debugger.current_context.frame_binding(n+2)
+      else
+        Debugger.current_context.frame_binding(n+1)
+      end
+    end
+  end
+end
+
+class Exception # :nodoc:
+  attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_context
+end
+
+class Module
+  #
+  # Wraps the +meth+ method with Debugger.start {...} block.
+  #
+  def debug_method(meth)
+    old_meth = "__debugee_#{meth}"
+    old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
+    alias_method old_meth.to_sym, meth
+    class_eval <<-EOD
+    def #{meth}(*args, &block)
+      Debugger.start do
+        debugger 2
+        #{old_meth}(*args, &block)
+      end
+    end
+    EOD
+  end
+
+  #
+  # Wraps the +meth+ method with Debugger.post_mortem {...} block.
+  #
+  def post_mortem_method(meth)
+    old_meth = "__postmortem_#{meth}"
+    old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
+    alias_method old_meth.to_sym, meth
+    class_eval <<-EOD
+    def #{meth}(*args, &block)
+      Debugger.start do |dbg|
+        dbg.post_mortem do
+          #{old_meth}(*args, &block)
+        end
+      end
+    end
+    EOD
+  end
+end