vim-jar 0.0.1

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/breakpoints.rb

@@ -0,0 +1,155 @@
+module Debugger
+
+  # Implements debugger "break" command.
+  class AddBreakpoint < Command
+    self.allow_in_control = true
+    
+    def regexp
+      / ^\s*
+        b(?:reak)?
+        (?: \s+ #{Position_regexp})? \s*
+        (?: \s+ (.*))? \s*
+        $
+      /x
+    end
+
+    def execute
+      if @match[1]
+        line, _, _, expr = @match.captures
+      else
+        _, file, line, expr = @match.captures
+      end
+      if expr 
+        if expr !~ /^\s*if\s+(.+)/
+          if file or line
+            errmsg "Expecting 'if' in breakpoint condition; got: #{expr}.\n"
+          else
+            errmsg "Invalid breakpoint location: #{expr}.\n"
+          end
+          return
+        else
+          expr = $1
+        end
+      end
+
+      brkpt_filename = nil
+      if file.nil?
+        unless @state.context
+          errmsg "We are not in a state that has an associated file.\n"
+          return 
+        end
+        brkpt_filename = @state.file
+        file = File.basename(@state.file)
+        if line.nil? 
+          # Set breakpoint at current line
+          line = @state.line.to_s
+        end
+      elsif line !~ /^\d+$/
+        # See if "line" is a method/function name
+        klass = debug_silent_eval(file)
+        if klass && klass.kind_of?(Module)
+          class_name = klass.name if klass
+        else
+          errmsg "Unknown class #{file}.\n"
+          throw :debug_error
+        end
+      else
+        # FIXME: This should be done in LineCache.
+        file = File.expand_path(file) if file.index(File::SEPARATOR) || \
+        File::ALT_SEPARATOR && file.index(File::ALT_SEPARATOR)
+        brkpt_filename = file
+      end
+      
+      if line =~ /^\d+$/
+        line = line.to_i
+        if LineCache.cache(brkpt_filename, Command.settings[:reload_source_on_change])
+          last_line = LineCache.size(brkpt_filename)
+          if line > last_line
+            errmsg("There are only %d lines in file \"%s\".\n", last_line, file) 
+            return
+          end
+          unless LineCache.trace_line_numbers(brkpt_filename).member?(line)
+            errmsg("Line %d is not a stopping point in file \"%s\".\n", line, file) 
+            return
+          end
+        else
+          errmsg("No source file named %s\n" % file)
+          return unless confirm("Set breakpoint anyway? (y/n) ")
+        end
+
+        unless @state.context
+          errmsg "We are not in a state we can add breakpoints.\n"
+          return 
+        end
+        brkpt_filename = File.basename(brkpt_filename) if 
+          Command.settings[:basename]
+        b = Debugger.add_breakpoint brkpt_filename, line, expr
+        print "Breakpoint %d file %s, line %s\n", b.id, brkpt_filename, line.to_s
+        unless syntax_valid?(expr)
+          errmsg("Expression \"#{expr}\" syntactically incorrect; breakpoint disabled.\n")
+          b.enabled = false
+        end
+      else
+        method = line.intern.id2name
+        b = Debugger.add_breakpoint class_name, method, expr
+        print "Breakpoint %d at %s::%s\n", b.id, class_name, method.to_s
+      end
+    end
+
+    class << self
+      def help_command
+        'break'
+      end
+
+      def help(cmd)
+        %{
+          b[reak] file:line [if expr]
+          b[reak] class(.|#)method [if expr]
+          \tset breakpoint to some position, (optionally) if expr == true
+        }
+      end
+    end
+  end
+
+  # Implements debugger "delete" command.
+  class DeleteBreakpointCommand < Command
+    self.allow_in_control = true
+
+    def regexp
+      /^\s *del(?:ete)? (?:\s+(.*))?$/ix
+    end
+
+    def execute
+      unless @state.context
+        errmsg "We are not in a state we can delete breakpoints.\n"
+        return 
+      end
+      brkpts = @match[1]
+      unless brkpts
+        if confirm("Delete all breakpoints? (y or n) ")
+          Debugger.breakpoints.clear
+        end
+      else
+        brkpts.split(/[ \t]+/).each do |pos|
+          pos = get_int(pos, "Delete", 1)
+          return unless pos
+          unless Debugger.remove_breakpoint(pos)
+            errmsg "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/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/catchpoint.rb

@@ -0,0 +1,55 @@
+module Debugger
+  class CatchCommand < Command # :nodoc:
+    self.allow_in_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.
+        info_catch
+      elsif not @match[2]
+        # One arg given.
+        if 'off' == excn
+          Debugger.catchpoints.clear if 
+            confirm("Delete all catchpoints? (y or n) ")
+        else
+          binding = @state.context ? get_binding : TOPLEVEL_BINDING
+          unless debug_eval("#{excn}.is_a?(Class)", binding)
+            print "Warning #{excn} is not known to be a Class\n"
+          end
+          Debugger.add_catchpoint(excn)
+          print "Catch exception %s.\n", excn
+        end
+      elsif @match[2] != 'off'
+        errmsg "Off expected. Got %s\n", @match[2]
+      elsif Debugger.catchpoints.member?(excn)
+        Debugger.catchpoints.delete(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\tsame as "info catch"
+          cat[ch] <exception-name> [on|off]
+\tIntercept <exception-name> when there would otherwise be no handler.
+\tWith an "on" or "off", turn handling the exception on or off.
+          cat[ch] off\tdelete all catchpoints
+        }
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/condition.rb

@@ -0,0 +1,49 @@
+module Debugger
+
+  class ConditionCommand < Command # :nodoc:
+
+    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]
+            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/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/continue.rb

@@ -0,0 +1,38 @@
+module Debugger
+
+  # Implements debugger "continue" command.
+  class ContinueCommand < Command
+    self.allow_in_post_mortem = true
+    self.need_context         = false
+    def regexp
+      /^\s* c(?:ont(?:inue)?)? (?:\s+(.*))? $/x
+    end
+
+    def execute
+      if @match[1] && !@state.context.dead?
+        filename = File.expand_path(@state.file)
+        line_number = get_int(@match[1], "Continue", 0, nil, 0)
+        return unless line_number
+        unless LineCache.trace_line_numbers(filename).member?(line_number)
+          errmsg("Line %d is not a stopping point in file \"%s\".\n", 
+                 line_number, filename) 
+          return
+        end
+        @state.context.set_breakpoint(filename, line_number)
+      end
+      @state.proceed
+    end
+
+    class << self
+      def help_command
+        'continue'
+      end
+
+      def help(cmd)
+        %{
+          c[ont[inue]][ nnn]\trun until program ends, hits a breakpoint or reaches line nnn 
+        }
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/control.rb

@@ -0,0 +1,107 @@
+module Debugger
+  class RestartCommand < Command # :nodoc:
+    self.allow_in_control = true
+
+    def regexp
+      / ^\s*
+      (?:restart|R)
+      (?:\s+ (\S?.*\S))? \s*
+      $
+      /ix
+    end
+    
+    def execute
+      if not defined? Debugger::PROG_SCRIPT
+        errmsg "Don't know name of debugged program\n"
+        return
+      end
+      prog_script = Debugger::PROG_SCRIPT
+      if not defined? Debugger::RDEBUG_SCRIPT
+        # FIXME? Should ask for confirmation? 
+        print "Debugger was not called from the outset...\n"
+        rdebug_script = prog_script
+      else 
+        rdebug_script = Debugger::RDEBUG_SCRIPT
+      end
+      begin
+        Dir.chdir(Debugger::INITIAL_DIR)
+      rescue
+        print "Failed to change initial directory #{Debugger::INITIAL_DIR}"
+      end
+      if not File.exist?(File.expand_path(prog_script))
+        errmsg "Ruby program #{prog_script} doesn't exist\n"
+        return
+      end
+      if not File.executable?(prog_script) and rdebug_script == prog_script
+        print "Ruby program #{prog_script} doesn't seem to be executable...\n"
+        print "We'll add a call to Ruby.\n"
+        ruby = begin defined?(Gem) ? Gem.ruby : "ruby" rescue "ruby" end
+        rdebug_script = "#{ruby} -I#{$:.join(' -I')} #{prog_script}"
+      else
+        rdebug_script += ' '
+      end
+      if @match[1]
+        argv = [prog_script] + @match[1].split(/[ \t]+/)
+      else
+        if not defined? Command.settings[:argv]
+          errmsg "Arguments have not been set. Use 'set args' to set them.\n"
+          return
+        else
+          argv = Command.settings[:argv]
+        end
+      end
+      args = argv.join(' ')
+
+      # An execv would be preferable to the "exec" below.
+      cmd = rdebug_script + args
+      print "Re exec'ing:\n\t#{cmd}\n"
+      exec cmd
+    rescue Errno::EOPNOTSUPP
+      print "Restart command is not available at this time.\n"
+    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 InterruptCommand < Command # :nodoc:
+    self.allow_in_control     = true
+    self.allow_in_post_mortem = false
+    self.event                = false
+    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/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/disassemble.RB

@@ -0,0 +1,38 @@
+module Debugger
+
+  require 'pp'
+  require 'nodepp'
+  require 'classtree'
+  require 'parse_tree'
+  class Disassemble < Command # :nodoc:
+    self.allow_in_control = false
+    @@parse_tree = ParseTree.new(true)
+    
+    def regexp
+      /^\s*(dis(?:assemble)?)\s+/
+    end
+
+    def execute
+      expr = @match ? @match.post_match : @input
+      binding = @state.context ? get_binding : TOPLEVEL_BINDING
+      method_str = "method(:#{expr})"
+      if method_obj = debug_eval(method_str, binding)
+        print @@parse_tree.parse_tree_for_method(method_obj.class, 
+                                                 method_str).inspect
+        print "#{method_obj}\n"
+      end
+    end
+
+    class << self
+      def help_command
+        %w|disassemble method-name|
+      end
+
+      def help(cmd)
+          %{
+            dis[assemble] method-name\tdo live unparsing of method name
+          }
+      end
+    end
+  end if false
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/display.rb

@@ -0,0 +1,120 @@
+module Debugger
+  module DisplayFunctions # :nodoc:
+    def display_expression(exp)
+      print "%s = %s\n", exp, debug_silent_eval(exp).to_s
+    end
+    
+    def active_display_expressions?
+      @state.display.select{|d| d[0]}.size > 0
+    end
+
+    def print_display_expressions
+      n = 1
+      for d in @state.display
+        if d[0]
+          print "%d: ", n
+          display_expression(d[1])
+        end
+        n += 1
+      end
+    end
+  end
+
+  class AddDisplayCommand < Command # :nodoc:
+    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 # :nodoc:
+    def self.always_run 
+      Debugger.annotate = 0 unless Debugger.annotate
+      if Debugger.annotate > 1 
+        0
+      else
+        2
+      end
+    end
+    
+    def regexp
+      /^\s*disp(?:lay)?$/
+    end
+
+    def execute
+      print_display_expressions
+    end
+
+    class << self
+      def help_command
+        'display'
+      end
+
+      def help(cmd)
+        %{
+          disp[lay]\t\tdisplay expression list
+        }
+      end
+    end
+  end
+
+  class DeleteDisplayCommand < Command # :nodoc:
+
+    def regexp
+      /^\s* undisp(?:lay)? \s* (?:(\S+))?$/x
+    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 = get_int(pos, "Undisplay")
+        return unless pos
+        if @state.display[pos-1]
+          @state.display[pos-1][0] = nil
+        else
+          errmsg "Display expression %d is not defined.\n", pos
+        end
+      end
+    end
+
+    class << self
+      def help_command
+        'undisplay'
+      end
+
+      def help(cmd)
+        %{
+          undisp[lay][ nnn]
+          Cancel some expressions to be displayed when program stops.
+          Arguments are the code numbers of the expressions to stop displaying.
+          No argument means cancel all automatic-display expressions.
+          "delete display" has the same effect as this command.
+          Do "info display" to see current list of code numbers.
+        }
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/ruby-debug-0.10.4/cli/ruby-debug/commands/edit.rb

@@ -0,0 +1,48 @@
+module Debugger
+  class Edit < Command # :nodoc:
+    self.allow_in_control = true
+    def regexp
+      /^\s* ed(?:it)? (?:\s+(.*))?$/ix
+    end
+    
+    def execute
+      if not @match[1] or @match[1].strip.empty?
+        unless @state.context
+          errmsg "We are not in a state that has an associated file.\n"
+          return 
+        end
+        file = @state.file
+        line_number = @state.line
+      elsif @pos_match = /([^:]+)[:]([0-9]+)/.match(@match[1])
+        file, line_number = @pos_match.captures
+      else
+        errmsg "Invalid file/line number specification: #{@match[1]}\n"
+        return
+      end
+      editor = ENV['EDITOR'] || 'ex'
+      if File.readable?(file)
+        system("#{editor} +#{line_number} #{file}")
+      else
+        errmsg "File \"#{file}\" is not readable.\n"
+      end
+    end
+    
+    class << self
+      def help_command
+        'edit'
+      end
+
+      def help(cmd)
+        %{
+          Edit specified file.
+
+With no argument, edits file containing most recent line listed.
+Editing targets can also be specified in this:
+  FILE:LINENUM, to edit at that line in that file,
+        }
+      end
+    end
+  end
+
+
+end # module Debugger