ruby-debug 0.1.5 → 0.2

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

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: ruby-debug
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
-date: 2006-07-13 08:20:06 -04:00
+  version: "0.2"
+date: 2006-07-17 02:11:17 -04:00
 summary: Fast Ruby debugger
 require_paths: 
 - lib
@@ -33,10 +33,15 @@ files:
 - README
 - LICENSE
 - CHANGES
+- lib/ruby-debug
 - lib/ruby-debug.rb
+- lib/ruby-debug/interface.rb
+- lib/ruby-debug/processor.rb
 - ext/extconf.rb
 - ext/ruby_debug.c
+- ext/win32
 - bin/rdebug
+- bin/remote
 test_files: []
 
 rdoc_options: []