byebug 1.8.2 → 2.0.0

data/ext/byebug/byebug.h

@@ -5,13 +5,15 @@
 #include <ruby/debug.h>
 
 /* flags */
-#define CTX_FL_SUSPEND      (1<<1)
-#define CTX_FL_TRACING      (1<<2)
-#define CTX_FL_SKIPPED      (1<<3)
-#define CTX_FL_DEAD         (1<<4)
-#define CTX_FL_ENABLE_BKPT  (1<<5)
-#define CTX_FL_FORCE_MOVE   (1<<6)
-#define CTX_FL_CATCHING     (1<<7)
+#define CTX_FL_CATCHING     (1<<1) /* catching of exceptions enabled         */
+#define CTX_FL_DEAD         (1<<2) /* this context belonged to a dead thread */
+#define CTX_FL_ENABLE_BKPT  (1<<3) /* cab check for breakpoints              */
+#define CTX_FL_FORCE_MOVE   (1<<4) /* don't stop unless we've changed line   */
+#define CTX_FL_IGNORE       (1<<5) /* this context belongs to ignored thread */
+#define CTX_FL_SKIPPED      (1<<6) /* skip all events                        */
+#define CTX_FL_SUSPEND      (1<<7) /* thread currently suspended             */
+#define CTX_FL_TRACING      (1<<8) /* call at_tracing method                 */
+#define CTX_FL_WAS_RUNNING  (1<<9) /* thread was previously running          */
 
 /* macro functions */
 #define CTX_FL_TEST(c,f)  ((c)->flags & (f))
@@ -31,6 +33,9 @@ typedef struct {
   int flags;
   ctx_stop_reason stop_reason;
 
+  VALUE thread;
+  int thnum;
+
   int dest_frame;
   int lines;                   /* # of lines in dest_frame before stopping    */
   int steps;                   /* # of steps before stopping                  */
@@ -53,22 +58,36 @@ struct call_with_inspection_data {
   VALUE *argv;
 };
 
+typedef struct {
+  st_table *tbl;
+} threads_table_t;
+
+/* functions from locker.c */
+extern int is_in_locked(VALUE thread_id);
+extern void add_to_locked(VALUE thread);
+extern VALUE remove_from_locked();
+
+/* functions from threads.c */
+extern VALUE threads_create(void);
+extern void threads_clear(VALUE table);
+extern void check_thread_contexts(void);
+extern void thread_context_lookup(VALUE thread, VALUE *context);
+extern void halt_while_other_thread_is_active(debug_context_t *dc);
+
+/* global variables */
+extern VALUE locker;
+extern VALUE threads;
+extern VALUE cThreadsTable;
 
 /* functions */
-extern VALUE Init_context(VALUE mByebug);
-
-extern VALUE context_create();
-
+extern void Init_context(VALUE mByebug);
+extern VALUE context_create(VALUE thread);
 extern VALUE context_dup(debug_context_t *context);
-
 extern void reset_stepping_stop_points(debug_context_t *context);
-
 extern VALUE call_with_debug_inspector(struct call_with_inspection_data *data);
-
 extern VALUE context_backtrace_set(const rb_debug_inspector_t *inspector,
                                    void *data);
 
-/* utility functions */
 static inline int
 classname_cmp(VALUE name, VALUE klass)
 {

data/ext/byebug/context.c

@@ -1,6 +1,8 @@
 #include <byebug.h>
 
 static VALUE cContext;
+static VALUE cDebugThread;
+static int thnum_max = 0;
 
 /* "Step", "Next" and "Finish" do their work by saving information about where
  * to stop next. reset_stepping_stop_points removes/resets this information. */
@@ -14,14 +16,13 @@ reset_stepping_stop_points(debug_context_t *context)
   context->before_frame = -1;
 }
 
-static inline VALUE
-Context_stack_size(VALUE self)
-{
-  debug_context_t *context;
-  Data_Get_Struct(self, debug_context_t, context);
-  return INT2FIX(context->stack_size);
-}
-
+/*
+ *  call-seq:
+ *    context.dead? -> bool
+ *
+ *  Returns +true+ if context doesn't represent a live context and is created
+ *  during post-mortem exception handling.
+ */
 static inline VALUE
 Context_dead(VALUE self)
 {
@@ -44,24 +45,31 @@ context_free(void *data)
 }
 
 static int
-real_stack_size()
+real_stack_size(VALUE thread)
 {
-  VALUE locs = rb_funcall(rb_cObject, rb_intern("caller_locations"), 1, INT2FIX(0));
+  VALUE locs = rb_funcall(thread, rb_intern("backtrace_locations"), 1, INT2FIX(1));
+  if (locs == Qnil)
+    return 0;
+
   return (int)RARRAY_LEN(locs);
 }
 
 extern VALUE
-context_create()
+context_create(VALUE thread)
 {
   debug_context_t *context = ALLOC(debug_context_t);
 
-  context->last_file  = Qnil;
-  context->last_line  = Qnil;
-  context->flags      = 0;
-  context->stack_size = real_stack_size();
+  context->last_file   = Qnil;
+  context->last_line   = Qnil;
+  context->flags       = 0;
+  context->stack_size  = real_stack_size(thread);
+  context->thnum       = ++thnum_max;
+  context->thread      = thread;
   reset_stepping_stop_points(context);
   context->stop_reason = CTX_STOP_NONE;
-  context->backtrace = Qnil;
+  context->backtrace   = Qnil;
+
+  if (rb_obj_class(thread) == cDebugThread) CTX_FL_SET(context, CTX_FL_IGNORE);
 
   return Data_Wrap_Struct(cContext, context_mark, context_free, context);
 }
@@ -82,9 +90,6 @@ context_dup(debug_context_t *context)
 static VALUE
 dc_backtrace(const debug_context_t *context)
 {
-  if (NIL_P(context->backtrace))
-    rb_raise(rb_eRuntimeError, "Backtrace information is not available");
-
   return context->backtrace;
 }
 
@@ -92,6 +97,9 @@ static VALUE
 dc_frame_get(const debug_context_t *context, int frame_index,
                                              enum frame_component type)
 {
+  if (NIL_P(dc_backtrace(context)))
+    rb_raise(rb_eRuntimeError, "Backtrace information is not available");
+
   if (frame_index >= RARRAY_LEN(dc_backtrace(context)))
     rb_raise(rb_eRuntimeError, "That frame doesn't exist!");
 
@@ -192,87 +200,170 @@ call_with_debug_inspector(struct call_with_inspection_data *data)
     frame_n = 0;                                                      \
   else                                                                \
     frame_n = FIX2INT(frame_no);                                      \
-  if (frame_n < 0 || frame_n >= context->stack_size)                  \
+  if (frame_n < 0 || frame_n >= real_stack_size(rb_thread_current())) \
   {                                                                   \
     rb_raise(rb_eArgError, "Invalid frame number %d, stack (0...%d)", \
-             frame_n, context->stack_size - 1);                       \
+             frame_n, real_stack_size(rb_thread_current() - 1));      \
   }                                                                   \
 
+/*
+ *  call-seq:
+ *    context.frame_binding(frame_position=0) -> binding
+ *
+ *  Returns frame's binding.
+ */
+static VALUE
+Context_frame_binding(int argc, VALUE *argv, VALUE self)
+{
+  FRAME_SETUP
+
+  return dc_frame_binding(context, frame_n);
+}
+
+/*
+ *  call-seq:
+ *    context.frame_class(frame_position=0) -> binding
+ *
+ *  Returns frame's defined class.
+ */
+ static VALUE
+Context_frame_class(int argc, VALUE *argv, VALUE self)
+{
+  FRAME_SETUP
+
+  return dc_frame_class(context, frame_n);
+}
+
+/*
+ *  call-seq:
+ *    context.frame_file(frame_position=0) -> string
+ *
+ *  Returns the name of the file in the frame.
+ */
 static VALUE
 Context_frame_file(int argc, VALUE *argv, VALUE self)
 {
-  FRAME_SETUP;
-  VALUE loc;
+  FRAME_SETUP
+
+  VALUE loc = dc_frame_location(context, frame_n);
 
-  loc = dc_frame_location(context, frame_n);
   return rb_funcall(loc, rb_intern("path"), 0);
 }
 
+/*
+ *  call-seq:
+ *    context.frame_line(frame_position) -> int
+ *
+ *  Returns the line number in the file.
+ */
 static VALUE
 Context_frame_line(int argc, VALUE *argv, VALUE self)
 {
-  FRAME_SETUP;
-  VALUE loc;
+  FRAME_SETUP
+
+  VALUE loc = dc_frame_location(context, frame_n);
 
-  loc = dc_frame_location(context, frame_n);
   return rb_funcall(loc, rb_intern("lineno"), 0);
 }
 
+/*
+ *  call-seq:
+ *    context.frame_method(frame_position=0) -> sym
+ *
+ *  Returns the sym of the called method.
+ */
 static VALUE
 Context_frame_method(int argc, VALUE *argv, VALUE self)
 {
-  FRAME_SETUP;
-  VALUE loc;
+  FRAME_SETUP
+
+  VALUE loc = dc_frame_location(context, frame_n);
 
-  loc = dc_frame_location(context, frame_n);
   return rb_str_intern(rb_funcall(loc, rb_intern("label"), 0));
 }
 
+/*
+ *  call-seq:
+ *    context.frame_self(frame_postion=0) -> obj
+ *
+ *  Returns self object of the frame.
+ */
 static VALUE
-Context_frame_binding(int argc, VALUE *argv, VALUE self)
+Context_frame_self(int argc, VALUE *argv, VALUE self)
 {
-  FRAME_SETUP;
+  FRAME_SETUP
 
-  return dc_frame_binding(context, frame_n);
+  return dc_frame_self(context, frame_n);
 }
 
-static VALUE
-Context_frame_self(int argc, VALUE *argv, VALUE self)
+/*
+ *  call-seq:
+ *    context.ignored? -> bool
+ *
+ *  Returns the ignore flag for the context, which marks whether the associated
+ *  thread is ignored while debugging.
+ */
+static inline VALUE
+Context_ignored(VALUE self)
 {
-  FRAME_SETUP;
-
-  return dc_frame_self(context, frame_n);
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return CTX_FL_TEST(context, CTX_FL_IGNORE) ? Qtrue : Qfalse;
 }
 
-static VALUE
-Context_frame_class(int argc, VALUE *argv, VALUE self)
+static void
+context_resume_0(debug_context_t *context)
 {
-  FRAME_SETUP;
+  if (!CTX_FL_TEST(context, CTX_FL_SUSPEND)) return;
 
-  return dc_frame_class(context, frame_n);
+  CTX_FL_UNSET(context, CTX_FL_SUSPEND);
+
+  if (CTX_FL_TEST(context, CTX_FL_WAS_RUNNING))
+    rb_thread_wakeup(context->thread);
 }
 
+/*
+ *  call-seq:
+ *    context.resume -> nil
+ *
+ *  Resumes thread from the suspended mode.
+ */
 static VALUE
-Context_tracing(VALUE self)
+Context_resume(VALUE self)
 {
-  debug_context_t *context;
+    debug_context_t *context;
 
-  Data_Get_Struct(self, debug_context_t, context);
-  return CTX_FL_TEST(context, CTX_FL_TRACING) ? Qtrue : Qfalse;
+    Data_Get_Struct(self, debug_context_t, context);
+
+    if (!CTX_FL_TEST(context, CTX_FL_SUSPEND))
+      rb_raise(rb_eRuntimeError, "Thread is not suspended.");
+
+    context_resume_0(context);
+
+    return Qnil;
 }
 
-static VALUE
-Context_set_tracing(VALUE self, VALUE value)
+/*
+ *  call-seq:
+ *    context.stack_size-> int
+ *
+ *  Returns the size of the context stack.
+ */
+static inline VALUE
+Context_stack_size(VALUE self)
 {
   debug_context_t *context;
-
   Data_Get_Struct(self, debug_context_t, context);
+  VALUE backtrace = dc_backtrace(context);
 
-  if (RTEST(value))
-      CTX_FL_SET(context, CTX_FL_TRACING);
-  else
-      CTX_FL_UNSET(context, CTX_FL_TRACING);
-  return value;
+  if (NIL_P(backtrace))
+    return INT2FIX(context->stack_size);
+
+  if (context->stack_size != RARRAY_LEN(backtrace))
+    rb_warn("Calculated stack size is %d but there are actually %ld frames",
+            context->stack_size, RARRAY_LEN(backtrace));
+
+  return INT2FIX(RARRAY_LEN(backtrace));
 }
 
 static VALUE
@@ -303,30 +394,14 @@ Context_stop_reason(VALUE self)
   return ID2SYM(rb_intern(symbol));
 }
 
-#if 0
-
-static VALUE
-Context_jump(VALUE self, VALUE line, VALUE file)
-{
-  debug_context_t *context;
-  debug_frame_t *frame;
-  int i, lineno;
-
-  Data_Get_Struct(self, debug_context_t, context);
-
-  frame = context->stack;
-  lineno = FIX2INT(line);
-
-  for (i = 0; i < context->stack_size; i++) {
-    if (strcmp(frame->file, RSTRING_PTR(file))) {
-      /* And now? */
-    }
-    frame = frame->prev;
-  }
-}
-
-#endif
-
+/*
+ *  call-seq:
+ *    context.step_into(steps, force = false)
+ *
+ *  Stops the current context after a number of +steps+ are made.
+ *  +force+ parameter (if true) ensures that the cursor moves away from the
+ *  current line.
+ */
 static VALUE
 Context_step_into(int argc, VALUE *argv, VALUE self)
 {
@@ -349,6 +424,36 @@ Context_step_into(int argc, VALUE *argv, VALUE self)
   return steps;
 }
 
+/*
+ *  call-seq:
+ *    context.step_out(frame)
+ *
+ *  Stops after frame number +frame+ is activated. Implements +finish+ and
+ *  +next+ commands.
+ */
+static VALUE
+Context_step_out(VALUE self, VALUE frame)
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+
+  if (FIX2INT(frame) < 0 || FIX2INT(frame) >= context->stack_size)
+    rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
+
+  context->after_frame = context->stack_size - FIX2INT(frame);
+
+  return frame;
+}
+
+/*
+ *  call-seq:
+ *    context.step_over(lines, frame = nil, force = false)
+ *
+ *  Steps over +lines+ lines.
+ *  Make step over operation on +frame+, by default the current frame.
+ *  +force+ parameter (if true) ensures that the cursor moves away from the
+ *  current line.
+ */
 static VALUE
 Context_step_over(int argc, VALUE *argv, VALUE self)
 {
@@ -375,8 +480,15 @@ Context_step_over(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    context.stop_return(frame)
+ *
+ *  Stops before frame number +frame+ is activated. Useful when you enter the
+ *  debugger after the last statement in a method.
+ */
 static VALUE
-Context_step_out(VALUE self, VALUE frame)
+Context_stop_return(VALUE self, VALUE frame)
 {
   debug_context_t *context;
   Data_Get_Struct(self, debug_context_t, context);
@@ -384,23 +496,128 @@ Context_step_out(VALUE self, VALUE frame)
   if (FIX2INT(frame) < 0 || FIX2INT(frame) >= context->stack_size)
     rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
 
-  context->after_frame = context->stack_size - FIX2INT(frame);
+  context->before_frame = context->stack_size - FIX2INT(frame);
 
   return frame;
 }
 
+static void
+context_suspend_0(debug_context_t *context)
+{
+  VALUE status = rb_funcall(context->thread, rb_intern("status"), 0);
+
+  if (rb_str_cmp(status, rb_str_new2("run")) == 0)
+    CTX_FL_SET(context, CTX_FL_WAS_RUNNING);
+  else if (rb_str_cmp(status, rb_str_new2("sleep")) == 0)
+    CTX_FL_UNSET(context, CTX_FL_WAS_RUNNING);
+  else
+    return;
+
+  CTX_FL_SET(context, CTX_FL_SUSPEND);
+}
+
+/*
+ *  call-seq:
+ *    context.suspend -> nil
+ *
+ *  Suspends the thread when it is running.
+ */
 static VALUE
-Context_stop_return(VALUE self, VALUE frame)
+Context_suspend(VALUE self)
 {
   debug_context_t *context;
   Data_Get_Struct(self, debug_context_t, context);
 
-  if (FIX2INT(frame) < 0 || FIX2INT(frame) >= context->stack_size)
-    rb_raise(rb_eRuntimeError, "Stop frame is out of range.");
+  if (CTX_FL_TEST(context, CTX_FL_SUSPEND))
+    rb_raise(rb_eRuntimeError, "Already suspended.");
 
-  context->before_frame = context->stack_size - FIX2INT(frame);
+  context_suspend_0(context);
+  return Qnil;
+}
 
-  return frame;
+/*
+ *  call-seq:
+ *    context.suspended? -> bool
+ *
+ *  Returns +true+ if the thread is suspended by debugger.
+ */
+static VALUE
+Context_is_suspended(VALUE self)
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+
+  return CTX_FL_TEST(context, CTX_FL_SUSPEND) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *    context.thnum -> int
+ *
+ *  Returns the context's number.
+ */
+static inline VALUE
+Context_thnum(VALUE self) {
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return INT2FIX(context->thnum);
+}
+
+/*
+ *  call-seq:
+ *    context.thread -> thread
+ *
+ *  Returns the thread this context is associated with.
+ */
+static inline VALUE
+Context_thread(VALUE self)
+{
+  debug_context_t *context;
+  Data_Get_Struct(self, debug_context_t, context);
+  return context->thread;
+}
+
+/*
+ *  call-seq:
+ *    context.tracing -> bool
+ *
+ *  Returns the tracing flag for the current context.
+ */
+static VALUE
+Context_tracing(VALUE self)
+{
+  debug_context_t *context;
+
+  Data_Get_Struct(self, debug_context_t, context);
+  return CTX_FL_TEST(context, CTX_FL_TRACING) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *    context.tracing = bool
+ *
+ *  Controls the tracing for this context.
+ */
+static VALUE
+Context_set_tracing(VALUE self, VALUE value)
+{
+  debug_context_t *context;
+
+  Data_Get_Struct(self, debug_context_t, context);
+
+  if (RTEST(value))
+      CTX_FL_SET(context, CTX_FL_TRACING);
+  else
+      CTX_FL_UNSET(context, CTX_FL_TRACING);
+  return value;
+}
+
+
+/* :nodoc: */
+static VALUE
+DebugThread_inherited(VALUE klass)
+{
+  rb_raise(rb_eRuntimeError, "Can't inherit Byebug::DebugThread class");
 }
 
 /*
@@ -410,25 +627,33 @@ Context_stop_return(VALUE self, VALUE frame)
  *
  *   Byebug keeps a single instance of this class.
  */
-VALUE
+void
 Init_context(VALUE mByebug)
 {
   cContext = rb_define_class_under(mByebug, "Context", rb_cObject);
-  rb_define_method(cContext, "stack_size", Context_stack_size, 0);
-  rb_define_method(cContext, "dead?", Context_dead, 0);
-  rb_define_method(cContext, "stop_reason", Context_stop_reason, 0);
-  rb_define_method(cContext, "tracing", Context_tracing, 0);
-  rb_define_method(cContext, "tracing=", Context_set_tracing, 1);
-  rb_define_method(cContext, "frame_file", Context_frame_file, -1);
-  rb_define_method(cContext, "frame_line", Context_frame_line, -1);
-  rb_define_method(cContext, "frame_method", Context_frame_method, -1);
+
+  rb_define_method(cContext, "dead?"        , Context_dead         ,  0);
   rb_define_method(cContext, "frame_binding", Context_frame_binding, -1);
-  rb_define_method(cContext, "frame_self", Context_frame_self, -1);
-  rb_define_method(cContext, "frame_class", Context_frame_class, -1);
-  rb_define_method(cContext, "step_into", Context_step_into, -1);
-  rb_define_method(cContext, "step_over", Context_step_over, -1);
-  rb_define_method(cContext, "step_out", Context_step_out, 1);
-  rb_define_method(cContext, "stop_return", Context_stop_return, 1);
-
-  return cContext;
+  rb_define_method(cContext, "frame_class"  , Context_frame_class  , -1);
+  rb_define_method(cContext, "frame_file"   , Context_frame_file   , -1);
+  rb_define_method(cContext, "frame_line"   , Context_frame_line   , -1);
+  rb_define_method(cContext, "frame_method" , Context_frame_method , -1);
+  rb_define_method(cContext, "frame_self"   , Context_frame_self   , -1);
+  rb_define_method(cContext, "ignored?"     , Context_ignored      ,  0);
+  rb_define_method(cContext, "resume"       , Context_resume       ,  0);
+  rb_define_method(cContext, "stack_size"   , Context_stack_size   ,  0);
+  rb_define_method(cContext, "step_into"    , Context_step_into    , -1);
+  rb_define_method(cContext, "step_out"     , Context_step_out     ,  1);
+  rb_define_method(cContext, "step_over"    , Context_step_over    , -1);
+  rb_define_method(cContext, "stop_return"  , Context_stop_return  ,  1);
+  rb_define_method(cContext, "stop_reason"  , Context_stop_reason  ,  0);
+  rb_define_method(cContext, "suspend"      , Context_suspend      ,  0);
+  rb_define_method(cContext, "suspended?"   , Context_is_suspended ,  0);
+  rb_define_method(cContext, "thnum"        , Context_thnum        ,  0);
+  rb_define_method(cContext, "thread"       , Context_thread       ,  0);
+  rb_define_method(cContext, "tracing"      , Context_tracing      ,  0);
+  rb_define_method(cContext, "tracing="     , Context_set_tracing  ,  1);
+
+  cDebugThread  = rb_define_class_under(mByebug, "DebugThread", rb_cThread);
+  rb_define_singleton_method(cDebugThread, "inherited", DebugThread_inherited, 1);
 }