debugger-ide 0.0.1 → 0.0.2

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

@@ -0,0 +1,129 @@
+module Debugger
+  class AddBreakpoint < Command # :nodoc:
+    self.control = true
+    
+    def regexp
+      / ^\s*
+        b(?:reak)?
+        (?: \s+
+        (?:
+          (\d+) |
+          (.+?)[:.#]([^.:\s]+)
+        ))?
+        (?:\s+
+          if\s+(.+)
+        )?
+        $
+      /x
+    end
+
+    def execute
+      if @match[1]
+        line, _, _, expr = @match.captures
+      else
+        _, file, line, expr = @match.captures
+      end
+
+      if file.nil?
+        file = File.basename(@state.file)
+      else
+        if line !~ /^\d+$/
+          klass = debug_silent_eval(file)
+          if klass && !klass.kind_of?(Module)
+            print_error "Unknown class #{file}"
+            throw :debug_error
+          end
+          file = klass.name if klass
+        else
+          file = File.expand_path(file) if file.index(File::SEPARATOR) || \
+            File::ALT_SEPARATOR && file.index(File::ALT_SEPARATOR)
+        end
+      end
+      
+      if line =~ /^\d+$/
+        line = line.to_i
+      else
+        line = line.intern.id2name
+      end
+      
+      b = Debugger.add_breakpoint file, line, expr
+      print_breakpoint_added b
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak] file:line [if expr]
+          b[reak] [file|class(:|.|#)]<line|method> [if expr] -
+          \tset breakpoint to some position, (optionally) if expr == true
+        }
+      end
+    end
+  end
+
+  class BreakpointsCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*b(?:reak)?$/
+    end
+
+    def execute
+      print_breakpoints Debugger.breakpoints
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak]\tlist breakpoints
+        }
+      end
+    end
+  end
+
+  class DeleteBreakpointCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*del(?:ete)?(?:\s+(.*))?$/
+    end
+
+    def execute
+      brkpts = @match[1]
+      unless brkpts
+          Debugger.breakpoints.clear
+      else
+        brkpts.split(/[ \t]+/).each do |pos|
+          pos = get_int(pos, "Delete", 1)
+          return unless pos
+          b = Debugger.remove_breakpoint(pos)
+          if b
+            print_breakpoint_deleted b
+          else
+            print_error "No breakpoint number %d\n", pos
+          end
+        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,52 @@
+module Debugger
+  class CatchCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s* cat(?:ch)? 
+           (?:\s+ (\S+))? 
+           (?:\s+ (off))? \s* $/ix
+    end
+
+    def execute
+      excn = @match[1] 
+      if not excn
+        # No args given.
+        errmsg "Exception class must be specified for 'catch' command"
+      elsif not @match[2]
+        # One arg given.
+        if 'off' == excn
+          Debugger.catchpoints.clear
+        else
+          binding = @state.context ? get_binding : TOPLEVEL_BINDING
+          unless debug_eval("#{excn}.is_a?(Class)", binding)
+            print_msg "Warning #{excn} is not known to be a Class"
+          end
+          Debugger.add_catchpoint(excn)
+          print_catchpoint_set(excn)
+        end
+      elsif @match[2] != 'off'
+        errmsg "Off expected. Got %s\n", @match[2]
+      elsif Debugger.catchpoints.member?(excn)
+        Debugger.catchpoints.delete(excn)
+        print_catchpoint_set(excn)
+        #print "Catch for exception %s removed.\n", excn
+      else
+        errmsg "Catch for exception %s not found.\n", excn
+      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/condition.rb

@@ -0,0 +1,51 @@
+module Debugger
+
+  class ConditionCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s* cond(?:ition)? (?:\s+(\d+)\s*(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"condition\" must be followed a breakpoint number and expression\n"
+      else
+        breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+        largest = breakpoints.inject(0) do |largest, b| 
+          largest = b.id if b.id > largest
+        end
+        if 0 == largest
+          print "No breakpoints have been set.\n"
+          return
+        end
+        pos = get_int(@match[1], "Condition", 1, largest)
+        return unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            b.expr = @match[2].empty? ? nil : @match[2]
+            print_contdition_set(b.id)
+            break
+          end
+        end
+
+      end
+    end
+    
+    class << self
+      def help_command
+        'condition'
+      end
+
+      def help(cmd)
+        %{
+          Condition breakpoint-number expression
+Specify breakpoint number N to break only if COND is true.
+N is an integer and COND is an expression to be evaluated whenever 
+breakpoint N is reached. If the empty string is used, the condition is removed.
+        }
+      end
+    end
+  end
+
+end # module Debugger

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

@@ -0,0 +1,129 @@
+module Debugger
+  class QuitCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*(?:q(?:uit)?|exit)\s*$/
+    end
+
+    def execute
+      begin
+        @printer.print_msg("finished")
+        @printer.print_debug("Exiting debugger.")
+      ensure
+        exit! # exit -> exit!: No graceful way to stop threads...
+      end
+    end
+
+    class << self
+      def help_command
+        %w[quit exit]
+      end
+
+      def help(cmd)
+        %{
+          q[uit]\texit from debugger, 
+          exit\talias to quit
+        }
+      end
+    end
+  end
+  
+  class RestartCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      / ^\s*
+      (restart|R)
+      (\s+ \S+ .*)?
+      $
+      /x
+    end
+    
+    def execute
+      if not defined? Debugger::RDEBUG_SCRIPT or not defined? Debugger::ARGV
+        print "We are not in a context we can restart from.\n"
+        return
+      end
+      if @match[2]
+        args = Debugger::PROG_SCRIPT + " " + @match[2]
+      else
+        args = Debugger::ARGV.join(" ")
+      end
+
+      # An execv would be preferable to the "exec" below.
+      cmd = Debugger::RDEBUG_SCRIPT + " " + args
+      print "Re exec'ing:\n\t#{cmd}\n"
+      exec cmd
+    end
+
+    class << self
+      def help_command
+        'restart'
+      end
+
+      def help(cmd)
+        %{
+          restart|R [args] 
+          Restart the program. This is is a re-exec - all debugger state
+          is lost. If command arguments are passed those are used.
+        }
+      end
+    end
+  end
+
+  class StartCommand < Command # :nodoc:
+    self.control = true
+
+    def regexp
+      /^\s*(start)(\s+ \S+ .*)?$/x
+    end
+    
+    def execute
+      @printer.print_debug("Starting: running program script")
+      Debugger.run_prog_script #Debugger.prog_script_running?
+    end
+
+    class << self
+      def help_command
+        'start'
+      end
+
+      def help(cmd)
+        %{
+          run prog script
+        }
+      end
+    end
+  end
+
+
+  class InterruptCommand < Command # :nodoc:
+    self.event = false
+    self.control = true
+    self.need_context = true
+    
+    def regexp
+      /^\s*i(?:nterrupt)?\s*$/
+    end
+    
+    def execute
+      unless Debugger.interrupt_last
+        context = Debugger.thread_context(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/enable.rb

@@ -0,0 +1,203 @@
+module Debugger
+  # Mix-in module to assist in command parsing.
+  module EnableDisableFunctions # :nodoc:
+    def enable_disable_breakpoints(is_enable, args)
+      breakpoints = Debugger.breakpoints.sort_by{|b| b.id }
+      largest = breakpoints.inject(0) do |largest, b| 
+        largest = b.id if b.id > largest
+      end
+      if 0 == largest
+        errmsg "No breakpoints have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} breakpoints", 1, largest)
+        return nil unless pos
+        breakpoints.each do |b|
+          if b.id == pos 
+            enabled = ("Enable" == is_enable)
+            if enabled
+              unless syntax_valid?(b.expr)
+                errmsg("Expression \"#{b.expr}\" syntactically incorrect; breakpoint remains disabled.\n")
+                break
+              end
+            end
+            b.enabled = enabled
+            enabled ? print_breakpoint_enabled(b) : print_breakpoint_disabled(b)
+            break
+          end
+        end
+      end
+    end
+
+    def enable_disable_display(is_enable, args)
+      if 0 == @state.display.size 
+        errmsg "No display expressions have been set.\n"
+        return
+      end
+      args.each do |pos|
+        pos = get_int(pos, "#{is_enable} display", 1, @state.display.size)
+        return nil unless pos
+        @state.display[pos-1][0] = ("Enable" == is_enable)
+      end
+    end
+
+  end
+
+  class EnableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 2, "Enable specified breakpoints",
+"Give breakpoint numbers (separated by spaces) as arguments.
+This is used to cancel the effect of the \"disable\" command."
+       ],
+       ['display', 2, 
+        "Enable some expressions to be displayed when program stops",
+"Arguments are the code numbers of the expressions to resume displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* en(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"enable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("enable_#{subcmd.name}", args)
+        else
+          send("enable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def enable_breakpoints(args)
+      enable_disable_breakpoints("Enable", args)
+    end
+    
+    def enable_display(args)
+      enable_disable_display("Enable", args)
+    end
+    
+    class << self
+      def help_command
+        'enable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'enable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Enable some things.
+          This is used to cancel the effect of the "disable" command.
+          -- 
+          List of enable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "enable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+  class DisableCommand < Command # :nodoc:
+    Subcommands = 
+      [
+       ['breakpoints', 1, "Disable some breakpoints",
+"Arguments are breakpoint numbers with spaces in between.
+A disabled breakpoint is not forgotten, but has no effect until reenabled."],
+       ['display', 1, "Disable some display expressions when program stops",
+"Arguments are the code numbers of the expressions to stop displaying.
+Do \"info display\" to see current list of code numbers."],
+      ].map do |name, min, short_help, long_help| 
+      SubcmdStruct.new(name, min, short_help, long_help)
+    end unless defined?(Subcommands)
+
+    def regexp
+      /^\s* dis(?:able)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1]
+        errmsg "\"disable\" must be followed \"display\", \"breakpoints\"" +
+          " or breakpoint numbers.\n"
+      else
+        args = @match[1].split(/[ \t]+/)
+        param = args.shift
+        subcmd = find(Subcommands, param)
+        if subcmd
+          send("disable_#{subcmd.name}", args)
+        else
+          send("disable_breakpoints", args.unshift(param))
+        end
+      end
+    end
+    
+    def disable_breakpoints(args)
+      enable_disable_breakpoints("Disable", args)
+    end
+    
+    def disable_display(args)
+      enable_disable_display("Disable", args)
+    end
+    
+    class << self
+      def help_command
+        'disable'
+      end
+
+      def help(args)
+        if args[1] 
+          s = args[1]
+          subcmd = Subcommands.find do |try_subcmd| 
+            (s.size >= try_subcmd.min) and
+              (try_subcmd.name[0..s.size-1] == s)
+          end
+          if subcmd
+            str = subcmd.short_help + '.'
+            str += "\n" + subcmd.long_help if subcmd.long_help
+            return str
+          else
+            return "Invalid 'disable' subcommand '#{args[1]}'."
+          end
+        end
+        s = %{
+          Disable some things.
+
+          A disabled item is not forgotten, but has no effect until reenabled.
+          Use the "enable" command to have it take effect again.
+          -- 
+          List of disable subcommands:
+          --  
+        }
+        for subcmd in Subcommands do
+          s += "disable #{subcmd.name} -- #{subcmd.short_help}\n"
+        end
+        return s
+      end
+    end
+  end
+
+end # module Debugger