byebug 0.0.1 → 1.0.0

data/.gitignore

@@ -1,5 +1,7 @@
 tmp
+pkg
 vendor/bundle
+doc
 
 .rvmrc
 .gdbinit
@@ -8,3 +10,5 @@ vendor/bundle
 .tags
 
 Gemfile.lock
+
+lib/byebug.so

data/.travis.yml

@@ -1,8 +1,3 @@
 before_script: rake compile
 rvm:
-- 1.9.2
-- 1.9.3
 - 2.0.0
-matrix:
-  allow_failures:
-  - rvm: 2.0.0

data/CHANGELOG.md

@@ -1,2 +1,8 @@
 ## 0.0.1
+
 * Initial release
+
+
+## 1.0.0
+
+* Green test suite

data/Gemfile

@@ -1,3 +1,3 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec

data/LICENSE

@@ -1,20 +1,23 @@
-Copyright (c) 2013 David Rodríguez
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright (C) 2013  David Rodríguez <deivid.rodriguez@gmail.com>
+All rights reserved.
+ *
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+ *
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/byebug.gemspec

@@ -5,7 +5,7 @@ require File.dirname(__FILE__) + "/lib/byebug/version"
 Gem::Specification.new do |s|
   s.name = %q{byebug}
   s.version = Byebug::VERSION
-  s.authors = ["David Rodríguez"]
+  s.authors = ["David Rodríguez", "Kent Sibilev", "Mark Moseley"]
   s.email = "deivid.rodriguez@mail.com"
   s.homepage = "http://github.com/deivid-rodriguez/byebug"
   s.summary = %q{Ruby 2.0 fast debugger - base + cli}
@@ -13,17 +13,17 @@ Gem::Specification.new do |s|
     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.
-}
+    bindings for stack frames among other things.}
   s.required_rubygems_version = ">= 1.3.6"
   s.extra_rdoc_files = [ "README.md" ]
   s.files = `git ls-files`.split("\n")
   s.extensions << "ext/byebug/extconf.rb"
   s.executables = ["byebug"]
-  s.add_dependency "columnize", ">= 0.3.1"
+  s.add_dependency "columnize", "~> 0.3.6"
   s.add_dependency "debugger-linecache", '~> 1.2.0'
   s.add_development_dependency 'rake', '~> 10.0.3'
   s.add_development_dependency 'rake-compiler', '~> 0.8.3'
   s.add_development_dependency 'mocha', '~> 0.13.3'
-  s.license = "MIT"
+  s.add_development_dependency 'minitest', '~> 4.7.0'
+  s.license = "BSD"
 end

data/ext/byebug/breakpoint.c

@@ -21,34 +21,6 @@ eval_expression(VALUE args)
   return rb_funcall2(rb_mKernel, idEval, 2, RARRAY_PTR(args));
 }
 
-extern VALUE
-catchpoint_hit_count(VALUE catchpoints, VALUE exception, VALUE *exception_name)
-{
-  VALUE ancestors;
-  VALUE expn_class;
-  VALUE aclass;
-  VALUE mod_name;
-  VALUE hit_count;
-  int i;
-
-  if (catchpoints == Qnil /*|| st_get_num_entries(RHASH_TBL(rdebug_catchpoints)) == 0)*/)
-    return Qnil;
-  expn_class = rb_obj_class(exception);
-  ancestors = rb_mod_ancestors(expn_class);
-  for(i = 0; i < RARRAY_LEN(ancestors); i++)
-  {
-    aclass    = rb_ary_entry(ancestors, i);
-    mod_name  = rb_mod_name(aclass);
-    hit_count = rb_hash_aref(catchpoints, mod_name);
-    if(hit_count != Qnil)
-    {
-      *exception_name = mod_name; 
-      return hit_count;
-    }
-  }
-  return Qnil;
-}
-
 static VALUE
 Breakpoint_hit_count(VALUE self)
 {
@@ -81,41 +53,41 @@ Breakpoint_set_hit_value(VALUE self, VALUE value)
 static VALUE
 Breakpoint_hit_condition(VALUE self)
 {
-    breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint;
 
-    Data_Get_Struct(self, breakpoint_t, breakpoint);
-    switch(breakpoint->hit_condition)
-    {
-        case HIT_COND_GE:
-            return ID2SYM(rb_intern("greater_or_equal"));
-        case HIT_COND_EQ:
-            return ID2SYM(rb_intern("equal"));
-        case HIT_COND_MOD:
-            return ID2SYM(rb_intern("modulo"));
-        case HIT_COND_NONE:
-        default:
-            return Qnil;
-    }
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  switch(breakpoint->hit_condition)
+  {
+    case HIT_COND_GE:
+      return ID2SYM(rb_intern("greater_or_equal"));
+    case HIT_COND_EQ:
+      return ID2SYM(rb_intern("equal"));
+    case HIT_COND_MOD:
+      return ID2SYM(rb_intern("modulo"));
+    case HIT_COND_NONE:
+    default:
+      return Qnil;
+  }
 }
 
 static VALUE
 Breakpoint_set_hit_condition(VALUE self, VALUE value)
 {
-    breakpoint_t *breakpoint;
-    ID id_value;
+  breakpoint_t *breakpoint;
+  ID id_value;
 
-    Data_Get_Struct(self, breakpoint_t, breakpoint);
-    id_value = rb_to_id(value);
-
-    if(rb_intern("greater_or_equal") == id_value || rb_intern("ge") == id_value)
-        breakpoint->hit_condition = HIT_COND_GE;
-    else if(rb_intern("equal") == id_value || rb_intern("eq") == id_value)
-        breakpoint->hit_condition = HIT_COND_EQ;
-    else if(rb_intern("modulo") == id_value || rb_intern("mod") == id_value)
-        breakpoint->hit_condition = HIT_COND_MOD;
-    else
-        rb_raise(rb_eArgError, "Invalid condition parameter");
-    return value;
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  id_value = rb_to_id(value);
+
+  if(rb_intern("greater_or_equal") == id_value || rb_intern("ge") == id_value)
+    breakpoint->hit_condition = HIT_COND_GE;
+  else if(rb_intern("equal") == id_value || rb_intern("eq") == id_value)
+    breakpoint->hit_condition = HIT_COND_EQ;
+  else if(rb_intern("modulo") == id_value || rb_intern("mod") == id_value)
+    breakpoint->hit_condition = HIT_COND_MOD;
+  else
+    rb_raise(rb_eArgError, "Invalid condition parameter");
+  return value;
 }
 
 static void
@@ -153,6 +125,7 @@ Breakpoint_initialize(VALUE self, VALUE source, VALUE pos, VALUE expr)
   breakpoint->expr = NIL_P(expr) ? expr : StringValue(expr);
   breakpoint->hit_count = 0;
   breakpoint->hit_value = 0;
+  breakpoint->hit_condition = HIT_COND_NONE;
 
   return Qnil;
 }
@@ -302,47 +275,45 @@ filename_cmp(VALUE source, char *file)
 #endif
 }
 
-/* XXX: Activate */
-/*
 static int
-check_breakpoint_hit_condition(VALUE breakpoint_object)
+check_breakpoint_by_hit_condition(VALUE breakpoint_object)
 {
-    breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint;
 
-    if (breakpoint == 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);
-    breakpoint->hit_count++;
+  breakpoint->hit_count++;
 
-    if (Qtrue != breakpoint->enabled)
-       return 0;
-    switch (breakpoint->hit_condition)
+  if (Qtrue != breakpoint->enabled)
+    return 0;
+
+  switch (breakpoint->hit_condition)
+  {
+    case HIT_COND_NONE:
+      return 1;
+    case HIT_COND_GE:
     {
-        case HIT_COND_NONE:
-            return 1;
-        case HIT_COND_GE:
-        {
-            if (breakpoint->hit_count >= breakpoint->hit_value)
-                return 1;
-            break;
-        }
-        case HIT_COND_EQ:
-        {
-            if (breakpoint->hit_count == breakpoint->hit_value)
-                return 1;
-            break;
-        }
-        case HIT_COND_MOD:
-        {
-            if (breakpoint->hit_count % breakpoint->hit_value == 0)
-                return 1;
-            break;
-        }
+      if (breakpoint->hit_count >= breakpoint->hit_value)
+        return 1;
+      break;
     }
-    return 0;
+    case HIT_COND_EQ:
+    {
+      if (breakpoint->hit_count == breakpoint->hit_value)
+        return 1;
+      break;
+    }
+    case HIT_COND_MOD:
+    {
+      if (breakpoint->hit_count % breakpoint->hit_value == 0)
+        return 1;
+      break;
+    }
+  }
+  return 0;
 }
-*/
 
 static int
 check_breakpoint_by_pos(VALUE breakpoint_object, char *file, int line)
@@ -352,6 +323,7 @@ check_breakpoint_by_pos(VALUE breakpoint_object, char *file, int line)
     if(breakpoint_object == Qnil)
         return 0;
     Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
+
     if (Qtrue != breakpoint->enabled)
         return 0;
     if(breakpoint->type != BP_POS_TYPE)
@@ -367,48 +339,43 @@ static int
 check_breakpoint_by_method(VALUE breakpoint_object, VALUE klass, ID mid,
                            VALUE self)
 {
-    breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint;
 
-    if (breakpoint_object == Qnil)
-        return 0;
-    Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
-    if (!Qtrue == breakpoint->enabled)
-        return 0;
-    if (breakpoint->type != BP_METHOD_TYPE)
-        return 0;
-    if (breakpoint->pos.mid != mid)
-        return 0;
-    if (classname_cmp(breakpoint->source, klass))
-        return 1;
-    if ((rb_type(self) == T_CLASS) &&
-        classname_cmp(breakpoint->source, self))
-        return 1;
+  if (breakpoint_object == Qnil)
+    return 0;
+  Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
+
+  if (!Qtrue == breakpoint->enabled)
+    return 0;
+  if (breakpoint->type != BP_METHOD_TYPE)
+    return 0;
+  if (breakpoint->pos.mid != mid)
     return 0;
+  if (classname_cmp(breakpoint->source, klass))
+    return 1;
+  if ((rb_type(self) == T_CLASS) && classname_cmp(breakpoint->source, self))
+    return 1;
+  return 0;
 }
 
 static int
 check_breakpoint_by_expr(VALUE breakpoint_object, VALUE binding)
 {
-    breakpoint_t *breakpoint;
-    VALUE args, expr_result;
+  breakpoint_t *breakpoint;
+  VALUE args, expr_result;
 
-    if (breakpoint_object == Qnil)
-        return 0;
-    Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
-    if (Qtrue != breakpoint->enabled)
-        return 0;
-    if (NIL_P(breakpoint->expr))
-        return 1;
-    args = rb_ary_new3(2, breakpoint->expr, binding);
-    expr_result = rb_protect(eval_expression, args, 0);
-    return RTEST(expr_result);
-}
+  if (breakpoint_object == Qnil)
+    return 0;
+  Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
 
-//static VALUE
-//Breakpoint_find(VALUE self, VALUE breakpoints, VALUE source, VALUE pos, VALUE binding)
-//{
-//  return breakpoint_find(breakpoints, source, pos, binding);
-//}
+  if (Qtrue != breakpoint->enabled)
+    return 0;
+  if (NIL_P(breakpoint->expr))
+    return 1;
+  args = rb_ary_new3(2, breakpoint->expr, binding);
+  expr_result = rb_protect(eval_expression, args, 0);
+  return RTEST(expr_result);
+}
 
 extern VALUE
 find_breakpoint_by_pos(VALUE breakpoints, VALUE source, VALUE pos,
@@ -425,7 +392,8 @@ find_breakpoint_by_pos(VALUE breakpoints, VALUE source, VALUE pos,
   {
     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_expr(breakpoint_object, binding)   &&
+         check_breakpoint_by_hit_condition(breakpoint_object) )
     {
       return breakpoint_object;
     }
@@ -437,17 +405,18 @@ extern VALUE
 find_breakpoint_by_method(VALUE breakpoints, VALUE klass, ID mid, VALUE binding,
                           VALUE self)
 {
-    VALUE breakpoint_object;
-    int i;
+  VALUE breakpoint_object;
+  int 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) )
-            return breakpoint_object;
-    }
-    return Qnil;
+  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) )
+      return breakpoint_object;
+  }
+  return Qnil;
 }
 
 extern void
@@ -455,7 +424,6 @@ Init_breakpoint(VALUE mByebug)
 {
   breakpoint_max = 0;
   cBreakpoint = rb_define_class_under(mByebug, "Breakpoint", rb_cObject);
-/*  rb_define_singleton_method(cBreakpoint, "find", Breakpoint_find, 4); */
   rb_define_singleton_method(cBreakpoint, "remove", Breakpoint_remove, 2);
   rb_define_method(cBreakpoint, "initialize", Breakpoint_initialize, 3);
   rb_define_method(cBreakpoint, "id", Breakpoint_id, 0);

data/ext/byebug/byebug.c

@@ -4,8 +4,10 @@ static VALUE mByebug; /* Ruby Byebug Module object */
 static VALUE cContext;
 static VALUE cDebugThread;
 
-static VALUE debug = Qfalse;
-static VALUE locker = Qnil;
+static VALUE tracing = Qfalse;
+static VALUE debug   = Qfalse;
+static VALUE locker  = Qnil;
+
 static VALUE contexts;
 static VALUE catchpoints;
 static VALUE breakpoints;
@@ -16,10 +18,6 @@ static VALUE tpReturn;
 static VALUE tpRaise;
 
 static VALUE idAlive;
-static VALUE idAtBreakpoint;
-static VALUE idAtCatchpoint;
-static VALUE idAtLine;
-static VALUE idAtTracing;
 
 static void
 print_debug_info(char *event, VALUE path, VALUE lineno, VALUE method_id,
@@ -87,9 +85,7 @@ check_start_processing(debug_context_t *context, VALUE thread)
 
   while(1)
   {
-    /* halt execution of the current thread if the byebug
-       is activated in another
-    */
+    /* halt execution of the current thread if byebug is activated in another */
     while(locker != Qnil && locker != thread)
     {
       add_to_locked(thread);
@@ -140,11 +136,11 @@ static void
 call_at_line(debug_context_t *context, char *file, int line,
              VALUE context_object, VALUE path, VALUE lineno)
 {
-  CTX_FL_UNSET(context, CTX_FL_STEPPED);
+  CTX_FL_UNSET(context, CTX_FL_ENABLE_BKPT);
   CTX_FL_UNSET(context, CTX_FL_FORCE_MOVE);
   context->last_file = file;
   context->last_line = line;
-  rb_funcall(context_object, idAtLine, 2, path, lineno);
+  rb_funcall(context_object, rb_intern("at_line"), 2, path, lineno);
 }
 
 static void
@@ -154,56 +150,62 @@ process_line_event(VALUE trace_point, void *data)
   VALUE context_object;
   VALUE breakpoint;
   debug_context_t *context;
-  int moved;
+  int moved = 0;
 
   context_object = Byebug_current_context(mByebug);
   Data_Get_Struct(context_object, debug_context_t, context);
   if (!check_start_processing(context, rb_thread_current())) return;
 
-  load_frame_info(trace_point, &path, &lineno, &method_id, &defined_class,
-                               &binding, &self);
+  load_frame_info(
+      trace_point, &path, &lineno, &method_id, &defined_class, &binding, &self);
   if (debug == Qtrue)
-    print_debug_info("line", path, lineno, method_id, defined_class,
-                                                           context->stack_size);
+    print_debug_info(
+      "line", path, lineno, method_id, defined_class, context->stack_size);
 
   update_frame(context_object, RSTRING_PTR(path), FIX2INT(lineno), method_id,
                                defined_class, binding, self);
 
-  moved = context->last_line != FIX2INT(lineno) || context->last_file == NULL ||
-          strcmp(context->last_file, RSTRING_PTR(path)) != 0;
+  if (context->last_line != FIX2INT(lineno) || context->last_file == NULL ||
+       strcmp(context->last_file, RSTRING_PTR(path)))
+  {
+    CTX_FL_SET(context, CTX_FL_ENABLE_BKPT);
+    moved = 1;
+  }
 
-  if (CTX_FL_TEST(context, CTX_FL_TRACING))
-    rb_funcall(context_object, idAtTracing, 2, path, lineno);
+  if (RTEST(tracing))
+    rb_funcall(context_object, rb_intern("at_tracing"), 2, path, lineno);
 
   if (context->dest_frame == -1 || context->stack_size == context->dest_frame)
   {
-      if (moved || !CTX_FL_TEST(context, CTX_FL_FORCE_MOVE))
-          context->stop_next--;
-      if (context->stop_next < 0)
-          context->stop_next = -1;
-      if (moved || (CTX_FL_TEST(context, CTX_FL_STEPPED) && !CTX_FL_TEST(context, CTX_FL_FORCE_MOVE)))
-      {
-          context->stop_line--;
-          CTX_FL_UNSET(context, CTX_FL_STEPPED);
-      }
+    if (moved || !CTX_FL_TEST(context, CTX_FL_FORCE_MOVE)) {
+      context->stop_next = context->stop_next <= 0 ? -1 : context->stop_next-1;
+      context->stop_line = context->stop_line <= 0 ? -1 : context->stop_line-1;
+    }
   }
   else if (context->stack_size < context->dest_frame)
   {
       context->stop_next = 0;
   }
 
-  breakpoint = find_breakpoint_by_pos(breakpoints, path, lineno, binding);
-  if (context->stop_next == 0 || context->stop_line == 0 ||
-      breakpoint != Qnil)
+  if (context->stop_next == 0 || context->stop_line == 0)
   {
     context->stop_reason = CTX_STOP_STEP;
+    reset_stepping_stop_points(context);
+    call_at_line(
+      context, RSTRING_PTR(path), FIX2INT(lineno), context_object, path, lineno);
+  }
+  else if (CTX_FL_TEST(context, CTX_FL_ENABLE_BKPT))
+  {
+    breakpoint = find_breakpoint_by_pos(breakpoints, path, lineno, binding);
     if (breakpoint != Qnil) {
-      rb_funcall(context_object, idAtBreakpoint, 1, breakpoint);
+      context->stop_reason = CTX_STOP_BREAKPOINT;
+      reset_stepping_stop_points(context);
+      rb_funcall(context_object, rb_intern("at_breakpoint"), 1, breakpoint);
+      call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
+                            path, lineno);
     }
-    reset_stepping_stop_points(context);
-    call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
-                 path, lineno);
   }
+
   cleanup(context);
 }
 
@@ -218,7 +220,7 @@ process_return_event(VALUE trace_point, void *data)
   Data_Get_Struct(context_object, debug_context_t, context);
   if (!check_start_processing(context, rb_thread_current())) return;
 
-  if(context->stack_size == context->stop_frame)
+  if (context->stack_size == context->stop_frame)
   {
       context->stop_next = 1;
       context->stop_frame = 0;
@@ -230,9 +232,9 @@ process_return_event(VALUE trace_point, void *data)
     print_debug_info("return", path, lineno, method_id, defined_class,
                                                            context->stack_size);
 
-  // rb_funcall(context_object, idAtReturn, 2, path, lineno);
-
+  //rb_funcall(context_object, idAtReturn, 2, path, lineno);
   pop_frame(context_object);
+
   cleanup(context);
 }
 
@@ -262,7 +264,7 @@ process_call_event(VALUE trace_point, void *data)
                                                       binding, self);
   if (breakpoint != Qnil) {
       context->stop_reason = CTX_STOP_BREAKPOINT;
-      rb_funcall(context_object, idAtBreakpoint, 1, breakpoint);
+      rb_funcall(context_object, rb_intern("at_breakpoint"), 1, breakpoint);
       call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
                  path, lineno);
   }
@@ -275,10 +277,11 @@ process_raise_event(VALUE trace_point, void *data)
 {
   VALUE path, lineno, method_id, defined_class, binding, self;
   VALUE context_object;
-  VALUE hit_count;
-  VALUE exception_name;
+  VALUE expn_class, aclass;
+  VALUE err = rb_errinfo();
+  VALUE ancestors;
   debug_context_t *context;
-  int c_hit_count;
+  int i;
 
   context_object = Byebug_current_context(mByebug);
   Data_Get_Struct(context_object, debug_context_t, context);
@@ -289,28 +292,47 @@ process_raise_event(VALUE trace_point, void *data)
   update_frame(context_object, RSTRING_PTR(path), FIX2INT(lineno), method_id,
                                defined_class, binding, self);
 
-  if (catchpoint_hit_count(catchpoints, rb_errinfo(), &exception_name) != Qnil) {
-    /* On 64-bit systems with gcc and -O2 there seems to be
-       an optimization bug in running INT2FIX(FIX2INT...)..)
-       So we do this in two steps.
-      */
-    c_hit_count = FIX2INT(rb_hash_aref(catchpoints, exception_name)) + 1;
-    hit_count = INT2FIX(c_hit_count);
-    rb_hash_aset(catchpoints, exception_name, hit_count);
-    context->stop_reason = CTX_STOP_CATCHPOINT;
-    rb_funcall(context_object, idAtCatchpoint, 1, rb_errinfo());
-    call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
-                 path, lineno);
+  if (debug == Qtrue)
+    print_debug_info("call", path, lineno, method_id, defined_class,
+                                                           context->stack_size);
+  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);
+    return;
+  }
+
+  ancestors = rb_mod_ancestors(expn_class);
+  for (i = 0; i < RARRAY_LEN(ancestors); i++) {
+    VALUE mod_name;
+    VALUE hit_count;
+
+    aclass    = rb_ary_entry(ancestors, i);
+    mod_name  = rb_mod_name(aclass);
+    hit_count = rb_hash_aref(catchpoints, mod_name);
+
+    if (hit_count != Qnil) {
+      /* increment exception */
+      rb_hash_aset(catchpoints, mod_name, INT2FIX(FIX2INT(hit_count) + 1));
+      context->stop_reason = CTX_STOP_CATCHPOINT;
+      rb_funcall(context_object, rb_intern("at_catchpoint"), 1, rb_errinfo());
+      call_at_line(context, RSTRING_PTR(path), FIX2INT(lineno), context_object,
+                   path, lineno);
+      break;
+    }
   }
 
   cleanup(context);
 }
 
-
 static VALUE
 Byebug_setup_tracepoints(VALUE self)
 {
   if (catchpoints != Qnil) return Qnil;
+
   contexts = rb_hash_new();
   breakpoints = rb_ary_new();
   catchpoints = rb_hash_new();
@@ -436,7 +458,18 @@ Byebug_load(int argc, VALUE *argv, VALUE self)
     return Qnil;
 }
 
+static VALUE
+Byebug_tracing(VALUE self)
+{
+    return tracing;
+}
 
+static VALUE
+Byebug_set_tracing(VALUE self, VALUE value)
+{
+    tracing = RTEST(value) ? Qtrue : Qfalse;
+    return value;
+}
 
 static VALUE
 Byebug_contexts(VALUE self)
@@ -467,34 +500,47 @@ Byebug_catchpoints(VALUE self)
   return catchpoints;
 }
 
+static VALUE
+Byebug_add_catchpoint(VALUE self, VALUE value)
+{
+  if (TYPE(value) != T_STRING)
+    rb_raise(rb_eTypeError, "value of a catchpoint must be String");
+
+  rb_hash_aset(catchpoints, rb_str_dup(value), INT2FIX(0));
+  return value;
+}
+
 /*
  *   Document-class: Byebug
  *
  *   == Summary
  *
- *   This is a singleton class allows controlling the byebug. Use it to start/stop
+ *   This is a singleton class allows controlling byebug. Use it to start/stop
  *   byebug, set/remove breakpoints, etc.
  */
 void
 Init_byebug()
 {
   mByebug = rb_define_module("Byebug");
-  rb_define_module_function(mByebug, "setup_tracepoints", Byebug_setup_tracepoints, 0);
-  rb_define_module_function(mByebug, "remove_tracepoints", Byebug_remove_tracepoints, 0);
-  rb_define_module_function(mByebug, "current_context", Byebug_current_context, 0);
+  rb_define_module_function(mByebug, "setup_tracepoints",
+                                     Byebug_setup_tracepoints, 0);
+  rb_define_module_function(mByebug, "remove_tracepoints",
+                                     Byebug_remove_tracepoints, 0);
+  rb_define_module_function(mByebug, "current_context",
+                                     Byebug_current_context, 0);
   rb_define_module_function(mByebug, "contexts", Byebug_contexts, 0);
   rb_define_module_function(mByebug, "breakpoints", Byebug_breakpoints, 0);
+  rb_define_module_function(mByebug, "add_catchpoint",
+                                     Byebug_add_catchpoint, 1);
   rb_define_module_function(mByebug, "catchpoints", Byebug_catchpoints, 0);
   rb_define_module_function(mByebug, "_start", Byebug_start, 0);
   rb_define_module_function(mByebug, "stop", Byebug_stop, 0);
   rb_define_module_function(mByebug, "started?", Byebug_started, 0);
+  rb_define_module_function(mByebug, "tracing", Byebug_tracing, 0);
+  rb_define_module_function(mByebug, "tracing=", Byebug_set_tracing, 1);
   rb_define_module_function(mByebug, "debug_load", Byebug_load, -1);
 
   idAlive = rb_intern("alive?");
-  idAtBreakpoint = rb_intern("at_breakpoint");
-  idAtCatchpoint = rb_intern("at_catchpoint");
-  idAtTracing    = rb_intern("at_tracing");
-  idAtLine       = rb_intern("at_line");
 
   cContext = Init_context(mByebug);