byebug 11.0.1

data/ext/byebug/extconf.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+makefile_config = RbConfig::MAKEFILE_CONFIG
+
+makefile_config["CC"] = ENV["CC"] if ENV["CC"]
+
+makefile_config["CFLAGS"] << " -gdwarf-2 -g3 -O0" if ENV["debug"]
+
+dir_config("ruby")
+with_cflags(makefile_config["CFLAGS"]) { create_makefile("byebug/byebug") }

data/ext/byebug/locker.c

@@ -0,0 +1,96 @@
+#include "byebug.h"
+
+/**
+ * A simple linked list containing locked threads, FIFO style.
+ */
+
+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;
+
+static 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
+byebug_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
+byebug_pop_from_locked()
+{
+  VALUE thread;
+  locked_thread_t *node;
+
+  if (!locked_head)
+    return Qnil;
+
+  node = locked_head;
+  locked_head = locked_head->next;
+
+  if (locked_tail == node)
+    locked_tail = NULL;
+
+  thread = node->thread;
+  xfree(node);
+
+  return thread;
+}
+
+extern void
+byebug_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)
+  {
+    byebug_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

@@ -0,0 +1,230 @@
+#include "byebug.h"
+
+/* 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 */
+static VALUE locker = Qnil;
+
+static int
+t_tbl_mark_keyvalue(st_data_t key, st_data_t value, st_data_t tbl)
+{
+  UNUSED(tbl);
+
+  rb_gc_mark((VALUE)key);
+
+  if (!value)
+    return ST_CONTINUE;
+
+  rb_gc_mark((VALUE)value);
+
+  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);
+}
+
+/*
+ *  Creates a numeric hash whose keys are the currently active threads and
+ *  whose values are their associated contexts.
+ */
+VALUE
+create_threads_table(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);
+}
+
+/*
+ *  Checks a single entry in the threads table.
+ *
+ *  If it has no associated context or the key doesn't correspond to a living
+ *  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 data)
+{
+  UNUSED(data);
+
+  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.
+ */
+static void
+cleanup_dead_threads(void)
+{
+  threads_table_t *t_tbl;
+
+  Data_Get_Struct(threads, threads_table_t, t_tbl);
+  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)
+{
+  threads_table_t *t_tbl;
+
+  Data_Get_Struct(threads, threads_table_t, t_tbl);
+
+  if (!st_lookup(t_tbl->tbl, thread, context) || !*context)
+  {
+    *context = byebug_context_create(thread);
+    st_insert(t_tbl->tbl, thread, *context);
+  }
+}
+
+/*
+ * Holds thread execution while another thread is active.
+ *
+ * Thanks to this, all threads are "frozen" while the user is typing commands.
+ */
+void
+acquire_lock(debug_context_t *dc)
+{
+  while ((!NIL_P(locker) && locker != rb_thread_current())
+         || CTX_FL_TEST(dc, CTX_FL_SUSPEND))
+  {
+    byebug_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);
+  }
+
+  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 = byebug_pop_from_locked();
+  else
+  {
+    byebug_remove_from_locked(next_thread);
+    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;
+}
+
+/*
+ *
+ *    Document-class: ThreadsTable
+ *
+ *    == Sumary
+ *
+ *    Hash table holding currently active threads and their associated contexts
+ */
+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.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "byebug/attacher"

data/lib/byebug/attacher.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+#
+# Main Container for all of Byebug's code
+#
+module Byebug
+  #
+  # Starts byebug, and stops at the first line of user's code.
+  #
+  def self.attach
+    unless started?
+      self.mode = :attached
+
+      start
+      run_init_script
+    end
+
+    current_context.step_out(3, true)
+  end
+
+  def self.spawn(host = "localhost", port = nil)
+    require "byebug/core"
+
+    self.wait_connection = true
+    start_server(host, port || PORT)
+  end
+end
+
+#
+# Adds a `byebug` method to the Kernel module.
+#
+# Dropping a `byebug` call anywhere in your code, you get a debug prompt.
+#
+module Kernel
+  def byebug
+    require "byebug/core"
+
+    Byebug.attach unless Byebug.mode == :off
+  end
+
+  def remote_byebug(host = "localhost", port = nil)
+    Byebug.spawn(host, port)
+
+    Byebug.attach
+  end
+
+  alias debugger byebug
+end

data/lib/byebug/breakpoint.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Implements breakpoints
+  #
+  class Breakpoint
+    #
+    # First breakpoint, in order of creation
+    #
+    def self.first
+      Byebug.breakpoints.first
+    end
+
+    #
+    # Last breakpoint, in order of creation
+    #
+    def self.last
+      Byebug.breakpoints.last
+    end
+
+    #
+    # Adds a new breakpoint
+    #
+    # @param [String] file
+    # @param [Fixnum] line
+    # @param [String] expr
+    #
+    def self.add(file, line, expr = nil)
+      breakpoint = Breakpoint.new(file, line, expr)
+      Byebug.breakpoints << breakpoint
+      breakpoint
+    end
+
+    #
+    # Removes a breakpoint
+    #
+    # @param id [integer] breakpoint number
+    #
+    def self.remove(id)
+      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 = "#{Time.new.to_i}_#{rand(2**31)}"
+      iseq = RubyVM::InstructionSequence.compile(File.read(filename), name)
+
+      if iseq.respond_to?(:each_child)
+        potential_lines_with_trace_points(iseq, {})
+      else
+        potential_lines_without_trace_points(iseq, {})
+      end
+    end
+
+    def self.potential_lines_with_trace_points(iseq, lines)
+      iseq.trace_points.each { |(line, _)| lines[line] = true }
+      iseq.each_child do |child|
+        potential_lines_with_trace_points(child, lines)
+      end
+
+      lines.keys.sort
+    end
+
+    private_class_method :potential_lines_with_trace_points
+
+    def self.potential_lines_without_trace_points(iseq, lines)
+      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
+
+    private_class_method :potential_lines_without_trace_points
+
+    #
+    # 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
+    #
+    def self.none?
+      Byebug.breakpoints.empty?
+    end
+
+    #
+    # Prints all information associated to the breakpoint
+    #
+    def inspect
+      meths = %w[id pos source expr hit_condition hit_count hit_value enabled?]
+      values = meths.map { |field| "#{field}: #{send(field)}" }.join(", ")
+      "#<Byebug::Breakpoint #{values}>"
+    end
+  end
+end