ruby-debug 0.1.5-mswin32 → 0.2-mswin32

data/CHANGES

@@ -1,3 +1,10 @@
+0.2 (2006-06-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)
 - Now the check for a  breakpoint uses base filename of the source file.
 - Removed compilation warnings when compiling with -Wall

data/Rakefile

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

data/bin/rdebug

@@ -1,13 +1,84 @@
 #!/usr/bin/env ruby
 
-if ARGV.empty?
-  puts "Usage: #{__FILE__} <script>"
-  exit(1)
-end
-
 require 'rubygems'
+require 'optparse'
+require "ostruct"
 require 'ruby-debug'
-trap('INT') { Debugger.interrupt_last }
 
-debugger 2
-load ARGV.shift
+options = OpenStruct.new(
+  'server' => false,
+  'client' => false,
+  'host'   => nil,
+  'port'   => Debugger::PORT
+)
+
+opts = OptionParser.new do |opts|
+  opts.banner = <<EOB
+ruby-debug #{Debugger::VERSION}
+Usage: rdebug [options] <script.rb> <script.rb parameters>
+EOB
+  opts.separator ""
+  opts.separator "Options:"
+  opts.on("-s", "--server", "Listen for remote connections") {options.server = 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.separator ""
+  opts.separator "Common options:"
+  opts.on_tail("--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on_tail("-v", "--version", "Show version") do
+    puts "ruby-debug #{Debugger::VERSION}"
+    exit
+  end
+end
+
+begin
+  opts.parse! ARGV
+rescue StandardError => e
+  puts opts
+  puts
+  puts e.message
+  exit(-1)
+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
+else
+  if ARGV.empty?
+    puts opts
+    puts
+    puts "Must specify a script to run"
+    exit(-1)
+  end
+
+  trap('INT') { Debugger.interrupt_last }
+  Debugger.start_server(options.host, options.port) if options.server
+  Debugger.start
+  debugger 2
+  load ARGV.shift
+end

data/bin/remote

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require "ruby-debug/inputs"
+
+host = ARGV[0] || "localhost"
+port = 8989
+
+input = Debugger::LocalInput.new
+socket = TCPSocket.new(host, port)
+puts "Connected."
+
+catch(:exit) do
+  while (line = socket.gets)
+    case line 
+    when /^PROMPT (.*)$/
+      data = input.read_command($1)
+      throw :exit unless data
+      socket.puts data
+    when /^CONFIRM (.*)$/
+      data = input.confirm($1)
+      throw :exit unless data
+      socket.puts data
+    else
+      print line
+    end
+  end
+end
+socket.close
+puts

data/ext/ruby_debug.c

@@ -4,13 +4,15 @@
 #include <rubysig.h>
 #include <st.h>
 
-#define DEBUG_VERSION "0.1.5"
+#define DEBUG_VERSION "0.2"
 
 typedef struct {
     int thnum;
+    VALUE last_file;
+    VALUE last_line;
+    int moved;
     int stop_next;
     int dest_frame;
-    int src_line;
     int stop_line;
     int stop_frame;
     int suspend;
@@ -43,7 +45,7 @@ static VALUE cContext;
 static VALUE cFrame;
 static VALUE cBreakpoint;
 
-static ID idDebugCommand;
+static ID idAtLine;
 static ID idAtBreakpoint;
 static ID idAtCatchpoint;
 static ID idAtTracing;
@@ -81,6 +83,8 @@ debug_context_mark(void* data)
     debug_context_t *debug_context = (debug_context_t *)data;
     rb_gc_mark(debug_context->frames);
     rb_gc_mark(debug_context->thread);
+    rb_gc_mark(debug_context->last_file);
+    rb_gc_mark(debug_context->last_line);
 }
 
 static VALUE
@@ -91,9 +95,13 @@ debug_context_create(VALUE thread)
     
     debug_context = ALLOC(debug_context_t);
     debug_context-> thnum = ++thnum_max;
+    
+    debug_context->last_file = Qnil;
+    debug_context->last_line = Qnil;
+    debug_context->moved = 0;
+
     debug_context->stop_next = -1;
     debug_context->dest_frame = -1;
-    debug_context->src_line = -1;
     debug_context->stop_line = -1;
     debug_context->stop_frame = -1;
     debug_context->suspend = 0;
@@ -145,16 +153,36 @@ debug_frame_create(VALUE file, VALUE line, VALUE binding, ID id)
     return result;
 }
 
-static VALUE
-call_debug_command(VALUE context, int thnum, VALUE binding, ID mid, VALUE file, VALUE line)
+static void
+save_current_position(VALUE context)
 {
-    VALUE id;
+    VALUE cur_frame;
+    debug_context_t *debug_context;
+    debug_frame_t *debug_frame;
+
+    Data_Get_Struct(context, debug_context_t, debug_context);
+    if(RARRAY(debug_context->frames)->len == 0)
+        return;
+
+    cur_frame = *RARRAY(debug_context->frames)->ptr;
+    Data_Get_Struct(cur_frame, debug_frame_t, debug_frame);
+    
+    debug_context->last_file = debug_frame->file;
+    debug_context->last_line = debug_frame->line;
+    debug_context->moved = 0;
+}
 
-    id = mid ? ID2SYM(mid) : Qnil;
+#define did_moved()   (debug_context->last_line != line || \
+                          debug_context->last_file == Qnil || \
+                          rb_str_cmp(debug_context->last_file, file) != 0)
 
+static VALUE
+call_at_line(VALUE context, int thnum, VALUE binding, VALUE file, VALUE line)
+{
     last_debugged_thnum = thnum;
+    save_current_position(context);
     debug_suspend(mDebugger);
-    return rb_funcall(context, idDebugCommand, 4, file, line, id, binding);
+    return rb_funcall(context, idAtLine, 3, file, line, binding);
 }
 
 static void
@@ -189,7 +217,7 @@ basename(VALUE filename)
 }
 
 static int
-check_breakpoints(VALUE context, VALUE file, VALUE klass, VALUE pos)
+check_breakpoints(debug_context_t *debug_context, VALUE file, VALUE klass, VALUE pos)
 {
     VALUE breakpoint; 
     debug_breakpoint_t *debug_breakpoint;
@@ -197,6 +225,9 @@ check_breakpoints(VALUE context, VALUE file, VALUE klass, VALUE pos)
 
     if(RARRAY(breakpoints)->len == 0)
         return -1;
+    if(!debug_context->moved)
+        return -1;
+    
     for(i = 0; i < RARRAY(breakpoints)->len; i++)
     {
         breakpoint = rb_ary_entry(breakpoints, i);
@@ -282,10 +313,12 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     debug_context_t *debug_context;
     VALUE file = Qnil, line = Qnil;
     int breakpoint_index = -1;
-
+    
     static int debugging = 0;
 
+    if (mid == ID_ALLOCATOR) return;
     if(debugging) return;
+    if(!node) return;
 
     debugging++;
 
@@ -294,11 +327,11 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     Data_Get_Struct(context, debug_context_t, debug_context);
     check_suspend(debug_context);
 
-    if(node)
-    {
-        file = rb_str_new2(node->nd_file);
-        line = INT2FIX(nd_line(node));
-    }
+    file = rb_str_new2(node->nd_file);
+    line = INT2FIX(nd_line(node));
+
+    if(did_moved())
+        debug_context->moved  = 1;
 
     switch(event)
     {
@@ -310,15 +343,15 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         {
             rb_funcall(context, idAtTracing, 2, file, line);
         }
-
+        
         if(debug_context->dest_frame == -1 || 
             RARRAY(debug_context->frames)->len == debug_context->dest_frame)
         {
             debug_context->stop_next--;
             if(debug_context->stop_next < 0)
-            debug_context->stop_next = -1;
+                debug_context->stop_next = -1;
             /* we check that we actualy moved to another line */
-            if(line != Qnil && debug_context->src_line != FIX2INT(line))
+            if(did_moved())
             {
                 debug_context->stop_line--;
             }
@@ -334,7 +367,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         }
 
         if(debug_context->stop_next == 0 || debug_context->stop_line == 0 ||
-            (breakpoint_index = check_breakpoints(context, file, klass, line)) != -1)
+            (breakpoint_index = check_breakpoints(debug_context, file, klass, line)) != -1)
         {
             binding = self? create_binding(self) : Qnil;
             /* check breakpoint expression */
@@ -342,41 +375,37 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             {
                 breakpoint = get_breakpoint_at(breakpoint_index);
                 if(check_breakpoint_expression(breakpoint, binding))
-                    rb_funcall(context, idAtBreakpoint, 2, breakpoint, mid ? rb_str_new2(rb_id2name(mid)) : Qnil);
+                    rb_funcall(context, idAtBreakpoint, 1, breakpoint);
                 else
                     break;
             }
 
             /* reset all pointers */
             debug_context->dest_frame = -1;
-            debug_context->src_line = -1;
             debug_context->stop_line = -1;
             debug_context->stop_next = -1;
 
-            call_debug_command(context, debug_context->thnum, binding, mid, file, line);
+            call_at_line(context, debug_context->thnum, binding, file, line);
         }
         break;
         }
     case RUBY_EVENT_C_CALL:
-        {
-        if(node)
         {
             set_frame_source(debug_context, file, line);
-        }
-        break;
+            break;
         }
     case RUBY_EVENT_CALL:
         {
         save_call_frame(self, file, line, mid, debug_context);
-        breakpoint_index = check_breakpoints(context, file, klass, rb_str_new2(rb_id2name(mid)));
+        breakpoint_index = check_breakpoints(debug_context, file, klass, rb_str_new2(rb_id2name(mid)));
         if(breakpoint_index != -1)
         {
             binding = self? create_binding(self) : Qnil;
             breakpoint = get_breakpoint_at(breakpoint_index);
             if(check_breakpoint_expression(breakpoint, binding))
             {
-                rb_funcall(context, idAtBreakpoint, 2, breakpoint, mid ? rb_str_new2(rb_id2name(mid)) : Qnil);
-                call_debug_command(context, debug_context->thnum, binding, mid, file, line);
+                rb_funcall(context, idAtBreakpoint, 1, breakpoint);
+                call_at_line(context, debug_context->thnum, binding, file, line);
             }
         }
         break;
@@ -407,7 +436,7 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
         if( !NIL_P(rb_class_inherited_p(expn_class, rb_eSystemExit)) )
         {
             debug_stop(mDebugger);
-            rb_exit(0);
+            break;
         }
 
         if(catchpoint == Qnil)
@@ -419,10 +448,10 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
             aclass = rb_ary_entry(ancestors, i);
             if(rb_str_cmp(rb_mod_name(aclass), catchpoint) == 0)
             {
-                rb_funcall(context, idAtCatchpoint, 0);
+                rb_funcall(context, idAtCatchpoint, 1, ruby_errinfo);
                 binding = self? create_binding(self) : Qnil;
-                call_debug_command(context, debug_context->thnum, binding, mid, file, line);
-            break;
+                call_at_line(context, debug_context->thnum, binding, file, line);
+                break;
             }
         }
 
@@ -437,18 +466,6 @@ debug_event_hook(rb_event_t event, NODE *node, VALUE self, ID mid, VALUE klass)
     debugging--;
 }
 
-static VALUE
-debug_thnum(VALUE self)
-{
-    VALUE thread, context;
-    debug_context_t *debug_context;
-    
-    thread = rb_thread_current();
-    context = thread_context_lookup(thread);
-    Data_Get_Struct(context, debug_context_t, debug_context);
-    return INT2FIX(debug_context->thnum);
-}
-
 static VALUE
 debug_start(VALUE self)
 {
@@ -743,9 +760,8 @@ context_stop_next(VALUE self, VALUE steps)
 static VALUE
 context_step_over(int argc, VALUE *argv, VALUE self)
 {
-    VALUE lines, frame, cur_frame;
+    VALUE lines, frame;
     debug_context_t *debug_context;
-    debug_frame_t *debug_frame;
 
     debug_check_started();
 
@@ -766,10 +782,6 @@ context_step_over(int argc, VALUE *argv, VALUE self)
         debug_context->dest_frame = FIX2INT(frame);
     }
 
-    cur_frame = *RARRAY(debug_context->frames)->ptr;
-    Data_Get_Struct(cur_frame, debug_frame_t, debug_frame);
-    debug_context->src_line = FIX2INT(debug_frame->line);
-
     return Qnil;
 }
 
@@ -937,7 +949,6 @@ Init_ruby_debug()
     rb_define_module_function(mDebugger, "start", debug_start, 0);
     rb_define_module_function(mDebugger, "stop", debug_stop, 0);
     rb_define_module_function(mDebugger, "started?", debug_is_started, 0);
-    rb_define_module_function(mDebugger, "thnum", debug_thnum, 0);
     rb_define_module_function(mDebugger, "breakpoints", debug_breakpoints, 0);
     rb_define_module_function(mDebugger, "add_breakpoint", debug_add_breakpoint, -1);
     rb_define_module_function(mDebugger, "catchpoint", debug_catchpoint, 0);
@@ -974,7 +985,7 @@ Init_ruby_debug()
     rb_define_method(cBreakpoint, "pos", breakpoint_pos, 0);
     rb_define_method(cBreakpoint, "expr", breakpoint_expr, 0);
 
-    idDebugCommand = rb_intern("debug_command");
+    idAtLine       = rb_intern("at_line");
     idAtBreakpoint = rb_intern("at_breakpoint");
     idAtCatchpoint = rb_intern("at_catchpoint");
     idAtTracing    = rb_intern("at_tracing");

data/lib/ruby-debug.rb

@@ -1,10 +1,13 @@
-require 'ruby_debug.so'
 require 'pp'
+require 'stringio'
+require 'thread'
+require 'ruby_debug.so'
+require 'ruby-debug/processor'
 
 SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
 
 module Debugger
-  class Mutex
+  MUTEX = Class.new do
     def initialize
       @locker = nil
       @waiting = []
@@ -42,582 +45,56 @@ module Debugger
       t.run if t
       self
     end
-  end
-
-  MUTEX = Mutex.new
-
-  @stdout = STDOUT
-  @display = []
-  @trace_proc = nil
+  end.new
+  
+  PORT = 8989
 
+  @processor = CommandProcessor.new
+  
   class Context
-    DEBUG_LAST_CMD = []
-
     private
 
-    begin
-      require 'readline'
-      def readline(prompt, hist)
-        Readline::readline(prompt, hist)
-      end
-    rescue LoadError
-      def readline(prompt, hist)
-        STDOUT.print prompt
-        STDOUT.flush
-        line = STDIN.gets
-        exit unless line
-        line.chomp!
-        line
-      end
-      USE_READLINE = false
+    def processor
+      Debugger.processor
     end
 
-    def stdout
-      Debugger.stdout
+    def at_breakpoint(breakpoint)
+      processor.at_breakpoint(self, breakpoint)
     end
 
-    def at_breakpoint(breakpoint, method_name)
-      n = Debugger.breakpoints.index(breakpoint) + 1
-      stdout.printf "Breakpoint %d, %s at %s:%s\n", n, method_name, breakpoint.source, breakpoint.pos
-    end
-
-    def at_catchpoint
-      frames = Debugger.current_context.frames
-      stdout.printf "%s:%d: `%s' (%s)\n", frames[0].file, frames[0].line, $!, $!.class
-      fs = frames.size
-      tb = caller(0)[-fs..-1]
-      if tb
-        for i in tb
-          stdout.printf "\tfrom %s\n", i
-        end
-      end
+    def at_catchpoint(excpt)
+      processor.at_catchpoint(self, excpt)
     end
 
     def at_tracing(file, line)
-      if Debugger.trace_proc
-        Debugger.trace_proc.call(self.thnum, file, line)
-      else
-        stdout.puts sprintf("Tracing(%d):%s:%s %s", self.thnum, file, line, line_at(file, line))
-      end
+      processor.at_tracing(self, file, line)
     end
 
-    def debug_command(file, line, id, binding)
+    def at_line(file, line, binding)
       MUTEX.lock
-      frame_pos = 0
-      binding_file = file
-      binding_line = line
-      previous_line = nil
-      stdout.printf "%s:%d: %s", binding_file, binding_line, line_at(binding_file, binding_line)
-      display_expressions(binding)
-      prompt = true
-      while prompt and input = readline("(rdb:%d) " % Debugger.thnum, true)
-        catch(:debug_error) do
-          if input == ""
-            next unless DEBUG_LAST_CMD[0]
-            input = DEBUG_LAST_CMD[0]
-          else
-            DEBUG_LAST_CMD[0] = input
-          end
-
-          case input
-          when /^\s*s(?:tep)?(?:\s+(\d+))?$/
-            self.stop_next = $1 ? $1.to_i : 1
-            prompt = false
-
-          when /^\s*c(?:ont)?$|^\s*r(?:un)?$/
-            prompt = false
-
-          when /^\s*v(?:ar)?\s+/
-            debug_variable_info($', binding)
-
-          when /^\s*w(?:here)?$/, /^\s*f(?:rame)?$/
-            display_frames(frame_pos)
-
-          when /^\s*l(?:ist)?(?:\s+(.+))?$/
-            if not $1
-              b = previous_line ? previous_line + 10 : binding_line - 5
-              e = b + 9
-            elsif $1 == '-'
-              b = previous_line ? previous_line - 10 : binding_line - 5
-              e = b + 9
-            else
-              b, e = $1.split(/[-,]/)
-              if e
-                b = b.to_i
-                e = e.to_i
-              else
-                b = b.to_i - 5
-                e = b + 9
-              end
-            end
-            previous_line = b
-            display_list(b, e, binding_file, binding_line)
-
-          when /^\s*n(?:ext)?(?:\s+(\d+))?$/
-            steps = $1 ? $1.to_i : 1
-            self.step_over steps, self.frames.size - frame_pos
-            prompt = false
-
-          when /^\s*up(?:\s+(\d+))?$/
-            previous_line = nil
-            frame_pos += $1 ? $1.to_i : 1
-            if frame_pos >= self.frames.size
-              frame_pos = self.frames.size - 1
-              stdout.puts "At toplevel"
-            end
-            frame = self.frames[frame_pos]
-            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
-            stdout.print format_frame(frame, frame_pos)
-
-          when /^\s*down(?:\s+(\d+))?$/
-            previous_line = nil
-            frame_pos -= $1 ? $1.to_i : 1
-            if frame_pos < 0
-              frame_pos = 0
-              stdout.print "At stack bottom\n"
-            end
-            frame = self.frames[frame_pos]
-            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
-            stdout.print format_frame(frame, frame_pos)
-
-          when /^\s*fin(?:ish)?$/
-            if frame_pos == self.frames.size
-              stdout.print "\"finish\" not meaningful in the outermost frame.\n"
-            else
-              self.stop_frame = self.frames.size - frame_pos
-              frame_pos = 0
-              prompt = false
-            end
-
-          when /^\s*b(?:reak)?\s+(?:(.+):)?([^.:\s]+)\s*(?:\sif\s+(.+))?$/
-            pos = $2
-            expr = $3
-            if $1
-              klass = debug_silent_eval($1, binding)
-              if klass && !klass.kind_of?(Module)
-                stdout.puts "Unknown class #$1"
-                throw :debug_error
-              end
-              klass = klass.name if klass
-              file = $1
-            end
-            if pos =~ /^\d+$/
-              pname = pos
-              pos = pos.to_i
-            else
-              pname = pos = pos.intern.id2name
-            end
-            Debugger.add_breakpoint klass || file, pos, expr
-            stdout.printf "Set breakpoint %d at %s:%s\n", Debugger.breakpoints.size, klass || file, pname
-
-          when /^\s*b(?:reak)?\s+(.+)[#.]([^.:\s]+)(?:\s+if\s+(.+))?$/
-            pos = $2.intern.id2name
-            expr = $3
-            klass = debug_eval($1, binding)
-            if klass.nil? || !klass.kind_of?(Module)
-              stdout.puts "Unknown class #$1"
-              throw :debug_error
-            end
-            Debugger.add_breakpoint klass.name, pos, expr
-            stdout.printf "Set breakpoint %d at %s.%s\n", Debugger.breakpoints.size, klass, pos
-
-          when /^\s*b(?:reak)?$/
-            unless Debugger.breakpoints.empty?
-              stdout.print "Breakpoints:\n"
-              Debugger.breakpoints.each_with_index do |b, n|
-                if b.expr.nil?
-                  stdout.printf "  %d %s:%s\n", n+1, b.source, b.pos
-                else
-                  stdout.printf "  %d %s:%s if %s\n", n+1, b.source, b.pos, b.expr
-                end
-              end
-              stdout.puts
-            else
-              stdout.print "No breakpoints\n"
-            end
-          when /^\s*del(?:ete)?(?:\s+(\d+))?$/
-            pos = $1
-            unless pos
-              input = readline("Clear all breakpoints? (y/n) ", false)
-              if input == "y"
-                Debugger.breakpoints.clear
-              end
-            else
-              pos = pos.to_i
-              unless Debugger.breakpoints.delete_at(pos-1)
-                stdout.printf "Breakpoint %d is not defined\n", pos
-              end
-            end
-
-          when /^\s*th(?:read)?\s+/
-            if Debugger.debug_thread_info($') == :cont
-              prompt = false
-            end
-
-          when /^\s*m(?:ethod)?\s+/
-            debug_method_info($', binding)
-
-          when /^\s*pp\s+/
-            PP.pp(debug_eval($', binding), stdout) rescue stdout.puts $!.message
-
-          when /^\s*p\s+/
-            stdout.printf "%s\n", debug_eval($', binding).inspect
-
-          when /^\s*h(?:elp)?$/
-            debug_print_help()
-
-          when /^\s*q(?:uit)?$/
-            input = readline("Really quit? (y/n) ", false)
-            if input == "y"
-              exit! # exit -> exit!: No graceful way to stop threads...
-            end
-
-          when /^\s*disp(?:lay)?\s+(.+)$/
-            exp = $1
-            display.push [true, exp]
-            stdout.printf "%d: ", display.size
-            display_expression(exp, binding)
-
-          when /^\s*disp(?:lay)?$/
-            display_expressions(binding)
-
-          when /^\s*undisp(?:lay)?(?:\s+(\d+))?$/
-            pos = $1
-            unless pos
-              input = readline("Clear all expressions? (y/n) ", false)
-              if input == "y"
-                for d in display
-                  d[0] = false
-                end
-              end
-            else
-              pos = pos.to_i
-              if display[pos-1]
-                display[pos-1][0] = false
-              else
-                stdout.printf "Display expression %d is not defined\n", pos
-              end
-            end
-
-          when /^\s*cat(?:ch)?(?:\s+(.+))?$/
-            if $1
-              excn = $1
-              if excn == 'off'
-                Debugger.catchpoint = nil
-                stdout.print "Clear catchpoint.\n"
-              else
-                Debugger.catchpoint = excn
-                stdout.printf "Set catchpoint %s.\n", excn
-              end
-            else
-              if Debugger.catchpoint
-                stdout.printf "Catchpoint %s.\n", Debugger.catchpoint
-              else
-                stdout.print "No catchpoint.\n"
-              end
-            end
-
-          when /^\s*tr(?:ace)?(?:\s+(on|off))?(?:\s+(all))?$/
-            if defined?( $2 )
-              Debugger.tracing = $1 == 'on'
-            elsif defined?( $1 )
-              self.tracing = $1 == 'on'
-            end
-            if Debugger.tracing || self.tracing
-              stdout.print "Trace on.\n"
-            else
-              stdout.print "Trace off.\n"
-            end
-
-          else
-            v = debug_eval(input, binding)
-            stdout.printf "%s\n", v.inspect
-          end
-        end
-      end
+      processor.at_line(self, file, line, binding)
       MUTEX.unlock
       Debugger.resume
     end
-
-    def debug_print_help
-      stdout.print <<EOHELP
-ruby-debug help v.#{Debugger::VERSION}
-Commands
-b[reak] [file|class:]<line|method> [if expr]
-b[reak] [class.]<line|method> [if expr]
-                           set breakpoint to some position,
-                           optionally if expr == true
-cat[ch] <an Exception>     set catchpoint to an exception
-cat[ch]                    show catchpoint
-disp[lay] <expression>     add expression into display expression list
-undisp[lay][ nnn]          delete one particular or all display expressions
-b[reak]                    list breakpoints
-del[ete][ nnn]             delete some or all breakpoints
-c[ont]                     run until program ends or hit breakpoint
-r[un]                      alias for cont
-s[tep][ nnn]               step (into methods) one line or till line nnn
-n[ext][ nnn]               go over one line or till line nnn
-w[here]                    display frames
-f[rame]                    alias for where
-l[ist][ (-|nn-mm)]         list program, - list backwards, nn-mm list given lines
-up[ nn]                    move to higher frame
-down[ nn]                  move to lower frame
-fin[ish]                   return to outer frame
-q[uit]                     exit from debugger
-v[ar] g[lobal]             show global variables
-v[ar] l[ocal]              show local variables
-v[ar] i[nstance] <object>  show instance variables of object
-v[ar] c[onst] <object>     show constants of object
-m[ethod] i[nstance] <obj>  show methods of object
-m[ethod] <class|module>    show instance methods of class or module
-th[read] l[ist]            list all threads
-th[read] c[ur[rent]]       show current thread
-th[read] [sw[itch]] <nnn>  switch thread context to nnn
-th[read] stop <nnn>        stop thread nnn
-th[read] resume <nnn>      resume thread nnn
-p expression               evaluate expression and print its value
-pp expression              evaluate expression and print its value
-h[elp]                     print this help
-<everything else>          evaluate
-EOHELP
-    end
-
-    def display_expressions(binding)
-      n = 1
-      for d in display
-        if d[0]
-          stdout.printf "%d: ", n
-          display_expression(d[1], binding)
-        end
-        n += 1
-      end
-    end
-
-    def display_expression(exp, binding)
-      stdout.printf "%s = %s\n", exp, debug_silent_eval(exp, binding).to_s
-    end
-
-    def debug_eval(str, binding)
-      begin
-        val = eval(str, binding)
-      rescue StandardError, ScriptError => e
-        at = eval("caller(1)", binding)
-        stdout.printf "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
-        for i in at
-          stdout.printf "\tfrom %s\n", i
-        end
-        throw :debug_error
-      end
-    end
-
-    def debug_silent_eval(str, binding)
-      begin
-        eval(str, binding)
-      rescue StandardError, ScriptError
-        nil
-      end
-    end
-
-    def debug_variable_info(input, binding)
-      case input
-      when /^\s*g(?:lobal)?\s*$/
-        var_list(global_variables, binding)
-
-      when /^\s*l(?:ocal)?\s*$/
-        var_list(eval("local_variables", binding), binding)
-
-      when /^\s*i(?:nstance)?\s+/
-        obj = debug_eval($', binding)
-        var_list(obj.instance_variables, obj.instance_eval{binding()})
-
-      when /^\s*c(?:onst(?:ant)?)?\s+/
-        obj = debug_eval($', binding)
-        unless obj.kind_of? Module
-          stdout.print "Should be Class/Module: ", $', "\n"
-        else
-          var_list(obj.constants, obj.module_eval{binding()})
-        end
-      end
-    end
-
-    def display_frames(pos)
-      self.frames.each_with_index do |frame, idx|
-        if idx == pos
-          stdout.print "--> "
-        else
-          stdout.print "    "
-        end
-        stdout.print format_frame(frame, idx)
-      end
-    end
-
-    def format_frame(frame, pos)
-      bind, file, line, id = frame.binding, frame.file, frame.line, frame.id
-      sprintf "#%d %s:%s%s\n", pos + 1, file, line,
-      (id ? ":in `#{id.id2name}'" : "")
-    end
-
-    def var_list(ary, binding)
-      ary.sort!
-      for v in ary
-        stdout.printf "  %s => %s\n", v, eval(v, binding).inspect
-      end
-    end
-
-    def display_list(b, e, file, line)
-      stdout.printf "[%d, %d] in %s\n", b, e, file
-      if lines = SCRIPT_LINES__[file] and lines != true
-        n = 0
-        b.upto(e) do |n|
-          if n > 0 && lines[n-1]
-            if n == line
-              stdout.printf "=> %d  %s\n", n, lines[n-1].chomp
-            else
-              stdout.printf "   %d  %s\n", n, lines[n-1].chomp
-            end
-          end
-        end
-      else
-        stdout.printf "No sourcefile available for %s\n", file
-      end
-    end
-
-    def line_at(file, line)
-      lines = SCRIPT_LINES__[file]
-      if lines
-        return "\n" if lines == true
-        line = lines[line-1]
-        return "\n" unless line
-        return line.gsub(/^\s+/, '')
-      end
-      return "\n"
-    end
-
-    def display
-      Debugger.display
-    end
   end
 
   class << self
-    def stdout
-      @stdout
-    end
-
-    def stdout=(v)
-      @stdout = v
-    end
-
-    def set_trace_proc &block
-      @trace_proc = block
-    end
-
-    def trace_proc
-      @trace_proc
-    end
-
-    def display
-      @display
-    end
-
-    def debug_method_info(input, binding)
-      case input
-      when /^i(:?nstance)?\s+/
-        obj = debug_eval($', binding)
-
-        len = 0
-        for v in obj.methods.sort
-          len += v.size + 1
-          if len > 70
-            len = v.size + 1
-            stdout.print "\n"
-          end
-          stdout.print v, " "
-        end
-        stdout.print "\n"
-
-      else
-        obj = debug_eval(input, binding)
-        unless obj.kind_of? Module
-          stdout.print "Should be Class/Module: ", input, "\n"
-        else
-          len = 0
-          for v in obj.instance_methods(false).sort
-            len += v.size + 1
-            if len > 70
-              len = v.size + 1
-              stdout.print "\n"
-            end
-            stdout.print v, " "
-          end
-          stdout.print "\n"
-        end
-      end
-    end
-
-    def display_context(c)
-      if c.thread == Thread.current
-        stdout.print "+"
-      else
-        stdout.print " "
-      end
-      stdout.printf "%d ", c.thnum
-      stdout.print c.thread.inspect, "\t"
-      last_frame = c.frames.first
-      if last_frame
-        @stdout.print last_frame.file,":",last_frame.line
-      end
-      @stdout.print "\n"
-    end
-
-    def display_all_contexts
-      threads = contexts.sort_by{|c| c.thnum}.each do |c|
-        display_context(c)
-      end
-    end
-
-    def get_context(thnum)
-      contexts.find{|c| c.thnum = thnum}
-    end
-
-    def debug_thread_info(input)
-      case input
-      when /^l(?:ist)?/
-        display_all_contexts
-
-      when /^c(?:ur(?:rent)?)?$/
-        display_context(current_context)
-
-      when /^(?:sw(?:itch)?\s+)?(\d+)/
-        c = get_context($1.to_i)
-        if c == current_context
-          stdout.print "It's the current thread.\n"
-        else
-          display_context(c)
-          c.stop_next = 1
-          c.thread.run
-          return :cont
-        end
-
-      when /^stop\s+(\d+)/
-        c = get_context($1.to_i)
-        if c == current_context
-          stdout.print "It's the current thread.\n"
-        elsif c.thread.stop?
-          stdout.print "Already stopped.\n"
-        else
-          display_context(c)
-          c.set_suspend
-        end
-
-      when /^resume\s+(\d+)/
-        c = get_context($1.to_i)
-        if c == current_context
-          stdout.print "It's the current thread.\n"
-        elsif !c.thread.stop?
-          stdout.print "Already running."
-        else
-          display_context(c)
-          c.thread.run
+    attr_accessor :processor
+    attr_reader :thread
+    
+    def interface=(value)
+      processor.interface = value
+    end
+    
+    def start_server(host = nil, port = PORT)
+      return if @thread
+      require "socket"
+      
+      server = TCPServer.new(host, port)
+      @thread = Thread.start do
+        while (session = server.accept)
+          interface = RemoteInterface.new(session)
+          self.interface = interface
         end
       end
     end
@@ -628,6 +105,4 @@ module Kernel
   def debugger(steps = 1)
     Debugger.current_context.stop_next = steps
   end
-end
-
-Debugger.start
+end