module Debugger

Debugger is the module name space for ruby-debug.

Constants

HOME_DIR
INITFILE: Of course MS Windows has to be different
PORT: the port number used for remote debugging
RUBY_DEBUG_DIR

Attributes

annotate[RW]

gdb-style annotation mode. Used in GNU Emacs interface

cmd_port[R]

control_thread[R]

ctrl_port[R]

start_sentinal[RW]

If set, a string to look for in caller() and is used to see if the call stack is truncated.

thread[R]

wait_connection[RW]

in remote mode, wait for the remote connection

Public Class Methods

inside_emacs?() click to toggle source

# File cli/ruby-debug/helper.rb, line 3
def inside_emacs?
  ENV['EMACS'] || ENV['INSIDE_EMACS']
end

run_init_script(out = handler.interface) click to toggle source

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.

# File cli/ruby-debug.rb, line 138
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

run_script(file, out = handler.interface, verbose=false) click to toggle source

Runs a script file

# File cli/ruby-debug.rb, line 150
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

settings() click to toggle source

Returns setting object. Use ::settings[] and ::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

# File cli/ruby-debug/command.rb, line 264
def self.settings
  Command.settings
end

start_client(host = 'localhost', port = PORT) click to toggle source

Connects to the remote debugger

# File cli/ruby-debug.rb, line 106
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 %r^PROMPT (.*)$/
        input = interface.read_command($1)
        throw :exit unless input
        socket.puts input
      when %r^CONFIRM (.*)$/
        input = interface.confirm($1)
        throw :exit unless input
        socket.puts input
      else
        print line
      end
    end
  end
  socket.close
end

start_remote(host = nil, port = PORT, post_mortem = false) { || ... } click to toggle source

Starts a remote debugger.

# File cli/ruby-debug.rb, line 47
def start_remote(host = nil, port = PORT, post_mortem = false)
  return if @thread
  return if started?

  self.interface = nil
  start
  self.post_mortem if post_mortem

  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

Also aliased as: start_server

start_server(host = nil, port = PORT, post_mortem = false) click to toggle source

Alias for: start_remote