byebug 1.0.3 → 1.1.0

data/ext/byebug/byebug.h

@@ -24,8 +24,6 @@ typedef struct rb_trace_arg_struct rb_trace_point_t;
 #define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
 #define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
 
-#define IS_THREAD_ALIVE(t) (rb_funcall((t), idAlive, 0) == Qtrue)
-
 /* types */
 typedef enum {
   CTX_STOP_NONE,
@@ -64,21 +62,21 @@ typedef struct {
 
 /* functions */
 extern VALUE Init_context(VALUE mByebug);
-extern VALUE context_create(VALUE thread, VALUE cDebugThread);
+extern VALUE Context_create(VALUE thread, VALUE cDebugThread);
+extern VALUE Context_dup(debug_context_t *context);
 extern void reset_stepping_stop_points(debug_context_t *context);
 extern VALUE Context_ignored(VALUE self);
 
-extern void push_frame(VALUE context_object, char* file, int lineno,
+extern void push_frame(debug_context_t *context, char* file, int lineno,
                        VALUE method_id, VALUE defined_class, VALUE binding,
                        VALUE self);
 
-extern void pop_frame(VALUE context_object);
+extern void pop_frame(debug_context_t *context);
 
-extern void update_frame(VALUE context_object, char* file, int lineno,
+extern void update_frame(debug_frame_t *context, char* file, int lineno,
                          VALUE method_id, VALUE defined_class, VALUE binding,
                          VALUE self);
 
-
 /* locked threads container */
 typedef struct locked_thread_t {
   VALUE thread;

data/ext/byebug/context.c

@@ -3,8 +3,6 @@
 static VALUE cContext;
 static int thnum_current = 0;
 
-static VALUE idAlive;
-
 static VALUE
 id2ref(VALUE id)
 {
@@ -45,9 +43,9 @@ delete_frame(debug_context_t *context)
   xfree(frame);
 }
 
-static inline void
-fill_frame(debug_frame_t *frame, char* file, int lineno, VALUE method_id,
-                                 VALUE defined_class, VALUE binding, VALUE self)
+extern void
+update_frame(debug_frame_t *frame, char* file, int lineno, VALUE method_id,
+                                   VALUE defined_class, VALUE binding, VALUE self)
 {
   frame->file = file;
   frame->line = lineno;
@@ -78,7 +76,7 @@ Context_dead(VALUE self)
 {
   debug_context_t *context;
   Data_Get_Struct(self, debug_context_t, context);
-  return IS_THREAD_ALIVE(context->thread) ? Qfalse : Qtrue;
+  return CTX_FL_TEST(context, CTX_FL_DEAD) ? Qtrue : Qfalse;
 }
 
 extern VALUE
@@ -92,54 +90,32 @@ Context_ignored(VALUE self)
 }
 
 extern void
-push_frame(VALUE context_object, char* file, int lineno, VALUE method_id,
+push_frame(debug_context_t *context, char* file, int lineno, VALUE method_id,
            VALUE defined_class, VALUE binding, VALUE self)
 {
-  debug_context_t *context;
   debug_frame_t *frame;
-  Data_Get_Struct(context_object, debug_context_t, context);
 
   frame = ALLOC(debug_frame_t);
-  fill_frame(frame, file, lineno, method_id, defined_class, binding, self);
+  update_frame(frame, file, lineno, method_id, defined_class, binding, self);
   frame->prev = context->stack;
   context->stack = frame;
   context->stack_size++;
 }
 
 extern void
-pop_frame(VALUE context_object)
+pop_frame(debug_context_t *context)
 {
-  debug_context_t *context;
-  Data_Get_Struct(context_object, debug_context_t, context);
-
   if (context->stack_size > 0) {
     delete_frame(context);
   }
 }
 
-extern void
-update_frame(VALUE context_object, char* file, int lineno, VALUE method_id,
-             VALUE defined_class, VALUE binding, VALUE self)
-{
-  debug_context_t *context;
-  Data_Get_Struct(context_object, debug_context_t, context);
-
-  if (context->stack_size == 0) {
-    push_frame(context_object, file, lineno, method_id, defined_class, binding,
-                               self);
-    return;
-  }
-  fill_frame(context->stack, file, lineno, method_id, defined_class, binding,
-                             self);
-
-}
-
 static void
 Context_mark(debug_context_t *context)
 {
   debug_frame_t *frame;
 
-  rb_gc_mark(context->thread);
+//rb_gc_mark(context->thread);
   frame = context->stack;
   while (frame != NULL) {
     rb_gc_mark(frame->self);
@@ -150,14 +126,14 @@ Context_mark(debug_context_t *context)
 
 static void
 Context_free(debug_context_t *context) {
-  while(context->stack_size > 0) {
+  while (context->stack_size > 0) {
     delete_frame(context);
   }
   xfree(context);
 }
 
 extern VALUE
-context_create(VALUE thread, VALUE cDebugThread) {
+Context_create(VALUE thread, VALUE cDebugThread) {
   debug_context_t *context;
 
   context = ALLOC(debug_context_t);
@@ -174,6 +150,45 @@ context_create(VALUE thread, VALUE cDebugThread) {
   return Data_Wrap_Struct(cContext, Context_mark, Context_free, context);
 }
 
+static void
+frame_copy(debug_frame_t *new_frame, debug_frame_t *old_frame)
+{
+  new_frame->file          = old_frame->file;
+  new_frame->line          = old_frame->line;
+  new_frame->method_id     = old_frame->method_id;
+  new_frame->defined_class = old_frame->defined_class;
+  new_frame->binding       = old_frame->binding;
+  new_frame->self          = old_frame->self;
+}
+
+extern VALUE
+Context_dup(debug_context_t *context)
+{
+    debug_context_t *new_context;
+    debug_frame_t *source_frame = context->stack, *dest_frame, *new_frame;
+
+    new_context = ALLOC(debug_context_t);
+    memcpy(new_context, context, sizeof(debug_context_t));
+    new_context->dest_frame = -1;
+    new_context->stop_line = -1;
+    new_context->stop_frame = -1;
+    new_context->stop_next = -1;
+    new_context->stack_size = context->stack_size;
+    CTX_FL_SET(new_context, CTX_FL_DEAD);
+    new_context->stack = ALLOC(debug_frame_t);
+    frame_copy(new_context->stack, context->stack);
+
+    new_frame = new_context->stack;
+    while ((source_frame = source_frame->prev))
+    {
+      dest_frame = new_frame;
+      new_frame = ALLOC(debug_frame_t);
+      frame_copy(new_frame, source_frame);
+      dest_frame->prev = new_frame;
+    }
+    return Data_Wrap_Struct(cContext, 0, Context_free, new_context);
+}
+
 static debug_frame_t*
 get_frame_no(debug_context_t *context, int frame_n)
 {
@@ -329,7 +344,9 @@ Context_stop_reason(VALUE self)
 
   Data_Get_Struct(self, debug_context_t, context);
 
-  switch(context->stop_reason)
+  if (CTX_FL_TEST(context, CTX_FL_DEAD))
+    symbol = "post-mortem";
+  else switch (context->stop_reason)
   {
     case CTX_STOP_STEP:
       symbol = "step";
@@ -344,9 +361,6 @@ Context_stop_reason(VALUE self)
     default:
       symbol = "none";
   }
-  if(CTX_FL_TEST(context, CTX_FL_DEAD))
-    symbol = "post-mortem";
-
   return ID2SYM(rb_intern(symbol));
 }
 
@@ -505,7 +519,5 @@ Init_context(VALUE mByebug)
   rb_define_method(cContext, "step_over", Context_step_over, -1);
   rb_define_method(cContext, "stop_frame=", Context_stop_frame, 1);
 
-  idAlive = rb_intern("alive?");
-
   return cContext;
 }

data/lib/byebug.rb

@@ -14,9 +14,9 @@ module Byebug
 
   # Default options to Byebug.start
   DEFAULT_START_SETTINGS = {
-    :init        => true,  # Set $0 and save ARGV?
-    :post_mortem => false, # post-mortem debugging on uncaught exception?
-    :tracing     => nil    # Byebug.tracing value. true/false resets
+    init:        true,  # Set $0 and save ARGV?
+    post_mortem: false, # post-mortem debugging on uncaught exception?
+    tracing:     nil    # Byebug.tracing? value. true/false resets
   } unless defined?(DEFAULT_START_SETTINGS)
 
   # Port number used for remote debugging
@@ -101,11 +101,11 @@ module Byebug
     # If it's called without a block it returns +true+, unless byebug was
     # already started.
     #
-    # If a block is given, it starts byebug and yields block. When the block is
+    # If a block is given, it starts byebug and yields block. After the block is
     # executed it stops byebug with Byebug.stop method. Inside the block you
     # will probably want to have a call to Byebug.byebug. For example:
     #
-    #     Byebug.start{byebug; foo}  # Stop inside of foo
+    #     Byebug.start { byebug; foo }  # Stop inside of foo
     #
     # Also, byebug only allows one invocation of byebug at a time; nested
     # Byebug.start's have no effect and you can't use this inside byebug itself.
@@ -131,14 +131,15 @@ module Byebug
         Byebug.const_set('INITIAL_DIR', Dir.pwd) unless defined? Byebug::INITIAL_DIR
       end
       Byebug.tracing = options[:tracing] unless options[:tracing].nil?
+      Byebug.start_sentinal=caller(0)[1]
       if Byebug.started?
         retval = block && block.call(self)
       else
         retval = Byebug._start(&block)
       end
-      #if options[:post_mortem]
-      #  post_mortem
-      #end
+      if options[:post_mortem]
+        post_mortem
+      end
       return retval
     end
 
@@ -254,62 +255,62 @@ module Byebug
       processor.process_commands(verbose)
     end
 
-    # XXX: Implement
-
-    #   # Activates the post-mortem mode. There are two ways of using it:
-    #   #
-    #   # == Global post-mortem mode
-    #   # By calling Byebug.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 Byebug.post_mortem, e.g.
-    #   #
-    #   #   def offender
-    #   #      raise 'error'
-    #   #   end
-    #   #   Byebug.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
+    ##
+    # Activates the post-mortem mode. There are two ways of using it:
+    #
+    # == Global post-mortem mode
+    # By calling Byebug.post_mortem method without a block, you install an
+    # at_exit hook that intercepts any exception not handled by your script
+    # 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 Byebug.post_mortem,
+    # e.g.
+    #
+    #   def offender
+    #      raise 'error'
     #   end
-
-    #   def handle_post_mortem(exp)
-    #     return if !exp || !exp.__debug_context ||
-    #       exp.__debug_context.stack_size == 0
-    #     Byebug.suspend
-    #     orig_tracing = Byebug.tracing, Byebug.current_context.tracing
-    #     Byebug.tracing = Byebug.current_context.tracing = false
-    #     Byebug.last_exception = exp
-    #     handler.at_line(exp.__debug_context, exp.__debug_file, exp.__debug_line)
-    #   ensure
-    #     Byebug.tracing, Byebug.current_context.tracing = orig_tracing
-    #     Byebug.resume
+    #   Byebug.post_mortem do
+    #      ...
+    #      offender
+    #      ...
     #   end
-    #   # private :handle_post_mortem
+    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 self.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
+      #Byebug.suspend
+      orig_tracing = Byebug.tracing?, Byebug.current_context.tracing
+      Byebug.tracing = Byebug.current_context.tracing = false
+      Byebug.last_exception = exp
+      handler.at_line(exp.__debug_context, exp.__debug_file, exp.__debug_line)
+    ensure
+      Byebug.tracing, Byebug.current_context.tracing = orig_tracing
+      #Byebug.resume
+    end
+    private :handle_post_mortem
 
   end
 
@@ -321,7 +322,7 @@ module Byebug
 
 end
 
-class Exception # :nodoc:
+class Exception
   attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_context
 end
 
@@ -343,24 +344,23 @@ class Module
     EOD
   end
 
-  # XXX: Implement
-  # #
-  # # Wraps the +meth+ method with Byebug.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)
-  #     Byebug.start do |dbg|
-  #       dbg.post_mortem do
-  #         #{old_meth}(*args, &block)
-  #       end
-  #     end
-  #   end
-  #   EOD
-  # end
+  #
+  # Wraps the +meth+ method with Byebug.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)
+      Byebug.start do |dbg|
+        dbg.post_mortem do
+          #{old_meth}(*args, &block)
+        end
+      end
+    end
+    EOD
+  end
 end
 
 module Kernel

data/lib/byebug/command.rb

@@ -20,24 +20,23 @@ module Byebug
     defined?(BYEBUG_DIR)
 
   class Command
-
     SubcmdStruct = Struct.new(:name, :min, :short_help, :long_help) unless
       defined?(SubcmdStruct)
 
     ##
     # Print list of subcmds
     #
-    def print_subcmds(subcmds)
+    def format_subcmds(subcmds)
       cmd_name = self.class.name[/Byebug::(.*)Command/, 1].downcase
-      errmsg "\"#{cmd_name}\" must be followed by the name of a subcommand.\n"
-      print "List of \"#{cmd_name}\" subcommands:\n"
+      s = "\n"                                     \
+          "--\n"                                   \
+          "List of \"#{cmd_name}\" subcommands:\n" \
+          "--\n"
       for subcmd in subcmds do
-        print "#{cmd_name} #{subcmd.name} -- #{subcmd.short_help}\n"
+        s += "#{cmd_name} #{subcmd.name} -- #{subcmd.short_help}\n"
       end
     end
 
-    include Columnize
-
     ##
     # Find param in subcmds.
     #
@@ -60,14 +59,12 @@ module Byebug
         @commands ||= []
       end
 
-      DEF_OPTIONS = {
-        :allow_in_control     => false,
-        :allow_in_post_mortem => false,
-        :event                => true ,
-        :always_run           => 0    ,
-        :unknown              => false,
-        :need_context         => false,
-      } unless defined?(DEF_OPTIONS)
+      DEF_OPTIONS = { allow_in_control:     false,
+                      allow_in_post_mortem: true ,
+                      event:                true ,
+                      always_run:           0    ,
+                      unknown:              false,
+                      need_context:         false } unless defined?(DEF_OPTIONS)
 
       def inherited(klass)
         DEF_OPTIONS.each do |o, v|
@@ -109,28 +106,14 @@ module Byebug
           @settings = Object.new
           map = settings_map
           c = class << @settings; self end
-          if c.respond_to?(:funcall)
-            c.funcall(:define_method, :[]) do |name|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:getter].call
-            end
-          else
-            c.send(:define_method, :[]) do |name|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:getter].call
-            end
+          c.send(:define_method, :[]) do |name|
+            raise "No such setting #{name}" unless map.has_key?(name)
+            map[name][:getter].call
           end
           c = class << @settings; self end
-          if c.respond_to?(:funcall)
-            c.funcall(:define_method, :[]=) do |name, value|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:setter].call(value)
-            end
-          else
-            c.send(:define_method, :[]=) do |name, value|
-              raise "No such setting #{name}" unless map.has_key?(name)
-              map[name][:setter].call(value)
-            end
+          c.send(:define_method, :[]=) do |name, value|
+            raise "No such setting #{name}" unless map.has_key?(name)
+            map[name][:setter].call(value)
           end
         end
         @settings