byebug 1.1.0 → 1.1.1

data/ext/byebug/locker.c

@@ -1,53 +0,0 @@
-#include <byebug.h>
-
-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/lib/byebug/commands/threads.rb

@@ -1,190 +0,0 @@
-module Byebug
-
-  module ThreadFunctions
-    def display_context(c, show_top_frame=true)
-      c_flag = c.thread == Thread.current ? '+' : ' '
-      c_flag = '$' if c.suspended?
-      d_flag = c.ignored? ? '!' : ' '
-      print "%s%s", c_flag, d_flag
-      print "%d ", c.thnum
-      print "%s\t", c.thread.inspect
-      if c.stack_size > 0 and show_top_frame
-        print "%s:%d", c.frame_file(0), c.frame_line(0)
-      end
-      print "\n"
-    end
-
-    def parse_thread_num(subcmd, arg)
-      if '' == arg
-        errmsg "'%s' needs a thread number\n" % subcmd
-        nil
-      else
-        thread_num = get_int(arg, "thread #{subcmd}", 1)
-        return nil unless thread_num
-        get_context(thread_num)
-      end
-    end
-
-    def parse_thread_num_for_cmd(subcmd, arg)
-      c = parse_thread_num(subcmd, arg)
-      return nil unless c
-      case
-      when nil == c
-        errmsg "No such thread.\n"
-      when @state.context == c
-        errmsg "It's the current thread.\n"
-      when c.ignored?
-        errmsg "Can't #{subcmd} to byebug's thread #{arg}.\n"
-      else # Everything is okay
-        return c
-      end
-      return nil
-    end
-  end
-
-  class ThreadListCommand < Command
-    self.allow_in_control = true
-
-    def regexp
-      /^\s*th(?:read)?\s+l(?:ist)?\s*$/
-    end
-
-    def execute
-      threads = Byebug.contexts.sort_by{|c| c.thnum}.each do |c|
-        display_context(c)
-      end
-    end
-
-    class << self
-      def help_command
-        'thread'
-      end
-
-      def help(cmd)
-        %{
-          th[read] l[ist]\t\t\tlist all threads
-        }
-      end
-    end
-  end
-
-  class ThreadStopCommand < Command
-    self.allow_in_control     = true
-    self.allow_in_post_mortem = false
-    self.need_context         = true
-
-    def regexp
-      /^\s*th(?:read)?\s+stop\s*(\S*)\s*$/
-    end
-
-    def execute
-      c = parse_thread_num_for_cmd("thread stop", @match[1])
-      return unless c
-      c.suspend
-      display_context(c)
-    end
-
-    class << self
-      def help_command
-        'thread'
-      end
-
-      def help(cmd)
-        %{
-          th[read] stop <nnn>\t\tstop thread nnn
-        }
-      end
-    end
-  end
-
-  class ThreadResumeCommand < Command
-    self.allow_in_post_mortem = false
-    self.allow_in_control = true
-    self.need_context = true
-
-    def regexp
-      /^\s*th(?:read)?\s+resume\s*(\S*)\s*$/
-    end
-
-    def execute
-      c = parse_thread_num_for_cmd("thread resume", @match[1])
-      return unless c
-      if !c.thread.stop?
-        print "Already running."
-        return
-      end
-      c.resume
-      display_context(c)
-    end
-
-    class << self
-      def help_command
-        'thread'
-      end
-
-      def help(cmd)
-        %{
-          th[read] resume <nnn>\t\tresume thread nnn
-        }
-      end
-    end
-  end
-
-  # Thread switch Must come after "Thread resume" because "switch" is
-  # optional
-
-  class ThreadSwitchCommand < Command
-    self.allow_in_control     = true
-    self.allow_in_post_mortem = false
-    self.need_context         = true
-
-    def regexp
-      /^\s*th(?:read)?\s*(?:sw(?:itch)?)?\s+(\S+)\s*$/
-    end
-
-    def execute
-      c = parse_thread_num_for_cmd("thread switch", @match[1])
-      return unless c
-      display_context(c)
-      c.stop_next = 1
-      c.thread.run
-      @state.proceed
-    end
-
-    class << self
-      def help_command
-        'thread'
-      end
-
-      def help(cmd)
-        %{
-          th[read] [sw[itch]] <nnn>\tswitch thread context to nnn
-        }
-      end
-    end
-  end
-
-  class ThreadCurrentCommand < Command
-    self.need_context = true
-
-    def regexp
-      /^\s*th(?:read)?\s*(?:cur(?:rent)?)?\s*$/
-    end
-
-    def execute
-      display_context(@state.context)
-    end
-
-    class << self
-      def help_command
-        'thread'
-      end
-
-      def help(cmd)
-        %{
-          th[read] [cur[rent]]\t\tshow current thread
-        }
-      end
-    end
-  end
-end

data/test/examples/frame_threads.rb

@@ -1,31 +0,0 @@
-byebug
-
-@should_break = false
-
-t = Thread.new do
-  while !@should_break
-    A.new.a
-    sleep 0.1
-  end
-end
-
-class A
-  def a
-    b
-  end
-  def b
-    c
-    2
-  end
-  def c
-    d('a')
-    3
-  end
-  def d(e)
-    5
-  end
-end
-
-A.new.a
-@should_break = true
-t.join

data/test/examples/info_threads.rb

@@ -1,48 +0,0 @@
-byebug
-def bla(a, b)
-  a + b
-end
-2
-3
-4
-5
-6
-bla("a" * 30, "b")
-
-class A
-  def initialize
-    @foo = "bar"
-    @bla = "blabla"
-  end
-
-  def a
-    a = "1" * 30
-    b = 2
-    @foo
-  end
-
-  def c
-    a = BasicObject.new
-    a
-  end
-
-  def b
-    a
-    e = "%.2f"
-    e
-  end
-end
-
-@break = false
-t1 = Thread.new do
-  while true
-    break if @break
-    sleep 0.02
-  end
-end
-
-A.new.b
-A.new.a
-@break = true
-t1.join
-A.new.c

data/test/examples/thread.rb

@@ -1,32 +0,0 @@
-byebug
-class ThreadExample
-  def initialize
-    Thread.main[:should_break] = false
-  end
-
-  def launch
-    @t1 = Thread.new do
-      while true
-        break if Thread.main[:should_break]
-        sleep 0.02
-      end
-    end
-
-    @t2 = Thread.new do
-      while true
-        sleep 0.02
-      end
-    end
-
-    @t1.join
-    Thread.main[:should_break]
-  end
-
-  def kill
-    @t2.kill
-  end
-end
-
-t = ThreadExample.new
-t.launch
-t.kill

data/test/examples/trace_threads.rb

@@ -1,20 +0,0 @@
-a = 2
-byebug
-b = 3
-@break1 = false
-@break2 = false
-
-t1 = Thread.new do
-  until @break1
-    sleep 0.02
-    @break2 = true
-  end
-end
-
-until @break2
-  sleep 0.02
-  @break1 = true
-end
-
-t1.join
-t1