byebug 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db82855de95f0558289aa633b2432e871bf4a3bb
-  data.tar.gz: 805e3ed4d731545dd2a7f5d9a60ecfe4925e4fdd
+  metadata.gz: dc04cc8b68063ec31b6318a54bd88e1d4ee354be
+  data.tar.gz: 070611b0dbc7fcc7f6fa276b588b32297c5d5588
 SHA512:
-  metadata.gz: 5662e984cfcb5562c7afe0ccfcb79b926e19ff8fefbf2cb55fae3f18705650983a5385daf5b1545c9dea85bb6d783a46e9ddc0204f08c3116a66e9cc1522a8f6
-  data.tar.gz: 2fe8c9c5934687b8dfdfccdec322a227a0892662010bc08db4be14ac5af4b49b674868da94773517691e57f6b4f4d3b53794e3c819cd9ccd1979092ed816a21e
+  metadata.gz: 1434e8a81a8f62b6af39ba73ba527c44b77c9219d06760ac36cc392d98de069f007d3a3b65f56c3f4db6b6ae3fcd3034fc660d8d9fa01781f677a53df2538bac
+  data.tar.gz: e679189a446359f9d98b18f086472129826218f57d1e1cc0c8d71fa186c146a917b0efafed1c4cc9a991d88f2390fff41c36d160a8f3a4ab2fb23f1ceacd1b90

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.1.0
+
+* Post mortem support
+
+
 ## 1.0.3
 
 * "autoreload" is set by default now

data/README.md

@@ -5,24 +5,26 @@ A Ruby 2.0 debugger.
 
 ## Install
 
-Just type
+Just type `gem install byebug` or drop `gem 'byebug'` in your Gemfile and run
+`bundle install`.
 
-    $ gem install byebug
 
-or if you use bundler, drop
-
-    gem 'byebug'
-
-in your Gemfile
+## Usage
 
+Simply drop `byebug` wherever you want to start debugging and the execution
+stop there. If you are debugging rails, start the server in normal mode with
+`rails server` and once the execution get to your `byebug` command you will get
+a debugging terminal.
 
-## Usage
 
-Wherever you want to start debugging, simply drop:
+## Configuration
 
-    byebug
+You can automatically load some configurations at startup by dropping them in
+the startup file `.byebugrc`, for example, `set listsize 20`. If you are coming
+from [debugger](https://github.com/cldwalker/debugger), notice however that you
+no longer need `set autolist`, `set autoreload` and `set autoeval` because they
+are default options in byebug.
 
-and the execution will stop and allow you to start debugging.
 
 ## Credits
 

data/Rakefile

@@ -1,7 +1,6 @@
 # -*- Ruby -*-
 require 'rake/testtask'
 require 'rake/extensiontask'
-require 'rubygems/package_task'
 require 'bundler/gem_tasks'
 
 Rake::ExtensionTask.new('byebug')
@@ -18,9 +17,4 @@ end
 
 base_spec = eval(File.read('byebug.gemspec'), binding, 'byebug.gemspec')
 
-# Rake task to build the default package
-Gem::PackageTask.new(base_spec) do |pkg|
-  pkg.need_tar = true
-end
-
 task :default => :test

data/bin/byebug

@@ -13,14 +13,15 @@
 #=== Options
 #
 #<tt>-A | --annotate</tt> <i>level</i>::
-#    Set gdb-style annotation to <i>level</i>, a number.  Additional
-#    information is output automatically when program state is changed. This
-#    can be used by front-ends such as GNU Emacs to post this updated
-#    information without having to poll for it.
+#    Set gdb-style annotation to <i>level</i>, a number.  Additional information
+#    is output automatically when program state is changed. This can be used by
+#    front-ends such as GNU Emacs to post this updated information without
+#    having to poll for it.
 #
 #<tt>--client</tt>::
 #    Connect to a remote byebug. Used with another byebug invocation using
-#    <tt>--server</tt>.  See also <tt>--host</tt> and <tt>--cport</tt> options
+#    <tt>--server</tt>.  See also <tt>--host</tt>, <tt>--port</tt> and
+#    <tt>--cport</tt> options.
 #
 #<tt>--cport=</tt><i>port</i>::
 #    Use port <i>port</i> for access to byebug control.
@@ -28,75 +29,65 @@
 #<tt>-d | --debug</tt>::
 #    Set $DEBUG true.
 #
-#<tt>--emacs</tt>::
-#    Activates full GNU Emacs mode. Is the equivalent of setting the options
-#    <tt>--emacs-basic --annotate=3 --no-stop --no-control --post-mortem</tt>.
-#
-#<tt>--emacs-basic</tt>::
-#     Activates GNU Emacs mode. Byebug prompts are prefaced with two octal 032
-#     characters.
-#
 #<tt>-h | --host=</tt><i>host</i>::
-#     Use host name <i>host</i> for remote debugging.
+#    Use host name <i>host</i> for remote debugging.
+#
+#<tt>--help</tt>::
+#      Show invocation help and exit.
 #
 #<tt>-I | --include</tt> <i>path</i>
-#     Add <i>path</i> to <tt>$LOAD_PATH</tt>
+#    Add <i>path</i> to <tt>$LOAD_PATH</tt>
+#
+#<tt>--keep-frame-binding</tt>::
+#    Keep frame bindings.
 #
 #<tt>-m | --post-mortem</tt>::
-#     Activate post-mortem mode.
+#    Activate post-mortem mode.
 #
 #<tt>--no-control</tt>::
-#      Do not automatically start control thread.
+#    Do not automatically start control thread.
+#
+#<tt>--no-quit</tt>::
+#    Do not quit when script terminates. Instead rerun the program.
 #
 #<tt>--no-stop</tt>::
-#      Do not stop when script is loaded.
+#    Do not stop when script is loaded.
+#
+#<tt>--nx</tt>::
+#    Don’t execute commands found in any initialization files like
+#    <tt>.byebugrc</tt>.
 #
 #<tt>-p | --port=PORT</tt>::
-#      Host name used for remote debugging.
+#    Use port <i>port</i> for remote debugging.
 #
 #<tt>-r | --require</tt><i>script</i>::
-#      Require the library, before executing your script.
-#
-#<tt>--script</tt> <i>file</i>::
-#      Run byebug script file <i>file</i>
-#
-#<tt>-x | --trace</tt>::
-#      Show lines before executing them.
+#    Require the library, before executing your script.
 #
-#<tt>--no-quit</tt>::
-#      Do not quit when script terminates. Instead rerun the program.
+#<tt>-s | --server</tt>::
+#    Listen for remote connections. Another byebug session accesses using the
+#    <tt>--client</tt>  option. See also the <tt>--host</tt>, <tt>--port</tt>
+#    and <tt>--cport</tt> options
 #
-#<tt>--version</tt>::
-#      Show the version number and exit.
-#
-#<tt>--verbose</tt>::
-#      Turn on verbose mode.
+#<tt>--script</tt>=<i>file</i>::
+#    Run script file <i>file</i>
 #
 #<tt>--v</tt>::
-#      Print the version number, then turn on verbose mode if a script name is
-#      given. If no script name is given just exit after printing the version
-#      number.
-#
-#<tt>--nx</tt>::
-#      Don’t execute commands found in any initialization files like
-#      <tt>.byebugrc</tt>.
+#    Print the version number, then turn on verbose mode if a script name is
+#    given. If no script name is given just exit after printing the version
+#    number.
 #
-#<tt>--keep-frame-binding</tt>::
-#      Keep frame bindings.
-#
-#<tt>--script=</tt><i>file</i>::
-#      Name of the script file to run.
+#<tt>--verbose</tt>::
+#    Turn on verbose mode.
 #
-#<tt>-s | --server</tt>::
-#      Listen for remote connections. Another byebug session accesses using the
-#      <tt>--client</tt>  option. See also the <tt>--host</tt>, <tt>--port</tt>
-#      and <tt>--cport</tt> options
+#<tt>--version</tt>::
+#    Show the version number and exit.
 #
 #<tt>-w | --wait</tt>::
 #      Wait for a client connection; implies <tt>-s</tt> option.
 #
-#<tt>--help</tt>::
-#      Show invocation help and exit.
+#<tt>-x | --trace</tt>::
+#    Show lines before executing them.
+#
 
 require 'optparse'
 require 'ostruct'
@@ -140,9 +131,9 @@ end
 options = OpenStruct.new(
   'annotate'           => Byebug.annotate,
   'client'             => false,
-  'control'            => true,
   'cport'              => Byebug::PORT + 1,
   'host'               => nil,
+  'control'            => true,
   'quit'               => true,
   'no_rewrite_program' => false,
   'stop'               => true,
@@ -165,67 +156,37 @@ Usage: #{program} [options] <script.rb> -- <script.rb parameters>
 EOB
     opts.separator ""
     opts.separator "Options:"
-    opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do
-      |annotate|
-        Byebug.annotate = annotate
-    end
-    opts.on("-c", "--client", "Connect to remote byebug") do
-      options.client = true
-    end
-    opts.on("--cport PORT", Integer, "Port used for control commands") do
-      |cport|
-      options.cport = cport
-    end
-    opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
-    opts.on("--emacs LEVEL", Integer,
-            "Activates full Emacs support at annotation level LEVEL") do
-      |level|
-      Byebug.annotate = level.to_i
-      ENV['EMACS'] = '1'
-      ENV['COLUMNS'] = '120' if ENV['COLUMNS'].to_i < 120
-      options.control = false
-      options.quit = false
-    end
-    opts.on('--emacs-basic', 'Activates basic Emacs mode') do
-      ENV['EMACS'] = '1'
-    end
-    opts.on('-h', '--host HOST', 'Host name used for remote debugging') do
-      |host|
-      options.host = host
-    end
-    opts.on('-I', '--include PATH', String, 'Add PATH to $LOAD_PATH') do |path|
-      $LOAD_PATH.unshift(path)
-    end
-    opts.on('--no-control', 'Do not automatically start control thread') do
-      options.control = false
-    end
-    opts.on('--no-quit', 'Do not quit when script finishes') do
-      options.quit = false
-    end
-    opts.on('--no-rewrite-program',
-            'Do not set $0 to the program being debugged') do
-      options.no_rewrite_program = true
-    end
-    opts.on('--no-stop', 'Do not stop when script is loaded') do
-      options.stop = false
-    end
-    opts.on('-nx', 'Not run byebug initialization files (e.g. .byebugrc') do
-      options.nx = true
-    end
-    opts.on('-p', '--port PORT', Integer, 'Port used for remote debugging') do
-      |port|
-      options.port = port
-    end
-    opts.on('-r', '--require SCRIPT', String,
-            'Require the library, before executing your script') do |name|
-      if name == 'debug'
-        puts "byebug is not compatible with Ruby's 'debug' library. This option is ignored."
+    opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") {
+      |annotate| Byebug.annotate = annotate }
+    opts.on("-c", "--client", "Connect to remote byebug") {
+      options.client = true }
+    opts.on("--cport PORT", Integer, "Port used for control commands") {
+      |cport| options.cport = cport }
+    opts.on("-d", "--debug", "Set $DEBUG=true") {
+      $DEBUG = true }
+    opts.on('-h', '--host HOST', 'Host name used for remote debugging') {
+      |host| options.host = host }
+    opts.on('-I', '--include PATH', String, 'Add PATH to $LOAD_PATH') {
+      |path| $LOAD_PATH.unshift(path) }
+    opts.on('--no-control', 'Do not automatically start control thread') {
+      options.control = false }
+    opts.on('--no-quit', 'Do not quit when script finishes') {
+      options.quit = false }
+    opts.on('--no-rewrite-program', 'Don\'t set $0 to the program debugged') {
+      options.no_rewrite_program = true }
+    opts.on('--no-stop', 'Do not stop when script is loaded') {
+      options.stop = false }
+    opts.on('-nx', 'Don\'t run any byebug initialization files') {
+      options.nx = true }
+    opts.on('-p', '--port PORT', Integer, 'Port used for remote debugging') {
+      |port| options.port = port }
+    opts.on('-r', '--require SCRIPT', String, 'Require library before script') {
+      |name| if name == 'debug'
+        puts 'byebug not compatible with Ruby\'s \'debug\' lib, option ignored'
       else
         require name
-      end
-    end
-    opts.on('--restart-script FILE', String,
-            'Name of the script file to run. Erased after read') do
+      end }
+    opts.on('--restart-script FILE', String, 'Name of the script file to run. Erased after read') do
       |restart_script|
       options.restart_script = restart_script
       unless File.exists?(options.restart_script)
@@ -241,21 +202,19 @@ EOB
         exit
       end
     end
-    opts.on('-s', '--server', 'Listen for remote connections') do
-      options.server = true
-    end
-    opts.on('-w', '--wait', 'Wait for a client connection, implies -s option') do
-      options.wait = true
-    end
-    opts.on('-x', '--trace', 'Turn on line tracing') {options.tracing = true}
+    opts.on('-s', '--server', 'Listen for remote connections') {
+      options.server = true }
+    opts.on('-w', '--wait', 'Wait for a client connection, implies -s option') {
+      options.wait = true }
+    opts.on('-x', '--trace', 'Turn on line tracing') {
+      options.tracing = true }
     opts.separator ''
     opts.separator 'Common options:'
     opts.on_tail('--help', 'Show this message') do
       puts opts
       exit
     end
-    opts.on_tail('--version',
-                 'Print the version') do
+    opts.on_tail('--version', 'Print program version') do
       puts "byebug #{Byebug::VERSION}"
       exit
     end
@@ -263,8 +222,7 @@ EOB
       $VERBOSE = true
       options.verbose_long = true
     end
-    opts.on_tail('-v',
-                 'Print version number, then turn on verbose mode') do
+    opts.on_tail('-v', 'Print version number, then turn on verbose mode') do
       puts "byebug #{Byebug::VERSION}"
       $VERBOSE = true
     end
@@ -274,16 +232,10 @@ end
 
 # What file is used for byebug startup commands.
 unless defined?(OPTS_INITFILE)
-  if RUBY_PLATFORM =~ /mswin/
-    # Of course MS Windows has to be different
-    OPTS_INITFILE = 'rdbopt.ini'
-    HOME_DIR =  (ENV['HOME'] ||
-                 ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
-  else
-    OPTS_INITFILE = '.rdboptrc'
-    HOME_DIR = ENV['HOME'].to_s
-  end
+  OPTS_INITFILE = '.byebugoptrc'
+  HOME_DIR = ENV['HOME'].to_s
 end
+
 begin
   initfile = File.join(HOME_DIR, OPTS_INITFILE)
   eval(File.read(initfile)) if File.exist?(initfile)
@@ -294,9 +246,6 @@ opts = process_options(options)
 begin
   Byebug::ARGV = ARGV.clone if not defined? Byebug::ARGV
   byebug_path = File.expand_path($0)
-  if RUBY_PLATFORM =~ /mswin/
-    byebug_path += '.cmd' unless byebug_path =~ /\.cmd$/i
-  end
   Byebug::BYEBUG_SCRIPT = byebug_path
   Byebug::INITIAL_DIR = Dir.pwd
   opts.parse! ARGV
@@ -330,9 +279,7 @@ else
   Byebug.wait_connection = options.wait
 
   if options.server
-    # start remote mode
     Byebug.start_remote(options.host, [options.port, options.cport]) do
-      # load initrc script
       Byebug.run_init_script(StringIO.new) unless options.nx
     end
     debug_program(options)

data/ext/byebug/byebug.c

@@ -4,9 +4,10 @@ static VALUE mByebug; /* Ruby Byebug Module object */
 static VALUE cContext;
 static VALUE cDebugThread;
 
-static VALUE tracing = Qfalse;
-static VALUE debug   = Qfalse;
-static VALUE locker  = Qnil;
+static VALUE tracing     = Qfalse;
+static VALUE post_mortem = Qfalse;
+static VALUE debug       = Qfalse;
+static VALUE locker      = Qnil;
 
 static VALUE contexts;
 static VALUE catchpoints;
@@ -14,11 +15,11 @@ static VALUE breakpoints;
 
 static VALUE tpLine;
 static VALUE tpCall;
+static VALUE tpCCall;
 static VALUE tpReturn;
+static VALUE tpCReturn;
 static VALUE tpRaise;
 
-static VALUE idAlive;
-
 static VALUE
 tp_inspect(VALUE trace_point) {
   rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(trace_point);
@@ -59,7 +60,7 @@ Byebug_thread_context(VALUE self, VALUE thread)
 
   context = rb_hash_aref(contexts, thread);
   if (context == Qnil) {
-    context = context_create(thread, cDebugThread);
+    context = Context_create(thread, cDebugThread);
     rb_hash_aset(contexts, thread, context);
   }
   return context;
@@ -71,11 +72,13 @@ Byebug_current_context(VALUE self)
   return Byebug_thread_context(self, rb_thread_current());
 }
 
+/*
 static int
 remove_dead_threads(VALUE thread, VALUE context, VALUE ignored)
 {
   return (IS_THREAD_ALIVE(thread)) ? ST_CONTINUE : ST_DELETE;
 }
+*/
 
 static void
 cleanup(debug_context_t *context)
@@ -96,9 +99,7 @@ cleanup(debug_context_t *context)
 static int
 check_start_processing(debug_context_t *context, VALUE thread)
 {
-  /* return if thread is marked as 'ignored'.
-    byebug's threads are marked this way
-  */
+  /* return if thread is marked as 'ignored' */
   if(CTX_FL_TEST(context, CTX_FL_IGNORE)) return 0;
 
   while(1)
@@ -161,26 +162,32 @@ call_at_line(debug_context_t *context, char *file, int line,
   rb_funcall(context_object, rb_intern("at_line"), 2, path, lineno);
 }
 
+#define EVENT_SETUP                                                        \
+  VALUE path, lineno, method_id, defined_class, binding, self;             \
+  VALUE context_object;                                                    \
+  debug_context_t *context;                                                \
+  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);                           \
+  if (debug == Qtrue)                                                      \
+    printf("%s (stack_size: %d)\n",                                        \
+            RSTRING_PTR(tp_inspect(trace_point)), context->stack_size);    \
+
 static void
 process_line_event(VALUE trace_point, void *data)
 {
-  VALUE path, lineno, method_id, defined_class, binding, self;
-  VALUE context_object;
+  EVENT_SETUP;
   VALUE breakpoint;
-  debug_context_t *context;
   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);
-  if (debug == Qtrue)
-    printf("%s (stack_size: %d)\n", RSTRING_PTR(tp_inspect(trace_point)),
-                                    context->stack_size);
-  update_frame(context_object, RSTRING_PTR(path), FIX2INT(lineno), method_id,
-                               defined_class, binding, self);
+  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);
 
   if (context->last_line != FIX2INT(lineno) || context->last_file == NULL ||
        strcmp(context->last_file, RSTRING_PTR(path)))
@@ -227,52 +234,48 @@ process_line_event(VALUE trace_point, void *data)
 }
 
 static void
-process_return_event(VALUE trace_point, void *data)
+process_c_return_event(VALUE trace_point, void *data)
 {
-  VALUE path, lineno, method_id, defined_class, binding, self;
-  VALUE context_object;
-  debug_context_t *context;
+  EVENT_SETUP;
 
-  context_object = Byebug_current_context(mByebug);
-  Data_Get_Struct(context_object, debug_context_t, context);
-  if (!check_start_processing(context, rb_thread_current())) return;
+  pop_frame(context);
 
-  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);
+  cleanup(context);
+}
+
+static void
+process_return_event(VALUE trace_point, void *data)
+{
+  EVENT_SETUP;
 
   if (context->stack_size == context->stop_frame)
   {
       context->stop_next = 1;
       context->stop_frame = 0;
   }
+  pop_frame(context);
+
+  cleanup(context);
+}
 
-  pop_frame(context_object);
+static void
+process_c_call_event(VALUE trace_point, void *data)
+{
+  EVENT_SETUP;
 
+  push_frame(context, RSTRING_PTR(path), FIX2INT(lineno), method_id,
+                      defined_class, binding, self);
   cleanup(context);
 }
 
 static void
 process_call_event(VALUE trace_point, void *data)
 {
-  VALUE path, lineno, method_id, defined_class, binding, self;
-  VALUE context_object;
+  EVENT_SETUP;
   VALUE breakpoint;
-  debug_context_t *context;
 
-  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);
-  if (debug == Qtrue)
-    printf("%s (stack_size: %d)\n", RSTRING_PTR(tp_inspect(trace_point)),
-                                    context->stack_size);
-  push_frame(context_object, RSTRING_PTR(path), FIX2INT(lineno), method_id,
-                             defined_class, binding, self);
+  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),
@@ -290,30 +293,27 @@ process_call_event(VALUE trace_point, void *data)
 static void
 process_raise_event(VALUE trace_point, void *data)
 {
-  VALUE path, lineno, method_id, defined_class, binding, self;
-  VALUE context_object;
+  EVENT_SETUP;
   VALUE expn_class, aclass;
   VALUE err = rb_errinfo();
   VALUE ancestors;
-  debug_context_t *context;
   int i;
 
-  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);
-  if (debug == Qtrue)
-    printf("%s (stack_size: %d)\n", RSTRING_PTR(tp_inspect(trace_point)),
-                                    context->stack_size);
-  update_frame(context_object, RSTRING_PTR(path), FIX2INT(lineno), method_id,
+  update_frame(context->stack, RSTRING_PTR(path), FIX2INT(lineno), method_id,
                                defined_class, binding, self);
 
+  if (post_mortem == Qtrue && self)
+  {
+    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));
+  }
+
   expn_class = rb_obj_class(err);
 
-  if (catchpoints == Qnil ||
-      context->stack_size == 0 ||
+  if (catchpoints == Qnil || context->stack_size == 0 ||
       CTX_FL_TEST(context, CTX_FL_CATCHING) ||
       RHASH_TBL(catchpoints)->num_entries == 0) {
     cleanup(context);
@@ -353,22 +353,34 @@ Byebug_setup_tracepoints(VALUE self)
   catchpoints = rb_hash_new();
 
   tpLine = rb_tracepoint_new(Qnil,
-      RUBY_EVENT_LINE,
-      process_line_event, NULL);
-  rb_tracepoint_enable(tpLine);
+    RUBY_EVENT_LINE,
+    process_line_event, NULL);
+
+  tpCall = rb_tracepoint_new(Qnil,
+    RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_CLASS,
+    process_call_event, NULL);
+
+  tpCCall = rb_tracepoint_new(Qnil,
+    RUBY_EVENT_C_CALL,
+    process_c_call_event, NULL);
 
   tpReturn = rb_tracepoint_new(Qnil,
-      RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_END,
-      process_return_event, NULL);
-  rb_tracepoint_enable(tpReturn);
+    RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_END,
+    process_return_event, NULL);
 
-  tpCall = rb_tracepoint_new(Qnil,
-      RUBY_EVENT_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_CLASS,
-      process_call_event, NULL);
-  rb_tracepoint_enable(tpCall);
+  tpCReturn = rb_tracepoint_new(Qnil,
+    RUBY_EVENT_C_RETURN,
+    process_c_return_event, NULL);
 
   tpRaise = rb_tracepoint_new(Qnil,
-      RUBY_EVENT_RAISE, process_raise_event, NULL);
+    RUBY_EVENT_RAISE,
+    process_raise_event, NULL);
+
+  rb_tracepoint_enable(tpLine);
+  rb_tracepoint_enable(tpCall);
+  rb_tracepoint_enable(tpCCall);
+  rb_tracepoint_enable(tpReturn);
+  rb_tracepoint_enable(tpCReturn);
   rb_tracepoint_enable(tpRaise);
 
   return Qnil;
@@ -381,14 +393,30 @@ Byebug_remove_tracepoints(VALUE self)
   breakpoints = Qnil;
   catchpoints = Qnil;
 
-  if (tpLine != Qnil) rb_tracepoint_disable(tpLine);
-  tpLine = Qnil;
-  if (tpReturn != Qnil) rb_tracepoint_disable(tpReturn);
-  tpReturn = Qnil;
-  if (tpCall != Qnil) rb_tracepoint_disable(tpCall);
-  tpCall = Qnil;
-  if (tpRaise != Qnil) rb_tracepoint_disable(tpRaise);
-  tpRaise = 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;
 }
 
@@ -399,16 +427,17 @@ values_i(VALUE key, VALUE value, VALUE ary)
     return ST_CONTINUE;
 }
 
+#define BYEBUG_STARTED (catchpoints != Qnil)
 static VALUE
 Byebug_started(VALUE self)
 {
-  return catchpoints != Qnil ? Qtrue : Qfalse;
+  return BYEBUG_STARTED;
 }
 
 static VALUE
 Byebug_stop(VALUE self)
 {
-    if (Byebug_started(self))
+    if (BYEBUG_STARTED)
     {
         Byebug_remove_tracepoints(self);
         return Qfalse;
@@ -421,7 +450,7 @@ Byebug_start(VALUE self)
 {
     VALUE result;
 
-    if (Byebug_started(self))
+    if (BYEBUG_STARTED)
         result = Qfalse;
     else
     {
@@ -435,6 +464,21 @@ Byebug_start(VALUE self)
     return result;
 }
 
+static VALUE
+set_current_skipped_status(VALUE status)
+{
+  VALUE context_object;
+  debug_context_t *context;
+
+  context_object = Byebug_current_context(mByebug);
+  Data_Get_Struct(context_object, debug_context_t, context);
+  if (status)
+    CTX_FL_SET(context, CTX_FL_SKIPPED);
+  else
+    CTX_FL_UNSET(context, CTX_FL_SKIPPED);
+  return Qnil;
+}
+
 static VALUE
 Byebug_load(int argc, VALUE *argv, VALUE self)
 {
@@ -466,24 +510,65 @@ Byebug_load(int argc, VALUE *argv, VALUE self)
         return errinfo;
     }
 
-    /* We should run all at_exit handler's in order to provide, 
-     * for instance, a chance to run all defined test cases */
+    /* We should run all at_exit handler's in order to provide, for instance, a
+     * chance to run all defined test cases */
     rb_exec_end_proc();
 
     return Qnil;
 }
 
+static VALUE
+debug_at_exit_c(VALUE proc)
+{
+  return rb_funcall(proc, rb_intern("call"), 0);
+}
+
+static void
+debug_at_exit_i(VALUE proc)
+{
+  if (BYEBUG_STARTED)
+  {
+    set_current_skipped_status(Qtrue);
+    rb_ensure(debug_at_exit_c, proc, set_current_skipped_status, Qfalse);
+  }
+  else
+    debug_at_exit_c(proc);
+}
+
+static VALUE
+Byebug_at_exit(VALUE self)
+{
+  VALUE proc;
+  if (!rb_block_given_p()) rb_raise(rb_eArgError, "called without a block");
+  proc = rb_block_proc();
+  rb_set_end_proc(debug_at_exit_i, proc);
+  return proc;
+}
+
 static VALUE
 Byebug_tracing(VALUE self)
 {
-    return tracing;
+  return tracing;
 }
 
 static VALUE
 Byebug_set_tracing(VALUE self, VALUE value)
 {
-    tracing = RTEST(value) ? Qtrue : Qfalse;
-    return value;
+  tracing = RTEST(value) ? Qtrue : Qfalse;
+  return value;
+}
+
+static VALUE
+Byebug_post_mortem(VALUE self)
+{
+  return post_mortem;
+}
+
+static VALUE
+Byebug_set_post_mortem(VALUE self, VALUE value)
+{
+  post_mortem = RTEST(value) ? Qtrue : Qfalse;
+  return value;
 }
 
 static VALUE
@@ -494,7 +579,7 @@ Byebug_contexts(VALUE self)
   ary = rb_ary_new();
 
   /* check that all contexts point to alive threads */
-  rb_hash_foreach(contexts, remove_dead_threads, 0);
+  /*rb_hash_foreach(contexts, remove_dead_threads, self);*/
 
   rb_hash_foreach(contexts, values_i, ary);
 
@@ -551,11 +636,12 @@ Init_byebug()
   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_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?");
+  rb_define_module_function(mByebug, "debug_at_exit", Byebug_at_exit, 0);
+  rb_define_module_function(mByebug, "post_mortem?", Byebug_post_mortem, 0);
+  rb_define_module_function(mByebug, "post_mortem=", Byebug_set_post_mortem, 1);
 
   cContext = Init_context(mByebug);