ruby-debug 0.10.0 → 0.10.1

data/README

@@ -14,6 +14,12 @@ are sometimes available), you'll need a C compiler and Ruby
 development headers, and a Make program so the extension in
 ruby-debug-base can be compiled when it is installed.
 
+To install on Microsoft Windows, unless you run under cygwin or mingw
+you'll need Microsoft Visual C++ 6.0 also known as VC6.
+http://rubyforge.org/tracker/index.php?func=detail&aid=16774&group_id=1900&atid=7436
+suggests why.
+
+
 == Install
 
 ruby-debug is provided as a RubyGem.  To install:
@@ -22,6 +28,10 @@ ruby-debug is provided as a RubyGem.  To install:
 
 This should also pull in <tt>ruby-debug-base</tt> as a dependency.
 
+(If you install ruby-debug-base explicitly, you can add in the secret
+--test option after "install" to have the regression test run before
+installing.)
+
 For Emacs support and the Reference Manual, get
 <tt>ruby-debug-extra</tt>.  This is not a RubyGem, you'll need a Make
 program and a POSIX shell. With this installed, run:
@@ -29,9 +39,28 @@ program and a POSIX shell. With this installed, run:
 <pre>
   sh ./configure
   make
-  make install
+  make test # optional, but a good idea
+  sudo make install
 </pre>
 
+==== Install on MS Windows
+
+Compiling under cygwin or mingw works like it does on Unix. 
+
+* Have Microsoft Visual C++ 6.0 (VC6) installed - exactly that version.
+
+* Set the appropriate environment variables.
+
+* run `nmake'.
+
+* Copy ruby_debug.so to `win32'.
+
+* Go to the ruby_debug root.
+
+* rake win32_gem
+
+* The file is in named `rdebug-debug-base-0.10.0-mswin32.gem'.
+
 == Usage
 
 There are two ways of running ruby-debug.

data/Rakefile

@@ -8,7 +8,9 @@ require 'rake/testtask'
 SO_NAME = "ruby_debug.so"
 
 # ------- Default Package ----------
-RUBY_DEBUG_VERSION = open("ext/ruby_debug.c"){|f| f.grep(/^#define DEBUG_VERSION/).first[/"(.+)"/,1]}
+RUBY_DEBUG_VERSION = open("ext/ruby_debug.c") do |f| 
+  f.grep(/^#define DEBUG_VERSION/).first[/"(.+)"/,1]
+end
 
 COMMON_FILES = FileList[
   'AUTHORS',
@@ -18,35 +20,35 @@ COMMON_FILES = FileList[
   'Rakefile',
 ]                        
 
-CLI_TEST_FILE_LIST = 'test/**/*test-*.rb'
+CLI_TEST_FILE_LIST = 'test/test-*.rb'
 CLI_FILES = COMMON_FILES + FileList[
   "cli/**/*",
   'ChangeLog',
   'bin/*',
   'doc/rdebug.1',
-  'test/**/*.cmd',
-  'test/**/*.right',
-  'test/**/gcd.rb',
-  'test/**/helper.rb',
-  'test/**/info-var-bug.rb',
-  'test/**/tdebug.rb',
-  'test/**/test-*.cmd',
-  'runner.sh',
+  'test/**/data/*.cmd',
+  'test/**/data/*.right',
+  'test/**/*.rb',
+  'rdbg.rb',
    CLI_TEST_FILE_LIST,                                    
 ]
 
-BASE_TEST_FILE_LIST = 'test/test-ruby-debug-base.rb'
+BASE_TEST_FILE_LIST = %w(
+  test/base/base.rb 
+  test/base/binding.rb 
+  test/base/catchpoint.rb)
 BASE_FILES = COMMON_FILES + FileList[
-  'lib/**/*',
-  'ext/ChangeLog',
-  'ext/ruby_debug.c',
+  'ext/breakpoint.c',
   'ext/extconf.rb',
+  'ext/ruby_debug.c',
+  'ext/ruby_debug.h',
   'ext/win32/*',
+  'lib/**/*',
   BASE_TEST_FILE_LIST,
 ]
 
 desc "Test everything."
-test_task = task :test => :lib do 
+test_task = task :test => [:lib, :test_base] do 
   Rake::TestTask.new(:test) do |t|
     t.libs << ['./ext', './lib', './cli']
     t.pattern = CLI_TEST_FILE_LIST
@@ -54,6 +56,15 @@ test_task = task :test => :lib do
   end
 end
 
+desc "Test ruby-debug-base."
+test_task = task :test_base => :lib do 
+  Rake::TestTask.new(:test_base) do |t|
+    t.libs << ['./ext', './lib']
+    t.test_files = FileList[BASE_TEST_FILE_LIST]
+    t.verbose = true
+  end
+end
+
 desc "Test everything - same as test."
 task :check => :test
 
@@ -99,12 +110,12 @@ EOF
   spec.platform = Gem::Platform::RUBY
   spec.require_path = "lib"
   spec.extensions = ["ext/extconf.rb"]
-  spec.autorequire = "ruby-debug-base"
   spec.files = BASE_FILES.to_a  
 
   spec.required_ruby_version = '>= 1.8.2'
   spec.date = Time.now
   spec.rubyforge_project = 'ruby-debug'
+  spec.add_dependency('linecache', '>= 0.3')
   
   spec.test_files = FileList[BASE_TEST_FILE_LIST]
   
@@ -130,12 +141,12 @@ EOF
   spec.require_path = "cli"
   spec.bindir = "bin"
   spec.executables = ["rdebug"]
-  spec.autorequire = "ruby-debug"
   spec.files = CLI_FILES.to_a
 
   spec.required_ruby_version = '>= 1.8.2'
   spec.date = Time.now
   spec.rubyforge_project = 'ruby-debug'
+  spec.add_dependency('columnize', '>= 0.1')
   spec.add_dependency('ruby-debug-base', RUBY_DEBUG_VERSION)
   
   # FIXME: work out operational logistics for this
@@ -159,7 +170,8 @@ task :default => [:package]
 # Windows specification
 win_spec = base_spec.clone
 win_spec.extensions = []
-win_spec.platform = Gem::Platform::WIN32
+## win_spec.platform = Gem::Platform::WIN32 # deprecated
+win_spec.platform = 'mswin32'
 win_spec.files += ["lib/#{SO_NAME}"]
 
 desc "Create Windows Gem"
@@ -170,20 +182,20 @@ task :win32_gem do
   target = File.join(current_dir, "lib", SO_NAME)
   cp(source, target)
 
-  # Create the gem, then move it to pkg
-	Gem::Builder.new(win_spec).build
-	gem_file = "#{win_spec.name}-#{win_spec.version}-#{win_spec.platform}.gem"
+  # Create the gem, then move it to pkg.
+  Gem::Builder.new(win_spec).build
+  gem_file = "#{win_spec.name}-#{win_spec.version}-#{win_spec.platform}.gem"
   mv(gem_file, "pkg/#{gem_file}")
 
-  # Remove win extension fro top level directory	
-	rm(target)
+  # Remove win extension from top level directory.
+  rm(target)
 end
 
 desc "Publish ruby-debug to RubyForge."
 task :publish do 
   require 'rake/contrib/sshpublisher'
   
-  # Get ruby-debug path
+  # Get ruby-debug path.
   ruby_debug_path = File.expand_path(File.dirname(__FILE__))
 
   publisher = Rake::SshDirPublisher.new("kent@rubyforge.org",
@@ -218,3 +230,22 @@ Rake::RDocTask.new("rdoc") do |rdoc|
                           'LICENSE')
 end
 
+desc "Publish the release files to RubyForge."
+task :rubyforge_upload do
+  `rubyforge login`
+  release_command = "rubyforge add_release #{PKG_NAME} #{PKG_NAME} '#{PKG_NAME}-#{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.gem"
+  puts release_command
+  system(release_command)
+end
+
+PKG_NAME      = 'ruby-debug'
+desc "Publish the release files to RubyForge."
+task :rubyforge_upload do
+  `rubyforge login`
+  for pkg_name in ['ruby-debug', 'ruby-debug-base'] do
+    pkg_file_name = "#{pkg_name}-#{pkg_version}"
+    release_command = "rubyforge add_release ruby-debug #{pkg_name} '#{pkg_file_name}' pkg/#{pkg_file_name}.gem"
+    puts release_command
+    system(release_command)
+  end
+end

data/bin/rdebug

@@ -3,127 +3,243 @@
 
 require 'rubygems'
 require 'optparse'
-require "ostruct"
+require 'ostruct'
 require 'ruby-debug'
 
+def debug_program(options)
+  # Make sure Ruby script syntax checks okay.
+  # Otherwise we get a load message that looks like rdebug has 
+  # a problem. 
+  output = `ruby -c #{Debugger::PROG_SCRIPT} 2>&1`
+  if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
+    puts output
+    exit $?.exitstatus 
+  end
+  print "\032\032starting\n" if Debugger.annotate and Debugger.annotate > 2
+  unless options.no_rewrite_program
+    # Set $0 so things like __FILE == $0 work.
+    # A more reliable way to do this is to put $0 = __FILE__ *after*
+    # loading the script to be debugged.  For this, adding a debug hook
+    # for the first time and then switching to the debug hook that's
+    # normally used would be helpful. Doing this would also help other
+    # first-time initializations such as reloading debugger state
+    # after a restart. 
+
+    # However This is just a little more than I want to take on right
+    # now, so I think I'll stick with the slightly hacky approach.
+    $RDEBUG_0 = $0
+
+    # cygwin does some sort of funky truncation on $0 ./abcdef => ./ab
+    # probably something to do with 3-letter extension truncation.
+    # The hacky workaround is to do slice assignment. Ugh.
+    d0 = if '.' == File.dirname(Debugger::PROG_SCRIPT) and
+             Debugger::PROG_SCRIPT[0..0] != '.'
+           File.join('.', Debugger::PROG_SCRIPT)
+         else
+           Debugger::PROG_SCRIPT
+         end
+    $0[0..-1] = d0
+  end
+  bt = Debugger.debug_load(Debugger::PROG_SCRIPT, options.stop)
+  if bt
+    if options.post_mortem
+      Debugger.handle_post_mortem(bt)
+    else
+      print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+      print "Uncaught exception: #{bt}\n"
+    end
+  end
+end
+
+# Do a shell-like path lookup for prog_script and return the results.
+# If we can't find anything return prog_script.
+def whence_file(prog_script)
+  if prog_script.index(File::SEPARATOR)
+    # Don't search since this name has path separator components
+    return prog_script
+  end
+  for dirname in ENV['PATH'].split(File::PATH_SEPARATOR) do
+    prog_script_try = File.join(dirname, prog_script)
+    return prog_script_try if File.exist?(prog_script_try)
+  end
+  # Failure
+  return prog_script
+end
+
 options = OpenStruct.new(
-  'annotate'    => Debugger.annotate,
-  'client'      => false,
-  'control'     => true,
-  'cport'       => Debugger::PORT + 1,
-  'frame_bind'  => false,
-  'host'        => nil,
-  'no-quit'     => false,
-  'no-stop'     => false,
-  'nx'          => false,
-  'port'        => Debugger::PORT,
-  'post_mortem' => false,
-  'script'      => nil,
-  'server'      => false,
-  'tracing'     => false,
-  'verbose_long'=> false,
-  'wait'        => false
+  'annotate'           => Debugger.annotate,
+  'client'             => false,
+  'control'            => true,
+  'cport'              => Debugger::PORT + 1,
+  'frame_bind'         => false,
+  'host'               => nil,
+  'quit'               => true,
+  'no_rewrite_program' => false,
+  'stop'               => true,
+  'nx'                 => false,
+  'port'               => Debugger::PORT,
+  'post_mortem'        => false,
+  'restart_script'     => nil,
+  'script'             => nil,
+  'server'             => false,
+  'tracing'            => false,
+  'verbose_long'       => false,
+  'wait'               => false
 )
 
-program = File.basename($0)
-opts = OptionParser.new do |opts|
-  opts.banner = <<EOB
+def process_options(options)
+  program = File.basename($0)
+  opts = OptionParser.new do |opts|
+    opts.banner = <<EOB
 #{program} #{Debugger::VERSION}
 Usage: #{program} [options] <script.rb> -- <script.rb parameters>
 EOB
-  opts.separator ""
-  opts.separator "Options:"
-  opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do 
-    |Debugger::annotate|
-  end
-  opts.on("-c", "--client", "Connect to remote debugger") do 
-    options.client = true
-  end
-  opts.on("--cport PORT", Integer, "Port used for control commands") do 
-    |options.cport|
-  end
-  opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
-  opts.on("--emacs", "Activates emacs mode") {ENV['EMACS'] = '1'}
-  opts.on("-h", "--host HOST", "Host name used for remote debugging") do
-    |options.host|
-  end
-  opts.on("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
-    $LOAD_PATH.unshift(path)
-  end
-  opts.on("--keep-frame-binding", "Keep frame bindings") do 
-    options.frame_bind = true
-  end
-  opts.on("-m", "--post-mortem", "Activate post-mortem mode") do 
-    options.post_mortem = true
-  end
-  opts.on("--no-control", "Do not automatically start control thread") do 
-    options.control = false
-  end
-  opts.on("--no-quit", "Do not quit when script finishes") do
-    options.noquit = true
-  end
-  opts.on("-n", "--no-stop", "Do not stop when script is loaded") do 
-    options.nostop = true
-  end
-  opts.on("-nx", "Not run debugger initialization files (e.g. .rdebugrc") do
-    options.nx = true
-  end
-  opts.on("-p", "--port PORT", Integer, "Port used for remote debugging") do 
-    |options.port|
-  end
-  opts.on("-r", "--require SCRIPT", String,
-          "Require the library, before executing your script") do |name|
-    if name == 'debug'
-      puts "ruby-debug is not compatible with Ruby's 'debug' library. This option is ignored."
-    else
-      require name
+    opts.separator ""
+    opts.separator "Options:"
+    opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") do 
+      |annotate|
+        Debugger.annotate = annotate
     end
-  end
-  opts.on("--script FILE", String, "Name of the script file to run") do 
-    |options.script| 
-    unless File.exists?(options.script)
-      puts "Script file '#{options.script}' is not found"
+    opts.on("-c", "--client", "Connect to remote debugger") do 
+      options.client = true
+    end
+    opts.on("--cport PORT", Integer, "Port used for control commands") do 
+      |cport|
+      options.cport = cport
+    end
+    opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
+    opts.on("--emacs LEVEL", Integer,
+            "Activates full Emacs support at annotation level LEVEL") do 
+      |level|
+      Debugger.annotate = level.to_i
+      ENV['EMACS'] = '1'
+      ENV['COLUMNS'] = '120' if ENV['COLUMNS'].to_i < 120
+      options.control = false
+      options.quit = false
+      options.post_mortem = true
+    end
+    opts.on('--emacs-basic', 'Activates basic Emacs mode') do 
+      ENV['EMACS'] = '1'
+    end
+    opts.on('-h', '--host HOST', 'Host name used for remote debugging') do
+      |host|
+      options.host = host
+    end
+    opts.on('-I', '--include PATH', String, 'Add PATH to $LOAD_PATH') do |path|
+      $LOAD_PATH.unshift(path)
+    end
+    opts.on('--keep-frame-binding', 'Keep frame bindings') do 
+      options.frame_bind = true
+    end
+    opts.on('-m', '--post-mortem', 'Activate post-mortem mode') do 
+      options.post_mortem = true
+    end
+    opts.on('--no-control', 'Do not automatically start control thread') do 
+      options.control = false
+    end
+    opts.on('--no-quit', 'Do not quit when script finishes') do
+      options.quit = false
+    end
+    opts.on('--no-rewrite-program',
+            'Do not set $0 to the program being debugged') do 
+      options.no_rewrite_program = true
+    end
+    opts.on('--no-stop', 'Do not stop when script is loaded') do 
+      options.stop = false
+    end
+    opts.on('-nx', 'Not run debugger initialization files (e.g. .rdebugrc') do
+      options.nx = true
+    end
+    opts.on('-p', '--port PORT', Integer, 'Port used for remote debugging') do 
+      |port|
+      options.port = port
+    end
+    opts.on('-r', '--require SCRIPT', String,
+            'Require the library, before executing your script') do |name|
+      if name == 'debug'
+        puts "ruby-debug is not compatible with Ruby's 'debug' library. This option is ignored."
+      else
+        require name
+      end
+    end
+    opts.on('--restart-script FILE', String, 
+            'Name of the script file to run. Erased after read') do 
+      |restart_script|
+      options.restart_script = restart_script
+      unless File.exists?(options.restart_script)
+        puts "Script file '#{options.restart_script}' is not found"
+        exit
+      end
+    end
+    opts.on('--script FILE', String, 'Name of the script file to run') do 
+      |script|
+      options.script = script
+      unless File.exists?(options.script)
+        puts "Script file '#{options.script}' is not found"
+        exit
+      end
+    end
+    opts.on('-s', '--server', 'Listen for remote connections') do 
+      options.server = true
+    end
+    opts.on('-w', '--wait', 'Wait for a client connection, implies -s option') do
+      options.wait = true
+    end
+    opts.on('-x', '--trace', 'Turn on line tracing') {options.tracing = true}
+    opts.separator ''
+    opts.separator 'Common options:'
+    opts.on_tail('--help', 'Show this message') do
+      puts opts
       exit
     end
+    opts.on_tail('--version', 
+                 'Print the version') do
+      puts "ruby-debug #{Debugger::VERSION}"
+      exit
+    end
+    opts.on('--verbose', 'Turn on verbose mode') do
+      $VERBOSE = true
+      options.verbose_long = true
+    end
+    opts.on_tail('-v', 
+                 'Print version number, then turn on verbose mode') do
+      puts "ruby-debug #{Debugger::VERSION}"
+      $VERBOSE = true
+    end
   end
-  opts.on("-s", "--server", "Listen for remote connections") do 
-    options.server = true
-  end
-  opts.on("-w", "--wait", "Wait for a client connection, implies -s option") do
-    options.wait = true
-  end
-  opts.on("-x", "--trace", "Turn on line tracing") {options.tracing = true}
-  opts.separator ""
-  opts.separator "Common options:"
-  opts.on_tail("--help", "Show this message") do
-    puts opts
-    exit
-  end
-  opts.on_tail("--version", 
-               "Print the version") do
-    puts "ruby-debug #{Debugger::VERSION}"
-    exit
-  end
-  opts.on("--verbose", "Turn on verbose mode") do
-    $VERBOSE = true
-    options.verbose_long = true
-  end
-  opts.on_tail("-v", 
-               "Print version number, then turn on verbose mode") do
-    puts "ruby-debug #{Debugger::VERSION}"
-    $VERBOSE = true
+  return opts
+end
+
+# What file is used for debugger startup commands.
+unless defined?(OPTS_INITFILE)
+  if RUBY_PLATFORM =~ /mswin/
+    # Of course MS Windows has to be different
+    OPTS_INITFILE = 'rdbopt.ini'
+    HOME_DIR =  (ENV['HOME'] || 
+                 ENV['HOMEDRIVE'].to_s + ENV['HOMEPATH'].to_s).to_s
+  else
+    OPTS_INITFILE = '.rdboptrc'
+    HOME_DIR = ENV['HOME'].to_s
   end
 end
+begin
+  initfile = File.join(HOME_DIR, OPTS_INITFILE)
+  eval(File.read(initfile)) if 
+    File.exist?(initfile)
+rescue
+end
 
+opts = process_options(options)
 begin
   if not defined? Debugger::ARGV
     Debugger::ARGV = ARGV.clone
   end
   rdebug_path = File.expand_path($0)
   if RUBY_PLATFORM =~ /mswin/
-    rdebug_path += ".cmd" unless rdebug_path =~ /\.cmd$/i
+    rdebug_path += '.cmd' unless rdebug_path =~ /\.cmd$/i
   end
   Debugger::RDEBUG_SCRIPT = rdebug_path
+  Debugger::RDEBUG_FILE = __FILE__
   Debugger::INITIAL_DIR = Dir.pwd
   opts.parse! ARGV
 rescue StandardError => e
@@ -140,12 +256,14 @@ else
     exit if $VERBOSE and not options.verbose_long
     puts opts
     puts
-    puts "Must specify a script to run"
+    puts 'Must specify a script to run'
     exit(-1)
   end
   
   # save script name
-  Debugger::PROG_SCRIPT = ARGV.shift
+  prog_script = ARGV.shift
+  prog_script = whence_file(prog_script) unless File.exist?(prog_script)
+  Debugger::PROG_SCRIPT = prog_script
   
   # install interruption handler
   trap('INT') { Debugger.interrupt_last }
@@ -161,8 +279,7 @@ else
       # load initrc script
       Debugger.run_init_script(StringIO.new) unless options.nx
     end
-    # load script
-    Debugger.debug_load Debugger::PROG_SCRIPT, !options.nostop
+    debug_program(options)
   else
     # activate debugger
     Debugger.start
@@ -172,41 +289,45 @@ else
     # load initrc script (e.g. .rdebugrc)
     Debugger.run_init_script(StringIO.new) unless options.nx
     
+    # run restore-settings startup script if specified
+    if options.restart_script
+      require 'fileutils'
+      Debugger.run_script(options.restart_script)
+      FileUtils.rm(options.restart_script)
+    end
+
     # run startup script if specified
     if options.script
       Debugger.run_script(options.script)
     end
+
     # activate post-mortem
     Debugger.post_mortem if options.post_mortem
-    Debugger.tracing = options.nostop = true if options.tracing
+    options.stop = false if options.tracing
+    Debugger.tracing = options.tracing
 
-    # Make sure Ruby script syntax checks okay.
-    # Otherwise we get a load message that looks like rdebug has 
-    # a problem. 
-    output = `ruby -c #{Debugger::PROG_SCRIPT} 2>&1`
-    if $?.exitstatus != 0 and RUBY_PLATFORM !~ /mswin/
-      puts output
-      exit $?.exitstatus 
-    end
-    if options.noquit
-      Debugger.stop if Debugger.started?
-      while true do
-        begin
-          Debugger.debug_load Debugger::PROG_SCRIPT, !options.nostop
-        rescue
-          print $!.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
-          print "Uncaught exception: #{$!}\n"
-        end
-        # FIXME: add status for whether we are interactive or not.
-        # if STDIN.tty? and !options.nostop
-        if !options.nostop
-          print "The program has finished and will be restarted.\n"
-        else
-          break
-        end
+    if !options.quit
+      if Debugger.started?
+        until Debugger.stop do end
+      end
+      begin
+        debug_program(options)
+      rescue SyntaxError
+        puts $!.backtrace.map{|l| "\t#{l}"}.join("\n")
+        puts "Uncaught Syntax Error\n"
+      rescue
+        print $!.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
+        print "Uncaught exception: #{$!}\n"
       end
+      print "The program finished.\n" unless 
+        Debugger.annotate.to_i > 1 # annotate has its own way
+      interface = Debugger::LocalInterface.new
+      # Not sure if ControlCommandProcessor is really the right
+      # thing to use. CommandProcessor requires a state.
+      processor = Debugger::ControlCommandProcessor.new(interface)
+      processor.process_commands
     else
-      Debugger.debug_load Debugger::PROG_SCRIPT, !options.nostop
+      debug_program(options)
     end
   end
 end