ruby-debug 0.2-mswin32 → 0.3-mswin32

data/CHANGES

@@ -1,23 +1,40 @@
-0.2 (2006-06-17)
+0.3 (2006-08-07)
+- Renamed Debugger.start_server to Debugger.start_remote.
+- Debugger.start_remote activates debugger by calling Debugger.start.
+- Debugger.start_remote starts a control thread which listen on port 8990 and accepts control 
+  commands, such as adding/deleting breakpoints, assigning catchpoint, etc. (Useful for GUI integration)
+- New Debugger.wait_connection option. When it's true, Debugger.start_remote waits until
+  a remote connection is made.
+- New Debugger.stop_on_connect option. When a remote connection is established, debugger
+  stops the main thread (Thread.main).
+- 'interrupt' command is available for the control thread.
+
+0.2.1 (2006-07-29)
+- 'f[rame] nn' command selects a numbered frame. Frame numbers can be obtained by running frame 
+  command without parameters.
+- 'l[ist] =' show code in the context of the current line.
+- 'tm[ate]' opens the current file in TextMate. Available only on Mac OSX. 
+
+0.2 (2006-07-17)
 - Added the remote debugging. It should be activated by calling Debugger#start_server method.
 - CHANGED: In order to activate the debugger, it's not enough to require 'ruby-debug'. 
   Debugger#start method must be called explicitly.
 - Debugger used to evaluate anything you enter as long as it's not a command. Starting from
   this version the 'eval' command must be used to evaluate an expression.
 
-0.1.5 (2006-06-13)
+0.1.5 (2006-07-13)
 - Now the check for a  breakpoint uses base filename of the source file.
 - Removed compilation warnings when compiling with -Wall
 
-0.1.4 (2006-06-12)
+0.1.4 (2006-07-12)
 - Remembers the previous command. Invoke it by typing a carriage return
   at the command prompt.
 
-0.1.3 (2006-06-11)
+0.1.3 (2006-07-11)
 - Conditional breakpoints
 - Bugfixes
 
-0.1.2 (2006-06-16)
+0.1.2 (2006-07-16)
 ========================
 
 - Initial release.

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/rdoctask'
 SO_NAME = "ruby_debug.so"
 
 # ------- Default Package ----------
-RUBY_DEBUG_VERSION = "0.2"
+RUBY_DEBUG_VERSION = "0.3"
 
 FILES = FileList[
   'Rakefile',

data/bin/rdebug

@@ -9,7 +9,10 @@ options = OpenStruct.new(
   'server' => false,
   'client' => false,
   'host'   => nil,
-  'port'   => Debugger::PORT
+  'port'   => Debugger::PORT,
+  'cport'  => Debugger::PORT + 1,
+  'wait'   => false,
+  'nostop' => false
 )
 
 opts = OptionParser.new do |opts|
@@ -20,9 +23,12 @@ EOB
   opts.separator ""
   opts.separator "Options:"
   opts.on("-s", "--server", "Listen for remote connections") {options.server = true}
+  opts.on("-w", "--wait", "Wait for a client connection, implies -s option") {options.wait = true}
+  opts.on("-n", "--nostop", "Do not stop when a client connects, implies -s option") {options.nostop = true}
   opts.on("-c", "--client", "Connect to remote debugger") {options.client = true}
   opts.on("-h", "--host HOST", "Host name used for remote debugging") {|options.host|}
   opts.on("-p", "--port PORT", Integer, "Port used for remote debugging") {|options.port|}
+  opts.on("--cport PORT", Integer, "Port used for contol commands, implies -s option") {|options.port|}
   opts.separator ""
   opts.separator "Common options:"
   opts.on_tail("--help", "Show this message") do
@@ -45,29 +51,7 @@ rescue StandardError => e
 end
 
 if options.client
-  require "socket"
-  interface = Debugger::LocalInterface.new
-  socket = TCPSocket.new(options.host, options.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
-  puts
+  Debugger.start_client(options.host, options.port)
 else
   if ARGV.empty?
     puts opts
@@ -77,8 +61,13 @@ else
   end
 
   trap('INT') { Debugger.interrupt_last }
-  Debugger.start_server(options.host, options.port) if options.server
-  Debugger.start
-  debugger 2
+  Debugger.stop_on_connect = !options.nostop
+  Debugger.wait_connection = options.wait
+  if options.server
+    Debugger.start_remote(options.host, [options.port, options.cport])
+  else
+    Debugger.start
+    debugger 2
+  end
   load ARGV.shift
 end

data/ext/ruby_debug.c

@@ -4,7 +4,7 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.2"
+#define DEBUG_VERSION "0.3"
 
 typedef struct {
     int thnum;
@@ -56,7 +56,7 @@ static ID idList;
 static ID idClear;
 
 static int thnum_max = 0;
-static int last_debugged_thnum = 0;
+static int last_debugged_thnum = -1;
 
 static VALUE debug_suspend(VALUE);
 static VALUE create_binding(VALUE);
@@ -176,13 +176,25 @@ save_current_position(VALUE context)
                           debug_context->last_file == Qnil || \
                           rb_str_cmp(debug_context->last_file, file) != 0)
 
+static VALUE
+call_at_line_unprotected(VALUE args)
+{
+    VALUE context;
+    context = *RARRAY(args)->ptr;
+    rb_funcall2(context, idAtLine, RARRAY(args)->len - 1, RARRAY(args)->ptr + 1);
+}
+
 static VALUE
 call_at_line(VALUE context, int thnum, VALUE binding, VALUE file, VALUE line)
 {
+    VALUE args;
+    
     last_debugged_thnum = thnum;
     save_current_position(context);
     debug_suspend(mDebugger);
-    return rb_funcall(context, idAtLine, 3, file, line, binding);
+    
+    args = rb_ary_new3(4, context, file, line, binding);
+    return rb_protect(call_at_line_unprotected, args, 0);
 }
 
 static void
@@ -288,7 +300,7 @@ get_breakpoint_at(int index)
 static VALUE
 eval_expression(VALUE args)
 {
-    return rb_funcall(rb_mKernel, idEval, 2, RARRAY(args)->ptr[0], RARRAY(args)->ptr[1]);
+    return rb_funcall2(rb_mKernel, idEval, 2, RARRAY(args)->ptr);
 }
 
 static int
@@ -558,22 +570,6 @@ debug_set_catchpoint(VALUE self, VALUE value)
     return value;
 }
 
-static VALUE
-debug_interrupt(VALUE self)
-{
-    VALUE thread, context;
-    debug_context_t *debug_context;
-
-    debug_check_started();
-
-    thread = rb_thread_current();
-    context = thread_context_lookup(thread);
-    Data_Get_Struct(context, debug_context_t, debug_context);
-    debug_context->stop_next = 1;
-
-    return Qnil;
-}
-
 static int
 find_last_context_func(VALUE key, VALUE value, VALUE *result)
 {
@@ -588,29 +584,14 @@ find_last_context_func(VALUE key, VALUE value, VALUE *result)
 }
 
 static VALUE
-find_last_context()
+debug_last_interrupted(VALUE self)
 {
     VALUE result = Qnil;
-    rb_hash_foreach(threads_tbl, find_last_context_func, (st_data_t)&result);
-    return result;
-}
-
-static VALUE
-debug_interrupt_last(VALUE self)
-{
-    VALUE context = Qnil;
-    debug_context_t *debug_context;
 
     debug_check_started();
 
-    context = find_last_context();
-    if(context != Qnil)
-    {
-        Data_Get_Struct(context, debug_context_t, debug_context);
-        debug_context->stop_next = 1;
-    }
-
-    return Qnil;
+    rb_hash_foreach(threads_tbl, find_last_context_func, (st_data_t)&result);
+    return result;
 }
 
 static VALUE
@@ -953,8 +934,7 @@ Init_ruby_debug()
     rb_define_module_function(mDebugger, "add_breakpoint", debug_add_breakpoint, -1);
     rb_define_module_function(mDebugger, "catchpoint", debug_catchpoint, 0);
     rb_define_module_function(mDebugger, "catchpoint=", debug_set_catchpoint, 1);
-    rb_define_module_function(mDebugger, "interrupt", debug_interrupt, 0);
-    rb_define_module_function(mDebugger, "interrupt_last", debug_interrupt_last, 0);
+    rb_define_module_function(mDebugger, "last_context", debug_last_interrupted, 0);
     rb_define_module_function(mDebugger, "contexts", debug_contexts, 0);
     rb_define_module_function(mDebugger, "current_context", debug_current_context, 0);
     rb_define_module_function(mDebugger, "suspend", debug_suspend, 0);

data/lib/ruby-debug.rb

@@ -2,56 +2,22 @@ require 'pp'
 require 'stringio'
 require 'thread'
 require 'ruby_debug.so'
+require 'ruby-debug/lock'
 require 'ruby-debug/processor'
 
 SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
 
 module Debugger
-  MUTEX = Class.new do
-    def initialize
-      @locker = nil
-      @waiting = []
-      @locked = false;
-    end
-
-    def locked?
-      @locked
-    end
-
-    def lock
-      return if Thread.critical
-      return if @locker == Thread.current
-      while (Thread.critical = true; @locked)
-        @waiting.push Thread.current
-        Thread.stop
-      end
-      @locked = true
-      @locker = Thread.current
-      Thread.critical = false
-      self
-    end
-
-    def unlock
-      return if Thread.critical
-      return unless @locked
-      unless @locker == Thread.current
-        raise RuntimeError, "unlocked by other"
-      end
-      Thread.critical = true
-      t = @waiting.shift
-      @locked = false
-      @locker = nil
-      Thread.critical = false
-      t.run if t
-      self
-    end
-  end.new
-  
+  MUTEX = Lock.new
   PORT = 8989
 
   @processor = CommandProcessor.new
   
   class Context
+    def interrupt
+      self.stop_next = 1
+    end
+
     private
 
     def processor
@@ -80,23 +46,135 @@ module Debugger
 
   class << self
     attr_accessor :processor
-    attr_reader :thread
+    
+    # stop main thread when remote connection established
+    attr_accessor :stop_on_connect
+    
+    # in remote mode, wait for the remote connection 
+    attr_accessor :wait_connection
+    
+    attr_reader :thread, :control_thread
+    
+    # Interrupts the main thread
+    def interrupt
+      context = contexts.find{|c| c.thread == Thread.current }
+      context.interrupt
+    end
+    
+    # Interrupts the last debugged thread
+    def interrupt_last
+      if context = last_context
+        context.interrupt
+      end
+      context
+    end
     
     def interface=(value)
       processor.interface = value
     end
     
-    def start_server(host = nil, port = PORT)
+    # Starts a remote debugger.
+    def start_remote(host = nil, port = PORT)
       return if @thread
+      return if started?
+
+      self.interface = nil
+      start
+
       require "socket"
       
-      server = TCPServer.new(host, port)
-      @thread = Thread.start do
+      if port.kind_of?(Array)
+        cmd_port, ctrl_port = port
+      else
+        cmd_port, ctrl_port = port, port + 1
+      end
+
+      @control_tread = Thread.start do
+        server = TCPServer.new(host, ctrl_port)
         while (session = server.accept)
           interface = RemoteInterface.new(session)
-          self.interface = interface
+          processor = ControlCommandProcessor.new(interface)
+          processor.process_commands
+        end
+      end
+      
+      mutex = Mutex.new
+      proceed = ConditionVariable.new
+      
+      @thread = Thread.start do
+        server = TCPServer.new(host, cmd_port)
+        while (session = server.accept)
+          self.interface = RemoteInterface.new(session)
+          if wait_connection
+            mutex.synchronize do
+              proceed.signal
+            end
+          else
+            stop_main_thread
+          end
+        end
+      end
+      if wait_connection
+        mutex.synchronize do
+          proceed.wait(mutex)
+        end 
+        stop_main_thread
+      end
+    end
+    alias start_server start_remote
+    
+    # Connects to the remote debugger
+    def start_client(host = 'localhost', port = PORT)
+      require "socket"
+      interface = Debugger::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
+      puts
+    end
+    
+    def stop_main_thread
+      return unless stop_on_connect
+      
+      context = contexts.find{ |c| c.thread == Thread.main }
+      context.stop_next = 2
+    end
+    private :stop_main_thread
+
+    def source_for(file)
+      if source = SCRIPT_LINES__[file]
+        return source unless source == true
+      end
+      if File.exists?(file)
+        SCRIPT_LINES__[file] = File.readlines(file)
+      end
+    end
+    
+    def line_at(file, line)
+      lines = source_for(file)
+      if lines
+        line = lines[line-1]
+        return "\n" unless line
+        return "#{line.gsub(/^\s+/, '').chomp}\n"
+      end
+      return "\n"
     end
   end
 end