byebug 3.5.1 → 4.0.0

data/ext/byebug/byebug.h

@@ -4,19 +4,21 @@
 #include <ruby.h>
 #include <ruby/debug.h>
 
+/* To prevent unused parameter warnings */
+#define UNUSED(x) (void)(x)
+
 /* flags */
 #define CTX_FL_DEAD         (1<<1) /* this context belonged to a dead thread */
-#define CTX_FL_ENABLE_BKPT  (1<<2) /* can check for breakpoints              */
-#define CTX_FL_FORCE_MOVE   (1<<3) /* don't stop unless we've changed line   */
-#define CTX_FL_IGNORE       (1<<4) /* this context belongs to ignored thread */
-#define CTX_FL_SUSPEND      (1<<5) /* thread currently suspended             */
-#define CTX_FL_TRACING      (1<<6) /* call at_tracing method                 */
-#define CTX_FL_WAS_RUNNING  (1<<7) /* thread was previously running          */
-#define CTX_FL_STOP_ON_RET  (1<<8) /* can stop on method 'end'               */
+#define CTX_FL_IGNORE       (1<<2) /* this context belongs to ignored thread */
+#define CTX_FL_SUSPEND      (1<<3) /* thread currently suspended             */
+#define CTX_FL_TRACING      (1<<4) /* call at_tracing method                 */
+#define CTX_FL_WAS_RUNNING  (1<<5) /* thread was previously running          */
+#define CTX_FL_STOP_ON_RET  (1<<6) /* can stop on method 'end'               */
+#define CTX_FL_IGNORE_STEPS (1<<7) /* doesn't countdown steps to break       */
 
 /* macro functions */
-#define CTX_FL_TEST(c,f)  ((c)->flags & (f))
-#define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
+#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)
 
 /* types */
@@ -40,9 +42,6 @@ typedef struct {
   int steps;                   /* # of steps before stopping               */
   int steps_out;               /* # of returns before stopping             */
 
-  VALUE last_file;
-  VALUE last_line;
-
   VALUE backtrace;             /* [[loc, self, klass, binding], ...] */
 } debug_context_t;
 
@@ -60,23 +59,45 @@ typedef struct {
   st_table *tbl;
 } threads_table_t;
 
+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;
+} breakpoint_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();
+extern VALUE pop_from_locked();
+extern void remove_from_locked(VALUE thread);
 
 /* functions from threads.c */
 extern void Init_threads_table(VALUE mByebug);
 extern VALUE create_threads_table(void);
-extern void check_threads_table(void);
 extern void thread_context_lookup(VALUE thread, VALUE *context);
-extern void halt_while_other_thread_is_active(debug_context_t *dc);
+extern int is_living_thread(VALUE thread);
+extern void acquire_lock(debug_context_t *dc);
+extern void release_lock(void);
 
 /* global variables */
-extern VALUE locker;
 extern VALUE threads;
+extern VALUE next_thread;
 
-/* functions */
+/* functions from context.c */
 extern void Init_context(VALUE mByebug);
 extern VALUE context_create(VALUE thread);
 extern VALUE context_dup(debug_context_t *context);
@@ -85,42 +106,21 @@ 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);
 
-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);
-}
-
-/* breakpoints & catchpoints */
-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;
-} breakpoint_t;
-
+/* functions from breakpoint.c */
 extern void Init_breakpoint(VALUE mByebug);
-extern VALUE catchpoint_hit_count(VALUE catchpoints, VALUE exception, VALUE *exception_name);
-extern VALUE find_breakpoint_by_pos(VALUE breakpoints, VALUE source, VALUE pos,
-                                    VALUE binding);
-extern VALUE find_breakpoint_by_method(VALUE breakpoints, VALUE klass,
-                                       VALUE mid, VALUE binding, VALUE self);
+extern VALUE catchpoint_hit_count(VALUE catchpoints,
+                                  VALUE exception,
+                                  VALUE *exception_name);
+
+extern VALUE find_breakpoint_by_pos(VALUE breakpoints,
+                                    VALUE source,
+                                    VALUE pos,
+                                    VALUE bind);
+
+extern VALUE find_breakpoint_by_method(VALUE breakpoints,
+                                       VALUE klass,
+                                       VALUE mid,
+                                       VALUE bind,
+                                       VALUE self);
 
 #endif

data/ext/byebug/context.c

@@ -7,12 +7,12 @@ 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. */
 extern void
-reset_stepping_stop_points(debug_context_t *context)
+reset_stepping_stop_points(debug_context_t * context)
 {
-  context->dest_frame   = -1;
-  context->lines        = -1;
-  context->steps        = -1;
-  context->steps_out    = -1;
+  context->dest_frame = -1;
+  context->lines = -1;
+  context->steps = -1;
+  context->steps_out = -1;
 }
 
 /*
@@ -26,6 +26,7 @@ static inline VALUE
 Context_dead(VALUE self)
 {
   debug_context_t *context;
+
   Data_Get_Struct(self, debug_context_t, context);
   return CTX_FL_TEST(context, CTX_FL_DEAD) ? Qtrue : Qfalse;
 }
@@ -33,14 +34,25 @@ Context_dead(VALUE self)
 static void
 context_mark(void *data)
 {
-  debug_context_t *context = (debug_context_t *)data;
+  debug_context_t *context = (debug_context_t *) data;
+
   rb_gc_mark(context->backtrace);
 }
 
+static VALUE
+dc_backtrace(const debug_context_t * context)
+{
+  return context->backtrace;
+}
+
 static int
-real_stack_size()
+dc_stack_size(debug_context_t * context)
 {
-  return FIX2INT(rb_funcall(cContext, rb_intern("stack_size"), 0));
+
+  if (NIL_P(dc_backtrace(context)))
+    return 0;
+
+  return RARRAY_LENINT(dc_backtrace(context));
 }
 
 extern VALUE
@@ -48,23 +60,23 @@ context_create(VALUE thread)
 {
   debug_context_t *context = ALLOC(debug_context_t);
 
-  context->last_file         = Qnil;
-  context->last_line         = Qnil;
-  context->flags             = 0;
-  context->calced_stack_size = real_stack_size();
-  context->thnum             = ++thnum_max;
-  context->thread            = thread;
+  context->flags = 0;
+  context->thnum = ++thnum_max;
+  context->thread = thread;
   reset_stepping_stop_points(context);
-  context->stop_reason       = CTX_STOP_NONE;
-  context->backtrace         = Qnil;
+  context->stop_reason = CTX_STOP_NONE;
+
+  rb_debug_inspector_open(context_backtrace_set, (void *)context);
+  context->calced_stack_size = dc_stack_size(context) + 1;
 
-  if (rb_obj_class(thread) == cDebugThread) CTX_FL_SET(context, CTX_FL_IGNORE);
+  if (rb_obj_class(thread) == cDebugThread)
+    CTX_FL_SET(context, CTX_FL_IGNORE);
 
   return Data_Wrap_Struct(cContext, context_mark, 0, context);
 }
 
 extern VALUE
-context_dup(debug_context_t *context)
+context_dup(debug_context_t * context)
 {
   debug_context_t *new_context = ALLOC(debug_context_t);
 
@@ -76,15 +88,10 @@ context_dup(debug_context_t *context)
   return Data_Wrap_Struct(cContext, context_mark, 0, new_context);
 }
 
-static VALUE
-dc_backtrace(const debug_context_t *context)
-{
-  return context->backtrace;
-}
 
 static VALUE
-dc_frame_get(const debug_context_t *context, int frame_index,
-                                             enum frame_component type)
+dc_frame_get(const debug_context_t * context, int frame_index,
+             enum frame_component type)
 {
   VALUE frame;
 
@@ -99,39 +106,40 @@ dc_frame_get(const debug_context_t *context, int frame_index,
 }
 
 static VALUE
-dc_frame_location(const debug_context_t *context, int frame_index)
+dc_frame_location(const debug_context_t * context, int frame_index)
 {
   return dc_frame_get(context, frame_index, LOCATION);
 }
 
 static VALUE
-dc_frame_self(const debug_context_t *context, int frame_index)
+dc_frame_self(const debug_context_t * context, int frame_index)
 {
   return dc_frame_get(context, frame_index, SELF);
 }
 
 static VALUE
-dc_frame_class(const debug_context_t *context, int frame_index)
+dc_frame_class(const debug_context_t * context, int frame_index)
 {
   return dc_frame_get(context, frame_index, CLASS);
 }
 
 static VALUE
-dc_frame_binding(const debug_context_t *context, int frame_index)
+dc_frame_binding(const debug_context_t * context, int frame_index)
 {
   return dc_frame_get(context, frame_index, BINDING);
 }
 
 static VALUE
-load_backtrace(const rb_debug_inspector_t *inspector)
+load_backtrace(const rb_debug_inspector_t * inspector)
 {
   VALUE backtrace = rb_ary_new();
   VALUE locs = rb_debug_inspector_backtrace_locations(inspector);
   int i;
 
-  for (i=0; i<RARRAY_LENINT(locs); i++)
+  for (i = 0; i < RARRAY_LENINT(locs); i++)
   {
     VALUE frame = rb_ary_new();
+
     rb_ary_push(frame, rb_ary_entry(locs, i));
     rb_ary_push(frame, rb_debug_inspector_frame_self_get(inspector, i));
     rb_ary_push(frame, rb_debug_inspector_frame_class_get(inspector, i));
@@ -144,19 +152,21 @@ load_backtrace(const rb_debug_inspector_t *inspector)
 }
 
 extern VALUE
-context_backtrace_set(const rb_debug_inspector_t *inspector, void *data)
+context_backtrace_set(const rb_debug_inspector_t * inspector, void *data)
 {
-  debug_context_t *dc = (debug_context_t *)data;
+  debug_context_t *dc = (debug_context_t *) data;
+
   dc->backtrace = load_backtrace(inspector);
 
   return Qnil;
 }
 
 static VALUE
-open_debug_inspector_i(const rb_debug_inspector_t *inspector, void *data)
+open_debug_inspector_i(const rb_debug_inspector_t * inspector, void *data)
 {
   struct call_with_inspection_data *cwi =
     (struct call_with_inspection_data *)data;
+
   cwi->dc->backtrace = load_backtrace(inspector);
 
   return rb_funcall2(cwi->context_obj, cwi->id, cwi->argc, cwi->argv);
@@ -178,8 +188,8 @@ close_debug_inspector(struct call_with_inspection_data *cwi)
 extern VALUE
 call_with_debug_inspector(struct call_with_inspection_data *data)
 {
-  return rb_ensure(open_debug_inspector, (VALUE)data,
-                   close_debug_inspector, (VALUE)data);
+  return rb_ensure(open_debug_inspector, (VALUE) data, close_debug_inspector,
+                   (VALUE) data);
 }
 
 #define FRAME_SETUP                                \
@@ -199,9 +209,9 @@ call_with_debug_inspector(struct call_with_inspection_data *data)
  *  Returns frame's binding.
  */
 static VALUE
-Context_frame_binding(int argc, VALUE *argv, VALUE self)
+Context_frame_binding(int argc, VALUE * argv, VALUE self)
 {
-  FRAME_SETUP
+  FRAME_SETUP;
 
   return dc_frame_binding(context, frame_n);
 }
@@ -213,9 +223,9 @@ Context_frame_binding(int argc, VALUE *argv, VALUE self)
  *  Returns frame's defined class.
  */
 static VALUE
-Context_frame_class(int argc, VALUE *argv, VALUE self)
+Context_frame_class(int argc, VALUE * argv, VALUE self)
 {
-  FRAME_SETUP
+  FRAME_SETUP;
 
   return dc_frame_class(context, frame_n);
 }
@@ -227,29 +237,34 @@ Context_frame_class(int argc, VALUE *argv, VALUE self)
  *  Returns the name of the file in the frame.
  */
 static VALUE
-Context_frame_file(int argc, VALUE *argv, VALUE self)
+Context_frame_file(int argc, VALUE * argv, VALUE self)
 {
-  VALUE loc;
+  VALUE loc, absolute_path;
 
-  FRAME_SETUP
+  FRAME_SETUP;
 
   loc = dc_frame_location(context, frame_n);
 
+  absolute_path = rb_funcall(loc, rb_intern("absolute_path"), 0);
+
+  if (!NIL_P(absolute_path))
+    return absolute_path;
+
   return rb_funcall(loc, rb_intern("path"), 0);
 }
 
 /*
  *  call-seq:
- *    context.frame_line(frame_position) -> int
+ *    context.frame_line(frame_position = 0) -> int
  *
  *  Returns the line number in the file.
  */
 static VALUE
-Context_frame_line(int argc, VALUE *argv, VALUE self)
+Context_frame_line(int argc, VALUE * argv, VALUE self)
 {
   VALUE loc;
 
-  FRAME_SETUP
+  FRAME_SETUP;
 
   loc = dc_frame_location(context, frame_n);
 
@@ -258,16 +273,16 @@ Context_frame_line(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.frame_method(frame_position=0) -> sym
+ *    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)
+Context_frame_method(int argc, VALUE * argv, VALUE self)
 {
   VALUE loc;
 
-  FRAME_SETUP
+  FRAME_SETUP;
 
   loc = dc_frame_location(context, frame_n);
 
@@ -276,14 +291,14 @@ Context_frame_method(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.frame_self(frame_postion=0) -> obj
+ *    context.frame_self(frame_postion = 0) -> obj
  *
  *  Returns self object of the frame.
  */
 static VALUE
-Context_frame_self(int argc, VALUE *argv, VALUE self)
+Context_frame_self(int argc, VALUE * argv, VALUE self)
 {
-  FRAME_SETUP
+  FRAME_SETUP;
 
   return dc_frame_self(context, frame_n);
 }
@@ -299,21 +314,11 @@ static inline VALUE
 Context_ignored(VALUE self)
 {
   debug_context_t *context;
+
   Data_Get_Struct(self, debug_context_t, context);
   return CTX_FL_TEST(context, CTX_FL_IGNORE) ? Qtrue : Qfalse;
 }
 
-static void
-context_resume_0(debug_context_t *context)
-{
-  if (!CTX_FL_TEST(context, CTX_FL_SUSPEND)) return;
-
-  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
@@ -323,34 +328,35 @@ context_resume_0(debug_context_t *context)
 static VALUE
 Context_resume(VALUE self)
 {
-    debug_context_t *context;
+  debug_context_t *context;
 
-    Data_Get_Struct(self, debug_context_t, context);
+  Data_Get_Struct(self, debug_context_t, context);
 
-    if (!CTX_FL_TEST(context, CTX_FL_SUSPEND))
-      rb_raise(rb_eRuntimeError, "Thread is not suspended.");
+  if (!CTX_FL_TEST(context, CTX_FL_SUSPEND))
+    return Qnil;
 
-    context_resume_0(context);
+  CTX_FL_UNSET(context, CTX_FL_SUSPEND);
 
-    return Qnil;
+  if (CTX_FL_TEST(context, CTX_FL_WAS_RUNNING))
+    rb_thread_wakeup(context->thread);
+
+  return Qnil;
 }
 
 /*
  *  call-seq:
- *    context.calced_stack_size-> int
+ *    context.backtrace-> int
  *
- *  Returns the calculated size of the context stack.
- *
- *  NOTE: it shouldn't be necessary to expose this, this is only done to ease
- *  the detection of TracePoint API bugs.
+ *  Returns the frame stack of a context.
  */
 static inline VALUE
-Context_calced_stack_size(VALUE self)
+Context_backtrace(VALUE self)
 {
   debug_context_t *context;
+
   Data_Get_Struct(self, debug_context_t, context);
 
-  return INT2FIX(context->calced_stack_size);
+  return dc_backtrace(context);
 }
 
 static VALUE
@@ -363,49 +369,59 @@ Context_stop_reason(VALUE self)
 
   if (CTX_FL_TEST(context, CTX_FL_DEAD))
     symbol = "post-mortem";
-  else switch (context->stop_reason)
-  {
-    case CTX_STOP_STEP:
-      symbol = "step";
-      break;
-    case CTX_STOP_BREAKPOINT:
-      symbol = "breakpoint";
-      break;
-    case CTX_STOP_CATCHPOINT:
-      symbol = "catchpoint";
-      break;
-    case CTX_STOP_NONE:
-    default:
-      symbol = "none";
-  }
+  else
+    switch (context->stop_reason)
+    {
+      case CTX_STOP_STEP:
+        symbol = "step";
+        break;
+      case CTX_STOP_BREAKPOINT:
+        symbol = "breakpoint";
+        break;
+      case CTX_STOP_CATCHPOINT:
+        symbol = "catchpoint";
+        break;
+      case CTX_STOP_NONE:
+      default:
+        symbol = "none";
+    }
   return ID2SYM(rb_intern(symbol));
 }
 
 /*
  *  call-seq:
- *    context.step_into(steps, force = false)
+ *    context.step_into(steps, frame = 0)
  *
- *  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.
+ *  Stops the current context after a number of +steps+ are made from frame
+ *  +frame+ (by default the newest one).
  */
 static VALUE
-Context_step_into(int argc, VALUE *argv, VALUE self)
+Context_step_into(int argc, VALUE * argv, VALUE self)
 {
-  VALUE steps, force;
+  VALUE steps, v_frame;
+  int n_args, from_frame;
   debug_context_t *context;
 
-  rb_scan_args(argc, argv, "11", &steps, &force);
-  if (FIX2INT(steps) < 0)
+  Data_Get_Struct(self, debug_context_t, context);
+
+  if (context->calced_stack_size == 0)
+    rb_raise(rb_eRuntimeError, "No frames collected.");
+
+  n_args = rb_scan_args(argc, argv, "11", &steps, &v_frame);
+
+  if (FIX2INT(steps) <= 0)
     rb_raise(rb_eRuntimeError, "Steps argument can't be negative.");
 
-  Data_Get_Struct(self, debug_context_t, context);
-  context->steps = FIX2INT(steps);
+  from_frame = n_args == 1 ? 0 : FIX2INT(v_frame);
 
-  if (RTEST(force))
-    CTX_FL_SET(context, CTX_FL_FORCE_MOVE);
-  else
-    CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
+  if (from_frame < 0 || from_frame >= context->calced_stack_size)
+    rb_raise(rb_eRuntimeError, "Destination frame (%d) is out of range (%d)",
+             from_frame, context->calced_stack_size);
+  else if (from_frame > 0)
+    CTX_FL_SET(context, CTX_FL_IGNORE_STEPS);
+
+  context->steps = FIX2INT(steps);
+  context->dest_frame = context->calced_stack_size - from_frame;
 
   return steps;
 }
@@ -420,7 +436,7 @@ Context_step_into(int argc, VALUE *argv, VALUE self)
  *  event for that frame is triggered.
  */
 static VALUE
-Context_step_out(int argc, VALUE *argv, VALUE self)
+Context_step_out(int argc, VALUE * argv, VALUE self)
 {
   int n_args, n_frames;
   VALUE v_frames, force;
@@ -433,7 +449,7 @@ Context_step_out(int argc, VALUE *argv, VALUE self)
 
   if (n_frames < 0 || n_frames > context->calced_stack_size)
     rb_raise(rb_eRuntimeError,
-             "You wan't to finish %d frames, but stack size is only %d",
+             "You want to finish %d frames, but stack size is only %d",
              n_frames, context->calced_stack_size);
 
   context->steps_out = n_frames;
@@ -447,18 +463,16 @@ Context_step_out(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.step_over(lines, frame = 0, force = false)
+ *    context.step_over(lines, frame = 0)
  *
- *  Steps over +lines+ lines.
- *  Make step over operation on +frame+, by default the newest frame.
- *  +force+ parameter (if true) ensures that the cursor moves away from the
- *  current line.
+ *  Steps over +lines+ lines in frame +frame+ (by default the newest one) or
+ *  higher (if frame +frame+ finishes).
  */
 static VALUE
-Context_step_over(int argc, VALUE *argv, VALUE self)
+Context_step_over(int argc, VALUE * argv, VALUE self)
 {
   int n_args, frame;
-  VALUE lines, v_frame, force;
+  VALUE lines, v_frame;
   debug_context_t *context;
 
   Data_Get_Struct(self, debug_context_t, context);
@@ -466,56 +480,66 @@ Context_step_over(int argc, VALUE *argv, VALUE self)
   if (context->calced_stack_size == 0)
     rb_raise(rb_eRuntimeError, "No frames collected.");
 
-  n_args = rb_scan_args(argc, argv, "12", &lines, &v_frame, &force);
+  n_args = rb_scan_args(argc, argv, "11", &lines, &v_frame);
   frame = n_args == 1 ? 0 : FIX2INT(v_frame);
 
   if (frame < 0 || frame >= context->calced_stack_size)
-    rb_raise(rb_eRuntimeError,
-             "Destination frame (%d) is out of range (%d)",
+    rb_raise(rb_eRuntimeError, "Destination frame (%d) is out of range (%d)",
              frame, context->calced_stack_size);
 
   context->lines = FIX2INT(lines);
   context->dest_frame = context->calced_stack_size - frame;
 
-  if (n_args == 3 && RTEST(force))
-    CTX_FL_SET(context, CTX_FL_FORCE_MOVE);
-  else
-    CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
-
   return Qnil;
 }
 
-static void
-context_suspend_0(debug_context_t *context)
+/*
+ *  call-seq:
+ *    context.suspend -> nil
+ *
+ *  Suspends the thread when it is running.
+ */
+static VALUE
+Context_suspend(VALUE self)
 {
-  VALUE status = rb_funcall(context->thread, rb_intern("status"), 0);
+  VALUE status;
+  debug_context_t *context;
+
+  Data_Get_Struct(self, debug_context_t, context);
+
+  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;
+    return Qnil;
 
   CTX_FL_SET(context, CTX_FL_SUSPEND);
+
+  return Qnil;
 }
 
 /*
  *  call-seq:
- *    context.suspend -> nil
+ *    context.switch -> nil
  *
- *  Suspends the thread when it is running.
+ *  Switches execution to this context.
  */
 static VALUE
-Context_suspend(VALUE self)
+Context_switch(VALUE self)
 {
   debug_context_t *context;
+
   Data_Get_Struct(self, debug_context_t, context);
 
-  if (CTX_FL_TEST(context, CTX_FL_SUSPEND))
-    rb_raise(rb_eRuntimeError, "Already suspended.");
+  next_thread = context->thread;
+
+  context->steps = 1;
+  context->steps_out = 0;
+  CTX_FL_SET(context, CTX_FL_STOP_ON_RET);
 
-  context_suspend_0(context);
   return Qnil;
 }
 
@@ -529,6 +553,7 @@ 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;
@@ -541,8 +566,10 @@ Context_is_suspended(VALUE self)
  *  Returns the context's number.
  */
 static inline VALUE
-Context_thnum(VALUE self) {
+Context_thnum(VALUE self)
+{
   debug_context_t *context;
+
   Data_Get_Struct(self, debug_context_t, context);
   return INT2FIX(context->thnum);
 }
@@ -557,6 +584,7 @@ static inline VALUE
 Context_thread(VALUE self)
 {
   debug_context_t *context;
+
   Data_Get_Struct(self, debug_context_t, context);
   return context->thread;
 }
@@ -590,15 +618,15 @@ Context_set_tracing(VALUE self, VALUE value)
   Data_Get_Struct(self, debug_context_t, context);
 
   if (RTEST(value))
-      CTX_FL_SET(context, CTX_FL_TRACING);
+    CTX_FL_SET(context, CTX_FL_TRACING);
   else
-      CTX_FL_UNSET(context, CTX_FL_TRACING);
+    CTX_FL_UNSET(context, CTX_FL_TRACING);
   return value;
 }
 
 /* :nodoc: */
 static VALUE
-DebugThread_inherited(VALUE klass)
+dt_inherited(VALUE klass)
 {
   rb_raise(rb_eRuntimeError, "Can't inherit Byebug::DebugThread class");
 
@@ -617,27 +645,28 @@ Init_context(VALUE mByebug)
 {
   cContext = rb_define_class_under(mByebug, "Context", rb_cObject);
 
-  rb_define_method(cContext, "dead?"            , Context_dead             ,  0);
-  rb_define_method(cContext, "frame_binding"    , Context_frame_binding    , -1);
-  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, "calced_stack_size", Context_calced_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_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);
+  rb_define_method(cContext, "backtrace", Context_backtrace, 0);
+  rb_define_method(cContext, "dead?", Context_dead, 0);
+  rb_define_method(cContext, "frame_binding", Context_frame_binding, -1);
+  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, "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_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, "switch", Context_switch, 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", dt_inherited, 1);
 }