ruby-debug 0.1.5-mswin32 → 0.2-mswin32

data/lib/ruby-debug/interface.rb

@@ -0,0 +1,69 @@
+module Debugger  
+  class LocalInterface
+    def read_command(prompt)
+      readline(prompt, true)
+    end
+    
+    def confirm(prompt)
+      readline(prompt, false)
+    end
+    
+    def print(*args)
+      STDOUT.printf(*args)
+    end
+    
+    def close
+    end
+    
+    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
+    end
+  end
+
+  class RemoteInterface
+    def initialize(socket)
+      @socket = socket
+    end
+    
+    def read_command(prompt)
+      send_command "PROMPT #{prompt}"
+    end
+    
+    def confirm(prompt)
+      send_command "CONFIRM #{prompt}"
+    end
+
+    def print(*args)
+      @socket.printf(*args)
+    end
+    
+    def close
+      @socket.close
+    rescue Exception
+    end
+    
+    private
+    
+    def send_command(msg)
+      @socket.puts msg
+      result = @socket.gets
+      raise IOError unless result
+      result.chomp
+    end
+  end
+end

data/lib/ruby-debug/processor.rb

@@ -0,0 +1,627 @@
+require 'ruby-debug/interface'
+
+module Debugger
+  class CommandProcessor
+    DEBUG_LAST_CMD = []
+    
+    attr_accessor :interface
+    
+    def initialize(interface = LocalInterface.new)
+      @interface = interface
+      @display = []
+      @mutex = Mutex.new
+    end
+    
+    def interface=(interface)
+      @mutex.synchronize do
+        @interface.close
+        @interface = interface        
+      end
+    end
+
+    def at_breakpoint(context, breakpoint)
+      @mutex.synchronize do
+        return unless @interface
+        n = Debugger.breakpoints.index(breakpoint) + 1
+        print "Breakpoint %d at %s:%s\n", n, breakpoint.source, breakpoint.pos
+      end
+    rescue IOError
+      self.interface = nil
+    end
+    
+    def at_catchpoint(context, excpt)
+      @mutex.synchronize do
+        frames = Debugger.current_context.frames
+        print "%s:%d: `%s' (%s)\n", frames[0].file, frames[0].line, excpt, excpt.class
+        fs = frames.size
+        tb = caller(0)[-fs..-1]
+        if tb
+          for i in tb
+            print "\tfrom %s\n", i
+          end
+        end
+      end
+    rescue IOError
+      self.interface = nil
+    end
+    
+    def at_tracing(context, file, line)
+      @mutex.synchronize do
+        print "Tracing(%d):%s:%s %s", context.thnum, file, line, line_at(file, line)
+      end
+    rescue IOError
+      self.interface = nil
+    end
+
+    def at_line(*args)
+      @mutex.synchronize do
+        process_commands(*args)
+      end
+    rescue IOError
+      puts 'error'
+      self.interface = nil
+    end
+
+    private
+    
+    def print(*args)
+      @interface.print(*args)
+    end
+    
+    def process_commands(context, file, line, binding)
+      frame_pos = 0
+      binding_file = file
+      binding_line = line
+      previous_line = nil
+      print "%s:%d: %s", binding_file, binding_line, line_at(binding_file, binding_line)
+      display_expressions(binding)
+      prompt = true
+      while prompt and input = @interface.read_command("(rdb:%d) " % context.thnum)
+        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+))?$/
+            context.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(context, 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
+            context.step_over steps, context.frames.size - frame_pos
+            prompt = false
+
+          when /^\s*up(?:\s+(\d+))?$/
+            previous_line = nil
+            frame_pos += $1 ? $1.to_i : 1
+            if frame_pos >= context.frames.size
+              frame_pos = context.frames.size - 1
+              print "At toplevel"
+            end
+            frame = context.frames[frame_pos]
+            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
+            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
+              print "At stack bottom\n"
+            end
+            frame = context.frames[frame_pos]
+            binding, binding_file, binding_line = frame.binding, frame.file, frame.line
+            print format_frame(frame, frame_pos)
+
+          when /^\s*fin(?:ish)?$/
+            if frame_pos == context.frames.size
+              print "\"finish\" not meaningful in the outermost frame.\n"
+            else
+              context.stop_frame = context.frames.size - frame_pos
+              frame_pos = 0
+              prompt = false
+            end
+
+          when /^\s*b(?:reak)?\s+(?:(.+):)?([^.:\s]+)\s*(?:\sif\s+(.+))?$/
+            pos = $2
+            expr = $3
+            b_file = file
+            if $1
+              klass = debug_silent_eval($1, binding)
+              if klass && !klass.kind_of?(Module)
+                print "Unknown class #$1\n"
+                throw :debug_error
+              end
+              klass = klass.name if klass
+              b_file = $1
+            end
+            if pos =~ /^\d+$/
+              pname = pos
+              pos = pos.to_i
+            else
+              pname = pos = pos.intern.id2name
+            end
+            b_file = File.basename(b_file)
+            Debugger.add_breakpoint klass || b_file, pos, expr
+            print "Set breakpoint %d at %s:%s\n", Debugger.breakpoints.size, klass || b_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)
+              print "Unknown class #$1\n"
+              throw :debug_error
+            end
+            Debugger.add_breakpoint klass.name, pos, expr
+            print "Set breakpoint %d at %s.%s\n", Debugger.breakpoints.size, klass, pos
+
+          when /^\s*b(?:reak)?$/
+            unless Debugger.breakpoints.empty?
+              print "Breakpoints:\n"
+              Debugger.breakpoints.each_with_index do |b, n|
+                if b.expr.nil?
+                  print "  %d %s:%s\n", n+1, b.source, b.pos
+                else
+                  print "  %d %s:%s if %s\n", n+1, b.source, b.pos, b.expr
+                end
+              end
+              print "\n"
+            else
+              print "No breakpoints\n"
+            end
+          when /^\s*del(?:ete)?(?:\s+(\d+))?$/
+            pos = $1
+            unless pos
+              input = @interface.confirm("Clear all breakpoints? (y/n) ")
+              if input == "y"
+                Debugger.breakpoints.clear
+              end
+            else
+              pos = pos.to_i
+              unless Debugger.breakpoints.delete_at(pos-1)
+                print "Breakpoint %d is not defined\n", pos
+              end
+            end
+
+          when /^\s*th(?:read)?\s+/
+            if debug_thread_info($') == :cont
+              prompt = false
+            end
+
+          when /^\s*m(?:ethod)?\s+/
+            debug_method_info($', binding)
+
+          when /^\s*pp\s+/
+            out = StringIO.new
+            PP.pp(debug_eval($', binding), out) rescue out.puts $!.message
+            print out.string
+
+          when /^\s*(\s*p|e(?:val)?)\s+/
+            print "%s\n", debug_eval($', binding).inspect
+
+          when /^\s*h(?:elp)?(?:\s+(.+))?$/
+            debug_print_help($1)
+
+          when /^\s*q(?:uit)?$/
+            input = @interface.confirm("Really quit? (y/n) ")
+            if input == "y"
+              exit! # exit -> exit!: No graceful way to stop threads...
+            end
+
+          when /^\s*disp(?:lay)?\s+(.+)$/
+            exp = $1
+            @display.push [true, exp]
+            print "%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 = @interface.confirm("Clear all expressions? (y/n) ")
+              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
+                print "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
+                print "Clear catchpoint.\n"
+              else
+                Debugger.catchpoint = excn
+                print "Set catchpoint %s.\n", excn
+              end
+            else
+              if Debugger.catchpoint
+                print "Catchpoint %s.\n", Debugger.catchpoint
+              else
+                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 )
+              context.tracing = $1 == 'on'
+            end
+            if Debugger.tracing || context.tracing
+              print "Trace on.\n"
+            else
+              print "Trace off.\n"
+            end
+
+          else
+            print "Unknown command\n"
+          end
+        end
+      end
+    end
+    
+    def display_expressions(binding)
+      n = 1
+      for d in @display
+        if d[0]
+          print "%d: ", n
+          display_expression(d[1], binding)
+        end
+        n += 1
+      end
+    end
+
+    def display_expression(exp, binding)
+      print "%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)
+        print "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
+        for i in at
+          print "\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
+          print "Should be Class/Module: %s\n", $'
+        else
+          var_list(obj.constants, obj.module_eval{binding()})
+        end
+      end
+    end
+
+    def display_frames(context, pos)
+      context.frames.each_with_index do |frame, idx|
+        if idx == pos
+          print "--> "
+        else
+          print "    "
+        end
+        print format_frame(frame, idx)
+      end
+    end
+
+    def format_frame(frame, pos)
+      file, line, id = frame.file, frame.line, frame.id
+      "#%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
+        print "  %s => %s\n", v, eval(v, binding).inspect
+      end
+    end
+
+    def display_list(b, e, file, line)
+      print "[%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
+              print "=> %d  %s\n", n, lines[n-1].chomp
+            else
+              print "   %d  %s\n", n, lines[n-1].chomp
+            end
+          end
+        end
+      else
+        print "No sourcefile available for %s\n", file
+      end
+    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
+            print "\n"
+          end
+          print "%s ", v
+        end
+        print "\n"
+
+      else
+        obj = debug_eval(input, binding)
+        unless obj.kind_of? Module
+          print "Should be Class/Module: %s\n", input
+        else
+          len = 0
+          for v in obj.instance_methods(false).sort
+            len += v.size + 1
+            if len > 70
+              len = v.size + 1
+              print "\n"
+            end
+            print "%s ", v
+          end
+          print "\n"
+        end
+      end
+    end
+
+    def display_context(c)
+      if c.thread == Thread.current
+        print "+"
+      else
+        print " "
+      end
+      print "%d ", c.thnum
+      print "%s\t", c.thread.inspect
+      last_frame = c.frames.first
+      if last_frame
+        print "%s:%d", last_frame.file, last_frame.line
+      end
+      print "\n"
+    end
+
+    def display_all_contexts
+      threads = Debugger.contexts.sort_by{|c| c.thnum}.each do |c|
+        display_context(c)
+      end
+    end
+
+    def get_context(thnum)
+      Debugger.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(Debugger.current_context)
+
+      when /^(?:sw(?:itch)?\s+)?(\d+)/
+        c = get_context($1.to_i)
+        if c == Debugger.current_context
+          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 == Debugger.current_context
+          print "It's the current thread.\n"
+        elsif c.thread.stop?
+          print "Already stopped.\n"
+        else
+          display_context(c)
+          c.set_suspend
+        end
+
+      when /^resume\s+(\d+)/
+        c = get_context($1.to_i)
+        if c == Debugger.current_context
+          print "It's the current thread.\n"
+        elsif !c.thread.stop?
+          print "Already running."
+        else
+          display_context(c)
+          c.thread.run
+        end
+      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
+    
+    COMMANDS = {
+      'break' => %{
+        b[reak]\tlist breakpoints
+        b[reak] [file|class(:|.)]<line|method> [if expr] -
+        set breakpoint to some position, (optionally) if expr == true
+      },
+      'delete' => %{
+        del[ete][ nnn]\tdelete some or all breakpoints
+      },
+      'catch' => %{
+        cat[ch]\t\t\tshow catchpoint
+        cat[ch] <an Exception>\tset catchpoint to an exception
+      },
+      'display' => %{
+        disp[lay] <expression>\tadd expression into display expression list
+      },
+      'undisplay' => %{
+        undisp[lay][ nnn]\tdelete one particular or all display expressions
+      },
+      'cont' => %{
+        c[ont]\trun until program ends or hit breakpoint
+      },
+      'run' => %{
+        r[un]\talias for cont
+      },
+      'step' => %{
+        s[tep][ nnn]\tstep (into methods) one line or till line nnn
+      },
+      'next' => %{
+        n[ext][ nnn]\tgo over one line or till line nnn
+      },
+      'where' => %{
+        w[here]\tdisplay frames
+      },
+      'frame' => %{
+        f[rame]\talias for where
+      },
+      'list' => %{
+        l[ist][ (-|nn-mm)]\tlist program, '-' list backwards, nn-mm list given lines
+      },
+      'up' => %{
+        up[ nn]\tmove to higher frame
+      },
+      'down' => %{
+        down[ nn]\tmove to lower frame
+      },
+      'finish' => %{
+        fin[ish]\treturn to outer frame
+      },
+      'quit' => %{
+        q[uit]\texit from debugger
+      },
+      'trace' => %{
+        tr[ace] (on|off)\tset trace mode of current thread
+        tr[ace] (on|off) all\tset trace mode of all threads
+      },
+      'var' => %{
+        v[ar] g[lobal]\t\t\tshow global variables
+        v[ar] l[ocal]\t\t\tshow local variables
+        v[ar] i[nstance] <object>\tshow instance variables of object
+        v[ar] c[onst] <object>\t\tshow constants of object
+      },
+      'method' => %{
+        m[ethod] i[nstance] <obj>\tshow methods of object
+        m[ethod] <class|module>\t\tshow instance methods of class or module
+      },
+      'thread' => %{
+        th[read] l[ist]\t\t\tlist all threads
+        th[read] c[ur[rent]]\t\tshow current thread
+        th[read] [sw[itch]] <nnn>\tswitch thread context to nnn
+        th[read] stop <nnn>\t\tstop thread nnn
+        th[read] resume <nnn>\t\tresume thread nnn
+      },
+      'p' => %{
+        p expression\tevaluate expression and print its value
+      },
+      'eval' => %{
+        e[val] expression\tevaluate expression and print its value,
+        \t\t\talias for p
+      },
+      'pp' => %{
+        pp expression\tevaluate expression and print its value
+      },
+      'help' => %{
+        h[elp]\tprint this help
+      }
+    }
+
+    def debug_print_help(command)
+      print "ruby-debug help v.#{Debugger::VERSION}\n"
+      help = COMMANDS[command]
+      if help
+        print help.split("\n").map{|l| l.gsub(/^ +/, '')}.join("\n")
+      else
+        print "Available commands:\n"
+        require 'enumerator'
+        COMMANDS.keys.sort.enum_slice(12).each do |slice|
+          print slice.join(' ')
+          print "\n"
+        end
+      end
+      print "\n"
+    end
+
+  end
+end