jets 0.5.5 → 0.5.6

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/ext/byebug/extconf.rb

@@ -1,12 +0,0 @@
-# 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/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/ext/byebug/locker.c

@@ -1,96 +0,0 @@
-#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
-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
-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
-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/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/ext/byebug/threads.c

@@ -1,230 +0,0 @@
-#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 = 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))
-  {
-    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 = pop_from_locked();
-  else
-  {
-    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/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug.rb

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

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/attacher.rb

@@ -1,48 +0,0 @@
-# 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
-    require "byebug/core"
-
-    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
-    Byebug.attach
-  end
-
-  def remote_byebug(host = "localhost", port = nil)
-    Byebug.spawn(host, port)
-
-    Byebug.attach
-  end
-
-  alias debugger byebug
-end

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/breakpoint.rb

@@ -1,111 +0,0 @@
-# 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