ruby-debug 0.2-mswin32 → 0.3-mswin32

data/lib/ruby-debug/command.rb

@@ -0,0 +1,76 @@
+module Debugger
+  class Command
+    class << self
+      def commands
+        @commands ||= []
+      end
+      
+      def inherited(klass)
+        klass.instance_variable_set("@event", 
+          klass.instance_variable_get("@event") || true)
+        klass.instance_variable_set("@control", 
+          klass.instance_variable_get("@control") || false)
+        commands << klass
+      end
+
+      def load_commands
+        dir = File.dirname(__FILE__)
+        Dir[File.join(dir, 'commands', '*')].each do |file|
+          require file
+        end
+      end
+      
+      attr_accessor :control
+      attr_accessor :event
+    end
+    
+    def initialize(state)
+      @state = state
+    end
+
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    def confirm(msg)
+      @state.confirm(msg) == 'y'
+    end
+
+    def debug_eval(str)
+      begin
+        val = eval(str, @state.binding)
+      rescue StandardError, ScriptError => e
+        at = eval("caller(1)", @state.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)
+      begin
+        eval(str, @state.binding)
+      rescue StandardError, ScriptError
+        nil
+      end
+    end
+
+    def line_at(file, line)
+      Debugger.line_at(file, line)
+    end
+
+    def get_context(thnum)
+      Debugger.contexts.find{|c| c.thnum == thnum}
+    end  
+  end
+  
+  Command.load_commands
+end

data/lib/ruby-debug/commands/breakpoints.rb

@@ -0,0 +1,136 @@
+module Debugger
+  class AddBreakpoint < Command
+    self.control = true
+    
+    def regexp
+      / ^\s*
+        b(?:reak)?
+        \s+
+        (?:
+          (\d+) |
+          (.+?)[:.#]([^.:\s]+)
+        )
+        (?:\s+
+          if\s+(.+)
+        )?
+        $
+      /x
+    end
+
+    def execute
+      if @match[1]
+        file, pos, expr = @match.captures
+      else
+        file, pos, expr = @match.captures[1..-1]
+      end
+      
+      if file =~ /^\d+$/
+        pos = file
+        file = File.basename(@state.file)
+      else
+        if pos !~ /^\d+$/
+          klass = debug_silent_eval(file)
+          if klass && !klass.kind_of?(Module)
+            print "Unknown class #{file}\n"
+            throw :debug_error
+          end
+          file = klass.name if klass
+        else
+          file = File.basename(file)
+        end
+      end
+      
+      if pos =~ /^\d+$/
+        pos = pos.to_i
+      else
+        pos = pos.intern.id2name
+      end
+      
+      Debugger.add_breakpoint file, pos, expr
+      print "Set breakpoint %d at %s:%s\n", Debugger.breakpoints.size, file, pos.to_s
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak] [file|class(:|.|#)]<line|method> [if expr] -
+          \tset breakpoint to some position, (optionally) if expr == true
+        }
+      end
+    end
+  end
+
+  class BreakpointsCommand < Command
+    self.control = true
+
+    def regexp
+      /^\s*b(?:reak)?$/
+    end
+
+    def execute
+      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
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak]\tlist breakpoints
+        }
+      end
+    end
+  end
+
+  class DeleteBreakpointCommand < Command
+    self.control = true
+
+    def regexp
+      /^\s*del(?:ete)?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      pos = @match[1]
+      unless pos
+        if confirm("Clear all breakpoints? (y/n) ")
+          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
+    end
+
+    class << self
+      def help_command
+        'delete'
+      end
+
+      def help(cmd)
+        %{
+          del[ete][ nnn]\tdelete some or all breakpoints
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/catchpoint.rb

@@ -0,0 +1,40 @@
+module Debugger
+  class CatchCommand < Command
+    self.control = true
+
+    def regexp
+      /^\s*cat(?:ch)?(?:\s+(.+))?$/
+    end
+
+    def execute
+      if excn = @match[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
+    end
+
+    class << self
+      def help_command
+        'catch'
+      end
+
+      def help(cmd)
+        %{
+          cat[ch]\t\t\tshow catchpoint
+          cat[ch] <an Exception>\tset catchpoint to an exception
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/control.rb

@@ -0,0 +1,55 @@
+module Debugger
+  class QuitCommand < Command
+    self.control = true
+
+    def regexp
+      /^\s*q(?:uit)?\s*$/
+    end
+
+    def execute
+      if confirm("Really quit? (y/n) ")
+        exit! # exit -> exit!: No graceful way to stop threads...
+      end
+    end
+
+    class << self
+      def help_command
+        'quit'
+      end
+
+      def help(cmd)
+        %{
+          q[uit]\texit from debugger
+        }
+      end
+    end
+  end
+  
+  class InterruptCommand < Command
+    self.event = false
+    self.control = true
+    
+    def regexp
+      /^\s*i(?:nterrupt)?\s*$/
+    end
+    
+    def execute
+      unless Debugger.interrupt_last
+        context = Debugger.contexts.find{ |c| c.thread == Thread.main }
+        context.interrupt
+      end
+    end
+    
+    class << self
+      def help_command
+        'interrupt'
+      end
+      
+      def help(cmd)
+        %{
+          i[nterrupt]\tinterrupt the program
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/display.rb

@@ -0,0 +1,106 @@
+module Debugger
+  module DisplayFunctions
+    def display_expression(exp)
+      print "%s = %s\n", exp, debug_silent_eval(exp).to_s
+    end
+  end
+
+  class AddDisplayCommand < Command
+    include DisplayFunctions
+
+    def regexp
+      /^\s*disp(?:lay)?\s+(.+)$/
+    end
+
+    def execute
+      exp = @match[1]
+      @state.display.push [true, exp]
+      print "%d: ", @state.display.size
+      display_expression(exp)
+    end
+
+    class << self
+      def help_command
+        'display'
+      end
+
+      def help(cmd)
+        %{
+          disp[lay] <expression>\tadd expression into display expression list
+        }
+      end
+    end
+  end
+
+  class DisplayCommand < Command
+    include DisplayFunctions
+    
+    def initialize(state)
+      super
+    end
+
+    def regexp
+      /^\s*disp(?:lay)?$/
+    end
+
+    def execute
+      n = 1
+      for d in @state.display
+        if d[0]
+          print "%d: ", n
+          display_expression(d[1])
+        end
+        n += 1
+      end
+    end
+
+    class << self
+      def help_command
+        'display'
+      end
+
+      def help(cmd)
+        %{
+          disp[lay]\t\tdisplay expression list
+        }
+      end
+    end
+  end
+
+  class DeleteDisplayCommand < Command
+    include DisplayFunctions
+
+    def regexp
+      /^\s*undisp(?:lay)?(?:\s+(\d+))?$/
+    end
+
+    def execute
+      unless pos = @match[1]
+        if confirm("Clear all expressions? (y/n) ")
+          for d in @state.display
+            d[0] = false
+          end
+        end
+      else
+        pos = pos.to_i
+        if @state.display[pos-1]
+          @state.display[pos-1][0] = false
+        else
+          print "Display expression %d is not defined\n", pos
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'undisplay'
+      end
+
+      def help(cmd)
+        %{
+          undisp[lay][ nnn]\tdelete one particular or all display expressions
+        }
+      end
+    end
+  end
+end

data/lib/ruby-debug/commands/eval.rb

@@ -0,0 +1,54 @@
+module Debugger
+  class EvalCommand < Command
+    def regexp
+      /^\s*(\s*p|e(?:val)?)\s+/
+    end
+
+    def execute
+      print "%s\n", debug_eval(@match.post_match).inspect
+    end
+
+    class << self
+      def help_command
+        %w|p eval|
+      end
+
+      def help(cmd)
+        if cmd == 'p'
+          %{
+            p expression\tevaluate expression and print its value
+          }
+        else
+          %{
+            e[val] expression\tevaluate expression and print its value,
+            \t\t\talias for p
+          }
+        end
+      end
+    end
+  end
+
+  class PPCommand < Command
+    def regexp
+      /^\s*pp\s+/
+    end
+
+    def execute
+      out = StringIO.new
+      PP.pp(debug_eval(@match.post_match), out) rescue out.puts $!.message
+      print out.string
+    end
+
+    class << self
+      def help_command
+        'pp'
+      end
+
+      def help(cmd)
+        %{
+          pp expression\tevaluate expression and print its value
+        }
+      end
+    end
+  end
+end