byebug 1.8.2 → 2.0.0

data/ext/byebug/extconf.rb

@@ -9,7 +9,7 @@ end
 
 if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
   $CFLAGS = '-Wall -Werror'
-  $CFLAGS += ' -g3' if ENV['debug']
+  $CFLAGS += ' -gdwarf-2 -g3' if ENV['debug']
 end
 
 dir_config("ruby")

data/ext/byebug/locker.c

@@ -0,0 +1,54 @@
+#include <byebug.h>
+
+typedef struct locked_thread_t {
+  VALUE thread;
+  struct locked_thread_t *next;
+} locked_thread_t;
+
+static locked_thread_t *locked_head = NULL;
+static locked_thread_t *locked_tail = NULL;
+
+extern int
+is_in_locked(VALUE thread)
+{
+  locked_thread_t *node;
+
+  if (!locked_head) return 0;
+
+  for (node = locked_head; node != locked_tail; node = node->next)
+  {
+    if (node->thread == thread) return 1;
+  }
+  return 0;
+}
+
+extern void
+add_to_locked(VALUE thread)
+{
+  locked_thread_t *node;
+
+  if (is_in_locked(thread)) return;
+
+  node = ALLOC(locked_thread_t);
+  node->thread = thread;
+  node->next = NULL;
+  if (locked_tail) locked_tail->next = node;
+  locked_tail = node;
+  if (!locked_head) locked_head = node;
+}
+
+extern VALUE
+remove_from_locked()
+{
+  VALUE thread;
+  locked_thread_t *node;
+
+  if (locked_head == NULL) return Qnil;
+
+  node = locked_head;
+  locked_head = locked_head->next;
+  if (locked_tail == node) locked_tail = NULL;
+  thread = node->thread;
+  xfree(node);
+  return thread;
+}

data/ext/byebug/threads.c

@@ -0,0 +1,113 @@
+#include <byebug.h>
+
+static int
+t_tbl_mark_keyvalue(st_data_t key, st_data_t value, st_data_t tbl)
+{
+  VALUE thread = (VALUE)key;
+
+  if (!value) return ST_CONTINUE;
+
+  rb_gc_mark((VALUE)value);
+  rb_gc_mark(thread);
+
+  return ST_CONTINUE;
+}
+
+static void
+t_tbl_mark(void* data)
+{
+  threads_table_t *t_tbl = (threads_table_t *)data;
+  st_table *tbl = t_tbl->tbl;
+  st_foreach(tbl, t_tbl_mark_keyvalue, (st_data_t)tbl);
+}
+
+static void
+t_tbl_free(void* data)
+{
+  threads_table_t *t_tbl = (threads_table_t*)data;
+  st_free_table(t_tbl->tbl);
+  xfree(t_tbl);
+}
+
+VALUE
+threads_create(void)
+{
+  threads_table_t *t_tbl;
+
+  t_tbl = ALLOC(threads_table_t);
+  t_tbl->tbl = st_init_numtable();
+  return Data_Wrap_Struct(cThreadsTable, t_tbl_mark, t_tbl_free, t_tbl);
+}
+
+void
+threads_clear(VALUE table)
+{
+  threads_table_t *t_tbl;
+
+  Data_Get_Struct(table, threads_table_t, t_tbl);
+  st_clear(t_tbl->tbl);
+}
+
+static int
+is_living_thread(VALUE thread)
+{
+  return rb_funcall(thread, rb_intern("alive?"), 0) == Qtrue;
+}
+
+static int
+t_tbl_check_i(st_data_t key, st_data_t value, st_data_t dummy)
+{
+  VALUE thread;
+
+  if (!value) return ST_DELETE;
+
+  thread = (VALUE)key;
+
+  if (!is_living_thread(thread)) return ST_DELETE;
+
+  return ST_CONTINUE;
+}
+
+void
+check_thread_contexts(void)
+{
+  threads_table_t *t_tbl;
+
+  Data_Get_Struct(threads, threads_table_t, t_tbl);
+  st_foreach(t_tbl->tbl, t_tbl_check_i, 0);
+}
+
+void
+thread_context_lookup(VALUE thread, VALUE *context)
+{
+  threads_table_t *t_tbl;
+
+  Data_Get_Struct(threads, threads_table_t, t_tbl);
+  if (!st_lookup(t_tbl->tbl, thread, context) || !*context)
+  {
+    *context = context_create(thread);
+    st_insert(t_tbl->tbl, thread, *context);
+  }
+}
+
+void
+halt_while_other_thread_is_active(debug_context_t *dc)
+{
+  while (1)
+  {
+    /* halt execution of current thread if debugger is activated in another */
+    while (locker != Qnil && locker != rb_thread_current())
+    {
+      add_to_locked(rb_thread_current());
+      rb_thread_stop();
+    }
+
+    /* stop the current thread if it's marked as suspended */
+    if (CTX_FL_TEST(dc, CTX_FL_SUSPEND) && locker != rb_thread_current())
+    {
+      CTX_FL_SET(dc, CTX_FL_WAS_RUNNING);
+      rb_thread_stop();
+    }
+    else break;
+  }
+}

data/lib/byebug.rb

@@ -29,9 +29,6 @@ module Byebug
     attr_accessor :last_exception
     Byebug.last_exception = nil
 
-    # gdb-style annotation mode. Used in GNU Emacs interface
-    attr_accessor :annotate
-
     def source_reload
       Object.send(:remove_const, "SCRIPT_LINES__") if
         Object.const_defined?("SCRIPT_LINES__")
@@ -39,8 +36,11 @@ module Byebug
       LineCache::clear_file_cache
     end
 
+    #
     # Get line +line_number+ from file named +filename+.
+    #
     # @return "\n" if there was a problem. Leaking blanks are stripped off.
+    #
     def line_at(filename, line_number)
       @@autoreload = nil unless defined?(@@autoreload)
       line = LineCache::getline filename, line_number, @@autoreload
@@ -48,11 +48,13 @@ module Byebug
       return "#{line.gsub(/^\s+/, '').chomp}"
     end
 
-    alias stop remove_tracepoints
-
+    #
+    # Add a new breakpoint
+    #
     # @param [String] file
     # @param [Fixnum] line
     # @param [String] expr
+    #
     def add_breakpoint(file, line, expr=nil)
       breakpoint = Breakpoint.new(file, line, expr)
       breakpoints << breakpoint
@@ -104,16 +106,12 @@ module Byebug
         Byebug.const_set('INITIAL_DIR', Dir.pwd) unless defined? Byebug::INITIAL_DIR
       end
       Byebug.tracing = options[:tracing] unless options[:tracing].nil?
-      if Byebug.started?
-        retval = block && block.call(self)
-      else
-        retval = Byebug._start(&block)
-      end
+      retval = Byebug._start(&block)
       post_mortem if options[:post_mortem]
       return retval
     end
 
-    ##
+    #
     # Runs normal byebug initialization scripts.
     #
     # Reads and executes the commands from init file (if any) in the current
@@ -132,7 +130,7 @@ module Byebug
       end
     end
 
-    ##
+    #
     # Runs a script file
     #
     def run_script(file, out = handler.interface, verbose=false)
@@ -141,7 +139,7 @@ module Byebug
       processor.process_commands(verbose)
     end
 
-    ##
+    #
     # Activates the post-mortem mode. There are two ways of using it:
     #
     # == Global post-mortem mode
@@ -185,70 +183,33 @@ module Byebug
     end
 
     def handle_post_mortem(exp)
-      return if !exp || !exp.__debug_context ||
-        exp.__debug_context.stack_size == 0
+      return if !exp || !exp.__bb_context || exp.__bb_context.stack_size == 0
       orig_tracing = Byebug.tracing?
       Byebug.tracing = false
       Byebug.last_exception = exp
-      handler.at_line(exp.__debug_context, exp.__debug_file, exp.__debug_line)
+      handler.at_line(exp.__bb_context, exp.__bb_file, exp.__bb_line)
     ensure
       Byebug.tracing = orig_tracing
     end
     private :handle_post_mortem
-
   end
 end
 
 class Exception
-  attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_context
-end
-
-class Module
-  #
-  # Wraps the +meth+ method with Byebug.start {...} block.
-  #
-  def debug_method(meth)
-    old_meth = "__debugee_#{meth}"
-    old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
-    alias_method old_meth.to_sym, meth
-    class_eval <<-EOD
-    def #{meth}(*args, &block)
-      Byebug.start do
-        byebug 2
-        #{old_meth}(*args, &block)
-      end
-    end
-    EOD
-  end
-
-  #
-  # Wraps the +meth+ method with Byebug.post_mortem {...} block.
-  #
-  def post_mortem_method(meth)
-    old_meth = "__postmortem_#{meth}"
-    old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
-    alias_method old_meth.to_sym, meth
-    class_eval <<-EOD
-    def #{meth}(*args, &block)
-      Byebug.start do |dbg|
-        dbg.post_mortem do
-          #{old_meth}(*args, &block)
-        end
-      end
-    end
-    EOD
-  end
+  attr_reader :__bb_file, :__bb_line, :__bb_binding, :__bb_context
 end
 
 module Kernel
-  ##
+  #
   # Enters byebug after _steps_into_ line events and _steps_out_ return events
   # occur. Before entering byebug startup, the init script is read.
   #
   def byebug(steps_into = 1, steps_out = 2)
     Byebug.start
     Byebug.run_init_script(StringIO.new)
-    Byebug.context.stop_return steps_out if steps_out >= 1
-    Byebug.context.step_into steps_into if steps_into >= 0
+    if Byebug.current_context.stack_size > 2
+      Byebug.current_context.stop_return steps_out if steps_out >= 1
+    end
+    Byebug.current_context.step_into steps_into if steps_into >= 0
   end
 end

data/lib/byebug/command.rb

@@ -5,7 +5,7 @@ require_relative 'helper'
 module Byebug
 
   module CommandFunctions
-    ##
+    #
     # Pad a string with dots at the end to fit :width setting
     #
     def pad_with_dots(string)
@@ -15,13 +15,8 @@ module Byebug
     end
   end
 
-  # Root dir for byebug
-  BYEBUG_DIR = File.expand_path(File.dirname(__FILE__)) unless
-    defined?(BYEBUG_DIR)
-
   class Command
-    SubcmdStruct = Struct.new(:name, :min, :short_help, :long_help) unless
-      defined?(SubcmdStruct)
+    Subcmd = Struct.new(:name, :min, :short_help, :long_help)
 
     class << self
       def commands
@@ -88,8 +83,8 @@ module Byebug
       end
 
       def load_commands
-        Dir[File.join(Byebug.const_get(:BYEBUG_DIR), 'commands', '*')].each {
-          |file| require file if file =~ /\.rb$/ }
+        Dir[File.join(File.dirname(__FILE__), 'commands', '*')].each {
+          |file| require file }
         Byebug.constants.grep(/Functions$/).map {
           |name| Byebug.const_get(name) }.each { |mod| include mod }
       end
@@ -170,11 +165,11 @@ module Byebug
     register_setting_var(:basename, false)
     register_setting_var(:callstyle, :long)
     register_setting_var(:testing, false)
-    register_setting_var(:force_stepping, false)
-    register_setting_var(:frame_fullpath, true)
+    register_setting_var(:forcestep, false)
+    register_setting_var(:fullpath, true)
     register_setting_var(:listsize, 10)
     register_setting_var(:stack_trace_on_error, false)
-    register_setting_var(:tracing_plus, false)
+    register_setting_var(:linetrace_plus, false)
     cols = terminal_width || 160
     register_setting_var(:width, cols > 10 ? cols : 160)
     Byebug::ARGV = ARGV.clone unless defined? Byebug::ARGV
@@ -232,6 +227,10 @@ module Byebug
       def get_binding pos = @state.frame_pos
         @state.context ? @state.context.frame_binding(pos) : TOPLEVEL_BINDING
       end
+
+      def get_context(thnum)
+        Byebug.contexts.find {|c| c.thnum == thnum}
+      end
   end
 
   Command.load_commands
@@ -241,18 +240,18 @@ module Byebug
   # Use Byebug.settings[] and Byebug.settings[]= methods to query and set
   # byebug settings. These settings are available:
   #
-  #  :autolist             - automatically calls 'list' command on breakpoint
   #  :autoeval             - evaluates input in the current binding if it's not
   #                          recognized as a byebug command
   #  :autoirb              - automatically calls 'irb' command on breakpoint
-  #  :stack_trace_on_error - shows full stack trace if eval command results in
-  #                          an exception
-  #  :frame_fullpath       - displays full paths when showing frame stack
-  #  :frame_class_names    - displays method's class name when showing frame
-  #                          stack
+  #  :autolist             - automatically calls 'list' command on breakpoint
   #  :autoreload           - makes 'list' command always display up-to-date
   #                          source code
-  #  :force_stepping       - stepping command always move to the new line
+  #  :frame_class_names    - displays method's class name when showing frame
+  #                          stack
+  #  :forcestep            - stepping command always move to the new line
+  #  :fullpath             - displays full paths when showing frame stack
+  #  :stack_trace_on_error - shows full stack trace if eval command results in
+  #                          an exception
   #
   def self.settings
     Command.settings

data/lib/byebug/commands/breakpoints.rb

@@ -66,9 +66,6 @@ module Byebug
           return unless confirm("Set breakpoint anyway? (y/n) ")
         end
 
-        return errmsg "We are not in a state we can add breakpoints.\n" unless
-          @state.context
-
         b = Byebug.add_breakpoint brkpt_filename, line, expr
         print "Created breakpoint #{b.id} at " \
               "#{CommandProcessor.canonic_file(brkpt_filename)}:#{line.to_s}\n"
@@ -103,7 +100,7 @@ module Byebug
     self.allow_in_control = true
 
     def regexp
-      /^\s *del(?:ete)? (?:\s+(.*))?$/ix
+      /^\s* del(?:ete)? (?:\s+(.*))?$/x
     end
 
     def execute

data/lib/byebug/commands/catchpoint.rb

@@ -4,7 +4,7 @@ module Byebug
     self.allow_in_control = true
 
     def regexp
-      /^\s* cat(?:ch)? (?:\s+(\S+))? (?:\s+(off))? \s*$/ix
+      /^\s* cat(?:ch)? (?:\s+(\S+))? (?:\s+(off))? \s*$/x
     end
 
     def execute

data/lib/byebug/commands/condition.rb

@@ -3,7 +3,7 @@ module Byebug
   class ConditionCommand < Command
 
     def regexp
-      /^\s* cond(?:ition)? (?:\s+(\d+)(?:\s+(.*))?)? \s*$/ix
+      /^\s* cond(?:ition)? (?:\s+(\d+)(?:\s+(.*))?)? \s*$/x
     end
 
     def execute