runger_byebug 11.2.0

data/ext/byebug/byebug.c

@@ -0,0 +1,900 @@
+#include "byebug.h"
+
+static VALUE mByebug; /* Ruby Byebug Module object */
+
+static VALUE tracing = Qfalse;
+static VALUE post_mortem = Qfalse;
+static VALUE verbose = Qfalse;
+
+static VALUE catchpoints = Qnil;
+static VALUE breakpoints = Qnil;
+static VALUE tracepoints = Qnil;
+
+static VALUE raised_exception = Qnil;
+
+static ID idPuts;
+static ID idEmpty;
+
+/* Hash table with active threads and their associated contexts */
+VALUE threads = Qnil;
+
+/*
+ *  call-seq:
+ *    Byebug.breakpoints -> array
+ *
+ *  Returns an array of breakpoints.
+ */
+static VALUE
+Breakpoints(VALUE self)
+{
+  UNUSED(self);
+
+  if (NIL_P(breakpoints))
+    breakpoints = rb_ary_new();
+
+  return breakpoints;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.catchpoints -> hash
+ *
+ *  Returns the catchpoints hash.
+ */
+static VALUE
+Catchpoints(VALUE self)
+{
+  UNUSED(self);
+
+  return catchpoints;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.raised_exception -> exception
+ *
+ *  Returns raised exception when in post_mortem mode.
+ */
+static VALUE
+Raised_exception(VALUE self)
+{
+  UNUSED(self);
+
+  return raised_exception;
+}
+
+#define IS_STARTED (!NIL_P(catchpoints))
+
+static void
+check_started()
+{
+  if (!IS_STARTED)
+  {
+    rb_raise(rb_eRuntimeError, "Byebug is not started yet.");
+  }
+}
+
+static void
+trace_print(rb_trace_arg_t *trace_arg, debug_context_t *dc,
+            const char *file_filter, const char *debug_msg)
+{
+  char *fullpath = NULL;
+  const char *basename;
+  int filtered = 0;
+  const char *event = rb_id2name(SYM2ID(rb_tracearg_event(trace_arg)));
+
+  VALUE rb_path = rb_tracearg_path(trace_arg);
+  const char *path = NIL_P(rb_path) ? "" : RSTRING_PTR(rb_path);
+
+  int line = NUM2INT(rb_tracearg_lineno(trace_arg));
+
+  VALUE rb_mid = rb_tracearg_method_id(trace_arg);
+  const char *mid = NIL_P(rb_mid) ? "(top level)" : rb_id2name(SYM2ID(rb_mid));
+
+  VALUE rb_cl = rb_tracearg_defined_class(trace_arg);
+  VALUE rb_cl_name = NIL_P(rb_cl) ? rb_cl : rb_mod_name(rb_cl);
+  const char *defined_class = NIL_P(rb_cl_name) ? "" : RSTRING_PTR(rb_cl_name);
+
+  if (!trace_arg)
+    return;
+
+  if (file_filter)
+  {
+#ifndef _WIN32
+    fullpath = realpath(path, NULL);
+#endif
+    basename = fullpath ? strrchr(fullpath, '/') : path;
+
+    if (!basename || strncmp(basename + 1, file_filter, strlen(file_filter)))
+      filtered = 1;
+
+#ifndef _WIN32
+    free(fullpath);
+#endif
+  }
+
+  if (!filtered)
+  {
+    if (debug_msg)
+      rb_funcall(mByebug, idPuts, 1,
+                 rb_sprintf("[#%d] %s\n", dc->thnum, debug_msg));
+    else
+      rb_funcall(mByebug, idPuts, 1,
+                 rb_sprintf("%*s [#%d] %s@%s:%d %s#%s\n", dc->calced_stack_size,
+                            "", dc->thnum, event, path, line, defined_class,
+                            mid));
+  }
+}
+
+static void
+cleanup(debug_context_t *dc)
+{
+  dc->stop_reason = CTX_STOP_NONE;
+
+  release_lock();
+}
+
+#define EVENT_TEARDOWN cleanup(dc);
+
+#define EVENT_SETUP                                     \
+  debug_context_t *dc;                                  \
+  VALUE context;                                        \
+  rb_trace_arg_t *trace_arg;                            \
+                                                        \
+  UNUSED(data);                                         \
+                                                        \
+  if (!is_living_thread(rb_thread_current()))           \
+    return;                                             \
+                                                        \
+  thread_context_lookup(rb_thread_current(), &context); \
+  Data_Get_Struct(context, debug_context_t, dc);        \
+                                                        \
+  trace_arg = rb_tracearg_from_tracepoint(trace_point); \
+  if (verbose == Qtrue)                                 \
+    trace_print(trace_arg, dc, 0, 0);                   \
+                                                        \
+  if (CTX_FL_TEST(dc, CTX_FL_IGNORE))                   \
+    return;                                             \
+                                                        \
+  acquire_lock(dc);
+
+
+#define CALL_EVENT_SETUP   \
+  dc->calced_stack_size++; \
+  dc->steps_out = dc->steps_out < 0 ? -1 : dc->steps_out + 1;
+
+#define RETURN_EVENT_SETUP \
+  dc->calced_stack_size--; \
+                           \
+  if (dc->steps_out == 1)  \
+    dc->steps = 1;
+
+#define RETURN_EVENT_TEARDOWN \
+  dc->steps_out = dc->steps_out <= 0 ? -1 : dc->steps_out - 1;
+
+
+/* Functions that return control to byebug after the different events */
+
+static VALUE
+call_at(VALUE ctx, debug_context_t *dc, ID mid, int argc, VALUE arg)
+{
+  struct call_with_inspection_data cwi;
+  VALUE argv[1];
+
+  argv[0] = arg;
+
+  cwi.dc = dc;
+  cwi.ctx = ctx;
+  cwi.id = mid;
+  cwi.argc = argc;
+  cwi.argv = &argv[0];
+
+  return call_with_debug_inspector(&cwi);
+}
+
+static VALUE
+call_at_line(VALUE ctx, debug_context_t *dc)
+{
+  return call_at(ctx, dc, rb_intern("at_line"), 0, Qnil);
+}
+
+static VALUE
+call_at_tracing(VALUE ctx, debug_context_t *dc)
+{
+  return call_at(ctx, dc, rb_intern("at_tracing"), 0, Qnil);
+}
+
+static VALUE
+call_at_breakpoint(VALUE ctx, debug_context_t *dc, VALUE breakpoint)
+{
+  dc->stop_reason = CTX_STOP_BREAKPOINT;
+
+  return call_at(ctx, dc, rb_intern("at_breakpoint"), 1, breakpoint);
+}
+
+static VALUE
+call_at_catchpoint(VALUE ctx, debug_context_t *dc, VALUE exp)
+{
+  dc->stop_reason = CTX_STOP_CATCHPOINT;
+
+  return call_at(ctx, dc, rb_intern("at_catchpoint"), 1, exp);
+}
+
+static VALUE
+call_at_return(VALUE ctx, debug_context_t *dc, VALUE return_value)
+{
+  dc->stop_reason = CTX_STOP_BREAKPOINT;
+
+  return call_at(ctx, dc, rb_intern("at_return"), 1, return_value);
+}
+
+static VALUE
+call_at_end(VALUE ctx, debug_context_t *dc)
+{
+  dc->stop_reason = CTX_STOP_BREAKPOINT;
+
+  return call_at(ctx, dc, rb_intern("at_end"), 0, Qnil);
+}
+
+static void
+call_at_line_check(VALUE ctx, debug_context_t *dc, VALUE breakpoint)
+{
+  dc->stop_reason = CTX_STOP_STEP;
+
+  if (!NIL_P(breakpoint))
+    call_at_breakpoint(ctx, dc, breakpoint);
+
+  byebug_reset_stepping_stop_points(dc);
+
+  call_at_line(ctx, dc);
+}
+
+
+/* TracePoint API event handlers */
+
+static void
+line_event(VALUE trace_point, void *data)
+{
+  VALUE brkpnt, file, line, binding;
+
+  EVENT_SETUP;
+
+  file = rb_tracearg_path(trace_arg);
+  line = rb_tracearg_lineno(trace_arg);
+  binding = rb_tracearg_binding(trace_arg);
+
+  if (RTEST(tracing))
+    call_at_tracing(context, dc);
+
+  if (!CTX_FL_TEST(dc, CTX_FL_IGNORE_STEPS))
+    dc->steps = dc->steps <= 0 ? -1 : dc->steps - 1;
+
+  if (dc->calced_stack_size <= dc->dest_frame)
+  {
+    dc->dest_frame = dc->calced_stack_size;
+    CTX_FL_UNSET(dc, CTX_FL_IGNORE_STEPS);
+
+    dc->lines = dc->lines <= 0 ? -1 : dc->lines - 1;
+  }
+
+  if (dc->steps == 0 || dc->lines == 0)
+    call_at_line_check(context, dc, Qnil);
+  else
+  {
+    brkpnt = Qnil;
+
+    if (!NIL_P(breakpoints))
+      brkpnt = find_breakpoint_by_pos(breakpoints, file, line, binding);
+
+    if (!NIL_P(brkpnt))
+      call_at_line_check(context, dc, brkpnt);
+  }
+
+  EVENT_TEARDOWN;
+}
+
+static void
+call_event(VALUE trace_point, void *data)
+{
+  VALUE brkpnt, klass, msym, mid, binding, self;
+
+  EVENT_SETUP;
+
+  if (dc->calced_stack_size <= dc->dest_frame)
+    CTX_FL_UNSET(dc, CTX_FL_IGNORE_STEPS);
+
+  CALL_EVENT_SETUP;
+
+  msym = rb_tracearg_method_id(trace_arg);
+
+  mid = SYM2ID(msym);
+  klass = rb_tracearg_defined_class(trace_arg);
+  binding = rb_tracearg_binding(trace_arg);
+  self = rb_tracearg_self(trace_arg);
+
+  brkpnt = Qnil;
+
+  if (!NIL_P(breakpoints))
+    brkpnt = find_breakpoint_by_method(breakpoints, klass, mid, binding, self);
+
+  if (!NIL_P(brkpnt))
+  {
+    call_at_breakpoint(context, dc, brkpnt);
+    call_at_line(context, dc);
+  }
+
+  EVENT_TEARDOWN;
+}
+
+static void
+return_event(VALUE trace_point, void *data)
+{
+  VALUE brkpnt, file, line, binding;
+
+  EVENT_SETUP;
+
+  RETURN_EVENT_SETUP;
+
+  if ((dc->steps_out == 0) && (CTX_FL_TEST(dc, CTX_FL_STOP_ON_RET)))
+  {
+    byebug_reset_stepping_stop_points(dc);
+
+    call_at_return(context, dc, rb_tracearg_return_value(trace_arg));
+  }
+  else if (!NIL_P(breakpoints))
+  {
+    file = rb_tracearg_path(trace_arg);
+    /*
+     * @todo Sometimes the TracePoint API gives some return events without
+     * file:line information, so we need to guard for nil until we know what's
+     * going on. This happens, for example, with active_support core extensions:
+     *
+     * [#7] call@.../core_ext/numeric/conversions.rb:124 Fixnum#to_s
+     *  [#7] b_call@.../core_ext/numeric/conversions.rb:124 BigDecimal#to_s
+     *   [#7] line@.../core_ext/numeric/conversions.rb:125 BigDecimal#to_s
+     *   [#7] c_call@.../core_ext/numeric/conversions.rb:125 Kernel#is_a?
+     *    [#7] c_return@.../core_ext/numeric/conversions.rb:125 Kernel#is_a?
+     *   [#7] line@.../core_ext/numeric/conversions.rb:131 BigDecimal#to_s
+     *   [#7] c_call@.../core_ext/numeric/conversions.rb:131 Fixnum#to_default_s
+     *    [#7] c_return@.../core_ext/numeric/conversions.rb:131 Fixnum#to_default_s
+     *   [#7] b_return@/hort/core_ext/numeric/conversions.rb:133 BigDecimal#to_s
+     *  [#7] return@:0 Fixnum#to_s # => This guy...
+     */
+    if (NIL_P(file))
+      rb_warn("The TracePoint API emitted a return event without file information. It might be a bug, please report this.");
+    else
+    {
+      line = rb_tracearg_lineno(trace_arg);
+      binding = rb_tracearg_binding(trace_arg);
+
+      brkpnt = find_breakpoint_by_pos(breakpoints, file, line, binding);
+
+      if (!NIL_P(brkpnt))
+        call_at_return(context, dc, rb_tracearg_return_value(trace_arg));
+    }
+  }
+
+  RETURN_EVENT_TEARDOWN;
+
+  EVENT_TEARDOWN;
+}
+
+static void
+end_event(VALUE trace_point, void *data)
+{
+  EVENT_SETUP;
+
+  RETURN_EVENT_SETUP;
+
+  if ((dc->steps_out == 0) && (CTX_FL_TEST(dc, CTX_FL_STOP_ON_RET)))
+  {
+    byebug_reset_stepping_stop_points(dc);
+
+    call_at_end(context, dc);
+  }
+
+  RETURN_EVENT_TEARDOWN;
+
+  EVENT_TEARDOWN;
+}
+
+static void
+raw_call_event(VALUE trace_point, void *data)
+{
+  EVENT_SETUP;
+
+  CALL_EVENT_SETUP;
+
+  EVENT_TEARDOWN;
+}
+
+static void
+raw_return_event(VALUE trace_point, void *data)
+{
+  EVENT_SETUP;
+
+  RETURN_EVENT_SETUP;
+
+  RETURN_EVENT_TEARDOWN;
+
+  EVENT_TEARDOWN;
+}
+
+static void
+raise_event(VALUE trace_point, void *data)
+{
+  VALUE expn_class, ancestors, pm_context;
+  int i;
+  debug_context_t *new_dc;
+
+  EVENT_SETUP;
+
+  raised_exception = rb_tracearg_raised_exception(trace_arg);
+
+  if (post_mortem == Qtrue && !rb_ivar_defined(raised_exception, rb_intern("@__bb_context")))
+  {
+    pm_context = context_dup(dc);
+    rb_ivar_set(raised_exception, rb_intern("@__bb_context"), pm_context);
+
+    Data_Get_Struct(pm_context, debug_context_t, new_dc);
+    rb_debug_inspector_open(context_backtrace_set, (void *)new_dc);
+  }
+
+  if (NIL_P(catchpoints) || dc->calced_stack_size == 0
+      || RHASH_TBL(catchpoints)->num_entries == 0)
+  {
+    EVENT_TEARDOWN;
+    return;
+  }
+
+  expn_class = rb_obj_class(raised_exception);
+  ancestors = rb_mod_ancestors(expn_class);
+  for (i = 0; i < RARRAY_LENINT(ancestors); i++)
+  {
+    VALUE ancestor_class, module_name, hit_count;
+
+    ancestor_class = rb_ary_entry(ancestors, i);
+    module_name = rb_mod_name(ancestor_class);
+    hit_count = rb_hash_aref(catchpoints, module_name);
+
+    /* increment exception */
+    if (!NIL_P(hit_count))
+    {
+      rb_hash_aset(catchpoints, module_name, INT2FIX(FIX2INT(hit_count) + 1));
+
+      call_at_catchpoint(context, dc, raised_exception);
+      call_at_line(context, dc);
+
+      break;
+    }
+  }
+
+  EVENT_TEARDOWN;
+}
+
+
+/* Setup TracePoint functionality */
+
+static void
+register_tracepoints(VALUE self)
+{
+  int i;
+  VALUE traces = tracepoints;
+
+  UNUSED(self);
+
+  if (NIL_P(traces))
+  {
+    int line_msk = RUBY_EVENT_LINE;
+    int call_msk = RUBY_EVENT_CALL;
+    int ret_msk = RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN;
+    int end_msk = RUBY_EVENT_END;
+    int raw_call_msk = RUBY_EVENT_C_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_CLASS;
+    int raw_ret_msk = RUBY_EVENT_C_RETURN;
+    int raise_msk = RUBY_EVENT_RAISE;
+
+    VALUE tpLine = rb_tracepoint_new(Qnil, line_msk, line_event, 0);
+    VALUE tpCall = rb_tracepoint_new(Qnil, call_msk, call_event, 0);
+    VALUE tpReturn = rb_tracepoint_new(Qnil, ret_msk, return_event, 0);
+    VALUE tpEnd = rb_tracepoint_new(Qnil, end_msk, end_event, 0);
+    VALUE tpCCall = rb_tracepoint_new(Qnil, raw_call_msk, raw_call_event, 0);
+    VALUE tpCReturn = rb_tracepoint_new(Qnil, raw_ret_msk, raw_return_event, 0);
+    VALUE tpRaise = rb_tracepoint_new(Qnil, raise_msk, raise_event, 0);
+
+    traces = rb_ary_new();
+    rb_ary_push(traces, tpLine);
+    rb_ary_push(traces, tpCall);
+    rb_ary_push(traces, tpReturn);
+    rb_ary_push(traces, tpEnd);
+    rb_ary_push(traces, tpCCall);
+    rb_ary_push(traces, tpCReturn);
+    rb_ary_push(traces, tpRaise);
+
+    tracepoints = traces;
+  }
+
+  for (i = 0; i < RARRAY_LENINT(traces); i++)
+    rb_tracepoint_enable(rb_ary_entry(traces, i));
+}
+
+static void
+clear_tracepoints(VALUE self)
+{
+  int i;
+
+  UNUSED(self);
+
+  for (i = RARRAY_LENINT(tracepoints) - 1; i >= 0; i--)
+    rb_tracepoint_disable(rb_ary_entry(tracepoints, i));
+}
+
+
+/* Byebug's Public API */
+
+/*
+ *  call-seq:
+ *    Byebug.contexts -> array
+ *
+ *   Returns an array of all contexts.
+ */
+static VALUE
+Contexts(VALUE self)
+{
+  volatile VALUE list;
+  volatile VALUE new_list;
+  VALUE context;
+  threads_table_t *t_tbl;
+  debug_context_t *dc;
+  int i;
+
+  UNUSED(self);
+
+  check_started();
+
+  new_list = rb_ary_new();
+  list = rb_funcall(rb_cThread, rb_intern("list"), 0);
+
+  for (i = 0; i < RARRAY_LENINT(list); i++)
+  {
+    VALUE thread = rb_ary_entry(list, i);
+
+    thread_context_lookup(thread, &context);
+    rb_ary_push(new_list, context);
+  }
+
+  Data_Get_Struct(threads, threads_table_t, t_tbl);
+  st_clear(t_tbl->tbl);
+
+  for (i = 0; i < RARRAY_LENINT(new_list); i++)
+  {
+    context = rb_ary_entry(new_list, i);
+    Data_Get_Struct(context, debug_context_t, dc);
+    st_insert(t_tbl->tbl, dc->thread, context);
+  }
+
+  return new_list;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.thread_context(thread) -> context
+ *
+ *   Returns context of the thread passed as an argument.
+ */
+static VALUE
+Thread_context(VALUE self, VALUE thread)
+{
+  VALUE context;
+
+  UNUSED(self);
+
+  check_started();
+
+  thread_context_lookup(thread, &context);
+
+  return context;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.current_context -> context
+ *
+ *  Returns the current context.
+ *    <i>Note:</i> Byebug.current_context.thread == Thread.current
+ */
+static VALUE
+Current_context(VALUE self)
+{
+  VALUE context;
+
+  UNUSED(self);
+
+  thread_context_lookup(rb_thread_current(), &context);
+
+  return context;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.started? -> bool
+ *
+ *  Returns +true+ byebug is started.
+ */
+static VALUE
+Started(VALUE self)
+{
+  UNUSED(self);
+
+  return IS_STARTED ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.stop -> bool
+ *
+ *  This method disables byebug. It returns +true+ if byebug was already
+ *  disabled, otherwise it returns +false+.
+ */
+static VALUE
+Stop(VALUE self)
+{
+  UNUSED(self);
+
+  if (IS_STARTED)
+  {
+    clear_tracepoints(self);
+
+    breakpoints = Qnil;
+    catchpoints = Qnil;
+
+    return Qfalse;
+  }
+
+  return Qtrue;
+}
+
+static VALUE
+Stoppable(VALUE self)
+{
+  VALUE context;
+  debug_context_t *dc;
+
+  if (!IS_STARTED)
+    return Qfalse;
+
+  if (!NIL_P(breakpoints) && rb_funcall(breakpoints, idEmpty, 0) == Qfalse)
+    return Qfalse;
+
+  if (!NIL_P(catchpoints) && rb_funcall(catchpoints, idEmpty, 0) == Qfalse)
+    return Qfalse;
+
+  if (post_mortem == Qtrue)
+    return Qfalse;
+
+  if (RTEST(tracing))
+    return Qfalse;
+
+  context = Current_context(self);
+  if (!NIL_P(context))
+  {
+    Data_Get_Struct(context, debug_context_t, dc);
+
+    if (dc->steps > 0)
+      return Qfalse;
+  }
+
+  return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.start -> bool
+ *
+ *  The return value is the value of !Byebug.started? <i>before</i> issuing the
+ *  +start+; That is, +true+ is returned, unless byebug was previously started.
+ */
+static VALUE
+Start(VALUE self)
+{
+  if (IS_STARTED)
+    return Qfalse;
+
+  catchpoints = rb_hash_new();
+
+  threads = create_threads_table();
+
+  register_tracepoints(self);
+
+  return Qtrue;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.debug_load(file, stop = false) -> nil
+ *
+ *  Same as Kernel#load but resets current context's frames.
+ *  +stop+ parameter forces byebug to stop at the first line of code in +file+
+ */
+static VALUE
+Debug_load(int argc, VALUE *argv, VALUE self)
+{
+  VALUE file, stop, context;
+  debug_context_t *dc;
+  VALUE status = Qnil;
+  int state = 0;
+
+  UNUSED(self);
+
+  if (rb_scan_args(argc, argv, "11", &file, &stop) == 1)
+    stop = Qfalse;
+
+  Start(self);
+
+  context = Current_context(self);
+  Data_Get_Struct(context, debug_context_t, dc);
+
+  dc->calced_stack_size = 1;
+
+  if (RTEST(stop))
+    dc->steps = 1;
+
+  rb_load_protect(file, 0, &state);
+  if (0 != state)
+  {
+    status = rb_errinfo();
+    byebug_reset_stepping_stop_points(dc);
+  }
+
+  return status;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.tracing? -> bool
+ *
+ *  Returns +true+ if global tracing is enabled.
+ */
+static VALUE
+Tracing(VALUE self)
+{
+  UNUSED(self);
+
+  return tracing;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.tracing = bool
+ *
+ *  Sets the global tracing flag.
+ */
+static VALUE
+Set_tracing(VALUE self, VALUE value)
+{
+  UNUSED(self);
+
+  tracing = RTEST(value) ? Qtrue : Qfalse;
+  return value;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.verbose? -> bool
+ *
+ *  Returns +true+ if global verbose flag for TracePoint API events is enabled.
+ */
+static VALUE
+Verbose(VALUE self)
+{
+  UNUSED(self);
+
+  return verbose;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.verbose = bool
+ *
+ *  Sets the global verbose flag for TracePoint API events is enabled.
+ */
+static VALUE
+Set_verbose(VALUE self, VALUE value)
+{
+  UNUSED(self);
+
+  verbose = RTEST(value) ? Qtrue : Qfalse;
+  return value;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.post_mortem? -> bool
+ *
+ *  Returns +true+ if post-mortem debugging is enabled.
+ */
+static VALUE
+Post_mortem(VALUE self)
+{
+  UNUSED(self);
+
+  return post_mortem;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.post_mortem = bool
+ *
+ *  Sets post-moterm flag.
+ */
+static VALUE
+Set_post_mortem(VALUE self, VALUE value)
+{
+  UNUSED(self);
+
+  post_mortem = RTEST(value) ? Qtrue : Qfalse;
+  return value;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.add_catchpoint(exception) -> exception
+ *
+ *  Adds a new exception to the catchpoints hash.
+ */
+static VALUE
+Add_catchpoint(VALUE self, VALUE value)
+{
+  UNUSED(self);
+
+  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-module: Byebug
+ *
+ *   == Summary
+ *
+ *   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, "add_catchpoint", Add_catchpoint, 1);
+  rb_define_module_function(mByebug, "breakpoints", Breakpoints, 0);
+  rb_define_module_function(mByebug, "catchpoints", Catchpoints, 0);
+  rb_define_module_function(mByebug, "contexts", Contexts, 0);
+  rb_define_module_function(mByebug, "current_context", Current_context, 0);
+  rb_define_module_function(mByebug, "debug_load", Debug_load, -1);
+  rb_define_module_function(mByebug, "post_mortem?", Post_mortem, 0);
+  rb_define_module_function(mByebug, "post_mortem=", Set_post_mortem, 1);
+  rb_define_module_function(mByebug, "raised_exception", Raised_exception, 0);
+  rb_define_module_function(mByebug, "start", Start, 0);
+  rb_define_module_function(mByebug, "started?", Started, 0);
+  rb_define_module_function(mByebug, "stop", Stop, 0);
+  rb_define_module_function(mByebug, "stoppable?", Stoppable, 0);
+  rb_define_module_function(mByebug, "thread_context", Thread_context, 1);
+  rb_define_module_function(mByebug, "tracing?", Tracing, 0);
+  rb_define_module_function(mByebug, "tracing=", Set_tracing, 1);
+  rb_define_module_function(mByebug, "verbose?", Verbose, 0);
+  rb_define_module_function(mByebug, "verbose=", Set_verbose, 1);
+
+  Init_threads_table(mByebug);
+  Init_byebug_context(mByebug);
+  Init_byebug_breakpoint(mByebug);
+
+  rb_global_variable(&breakpoints);
+  rb_global_variable(&catchpoints);
+  rb_global_variable(&tracepoints);
+  rb_global_variable(&raised_exception);
+  rb_global_variable(&threads);
+
+  idPuts = rb_intern("puts");
+  idEmpty = rb_intern("empty?");
+}