byebug 0.0.1

data/ext/byebug/extconf.rb

@@ -0,0 +1,21 @@
+require 'mkmf'
+
+if RUBY_VERSION < "2.0"
+  STDERR.print("Ruby version is too old\n")
+  exit(1)
+end
+
+$CFLAGS = '-Wall -Werror'
+$CFLAGS += ' -g3' if ENV['debug']
+
+dir_config("ruby")
+create_makefile("byebug")
+
+#if !Byebug::RubyCoreSource.create_makefile_with_core(hdrs, "ruby_debug")
+#  STDERR.print("Makefile creation failed\n")
+#  STDERR.print("*************************************************************\n\n")
+#  STDERR.print("  NOTE: If your headers were not found, try passing\n")
+#  STDERR.print("        --with-ruby-include=PATH_TO_HEADERS      \n\n")
+#  STDERR.print("*************************************************************\n\n")
+#  exit(1)
+#end

data/ext/byebug/locker.c

@@ -0,0 +1,53 @@
+#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.rb

@@ -0,0 +1,404 @@
+require_relative 'byebug.so'
+require_relative 'byebug/version'
+require_relative 'byebug/context'
+require_relative 'byebug/processor'
+require 'pp'
+require 'stringio'
+require 'socket'
+require 'thread'
+require 'linecache19'
+
+module Byebug
+
+  @reload_source_on_change = false
+  @tracing_started = false
+
+  self.handler = CommandProcessor.new
+
+  # Default options to Byebug.start
+  DEFAULT_START_SETTINGS = {
+    :init        => true,  # Set $0 and save ARGV?
+    :post_mortem => false, # post-mortem debugging on uncaught exception?
+    :tracing     => nil    # Byebug.tracing value. true/false resets,
+  } unless defined?(DEFAULT_START_SETTINGS)
+
+  # the port number used for remote debugging
+  PORT = 8989 unless defined?(PORT)
+
+  # What file is used for byebug startup commands.
+  unless defined?(INITFILE)
+    INITFILE = '.rdebugrc'
+    HOME_DIR = ENV['HOME'].to_s
+  end
+
+  class << self
+
+    # if true, checks the modification time of source files and reloads if it was modified
+    attr_accessor :reload_source_on_change
+
+    attr_accessor :last_exception
+    Byebug.last_exception = nil
+
+    # gdb-style annotation mode. Used in GNU Emacs interface
+    attr_accessor :annotate
+
+    # in remote mode, wait for the remote connection
+    attr_accessor :wait_connection
+
+    # If set, a string to look for in caller() and is used to see
+    # if the call stack is truncated.
+    attr_accessor :start_sentinal
+
+    attr_reader :thread, :control_thread, :cmd_port, :ctrl_port
+
+    #
+    # Interrupts the current thread
+    #
+    def interrupt
+      current_context.interrupt
+    end
+
+    #
+    # Interrupts the last debugged thread
+    #
+    def interrupt_last
+      if context = last_context
+        return nil unless context.thread.alive?
+        context.interrupt
+      end
+      context
+    end
+
+    def source_reload
+      Object.send(:remove_const, "SCRIPT_LINES__") if Object.const_defined?("SCRIPT_LINES__")
+      Object.const_set("SCRIPT_LINES__", {})
+      LineCache::clear_file_cache
+    end
+
+    # Get line +line_number+ from file named +filename+. Return "\n" if
+    # there was a problem. Leaking blanks are stripped off.
+    def line_at(filename, line_number) # :nodoc:
+      @reload_on_change=nil unless defined?(@reload_on_change)
+      line = LineCache::getline(filename, line_number, @reload_on_change)
+      return "\n" unless line
+      return "#{line.gsub(/^\s+/, '').chomp}\n"
+    end
+
+    alias stop remove_tracepoints
+
+    # @param [String] file
+    # @param [Fixnum] line
+    # @param [String] expr
+    def add_breakpoint(file, line, expr=nil)
+      breakpoint = Breakpoint.new(file, line, expr)
+      breakpoints << breakpoint
+      breakpoint
+    end
+
+    def remove_breakpoint(id)
+      Breakpoint.remove breakpoints, id
+    end
+
+    def interface=(value) # :nodoc:
+      handler.interface = value
+    end
+
+    #
+    # Byebug.start(options) -> bool
+    # Byebug.start(options) { ... } -> obj
+    #
+    # If it's called without a block it returns +true+, unless byebug was
+    # already started.
+    #
+    # If a block is given, it starts byebug and yields to block. When the
+    # block is finished executing it stops the byebug with Byebug.stop
+    # method. Inside the block you will probably want to have a call to
+    # Byebug.byebug. For example:
+    #
+    #     Byebug.start{byebug; foo}  # Stop inside of foo
+    #
+    # Also, byebug only allows one invocation of byebug at a time; nested
+    # Byebug.start's have no effect and you can't use this inside the byebug
+    # itself.
+    #
+    # <i>Note that if you want to stop byebug, you must call Byebug.stop as
+    # many times as you called Byebug.start method.</i>
+    #
+    # +options+ is a hash used to set various debugging options.
+    #   :init        - true if you want to save ARGV and some other variables to
+    #                  make a byebug restart possible. Only the first time :init
+    #                  is set to true the values will get set. Since ARGV is
+    #                  saved, you should make sure it hasn't been changed before
+    #                  the (first) call.
+    #   :post_mortem - true if you want to enter post-mortem debugging on an
+    #                  uncaught exception. Once post-mortem debugging is set, it
+    #                  can't be unset.
+    #
+    def start(options={}, &block)
+      options = Byebug::DEFAULT_START_SETTINGS.merge(options)
+      if options[:init]
+        Byebug.const_set('ARGV', ARGV.clone) unless defined? Byebug::ARGV
+        Byebug.const_set('PROG_SCRIPT', $0) unless defined? Byebug::PROG_SCRIPT
+        Byebug.const_set('INITIAL_DIR', Dir.pwd) unless defined? Byebug::INITIAL_DIR
+      end
+      #Byebug.tracing = options[:tracing] unless options[:tracing].nil?
+      if Byebug.started?
+        retval = block && block.call(self)
+      else
+        retval = Byebug._start(&block)
+      end
+      if options[:post_mortem]
+        post_mortem
+      end
+      return retval
+    end
+
+    #
+    # Starts a remote byebug.
+    #
+    def start_remote(host = nil, port = PORT)
+      return if @thread
+
+      self.interface = nil
+      start
+
+      if port.kind_of?(Array)
+        cmd_port, ctrl_port = port
+      else
+        cmd_port, ctrl_port = port, port + 1
+      end
+
+      ctrl_port = start_control(host, ctrl_port)
+
+      yield if block_given?
+
+      mutex = Mutex.new
+      proceed = ConditionVariable.new
+
+      server = TCPServer.new(host, cmd_port)
+      @cmd_port = cmd_port = server.addr[1]
+      @thread = DebugThread.new do
+        while (session = server.accept)
+          self.interface = RemoteInterface.new(session)
+          if wait_connection
+            mutex.synchronize do
+              proceed.signal
+            end
+          end
+        end
+      end
+      if wait_connection
+        mutex.synchronize do
+          proceed.wait(mutex)
+        end
+      end
+    end
+    alias start_server start_remote
+
+    def start_control(host = nil, ctrl_port = PORT + 1) # :nodoc:
+      return @ctrl_port if defined?(@control_thread) && @control_thread
+      server = TCPServer.new(host, ctrl_port)
+      @ctrl_port = server.addr[1]
+      @control_thread = DebugThread.new do
+        while (session = server.accept)
+          interface = RemoteInterface.new(session)
+          processor = ControlCommandProcessor.new(interface)
+          processor.process_commands
+        end
+      end
+      @ctrl_port
+    end
+
+    #
+    # Connects to the remote byebug
+    #
+    def start_client(host = 'localhost', port = PORT)
+      require "socket"
+      interface = Byebug::LocalInterface.new
+      socket = TCPSocket.new(host, port)
+      puts "Connected."
+
+      catch(:exit) do
+        while (line = socket.gets)
+          case line
+          when /^PROMPT (.*)$/
+            input = interface.read_command($1)
+            throw :exit unless input
+            socket.puts input
+          when /^CONFIRM (.*)$/
+            input = interface.confirm($1)
+            throw :exit unless input
+            socket.puts input
+          else
+            print line
+          end
+        end
+      end
+      socket.close
+    end
+
+    #
+    # Runs normal byebug initialization scripts.
+    #
+    # Reads and executes the commands from init file (if any) in the current
+    # working directory.  This is only done if the current directory is
+    # different from your home directory.  Thus, you can have more than one init
+    # file, one generic in your home directory, and another, specific to the
+    # program you are debugging, in the directory where you invoke byebug.
+    #
+    def run_init_script(out = handler.interface)
+      cwd_script_file  = File.expand_path(File.join(".", INITFILE))
+      run_script(cwd_script_file, out) if File.exists?(cwd_script_file)
+
+      home_script_file = File.expand_path(File.join(HOME_DIR, INITFILE))
+      run_script(home_script_file, out) if File.exists?(home_script_file) and
+        cwd_script_file != home_script_file
+    end
+
+    #
+    # Runs a script file
+    #
+    def run_script(file, out = handler.interface, verbose=false)
+      interface = ScriptInterface.new(File.expand_path(file), out)
+      processor = ControlCommandProcessor.new(interface)
+      processor.process_commands(verbose)
+    end
+
+    # XXX: Implement
+
+    #   # Activates the post-mortem mode. There are two ways of using it:
+    #   #
+    #   # == Global post-mortem mode
+    #   # By calling Byebug.post_mortem method without a block, you install
+    #   # at_exit hook that intercepts any unhandled by your script exceptions
+    #   # and enables post-mortem mode.
+    #   #
+    #   # == Local post-mortem mode
+    #   #
+    #   # If you know that a particular block of code raises an exception you can
+    #   # enable post-mortem mode by wrapping this block with Byebug.post_mortem, e.g.
+    #   #
+    #   #   def offender
+    #   #      raise 'error'
+    #   #   end
+    #   #   Byebug.post_mortem do
+    #   #      ...
+    #   #      offender
+    #   #      ...
+    #   #   end
+    #   def post_mortem
+    #     if block_given?
+    #       old_post_mortem = self.post_mortem?
+    #       begin
+    #         self.post_mortem = true
+    #         yield
+    #       rescue Exception => exp
+    #         handle_post_mortem(exp)
+    #         raise
+    #       ensure
+    #         self.post_mortem = old_post_mortem
+    #       end
+    #     else
+    #       return if post_mortem?
+    #       self.post_mortem = true
+    #       debug_at_exit do
+    #         handle_post_mortem($!) if $! && post_mortem?
+    #       end
+    #     end
+    #   end
+
+    #   def handle_post_mortem(exp)
+    #     return if !exp || !exp.__debug_context ||
+    #       exp.__debug_context.stack_size == 0
+    #     Byebug.suspend
+    #     orig_tracing = Byebug.tracing, Byebug.current_context.tracing
+    #     Byebug.tracing = Byebug.current_context.tracing = false
+    #     Byebug.last_exception = exp
+    #     handler.at_line(exp.__debug_context, exp.__debug_file, exp.__debug_line)
+    #   ensure
+    #     Byebug.tracing, Byebug.current_context.tracing = orig_tracing
+    #     Byebug.resume
+    #   end
+    #   # private :handle_post_mortem
+
+  end
+
+  class DebugThread # :nodoc:
+  end
+
+  class ThreadsTable # :nodoc:
+  end
+
+end
+
+class Exception # :nodoc:
+  attr_reader :__debug_file, :__debug_line, :__debug_binding, :__debug_context
+end
+
+class Module
+  #
+  # Wraps the +meth+ method with Byebug.start {...} block.
+  #
+  def debug_method(meth)
+    old_meth = "__debugee_#{meth}"
+    old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
+    alias_method old_meth.to_sym, meth
+    class_eval <<-EOD
+    def #{meth}(*args, &block)
+      Byebug.start do
+        byebug 2
+        #{old_meth}(*args, &block)
+      end
+    end
+    EOD
+  end
+
+  # XXX: Implement
+  # #
+  # # Wraps the +meth+ method with Byebug.post_mortem {...} block.
+  # #
+  # def post_mortem_method(meth)
+  #   old_meth = "__postmortem_#{meth}"
+  #   old_meth = "#{$1}_set" if old_meth =~ /^(.+)=$/
+  #   alias_method old_meth.to_sym, meth
+  #   class_eval <<-EOD
+  #   def #{meth}(*args, &block)
+  #     Byebug.start do |dbg|
+  #       dbg.post_mortem do
+  #         #{old_meth}(*args, &block)
+  #       end
+  #     end
+  #   end
+  #   EOD
+  # end
+end
+module Kernel
+
+  # Enters byebug in the current thread after _steps_ line events occur.
+  #
+  # Before entering byebug startup, the init script is read. Setting _steps_ to 0
+  # will cause a break in the byebug subroutine and not wait for a line event to
+  # occur. You will have to go "up 1" in order to be back to your debugged program
+  # from byebug program. Setting _steps_ to 0 could be useful if you want to stop
+  # right after the last statement in some scope, because the next step will take
+  # you out of some scope.
+  def byebug(steps = 1)
+    Byebug.start
+    Byebug.run_init_script(StringIO.new)
+    if 0 == steps
+      Byebug.current_context.stop_frame = 0
+    else
+      Byebug.current_context.stop_next = steps
+    end
+  end
+  alias breakpoint byebug unless respond_to?(:breakpoint)
+
+  #
+  # Returns a binding of n-th call frame
+  #
+  def binding_n(n = 0)
+    Byebug.skip do
+      Byebug.current_context.frame_binding(n+1)
+    end
+  end
+end