byebug 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 497f9606e8de41c51c02441cdbda3092f7131ec3
-  data.tar.gz: 12a94e7916cc107fb392af1a7abc0cd8515ce696
+  metadata.gz: d18d944520a45aaad538b12d098effea86da264b
+  data.tar.gz: a9a224673d713f67bd67c13e5e1f1a88b08d90c5
 SHA512:
-  metadata.gz: 7ffdf9b6cf8fc471af1b57efacabaa9e3159c115e59d718417792e6a70a7686070a7537a1d2c10da741988fb1416bf61cb95d71420718f89219d434d3c318b7f
-  data.tar.gz: f1ddc5b71c708a81de661402d52a2b758913cdd09d2b4827cf850643467ef857b50dc64fa0f98ed3ba774de0dc34f1dc6b69c6d3b68d4226f3a5ac835fb8ef7d
+  metadata.gz: 29d6e1b0b24f742210043e44e5a6cc767982e5d95bb22fe7e72e42841b2c8d8c347c94431d59d72f0b1138336a6e2b5c52a3b2cae52e1838cab2f73560ee0f9b
+  data.tar.gz: bbc117ad67be478a69e5116a335539be57ebb007f101e4f4de4fab4fac8a793c155a948a287f95af670718513aee946622ef1fcac23913471700ed207959409a

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.4.0
+
+* Byebug now uses the Debug Inspector API: faster and nicer!
+* Fixes bug that prevents some random crashes
+
+
 ## 1.3.1
 
 * Byebug now works with Rails debugging flag

data/README.md

@@ -6,8 +6,9 @@
 _Debugging in Ruby 2.0_
 
 Byebug is a simple to use, feature rich debugger for Ruby 2.0. It uses the new
-TracePoint API, so it doesn't depend on internal core sources. It's developed as
-a C extension, so it's fast. And it has a full test suite so it's (I hope)
+TracePoint API for execution control and the new Debug Inspector API for call
+stack navigation, so it doesn't depend on internal core sources. It's developed
+as a C extension, so it's fast. And it has a full test suite so it's (I hope)
 reliable.
 
 It allows you to see what is going on _inside_ a Ruby program while it executes

data/bin/byebug

@@ -206,6 +206,7 @@ opts = process_options(options)
 begin
   Byebug::ARGV = ARGV.clone if not defined? Byebug::ARGV
   Byebug::BYEBUG_SCRIPT = File.expand_path(__FILE__)
+  Byebug::IGNORED_FILES << Byebug::BYEBUG_SCRIPT
   Byebug::INITIAL_DIR = Dir.pwd
   opts.parse! ARGV
 rescue StandardError => e

data/byebug.gemspec

@@ -10,10 +10,11 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/deivid-rodriguez/byebug"
   s.summary = %q{Ruby 2.0 fast debugger - base + cli}
   s.description = %q{Byebug is a Ruby 2.0 debugger. It's implemented using the
-    Ruby 2.0 TracePoint C API. The C extension was forked from debase whereas
-    the rest of the gem was forked from debugger. The core component provides
-    support that front-ends can build on. It provides breakpoint handling,
-    bindings for stack frames among other things.}
+    Ruby 2.0 TracePoint C API for execution control and the Debug Inspector C
+    API for call stack navigation.  The core component provides support that
+    front-ends can build on. It provides breakpoint handling and bindings for
+    stack frames among other things and it comes with an easy to use command
+    line interface.}
 
   s.required_ruby_version = '>= 2.0.0'
   s.required_rubygems_version = ">= 2.0.3"
@@ -28,7 +29,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake', '~> 10.0.4'
   s.add_development_dependency 'rake-compiler', '~> 0.8.3'
   s.add_development_dependency 'mocha', '~> 0.14.0'
-  s.add_development_dependency 'minitest', '~> 5.0.2'
+  s.add_development_dependency 'minitest', '~> 5.0.3'
 
   s.license = "BSD"
 end

data/ext/byebug/breakpoint.c

@@ -100,10 +100,9 @@ Breakpoint_mark(breakpoint_t *breakpoint)
 static VALUE
 Breakpoint_create(VALUE klass)
 {
-    breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint = ALLOC(breakpoint_t);
 
-    breakpoint = ALLOC(breakpoint_t);
-    return Data_Wrap_Struct(klass, Breakpoint_mark, xfree, breakpoint);
+  return Data_Wrap_Struct(klass, Breakpoint_mark, xfree, breakpoint);
 }
 
 static VALUE
@@ -179,10 +178,10 @@ Breakpoint_pos(VALUE self)
   breakpoint_t *breakpoint;
 
   Data_Get_Struct(self, breakpoint_t, breakpoint);
-  if(breakpoint->type == BP_METHOD_TYPE)
-      return rb_str_new2(rb_id2name(breakpoint->pos.mid));
+  if (breakpoint->type == BP_METHOD_TYPE)
+    return rb_str_new2(rb_id2name(breakpoint->pos.mid));
   else
-      return INT2FIX(breakpoint->pos.line);
+    return INT2FIX(breakpoint->pos.line);
 }
 
 
@@ -198,11 +197,11 @@ Breakpoint_expr(VALUE self)
 static VALUE
 Breakpoint_set_expr(VALUE self, VALUE expr)
 {
-    breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint;
 
-    Data_Get_Struct(self, breakpoint_t, breakpoint);
-    breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
-    return expr;
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
+  return expr;
 }
 
 static VALUE
@@ -318,19 +317,19 @@ check_breakpoint_by_hit_condition(VALUE breakpoint_object)
 static int
 check_breakpoint_by_pos(VALUE breakpoint_object, char *file, int line)
 {
-    breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint;
 
-    if (breakpoint_object == Qnil)
-      return 0;
+  if (breakpoint_object == Qnil)
+    return 0;
 
-    Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
+  Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
 
-    if ( (Qtrue != breakpoint->enabled)    ||
-         (breakpoint->type != BP_POS_TYPE) ||
-         (breakpoint->pos.line != line) )
-      return 0;
+  if ( (Qtrue != breakpoint->enabled)    ||
+       (breakpoint->type != BP_POS_TYPE) ||
+       (breakpoint->pos.line != line) )
+    return 0;
 
-    return filename_cmp(breakpoint->source, file);
+  return filename_cmp(breakpoint->source, file);
 }
 
 static int
@@ -362,7 +361,7 @@ check_breakpoint_by_expr(VALUE breakpoint_object, VALUE binding)
   breakpoint_t *breakpoint;
   VALUE args, expr_result;
 
-  if (breakpoint_object == Qnil)
+  if (NIL_P(breakpoint_object))
     return 0;
 
   Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
@@ -390,12 +389,12 @@ find_breakpoint_by_pos(VALUE breakpoints, VALUE source, VALUE pos,
 
   file = RSTRING_PTR(source);
   line = FIX2INT(pos);
-  for(i = 0; i < RARRAY_LEN(breakpoints); i++)
+  for (i = 0; i < RARRAY_LEN(breakpoints); i++)
   {
     breakpoint_object = rb_ary_entry(breakpoints, i);
-    if ( check_breakpoint_by_pos(breakpoint_object, file, line) &&
-         check_breakpoint_by_expr(breakpoint_object, binding)   &&
-         check_breakpoint_by_hit_condition(breakpoint_object) )
+    if (check_breakpoint_by_pos(breakpoint_object, file, line) &&
+        check_breakpoint_by_expr(breakpoint_object, binding)   &&
+        check_breakpoint_by_hit_condition(breakpoint_object))
     {
       return breakpoint_object;
     }
@@ -410,13 +409,15 @@ find_breakpoint_by_method(VALUE breakpoints, VALUE klass, ID mid, VALUE binding,
   VALUE breakpoint_object;
   int i;
 
-  for(i = 0; i < RARRAY_LEN(breakpoints); i++)
+  for (i = 0; i < RARRAY_LEN(breakpoints); i++)
   {
     breakpoint_object = rb_ary_entry(breakpoints, i);
-    if ( check_breakpoint_by_method(breakpoint_object, klass, mid, self) &&
-         check_breakpoint_by_expr(breakpoint_object, binding)            &&
-         check_breakpoint_by_hit_condition(breakpoint_object) )
+    if (check_breakpoint_by_method(breakpoint_object, klass, mid, self) &&
+        check_breakpoint_by_expr(breakpoint_object, binding)            &&
+        check_breakpoint_by_hit_condition(breakpoint_object))
+    {
       return breakpoint_object;
+    }
   }
   return Qnil;
 }

data/ext/byebug/byebug.c

@@ -7,20 +7,19 @@ static VALUE tracing     = Qfalse;
 static VALUE post_mortem = Qfalse;
 static VALUE debug       = Qfalse;
 
-static VALUE context;
-static VALUE catchpoints;
-static VALUE breakpoints;
+static VALUE context     = Qnil;
+static VALUE catchpoints = Qnil;
+static VALUE breakpoints = Qnil;
 
-static VALUE tpLine;
-static VALUE tpCall;
-static VALUE tpCCall;
-static VALUE tpReturn;
-static VALUE tpCReturn;
-static VALUE tpRaise;
+static VALUE tpLine    = Qnil;
+static VALUE tpCall    = Qnil;
+static VALUE tpCCall   = Qnil;
+static VALUE tpReturn  = Qnil;
+static VALUE tpCReturn = Qnil;
+static VALUE tpRaise   = Qnil;
 
 static VALUE
-tp_inspect(VALUE trace_point) {
-  rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(trace_point);
+tp_inspect(rb_trace_arg_t *trace_arg) {
   if (trace_arg) {
     VALUE event = rb_tracearg_event(trace_arg);
     if (ID2SYM(rb_intern("line")) == event ||
@@ -55,216 +54,265 @@ static VALUE
 Byebug_context(VALUE self)
 {
   if (context == Qnil) {
-    context = Context_create();
+    context = context_create();
   }
   return context;
 }
 
 static void
-cleanup(debug_context_t *context)
+cleanup(debug_context_t *dc)
 {
-  context->stop_reason = CTX_STOP_NONE;
+  dc->stop_reason = CTX_STOP_NONE;
 }
 
-static int
-check_start_processing(debug_context_t *context)
+static void
+save_current_position(debug_context_t *dc, VALUE file, VALUE line)
 {
-  /* ignore a skipped section of code */
-  if(CTX_FL_TEST(context, CTX_FL_SKIPPED)) {
-    cleanup(context);
-    return 0;
-  }
-  return 1;
+  dc->last_file = file;
+  dc->last_line = line;
+  CTX_FL_UNSET(dc, CTX_FL_ENABLE_BKPT);
+  CTX_FL_UNSET(dc, CTX_FL_FORCE_MOVE);
+}
+
+static VALUE
+call_at(VALUE context_obj, debug_context_t *dc, ID mid, int argc, VALUE a0,
+                                                                  VALUE a1)
+{
+  struct call_with_inspection_data cwi;
+  VALUE argv[2];
+
+  argv[0] = a0;
+  argv[1] = a1;
+
+  cwi.dc          = dc;
+  cwi.context_obj = context_obj;
+  cwi.id          = mid;
+  cwi.argc        = argc;
+  cwi.argv        = &argv[0];
+
+  return call_with_debug_inspector(&cwi);
+}
+
+static VALUE
+call_at_line(VALUE context_obj, debug_context_t *dc, VALUE file, VALUE line)
+{
+  save_current_position(dc, file, line);
+  return call_at(context_obj, dc, rb_intern("at_line"), 2, file, line);
 }
 
-static inline void
-load_frame_info(VALUE trace_point, VALUE *path, VALUE *lineno, VALUE *method_id,
-                                   VALUE *defined_class, VALUE *binding,
-                                   VALUE *self)
+static VALUE
+call_at_tracing(VALUE context_obj, debug_context_t *dc, VALUE file, VALUE line)
 {
-  rb_trace_point_t *tp;
+  return call_at(context_obj, dc, rb_intern("at_tracing"), 2, file, line);
+}
 
-  tp = rb_tracearg_from_tracepoint(trace_point);
+static VALUE
+call_at_breakpoint(VALUE context_obj, debug_context_t *dc, VALUE breakpoint)
+{
+  dc->stop_reason = CTX_STOP_BREAKPOINT;
+  return call_at(context_obj, dc, rb_intern("at_breakpoint"), 1, breakpoint, 0);
+}
 
-  *path = rb_tracearg_path(tp);
-  *lineno = rb_tracearg_lineno(tp);
-  *binding = rb_tracearg_binding(tp);
-  *self = rb_tracearg_self(tp);
-  *method_id = rb_tracearg_method_id(tp);
-  *defined_class = rb_tracearg_defined_class(tp);
+static VALUE
+call_at_catchpoint(VALUE context_obj, debug_context_t *dc, VALUE exp)
+{
+  dc->stop_reason = CTX_STOP_CATCHPOINT;
+  return call_at(context_obj, dc, rb_intern("at_catchpoint"), 1, exp, 0);
 }
 
 static void
-call_at_line(debug_context_t *context, VALUE context_obj,
-                                       VALUE path, VALUE lineno)
-{
-  CTX_FL_UNSET(context, CTX_FL_ENABLE_BKPT);
-  CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
-  context->last_file = RSTRING_PTR(path);
-  context->last_line = FIX2INT(lineno);
-  rb_funcall(context_obj, rb_intern("at_line"), 2, path, lineno);
-}
-
-#define EVENT_SETUP                                                        \
-  VALUE path, lineno, method_id, defined_class, binding, self;             \
-  VALUE context_obj;                                                       \
-  debug_context_t *context;                                                \
-  context_obj = Byebug_context(mByebug);                                   \
-  Data_Get_Struct(context_obj, debug_context_t, context);                  \
-  if (!check_start_processing(context)) return;                            \
-  load_frame_info(trace_point, &path, &lineno, &method_id, &defined_class, \
-                               &binding, &self);                           \
-  if (debug == Qtrue)                                                      \
-    printf("%s (stack_size: %d)\n",                                        \
-            RSTRING_PTR(tp_inspect(trace_point)), context->stack_size);    \
+call_at_line_check(VALUE context_obj, debug_context_t *dc,
+                   VALUE breakpoint, VALUE file, VALUE line)
+{
+  dc->stop_reason = CTX_STOP_STEP;
+
+  if (breakpoint != Qnil)
+    call_at_breakpoint(context_obj, dc, breakpoint);
+
+  reset_stepping_stop_points(dc);
+  call_at_line(context_obj, dc, file, line);
+}
+
+#define EVENT_SETUP                                                     \
+  rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(trace_point); \
+  VALUE context_obj;                                                    \
+  debug_context_t *dc;                                                  \
+  context_obj = Byebug_context(mByebug);                                \
+  Data_Get_Struct(context_obj, debug_context_t, dc);                    \
+  if (debug == Qtrue)                                                   \
+    printf("%s (stack_size: %d)\n",                                     \
+            RSTRING_PTR(tp_inspect(trace_arg)), dc->stack_size);        \
+
+#define EVENT_COMMON() \
+  if (trace_common(trace_arg, dc) == 0) { return; }
+
+static int
+trace_common(rb_trace_arg_t *trace_arg, debug_context_t *dc)
+{
+  /* ignore a skipped section of code */
+  if (CTX_FL_TEST(dc, CTX_FL_SKIPPED))
+  {
+    cleanup(dc);
+    return 0;
+  }
+
+  /* Many events per line, but only *one* breakpoint */
+  if (dc->last_line != rb_tracearg_lineno(trace_arg) ||
+      dc->last_file != rb_tracearg_path(trace_arg))
+  {
+    CTX_FL_SET(dc, CTX_FL_ENABLE_BKPT);
+  }
+
+  return 1;
+}
 
 static void
 process_line_event(VALUE trace_point, void *data)
 {
   EVENT_SETUP;
-  VALUE breakpoint;
+  VALUE breakpoint = Qnil;
+  VALUE file    = rb_tracearg_path(trace_arg);
+  VALUE line    = rb_tracearg_lineno(trace_arg);
+  VALUE binding = rb_tracearg_binding(trace_arg);
   int moved = 0;
 
-  if (context->stack_size == 0)
-    push_frame(context, RSTRING_PTR(path), FIX2INT(lineno), method_id,
-                        defined_class, binding, self);
-  else
-    update_frame(context->stack, RSTRING_PTR(path), FIX2INT(lineno), method_id,
-                                 defined_class, binding, self);
+  EVENT_COMMON();
 
-  if (context->last_line != FIX2INT(lineno) || context->last_file == NULL ||
-       strcmp(context->last_file, RSTRING_PTR(path)))
+  if (dc->stack_size == 0) dc->stack_size++;
+
+  if (dc->last_line != rb_tracearg_lineno(trace_arg) ||
+      dc->last_file != rb_tracearg_path(trace_arg))
   {
-    CTX_FL_SET(context, CTX_FL_ENABLE_BKPT);
     moved = 1;
   }
 
   if (RTEST(tracing))
-    rb_funcall(context_obj, rb_intern("at_tracing"), 2, path, lineno);
+    call_at_tracing(context_obj, dc, file, line);
 
-  if (context->dest_frame == -1 || context->stack_size == context->dest_frame)
+  if (moved || !CTX_FL_TEST(dc, CTX_FL_FORCE_MOVE))
   {
-    if (moved || !CTX_FL_TEST(context, CTX_FL_FORCE_MOVE))
+    dc->steps = dc->steps <= 0 ? -1 : dc->steps - 1;
+    if (dc->stack_size <= dc->dest_frame)
     {
-      context->steps = context->steps <= 0 ? -1 : context->steps - 1;
-      context->lines = context->lines <= 0 ? -1 : context->lines - 1;
+      dc->lines = dc->lines <= 0 ? -1 : dc->lines - 1;
+      dc->dest_frame = dc->stack_size;
     }
   }
-  else if (context->stack_size < context->dest_frame)
-  {
-      context->steps = 0;
-  }
 
-  if (context->steps == 0 || context->lines == 0)
-  {
-    context->stop_reason = CTX_STOP_STEP;
-    reset_stepping_stop_points(context);
-    call_at_line(context, context_obj, path, lineno);
-  }
-  else if (CTX_FL_TEST(context, CTX_FL_ENABLE_BKPT))
+  if (dc->steps == 0 || dc->lines == 0 ||
+      (CTX_FL_TEST(dc, CTX_FL_ENABLE_BKPT) &&
+      (!NIL_P(
+       breakpoint = find_breakpoint_by_pos(breakpoints, file, line, binding)))))
   {
-    breakpoint = find_breakpoint_by_pos(breakpoints, path, lineno, binding);
-    if (breakpoint != Qnil)
-    {
-      context->stop_reason = CTX_STOP_BREAKPOINT;
-      reset_stepping_stop_points(context);
-      rb_funcall(context_obj, rb_intern("at_breakpoint"), 1, breakpoint);
-      call_at_line(context, context_obj, path, lineno);
-    }
+    call_at_line_check(context_obj, dc, breakpoint, file, line);
   }
 
-  cleanup(context);
+  cleanup(dc);
 }
 
 static void
 process_c_return_event(VALUE trace_point, void *data)
 {
   EVENT_SETUP;
+  if (dc->stack_size > 0) dc->stack_size--;
+  EVENT_COMMON();
 
-  pop_frame(context);
-
-  cleanup(context);
+  cleanup(dc);
 }
 
 static void
 process_return_event(VALUE trace_point, void *data)
 {
   EVENT_SETUP;
+  if (dc->stack_size > 0) dc->stack_size--;
+  EVENT_COMMON();
 
-  if (context->stack_size == context->stop_frame)
+  if (dc->stack_size + 1 == dc->stop_frame)
   {
-      context->steps      = 1;
-      context->stop_frame = -1;
+    dc->steps      = 1;
+    dc->stop_frame = -1;
   }
-  pop_frame(context);
 
-  cleanup(context);
+  cleanup(dc);
 }
 
 static void
 process_c_call_event(VALUE trace_point, void *data)
 {
   EVENT_SETUP;
+  dc->stack_size++;
+  EVENT_COMMON();
 
-  push_frame(context, RSTRING_PTR(path), FIX2INT(lineno), method_id,
-                      defined_class, binding, self);
-  cleanup(context);
+  cleanup(dc);
 }
 
 static void
 process_call_event(VALUE trace_point, void *data)
 {
   EVENT_SETUP;
-  VALUE breakpoint;
-
-  push_frame(context, RSTRING_PTR(path), FIX2INT(lineno), method_id,
-                      defined_class, binding, self);
-
-  breakpoint = find_breakpoint_by_method(breakpoints, defined_class,
-                                                      SYM2ID(method_id),
-                                                      binding, self);
+  dc->stack_size++;
+  EVENT_COMMON();
+
+  VALUE breakpoint = Qnil;
+  VALUE klass   = rb_tracearg_defined_class(trace_arg);
+  VALUE mid     = SYM2ID(rb_tracearg_method_id(trace_arg));
+  VALUE binding = rb_tracearg_binding(trace_arg);
+  VALUE self    = rb_tracearg_self(trace_arg);
+  VALUE file    = rb_tracearg_path(trace_arg);
+  VALUE line    = rb_tracearg_lineno(trace_arg);
+
+  breakpoint =
+    find_breakpoint_by_method(breakpoints, klass, mid, binding, self);
   if (breakpoint != Qnil)
   {
-    context->stop_reason = CTX_STOP_BREAKPOINT;
-    rb_funcall(context_obj, rb_intern("at_breakpoint"), 1, breakpoint);
-    call_at_line(context, context_obj, path, lineno);
+    call_at_breakpoint(context_obj, dc, breakpoint);
+    call_at_line(context_obj, dc, file, line);
   }
 
-  cleanup(context);
+  cleanup(dc);
 }
 
 static void
 process_raise_event(VALUE trace_point, void *data)
 {
-  EVENT_SETUP;
+  EVENT_SETUP
   VALUE expn_class, aclass;
   VALUE err = rb_errinfo();
   VALUE ancestors;
   int i;
+  debug_context_t *new_dc;
+
+  EVENT_COMMON();
 
-  update_frame(context->stack, RSTRING_PTR(path), FIX2INT(lineno), method_id,
-                               defined_class, binding, self);
+  VALUE binding = rb_tracearg_binding(trace_arg);
+  VALUE path    = rb_tracearg_path(trace_arg);
+  VALUE lineno  = rb_tracearg_lineno(trace_arg);
 
-  if (post_mortem == Qtrue && self)
+  if (post_mortem == Qtrue)
   {
-    VALUE binding = rb_binding_new();
-    rb_ivar_set(rb_errinfo(), rb_intern("@__debug_file"), path);
-    rb_ivar_set(rb_errinfo(), rb_intern("@__debug_line"), lineno);
-    rb_ivar_set(rb_errinfo(), rb_intern("@__debug_binding"), binding);
-    rb_ivar_set(rb_errinfo(), rb_intern("@__debug_context"), Context_dup(context));
+    context = context_dup(dc);
+    rb_ivar_set(err, rb_intern("@__debug_file")   , path);
+    rb_ivar_set(err, rb_intern("@__debug_line")   , lineno);
+    rb_ivar_set(err, rb_intern("@__debug_binding"), binding);
+    rb_ivar_set(err, rb_intern("@__debug_context"), context);
+
+    Data_Get_Struct(context, debug_context_t, new_dc);
+    rb_debug_inspector_open(context_backtrace_set, (void *)new_dc);
   }
 
   expn_class = rb_obj_class(err);
 
-  if (catchpoints == Qnil || context->stack_size == 0 ||
-      CTX_FL_TEST(context, CTX_FL_CATCHING) ||
-      RHASH_TBL(catchpoints)->num_entries == 0) {
-    cleanup(context);
+  if (catchpoints == Qnil || dc->stack_size == 0 ||
+      CTX_FL_TEST(dc, CTX_FL_CATCHING) ||
+      RHASH_TBL(catchpoints)->num_entries == 0)
+  {
+    cleanup(dc);
     return;
   }
 
   ancestors = rb_mod_ancestors(expn_class);
-  for (i = 0; i < RARRAY_LEN(ancestors); i++) {
+  for (i = 0; i < RARRAY_LEN(ancestors); i++)
+  {
     VALUE mod_name;
     VALUE hit_count;
 
@@ -272,17 +320,17 @@ process_raise_event(VALUE trace_point, void *data)
     mod_name  = rb_mod_name(aclass);
     hit_count = rb_hash_aref(catchpoints, mod_name);
 
-    if (hit_count != Qnil) {
-      /* increment exception */
+    /* increment exception */
+    if (hit_count != Qnil)
+    {
       rb_hash_aset(catchpoints, mod_name, INT2FIX(FIX2INT(hit_count) + 1));
-      context->stop_reason = CTX_STOP_CATCHPOINT;
-      rb_funcall(context_obj, rb_intern("at_catchpoint"), 1, rb_errinfo());
-      call_at_line(context, context_obj, path, lineno);
+      call_at_catchpoint(context_obj, dc, err);
+      call_at_line(context_obj, dc, path, lineno);
       break;
     }
   }
 
-  cleanup(context);
+  cleanup(dc);
 }
 
 static VALUE
@@ -330,34 +378,17 @@ Byebug_setup_tracepoints(VALUE self)
 static VALUE
 Byebug_remove_tracepoints(VALUE self)
 {
+  rb_tracepoint_disable(tpRaise);
+  rb_tracepoint_disable(tpCReturn);
+  rb_tracepoint_disable(tpReturn);
+  rb_tracepoint_disable(tpCCall);
+  rb_tracepoint_disable(tpCall);
+  rb_tracepoint_disable(tpLine);
+
   context = Qnil;
   breakpoints = Qnil;
   catchpoints = Qnil;
 
-  if (tpLine != Qnil) {
-    rb_tracepoint_disable(tpLine);
-    tpLine = Qnil;
-  }
-  if (tpCall != Qnil) {
-    rb_tracepoint_disable(tpCall);
-    tpCall = Qnil;
-  }
-  if (tpCCall != Qnil) {
-    rb_tracepoint_disable(tpCCall);
-    tpCCall = Qnil;
-  }
-  if (tpReturn != Qnil) {
-    rb_tracepoint_disable(tpReturn);
-    tpReturn = Qnil;
-  }
-  if (tpCReturn != Qnil) {
-    rb_tracepoint_disable(tpCReturn);
-    tpCReturn = Qnil;
-  }
-  if (tpRaise != Qnil) {
-    rb_tracepoint_disable(tpRaise);
-    tpRaise = Qnil;
-  }
   return Qnil;
 }
 
@@ -371,45 +402,45 @@ Byebug_started(VALUE self)
 static VALUE
 Byebug_stop(VALUE self)
 {
-    if (BYEBUG_STARTED)
-    {
-        Byebug_remove_tracepoints(self);
-        return Qfalse;
-    }
-    return Qtrue;
+  if (BYEBUG_STARTED)
+  {
+    Byebug_remove_tracepoints(self);
+    return Qfalse;
+  }
+  return Qtrue;
 }
 
 static VALUE
 Byebug_start(VALUE self)
 {
-    VALUE result;
+  VALUE result;
 
-    if (BYEBUG_STARTED)
-        result = Qfalse;
-    else
-    {
-        Byebug_setup_tracepoints(self);
-        result = Qtrue;
-    }
+  if (BYEBUG_STARTED)
+    result = Qfalse;
+  else
+  {
+    Byebug_setup_tracepoints(self);
+    result = Qtrue;
+  }
 
-    if (rb_block_given_p())
-      rb_ensure(rb_yield, self, Byebug_stop, self);
+  if (rb_block_given_p())
+    rb_ensure(rb_yield, self, Byebug_stop, self);
 
-    return result;
+  return result;
 }
 
 static VALUE
 set_current_skipped_status(VALUE status)
 {
   VALUE context_obj;
-  debug_context_t *context;
+  debug_context_t *dc;
 
   context_obj = Byebug_context(mByebug);
-  Data_Get_Struct(context_obj, debug_context_t, context);
+  Data_Get_Struct(context_obj, debug_context_t, dc);
   if (status)
-    CTX_FL_SET(context, CTX_FL_SKIPPED);
+    CTX_FL_SET(dc, CTX_FL_SKIPPED);
   else
-    CTX_FL_UNSET(context, CTX_FL_SKIPPED);
+    CTX_FL_UNSET(dc, CTX_FL_SKIPPED);
   return Qnil;
 }
 
@@ -417,7 +448,7 @@ static VALUE
 Byebug_load(int argc, VALUE *argv, VALUE self)
 {
   VALUE file, stop, context_obj;
-  debug_context_t *context;
+  debug_context_t *dc;
   int state = 0;
 
   if (rb_scan_args(argc, argv, "11", &file, &stop) == 1)
@@ -428,9 +459,11 @@ Byebug_load(int argc, VALUE *argv, VALUE self)
   Byebug_start(self);
 
   context_obj = Byebug_context(self);
-  Data_Get_Struct(context_obj, debug_context_t, context);
-  context->stack_size = 0;
-  if (RTEST(stop)) context->steps = 1;
+  Data_Get_Struct(context_obj, debug_context_t, dc);
+  if (RTEST(stop)) dc->steps = 1;
+
+  /* Resetting stack size */
+  dc->stack_size = 0;
 
   /* Initializing $0 to the script's path */
   ruby_script(RSTRING_PTR(file));
@@ -438,7 +471,7 @@ Byebug_load(int argc, VALUE *argv, VALUE self)
   if (0 != state)
   {
       VALUE errinfo = rb_errinfo();
-      reset_stepping_stop_points(context);
+      reset_stepping_stop_points(dc);
       rb_set_errinfo(Qnil);
       return errinfo;
   }