needy_debugger 1.4.0

data/ext/ruby_debug/200/ruby_debug.h

@@ -0,0 +1,148 @@
+/* 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)
+#define CTX_FL_TRACING      (1<<2)
+#define CTX_FL_SKIPPED      (1<<3)
+#define CTX_FL_IGNORE       (1<<4)
+#define CTX_FL_DEAD         (1<<5)
+#define CTX_FL_WAS_RUNNING  (1<<6)
+#define CTX_FL_ENABLE_BKPT  (1<<7)
+#define CTX_FL_STEPPED      (1<<8)
+#define CTX_FL_FORCE_MOVE   (1<<9)
+#define CTX_FL_CATCHING     (1<<10)
+
+#define CTX_FL_TEST(c,f)  ((c)->flags & (f))
+#define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
+#define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
+
+typedef struct {
+    struct iseq_catch_table_entry tmp_catch_table;
+    struct iseq_catch_table_entry *old_catch_table;
+    int old_catch_table_size;
+    VALUE mod_name;
+    VALUE errinfo;
+} debug_catch_t;
+
+typedef struct {
+    struct rb_iseq_struct *iseq;
+    struct iseq_catch_table_entry *catch_table;
+    int catch_table_size;
+} iseq_catch_t;
+
+typedef struct {
+    int argc;         /* Number of arguments a frame should have. */
+    VALUE binding;
+    ID id;
+    ID orig_id;
+    int line;
+    const char * file;
+    short dead;
+    VALUE self;
+    VALUE arg_ary;
+    union {
+        struct {
+			rb_control_frame_t *cfp;
+			VALUE *bp;
+			struct rb_iseq_struct *block_iseq;
+			VALUE *block_pc;
+            VALUE *last_pc;
+        } runtime;
+        struct {
+            VALUE args;
+            VALUE locals;
+	        VALUE arg_ary;
+        } copy;
+    } info;
+} debug_frame_t;
+
+typedef struct {
+    VALUE thread_id;
+    int thnum;
+    int flags;
+    enum ctx_stop_reason stop_reason;
+    int stop_next;
+    int dest_frame;
+    int stop_line;
+    int stop_frame;
+    int stack_size;
+    int stack_len;
+    debug_frame_t *frames;
+    const char * last_file;
+    int last_line;
+    VALUE breakpoint;
+    debug_catch_t catch_table;
+    VALUE saved_jump_ins[2];
+    rb_control_frame_t *jump_cfp;
+    VALUE *jump_pc;
+    iseq_catch_t *old_iseq_catch;
+    volatile int thread_pause;
+} debug_context_t;
+
+/* variables in ruby_debug.c */
+extern VALUE mDebugger;
+extern VALUE rdebug_breakpoints;
+extern VALUE rdebug_catchpoints;
+extern VALUE rdebug_threads_tbl;
+
+/* routines in ruby_debug.c */
+extern int  filename_cmp(VALUE source, char *file);
+
+#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, 
+    char *file, int 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/ext/ruby_debug/extconf.rb

@@ -0,0 +1,94 @@
+# autodetect ruby headers
+unless ARGV.any? {|arg| arg.include?('--with-ruby-include') }
+  require 'rbconfig'
+  bindir = RbConfig::CONFIG['bindir']
+  if bindir =~ %r{(^.*/\.rbenv/versions)/([^/]+)/bin$}
+    ruby_include = "#{$1}/#{$2}/include/ruby-#{RUBY_VERSION.start_with?("1.9") ? "1.9.1" : RUBY_VERSION}/ruby-#{$2}"
+    ARGV << "--with-ruby-include=#{ruby_include}"
+  elsif bindir =~ %r{(^.*/\.rvm/rubies)/([^/]+)/bin$}
+    ruby_include = "#{$1}/#{$2}/include/ruby-#{RUBY_VERSION.start_with?("1.9") ? "1.9.1" : RUBY_VERSION}/#{$2}"
+    ruby_include = "#{ENV['rvm_path']}/src/#{$2}" unless File.exist?(ruby_include)
+    ARGV << "--with-ruby-include=#{ruby_include}"
+  end
+end
+
+require "mkmf"
+require "debugger/ruby_core_source"
+require 'fileutils'
+
+if RUBY_VERSION < "1.9"
+  STDERR.print("Ruby version is too old\n")
+  exit(1)
+end
+
+hdrs = if RUBY_VERSION == '1.9.2'
+  lambda {
+    have_struct_member("rb_method_entry_t", "body", "method.h")
+    have_header("vm_core.h") and have_header("iseq.h") and have_header("insns.inc") and
+    have_header("insns_info.inc") and have_header("eval_intern.h")
+  }
+elsif RUBY_VERSION == '1.9.3'
+  lambda {
+    iseqs = %w[vm_core.h iseq.h]
+    begin
+      have_struct_member("rb_method_entry_t", "called_id", "method.h") or
+      have_struct_member("rb_control_frame_t", "method_id", "method.h")
+    end and
+    have_header("vm_core.h") and have_header("iseq.h") and have_header("insns.inc") and
+    have_header("insns_info.inc") and have_header("eval_intern.h") or return(false)
+    have_type("struct iseq_line_info_entry", iseqs) or
+    have_type("struct iseq_insn_info_entry", iseqs) or
+    return(false)
+    if checking_for(checking_message("if rb_iseq_compile_with_option was added an argument filepath")) do
+        try_compile(<<SRC)
+#include <ruby.h>
+#include "vm_core.h"
+extern VALUE rb_iseq_new_main(NODE *node, VALUE filename, VALUE filepath);
+SRC
+      end
+      $defs << '-DRB_ISEQ_COMPILE_5ARGS'
+    end
+  }
+elsif RUBY_VERSION == '2.0.0'
+  lambda {
+    iseqs = %w[vm_core.h iseq.h]
+    begin
+      have_struct_member("rb_method_entry_t", "called_id", "method.h") or
+          have_struct_member("rb_control_frame_t", "method_id", "method.h")
+    end and
+        have_header("vm_core.h") and have_header("iseq.h") and have_header("insns.inc") and
+        have_header("insns_info.inc") and have_header("eval_intern.h") or return(false)
+    have_type("struct iseq_line_info_entry", iseqs) or
+        have_type("struct iseq_insn_info_entry", iseqs) or
+        return(false)
+    if checking_for(checking_message("if rb_iseq_compile_with_option was added an argument filepath")) do
+      try_compile(<<SRC)
+#include <ruby.h>
+#include "vm_core.h"
+extern VALUE rb_iseq_new_main(NODE *node, VALUE filename, VALUE filepath);
+SRC
+    end
+      $defs << "-DHAVE_RB_ISEQ_COMPILE_ON_BASE  -DVM_DEBUG_BP_CHECK -DHAVE_RB_CONTROL_FRAME_T_EP -DHAVE_RB_ISEQ_T_LOCATION -DHAVE_RB_ISEQ_T_LINE_INFO_SIZE "
+    end
+  }
+else
+  STDERR.puts "Ruby version #{RUBY_VERSION} is not supported."
+  exit(1)
+end
+
+
+header_dir = RUBY_VERSION.gsub('.', '')
+current_dir = File.dirname(__FILE__)
+%w{ruby_debug.h ruby_debug.c breakpoint.c}.each do |file|
+  FileUtils.cp("#{current_dir}/#{header_dir}/#{file}", current_dir)
+end
+
+dir_config("ruby")
+if !Debugger::RubyCoreSource.create_makefile_with_core(hdrs, "ruby_debug")
+  STDERR.print("Makefile creation failed\n")
+  STDERR.print("*************************************************************\n\n")
+  STDERR.print("  NOTE: If your headers were not found, try passing\n")
+  STDERR.print("        --with-ruby-include=PATH_TO_HEADERS      \n\n")
+  STDERR.print("*************************************************************\n\n")
+  exit(1)
+end

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.4.0'
+end

data/lib/ruby-debug-base.rb

@@ -0,0 +1,305 @@
+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)
+      __c_frame_binding(frame) || 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