needy_debugger 1.4.0

data/lib/ruby-debug.rb

@@ -0,0 +1,177 @@
+require 'pp'
+require 'stringio'
+require 'socket'
+require 'thread'
+require 'ruby-debug-base'
+require 'ruby-debug/processor'
+
+module Debugger
+  self.handler = CommandProcessor.new
+
+  # the port number used for remote debugging
+  PORT = 8989 unless defined?(PORT)
+
+  # What file is used for debugger startup commands.
+  unless defined?(INITFILE)
+    if RUBY_PLATFORM =~ /mswin/
+      # Of course MS Windows has to be different
+      INITFILE = 'rdebug.ini'
+      HOME_DIR =  (ENV['HOME'] ||
+                   ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
+    else
+      INITFILE = '.rdebugrc'
+      HOME_DIR = ENV['HOME'].to_s
+    end
+  end
+
+  class << self
+    # gdb-style annotation mode. Used in GNU Emacs interface
+    attr_accessor :annotate
+
+    # in remote mode, wait for the remote connection
+    attr_accessor :wait_connection
+
+    # If set, a string to look for in caller() and is used to see
+    # if the call stack is truncated.
+    attr_accessor :start_sentinal
+
+    attr_reader :thread, :control_thread, :cmd_port, :ctrl_port
+
+    def interface=(value) # :nodoc:
+      handler.interface = value
+    end
+
+    #
+    # Starts a remote debugger.
+    #
+    def start_remote(host = nil, port = PORT)
+      return if @thread
+
+      self.interface = nil
+      start
+
+      if port.kind_of?(Array)
+        cmd_port, ctrl_port = port
+      else
+        cmd_port, ctrl_port = port, port + 1
+      end
+
+      ctrl_port = start_control(host, ctrl_port)
+
+      yield if block_given?
+
+      mutex = Mutex.new
+      proceed = ConditionVariable.new
+
+      server = TCPServer.new(host, cmd_port)
+      @cmd_port = cmd_port = server.addr[1]
+
+      @thread = DebugThread.new do
+        while (session = server.accept)
+          self.interface = RemoteInterface.new(session)
+          if wait_connection
+            mutex.synchronize do
+              proceed.signal
+            end
+          end
+        end
+      end
+      if wait_connection
+        mutex.synchronize do
+          proceed.wait(mutex)
+        end
+      end
+    end
+    alias start_server start_remote
+
+    def start_control(host = nil, ctrl_port = PORT + 1) # :nodoc:
+      return @ctrl_port if defined?(@control_thread) && @control_thread
+      server = TCPServer.new(host, ctrl_port)
+      @ctrl_port = server.addr[1]
+      @control_thread = DebugThread.new do
+        while (session = server.accept)
+          interface = RemoteInterface.new(session)
+          processor = ControlCommandProcessor.new(interface)
+          processor.process_commands
+        end
+      end
+      @ctrl_port
+    end
+
+    #
+    # Connects to the remote debugger
+    #
+    def start_client(host = 'localhost', port = PORT)
+      require "socket"
+      interface = Debugger::LocalInterface.new
+      socket = TCPSocket.new(host, port)
+      puts "Connected."
+
+      catch(:exit) do
+        while (line = socket.gets)
+          case line
+          when /^PROMPT (.*)$/
+            input = interface.read_command($1)
+            throw :exit unless input
+            socket.puts input
+          when /^CONFIRM (.*)$/
+            input = interface.confirm($1)
+            throw :exit unless input
+            socket.puts input
+          else
+            print line
+          end
+        end
+      end
+      socket.close
+    end
+
+    # Runs normal debugger initialization scripts
+    # Reads and executes the commands from init file (if any) in the
+    # current working directory.  This is only done if the current
+    # directory is different from your home directory.  Thus, you can
+    # have more than one init file, one generic in your home directory,
+    #  and another, specific to the program you are debugging, in the
+    # directory where you invoke ruby-debug.
+    def run_init_script(out = handler.interface)
+      cwd_script_file  = File.expand_path(File.join(".", INITFILE))
+      run_script(cwd_script_file, out) if File.exists?(cwd_script_file)
+
+      home_script_file = File.expand_path(File.join(HOME_DIR, INITFILE))
+      run_script(home_script_file, out) if File.exists?(home_script_file) and
+        cwd_script_file != home_script_file
+    end
+
+    #
+    # Runs a script file
+    #
+    def run_script(file, out = handler.interface, verbose=false)
+      interface = ScriptInterface.new(File.expand_path(file), out)
+      processor = ControlCommandProcessor.new(interface)
+      processor.process_commands(verbose)
+    end
+  end
+end
+
+module Kernel
+
+  # Enters the debugger in the current thread after _steps_ line events occur.
+  # Before entering the debugger startup script is read.
+  #
+  # Setting _steps_ to 0 will cause a break in the debugger subroutine
+  # and not wait for a line event to occur. You will have to go "up 1"
+  # in order to be back in your debugged program rather than the
+  # debugger. Settings _steps_ to 0 could be useful you want to stop
+  # right after the last statement in some scope, because the next
+  # step will take you out of some scope.
+  def debugger(steps = 1)
+    Debugger.start
+    Debugger.run_init_script(StringIO.new)
+    if 0 == steps
+      Debugger.current_context.stop_frame = 0
+    else
+      Debugger.current_context.stop_next = steps
+    end
+  end
+  alias breakpoint debugger unless respond_to?(:breakpoint)
+end

data/lib/ruby-debug/command.rb

@@ -0,0 +1,227 @@
+require 'columnize'
+require 'ruby-debug/helper'
+
+module Debugger
+  RUBY_DEBUG_DIR = File.expand_path(File.dirname(__FILE__)) unless
+    defined?(RUBY_DEBUG_DIR)
+
+  class Command # :nodoc:
+    SubcmdStruct=Struct.new(:name, :min, :short_help, :long_help) unless
+      defined?(SubcmdStruct)
+
+    include Columnize
+
+    # Find param in subcmds. param id downcased and can be abbreviated
+    # to the minimum length listed in the subcommands
+    def find(subcmds, param)
+      param.downcase!
+      for try_subcmd in subcmds do
+        if (param.size >= try_subcmd.min) and
+            (try_subcmd.name[0..param.size-1] == param)
+          return try_subcmd
+        end
+      end
+      return nil
+    end
+
+    class << self
+      def commands
+        @commands ||= []
+      end
+
+      DEF_OPTIONS = {
+        :allow_in_control     => false,
+        :allow_in_post_mortem => true,
+        :event => true,
+        :always_run => 0,
+        :unknown => false,
+        :need_context => false,
+      } unless defined?(DEF_OPTIONS)
+
+      def inherited(klass)
+        DEF_OPTIONS.each do |o, v|
+          klass.options[o] = v if klass.options[o].nil?
+        end
+        commands << klass
+      end
+
+      def load_commands
+        Dir[File.join(Debugger.const_get(:RUBY_DEBUG_DIR), 'commands', '*')].each do |file|
+          require file if file =~ /\.rb$/
+        end
+        Debugger.constants.grep(/Functions$/).map { |name| Debugger.const_get(name) }.each do |mod|
+          include mod
+        end
+      end
+
+      def method_missing(meth, *args, &block)
+        if meth.to_s =~ /^(.+?)=$/
+          @options[$1.intern] = args.first
+        else
+          if @options.has_key?(meth)
+            @options[meth]
+          else
+            super
+          end
+        end
+      end
+
+      def options
+        @options ||= {}
+      end
+
+      def settings_map
+        @@settings_map ||= {}
+      end
+      private :settings_map
+
+      def settings
+        unless true and defined? @settings and @settings
+          @settings = Object.new
+          map = settings_map
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
+          else
+            c.send(:define_method, :[]) do |name|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:getter].call
+            end
+          end
+          c = class << @settings; self end
+          if c.respond_to?(:funcall)
+            c.funcall(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
+          else
+            c.send(:define_method, :[]=) do |name, value|
+              raise "No such setting #{name}" unless map.has_key?(name)
+              map[name][:setter].call(value)
+            end
+          end
+        end
+        @settings
+      end
+
+      def register_setting_var(name, default)
+        var_name = "@@#{name}"
+        class_variable_set(var_name, default)
+        register_setting_get(name) { class_variable_get(var_name) }
+        register_setting_set(name) { |value| class_variable_set(var_name, value) }
+      end
+
+      def register_setting_get(name, &block)
+        settings_map[name] ||= {}
+        settings_map[name][:getter] = block
+      end
+
+      def register_setting_set(name, &block)
+        settings_map[name] ||= {}
+        settings_map[name][:setter] = block
+      end
+    end
+
+    register_setting_var(:basename, false)  # use basename in showing files?
+    register_setting_var(:callstyle, :last)
+    register_setting_var(:debuggertesting, false)
+    register_setting_var(:force_stepping, false)
+    register_setting_var(:full_path, true)
+    register_setting_var(:listsize, 10)    # number of lines in list command
+    register_setting_var(:stack_trace_on_error, false)
+    register_setting_var(:tracing_plus, false) # different linetrace lines?
+
+    # width of line output. Use COLUMNS value if it exists and is
+    # not too rediculously large.
+    width = ENV['COLUMNS'].to_i
+    width = 80 unless width > 10
+    register_setting_var(:width, width)
+
+    if not defined? Debugger::ARGV
+      Debugger::ARGV = ARGV.clone
+    end
+    register_setting_var(:argv, Debugger::ARGV)
+
+    def initialize(state)
+      @state = state
+    end
+
+    def match(input)
+      @match = regexp.match(input)
+    end
+
+    protected
+
+    # FIXME: use delegate?
+    def errmsg(*args)
+      @state.errmsg(*args)
+    end
+
+    def print(*args)
+      @state.print(*args)
+    end
+
+    def confirm(msg)
+      @state.confirm(msg) == 'y'
+    end
+
+    def debug_eval(str, b = get_binding)
+      begin
+        val = eval(str, b)
+      rescue StandardError, ScriptError => e
+        if Command.settings[:stack_trace_on_error]
+          at = eval("caller(1)", b)
+          print "%s:%s\n", at.shift, e.to_s.sub(/\(eval\):1:(in `.*?':)?/, '')
+          for i in at
+            print "\tfrom %s\n", i
+          end
+        else
+          print "#{e.class} Exception: #{e.message}\n"
+        end
+        throw :debug_error
+      end
+    end
+
+    def debug_silent_eval(str)
+      begin
+        eval(str, get_binding)
+      rescue StandardError, ScriptError
+        nil
+      end
+    end
+
+    def get_binding
+      @state.context.frame_binding(@state.frame_pos)
+    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
+
+  # Returns setting object.
+  # Use Debugger.settings[] and Debugger.settings[]= methods to query and set
+  # debugger settings. These settings are available:
+  #
+  # - :autolist - automatically calls 'list' command on breakpoint
+  # - :autoeval - evaluates input in the current binding if it's not recognized as a debugger command
+  # - :autoirb - automatically calls 'irb' command on breakpoint
+  # - :stack_trace_on_error - shows full stack trace if eval command results with an exception
+  # - :frame_full_path - displays full paths when showing frame stack
+  # - :frame_class_names - displays method's class name when showing frame stack
+  # - :reload_source_on_change - makes 'list' command to always display up-to-date source code
+  # - :force_stepping - stepping command asways move to the new line
+  #
+  def self.settings
+    Command.settings
+  end
+end

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

@@ -0,0 +1,153 @@
+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
+        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