byebug 3.5.1 → 4.0.0

data/ext/byebug/extconf.rb

@@ -5,13 +5,16 @@ end
 
 require 'mkmf'
 
-RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+makefile_config = RbConfig::MAKEFILE_CONFIG
 
-if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
-  $CFLAGS ||= ''
-  $CFLAGS += ' -Wall -Werror -Wno-unused-parameter'
-  $CFLAGS += ' -gdwarf-2 -g3 -O0' if ENV['debug']
+makefile_config['CC'] = ENV['CC'] if ENV['CC']
+
+makefile_config['CFLAGS'] << ' -Wall -Werror'
+makefile_config['CFLAGS'] << ' -gdwarf-2 -g3 -O0' if ENV['debug']
+
+if makefile_config['CC'] =~ /clang/
+  makefile_config['CFLAGS'] << ' -Wno-unknown-warning-option'
 end
 
 dir_config('ruby')
-create_makefile('byebug/byebug')
+with_cflags(makefile_config['CFLAGS']) { create_makefile('byebug/byebug') }

data/ext/byebug/locker.c

@@ -1,6 +1,11 @@
 #include <byebug.h>
 
-typedef struct locked_thread_t {
+/**
+ * A simple linked list containing locked threads, FIFO style.
+ */
+
+typedef struct locked_thread_t
+{
   VALUE thread;
   struct locked_thread_t *next;
 } locked_thread_t;
@@ -13,12 +18,13 @@ is_in_locked(VALUE thread)
 {
   locked_thread_t *node;
 
-  if (!locked_head) return 0;
+  if (!locked_head)
+    return 0;
 
   for (node = locked_head; node != locked_tail; node = node->next)
-  {
-    if (node->thread == thread) return 1;
-  }
+    if (node->thread == thread)
+      return 1;
+
   return 0;
 }
 
@@ -27,28 +33,64 @@ add_to_locked(VALUE thread)
 {
   locked_thread_t *node;
 
-  if (is_in_locked(thread)) return;
+  if (is_in_locked(thread))
+    return;
 
   node = ALLOC(locked_thread_t);
   node->thread = thread;
   node->next = NULL;
-  if (locked_tail) locked_tail->next = node;
+
+  if (locked_tail)
+    locked_tail->next = node;
+
   locked_tail = node;
-  if (!locked_head) locked_head = node;
+
+  if (!locked_head)
+    locked_head = node;
 }
 
 extern VALUE
-remove_from_locked()
+pop_from_locked()
 {
   VALUE thread;
   locked_thread_t *node;
 
-  if (locked_head == NULL) return Qnil;
+  if (!locked_head)
+    return Qnil;
 
   node = locked_head;
   locked_head = locked_head->next;
-  if (locked_tail == node) locked_tail = NULL;
+
+  if (locked_tail == node)
+    locked_tail = NULL;
+
   thread = node->thread;
   xfree(node);
+
   return thread;
 }
+
+extern void
+remove_from_locked(VALUE thread)
+{
+  locked_thread_t *node;
+  locked_thread_t *next_node;
+
+  if (NIL_P(thread) || !locked_head || !is_in_locked(thread))
+    return;
+
+  if (locked_head->thread == thread)
+  {
+    pop_from_locked();
+    return;
+  }
+
+  for (node = locked_head; node != locked_tail; node = node->next)
+    if (node->next && node->next->thread == thread)
+    {
+      next_node = node->next;
+      node->next = next_node->next;
+      xfree(next_node);
+      return;
+    }
+}

data/ext/byebug/threads.c

@@ -3,31 +3,41 @@
 /* Threads table class */
 static VALUE cThreadsTable;
 
+/* If not Qnil, holds the next thread that must be run */
+VALUE next_thread = Qnil;
+
+/* To allow thread syncronization, we must stop threads when debugging */
+VALUE locker = Qnil;
+
 static int
 t_tbl_mark_keyvalue(st_data_t key, st_data_t value, st_data_t tbl)
 {
-  VALUE thread = (VALUE)key;
+  UNUSED(tbl);
 
-  if (!value) return ST_CONTINUE;
+  rb_gc_mark((VALUE) key);
 
-  rb_gc_mark((VALUE)value);
-  rb_gc_mark(thread);
+  if (!value)
+    return ST_CONTINUE;
+
+  rb_gc_mark((VALUE) value);
 
   return ST_CONTINUE;
 }
 
 static void
-t_tbl_mark(void* data)
+t_tbl_mark(void *data)
 {
-  threads_table_t *t_tbl = (threads_table_t *)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);
+
+  st_foreach(tbl, t_tbl_mark_keyvalue, (st_data_t) tbl);
 }
 
 static void
-t_tbl_free(void* data)
+t_tbl_free(void *data)
 {
-  threads_table_t *t_tbl = (threads_table_t*)data;
+  threads_table_t *t_tbl = (threads_table_t *) data;
+
   st_free_table(t_tbl->tbl);
   xfree(t_tbl);
 }
@@ -46,16 +56,6 @@ create_threads_table(void)
   return Data_Wrap_Struct(cThreadsTable, t_tbl_mark, t_tbl_free, t_tbl);
 }
 
-/*
- *  The condition to be in the thread's table is to be either running or
- *  sleeping, namely, to be Thread#alive?
- */
-static int
-is_living_thread(VALUE thread)
-{
-  return rb_funcall(thread, rb_intern("alive?"), 0) == Qtrue;
-}
-
 /*
  *  Checks a single entry in the threads table.
  *
@@ -63,20 +63,42 @@ is_living_thread(VALUE thread)
  *  thread, the entry is removed from the thread's list.
  */
 static int
-check_thread_i(st_data_t key, st_data_t value, st_data_t dummy)
+check_thread_i(st_data_t key, st_data_t value, st_data_t data)
 {
-  if (!value) return ST_DELETE;
+  UNUSED(data);
 
-  if (!is_living_thread((VALUE)key)) return ST_DELETE;
+  if (!value)
+    return ST_DELETE;
+
+  if (!is_living_thread((VALUE) key))
+    return ST_DELETE;
 
   return ST_CONTINUE;
 }
 
+/*
+ *  Checks whether a thread is either in the running or sleeping state.
+ */
+int
+is_living_thread(VALUE thread)
+{
+  VALUE status = rb_funcall(thread, rb_intern("status"), 0);
+
+  if (NIL_P(status) || status == Qfalse)
+    return 0;
+
+  if (rb_str_cmp(status, rb_str_new2("run")) == 0
+      || rb_str_cmp(status, rb_str_new2("sleep")) == 0)
+    return 1;
+
+  return 0;
+}
+
 /*
  *  Checks threads table for dead/finished threads.
  */
 void
-check_threads_table(void)
+cleanup_dead_threads(void)
 {
   threads_table_t *t_tbl;
 
@@ -84,12 +106,16 @@ check_threads_table(void)
   st_foreach(t_tbl->tbl, check_thread_i, 0);
 }
 
+/*
+ * Looks up a context in the threads table. If not present, it creates it.
+ */
 void
-thread_context_lookup(VALUE thread, VALUE *context)
+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);
@@ -97,26 +123,95 @@ thread_context_lookup(VALUE thread, VALUE *context)
   }
 }
 
+/*
+ * Holds thread execution while another thread is active.
+ *
+ * Thanks to this, all threads are "frozen" while the user is typing commands.
+ */
 void
-halt_while_other_thread_is_active(debug_context_t *dc)
+acquire_lock(debug_context_t * dc)
 {
-  while (1)
+  while ((!NIL_P(locker) && locker != rb_thread_current())
+         || CTX_FL_TEST(dc, CTX_FL_SUSPEND))
   {
-    /* 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())
-    {
+    add_to_locked(rb_thread_current());
+    rb_thread_stop();
+
+    if (CTX_FL_TEST(dc, CTX_FL_SUSPEND))
       CTX_FL_SET(dc, CTX_FL_WAS_RUNNING);
-      rb_thread_stop();
-    }
-    else break;
   }
+
+  locker = rb_thread_current();
+}
+
+/*
+ * Releases our global lock and passes execution on to another thread, either
+ * the thread specified by +next_thread+ or any other thread if +next_thread+
+ * is nil.
+ */
+void
+release_lock(void)
+{
+  VALUE thread;
+
+  cleanup_dead_threads();
+
+  locker = Qnil;
+
+  if (NIL_P(next_thread))
+    thread = pop_from_locked();
+  else
+  {
+    remove_from_locked(next_thread);
+    thread = next_thread;
+  }
+
+  if (thread == next_thread)
+    next_thread = Qnil;
+
+  if (!NIL_P(thread) && is_living_thread(thread))
+    rb_thread_run(thread);
+}
+
+/*
+ *  call-seq:
+ *    Byebug.unlock -> nil
+ *
+ *  Unlocks global switch so other threads can run.
+ */
+static VALUE
+Unlock(VALUE self)
+{
+  UNUSED(self);
+
+  release_lock();
+
+  return locker;
+}
+
+/*
+ *  call-seq:
+ *    Byebug.lock -> Thread.current
+ *
+ *  Locks global switch to reserve execution to current thread exclusively.
+ */
+static VALUE
+Lock(VALUE self)
+{
+  debug_context_t *dc;
+  VALUE context;
+
+  UNUSED(self);
+
+  if (!is_living_thread(rb_thread_current()))
+    rb_raise(rb_eRuntimeError, "Current thread is dead!");
+
+  thread_context_lookup(rb_thread_current(), &context);
+  Data_Get_Struct(context, debug_context_t, dc);
+
+  acquire_lock(dc);
+
+  return locker;
 }
 
 /*
@@ -131,4 +226,7 @@ void
 Init_threads_table(VALUE mByebug)
 {
   cThreadsTable = rb_define_class_under(mByebug, "ThreadsTable", rb_cObject);
+
+  rb_define_module_function(mByebug, "unlock", Unlock, 0);
+  rb_define_module_function(mByebug, "lock", Lock, 0);
 }

data/lib/byebug/attacher.rb

@@ -1,12 +1,17 @@
+#
+# Main Container for all of Byebug's code
+#
 module Byebug
   #
   # Enters byebug right before (or right after if _before_ is false) return
   # events occur. Before entering byebug the init script is read.
   #
   def self.attach(steps_out, before)
+    setup_cmd_line_args
+
     start
-    self.debugged_program = $PROGRAM_NAME
-    run_init_script(StringIO.new)
+    run_init_script
+
     current_context.step_out(steps_out, before)
   end
 end

data/lib/byebug/breakpoint.rb

@@ -39,6 +39,36 @@ module Byebug
       Byebug.breakpoints.reject! { |b| b.id == id }
     end
 
+    #
+    # Returns an array of line numbers in file named +filename+ where
+    # breakpoints could be set. The list will contain an entry for each
+    # distinct line event call so it is possible (and possibly useful) for a
+    # line number appear more than once.
+    #
+    # @param filename [String] File name to inspect for possible breakpoints
+    #
+    def self.potential_lines(filename)
+      name, lines = "#{Time.new.to_i}_#{rand(2**31)}", {}
+      iseq = RubyVM::InstructionSequence.compile(File.read(filename), name)
+
+      iseq.disasm.each_line do |line|
+        res = /^\d+ (?<insn>\w+)\s+.+\(\s*(?<lineno>\d+)\)$/.match(line)
+        next unless res && res[:insn] == 'trace'
+
+        lines[res[:lineno].to_i] = true
+      end
+
+      lines.keys
+    end
+
+    #
+    # Returns true if a breakpoint could be set in line number +lineno+ in file
+    # name +filename.
+    #
+    def self.potential_line?(filename, lineno)
+      potential_lines(filename).member?(lineno)
+    end
+
     #
     # True if there's no breakpoints
     #

data/lib/byebug/command.rb

@@ -9,6 +9,11 @@ module Byebug
   # Subclasses need to implement a `regexp` and an `execute` command.
   #
   class Command
+    extend Forwardable
+
+    include ParseFunctions
+    include FileFunctions
+
     Subcmd = Struct.new(:name, :min, :help)
 
     def initialize(state)
@@ -19,36 +24,49 @@ module Byebug
       @match = regexp.match(input)
     end
 
-    protected
+    def_delegator :"Byebug.printer", :print, :pr
+    def_delegator :"Byebug.printer", :print_collection, :prc
+    def_delegator :"Byebug.printer", :print_variables, :prv
 
-    extend Forwardable
-    def_delegators :@state, :errmsg, :puts
+    protected
 
-    def confirm(msg)
-      @state.confirm(msg) == 'y'
-    end
+    def_delegators :@state, :errmsg, :puts, :print, :confirm
 
+    #
+    # Evaluates a string containing Ruby code, using binding +b+. In case of
+    # error full stack trace and error are printed.
+    #
     def bb_eval(str, b = get_binding)
-      eval(str, b)
+      b.eval(str)
     rescue StandardError, ScriptError => e
-      at = eval('Thread.current.backtrace_locations', b)
-      puts "#{at.shift}: #{e.class} Exception(#{e.message})"
-      at.each { |path| puts "\tfrom #{path}" }
+      at = e.backtrace
+      locations = []
+      locations << "#{at.shift}: #{e.class} Exception(#{e.message})"
+      locations += at.map { |path| "\tfrom #{path}" }
+
+      errmsg(pr('eval.exception', text_message: locations.join("\n")))
       nil
     end
 
+    #
+    # Evaluates a string containing Ruby code, using binding +b+. In case of
+    # error, an error message with the exception is printed.
+    #
     def bb_warning_eval(str, b = get_binding)
-      eval(str, b)
+      b.eval(str)
     rescue StandardError, ScriptError => e
-      puts "#{e.class} Exception: #{e.message}"
+      text_message = "#{e.class} Exception: #{e.message}"
+      errmsg(pr('eval.exception', text_message: text_message))
       nil
     end
 
-    def get_binding(pos = @state.frame_pos)
+    def get_binding(pos = @state.frame)
       @state.context ? @state.context.frame_binding(pos) : TOPLEVEL_BINDING
     end
 
     class << self
+      include StringFunctions
+
       attr_accessor :allow_in_control
       attr_writer :allow_in_post_mortem, :always_run
 
@@ -60,13 +78,11 @@ module Byebug
         @always_run ||= 0
       end
 
-      def help(args = nil)
-        if args && args[1]
-          output = format_subcmd(args[1])
-        else
-          output = description.gsub(/^ +/, '') + "\n"
-          output += format_subcmds if defined? self::Subcommands
-        end
+      def help(subcmd = nil)
+        return format_subcmd(subcmd) if subcmd
+
+        output = description
+        output += format_subcmds if defined? self::Subcommands
         output
       end
 
@@ -106,18 +122,6 @@ module Byebug
       def inherited(klass)
         commands << klass
       end
-
-      def load_commands
-        Dir.glob(File.expand_path('../commands/*.rb', __FILE__)).each do |file|
-          require file
-        end
-
-        Byebug.constants.grep(/Functions$/).map do |name|
-          include Byebug.const_get(name)
-        end
-      end
     end
   end
-
-  Command.load_commands
 end