runger_byebug 11.2.0

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,241 @@
+#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)
+{
+  debug_context_t *dc;
+  VALUE context;
+
+  UNUSED(self);
+
+  thread_context_lookup(rb_thread_current(), &context);
+  Data_Get_Struct(context, debug_context_t, dc);
+
+  CTX_FL_SET(dc, CTX_FL_IGNORE);
+
+  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);
+
+  CTX_FL_UNSET(dc, CTX_FL_IGNORE);
+
+  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_undef_alloc_func(cThreadsTable);
+
+  rb_define_module_function(mByebug, "unlock", Unlock, 0);
+  rb_define_module_function(mByebug, "lock", Lock, 0);
+}

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_relative "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_relative "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,94 @@
+# 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)
+
+      potential_lines_with_trace_points(iseq, {})
+    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
+
+    #
+    # 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

data/lib/byebug/command.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require_relative "helpers/string"
+
+module Byebug
+  #
+  # Parent class of all byebug commands.
+  #
+  # Subclass it and name the subclass ending with the word Command to implement
+  # your own custom command.
+  #
+  # @example Define a custom command
+  #
+  # class MyCustomCommand < Command
+  #   def self.regexp
+  #     /custom_regexp/
+  #   end
+  #
+  #   def self.description
+  #     "Custom long desc"
+  #   end
+  #
+  #   def.short_description
+  #     "Custom short desc"
+  #   end
+  #
+  #   def execute
+  #     # My command's implementation
+  #   end
+  # end
+  #
+  class Command
+    extend Forwardable
+
+    attr_reader :processor
+
+    def initialize(processor, input = self.class.to_s)
+      @processor = processor
+      @match = match(input)
+    end
+
+    def context
+      @context ||= processor.context
+    end
+
+    def frame
+      @frame ||= context.frame
+    end
+
+    def arguments
+      @match[0].split(" ").drop(1).join(" ")
+    end
+
+    def_delegators "self.class", :help, :match
+
+    def_delegator "processor.printer", :print, :pr
+    def_delegator "processor.printer", :print_collection, :prc
+    def_delegator "processor.printer", :print_variables, :prv
+
+    def_delegators "processor.interface", :errmsg, :puts, :print, :confirm
+
+    class << self
+      include Helpers::StringHelper
+
+      #
+      # Special methods to allow command filtering in processors
+      #
+      attr_accessor :allow_in_control, :allow_in_post_mortem
+
+      attr_writer :always_run
+
+      def always_run
+        @always_run ||= 0
+      end
+
+      #
+      # Name of the command, as executed by the user.
+      #
+      def to_s
+        name
+          .split("::")
+          .map { |n| n.gsub(/Command$/, "").downcase if /Command$/.match?(n) }
+          .compact
+          .join(" ")
+      end
+
+      def columnize(width)
+        format(
+          "  %-<name>#{width}s -- %<description>s\n",
+          name: to_s,
+          description: short_description
+        )
+      end
+
+      #
+      # Default help text for a command.
+      #
+      def help
+        prettify(description)
+      end
+
+      #
+      # Command's regexp match against an input
+      #
+      def match(input)
+        regexp.match(input)
+      end
+    end
+  end
+end

data/lib/byebug/command_list.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Byebug
+  #
+  # Holds an array of subcommands for a command
+  #
+  class CommandList
+    include Enumerable
+
+    def initialize(commands)
+      @commands = commands.sort_by(&:to_s)
+    end
+
+    def match(input)
+      find { |cmd| cmd.match(input) }
+    end
+
+    def each
+      @commands.each { |cmd| yield(cmd) }
+    end
+
+    def to_s
+      "\n" + map { |cmd| cmd.columnize(width) }.join + "\n"
+    end
+
+    private
+
+    def width
+      @width ||= map(&:to_s).max_by(&:size).size
+    end
+  end
+end