debugger 1.2.4 → 1.3.0

data/test/info-var-bug.rb

@@ -1,47 +0,0 @@
-class Lousy_inspect
-  attr_accessor :var
-  def inspect    # An unhelpful inspect
-    throw "Foo"  # Raises an exception
-  end
-  def initialize
-    @var = 'initialized'
-  end
-end
-class Lousy_inspect_and_to_s
-  attr_accessor :var
-  def inspect    # An unhelpful inspect
-    throw "Foo"  # Raises an exception
-  end
-  def to_s       # An unhelpful to_s
-    throw "bar"  # Raises an exception
-  end
-  def initialize
-    @var = 'initialized'  # Something to inspect
-  end
-end
-
-# Something that will be passed objects with
-# bad inspect or to_s methods
-class UnsuspectingClass
-  @@Const = 'A constant'
-  @@var = 'a class variable'
-  def initialize(a)
-    @a = a      # "info locals" will try to use
-                # inspect or to_s here
-    @b = 5
-  end
-end
-def test_Lousy_inspect
-  x = Lousy_inspect.new
-  x
-end
-def test_lousy_inspect_and_to_s
-  x = Lousy_inspect_and_to_s.new
-  x
-end
-x = test_Lousy_inspect
-y = test_lousy_inspect_and_to_s
-UnsuspectingClass.new(10)
-UnsuspectingClass.new(x)
-UnsuspectingClass.new(y)
-y = 2

data/test/info-var-bug2.rb

@@ -1,2 +0,0 @@
-s = '<%= PRODUCT[:name] %>'
-y = 0

data/test/jump.rb

@@ -1,14 +0,0 @@
-def foo
-  j = 0
-  [1,2,3,4,5].each { |i|
-    j = i
-    [10,11,12].each { |k|
-      j = j + k
-      puts j
-    }
-  }
-  puts j
-end
-
-foo
-puts "done"

data/test/jump2.rb

@@ -1,27 +0,0 @@
-def foo3(arg)
-  arg = arg + 3
-  puts arg
-  arg = arg/0 if arg > 10
-  rescue
-    puts "r3"
-end
-
-def foo2(arg)
-  arg = arg + 2
-  foo3(arg)
-  puts arg
-  rescue
-    puts "r2"
-end
-
-def foo1(arg)
-  arg = arg + 1
-  foo2(arg)
-  puts arg
-  rescue
-    puts "r1"
-end
-
-foo1(0)
-foo2(10)
-puts "done"

data/test/lib/commands/catchpoint_test.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'ruby-debug'
-
-class TestCatchCommand < Test::Unit::TestCase
-
-  class MockState
-    attr_accessor :message
-    def context; end
-    def confirm(msg); true end
-    def print(*args)
-      @message = *args
-    end
-  end
-
-  # regression test for bug #20156
-  def test_catch_does_not_blow_up
-    state = MockState.new
-    catch_cmd = Debugger::CatchCommand.new(state)
-    assert(catch_cmd.match('catch off'))
-    catch(:debug_error) do
-      catch_cmd.execute
-    end
-    assert_equal(nil, state.message)
-  end
-
-end

data/test/lib/commands/unit/regexp.rb

@@ -1,38 +0,0 @@
-require 'test/unit'
-
-
-class TestCommandREs < Test::Unit::TestCase
-  require 'ruby-debug/command'
-  require 'ruby-debug/commands/frame'
-  include Debugger
-
-  def test_quit
-    c = QuitCommand.new(nil)
-    assert c.regexp.match('quit')
-    assert c.regexp.match('q')
-    assert c.regexp.match('quit!')
-    assert c.regexp.match('q!')
-    assert c.regexp.match('quit unconditionally')
-    assert c.regexp.match('exit')
-    assert c.regexp.match('exit!')
-  end
-
-  def test_up
-    c = UpCommand.new(nil)
-    assert c.regexp.match('up')
-    assert c.regexp.match('up 2')
-    assert c.regexp.match('up 2+5')
-    assert c.regexp.match('u')
-    assert c.regexp.match('u 2')
-    assert_equal nil, c.regexp.match('ufoo')
-  end
-
-  def test_down
-    c = DownCommand.new(nil)
-    assert c.regexp.match('down')
-    assert c.regexp.match('down 2')
-    assert_equal(nil, c.regexp.match('d 2'))
-    assert_equal(nil, c.regexp.match('d'))
-    assert_equal(nil, c.regexp.match('dow'))
-  end
-end

data/test/next.rb

@@ -1,18 +0,0 @@
-def foo
-  a = 1
-  puts "Stop here"
-  b = 2
-end
-
-a = 1
-if a == 1
-  a += 2
-  puts a
-end
-foo
-b = 2
-b += 2
-puts "one"
-c = 4
-puts "two"
-

data/test/null.rb

@@ -1 +0,0 @@
-# Nothing here. Move along.

data/test/output.rb

@@ -1,2 +0,0 @@
-puts "one"
-puts "two"

data/test/pm-base.rb

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-# Test post-mortem handling using only ruby-debug-base.
-require 'ruby-debug-base'
-
-class CommandProcessor
-  def at_line(context, file, line)
-    puts 'file: %s, line: %s' % [ File.basename(file), line ]
-    exit!
-  end
-end
-
-Debugger.start(:post_mortem => true)
-Debugger.handler = CommandProcessor.new
-def zero_div
-  1/0
-end
-zero_div

data/test/pm-bug.rb

@@ -1,3 +0,0 @@
-a = 1
-@x = 2
-raise

data/test/pm-catch.rb

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-# Test Debugger.catchpoint and post-mortem handling
-def zero_div
-  x = 5
-  1/0
-  x = 6
-end
-x = 2
-puts zero_div
-raise RuntimeError
-x = 3
-

data/test/pm-catch2.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# Test Debugger.catchpoint 
-def bar(arg)
-  puts "bar begin"
-  1/0 if arg
-  raise ZeroDivisionError
-  puts "bar end"
-end
-
-def foo
-  puts "foo begin"
-  yield 1
-  puts "foo end"
-rescue ZeroDivisionError
-  puts "rescue"
-end
-
-def zero_div(arg)
-  x = 5
-  foo { |i| bar(i) }
-  x + arg
-rescue ZeroDivisionError
-  "zero_div rescue"
-end
-
-puts zero_div(10)
-puts "done"

data/test/pm-catch3.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-# Test catching uncaught exceptions
-def get_exception(arg)
-  result = case arg
-    when 0 then LoadError
-    when 1 then ZeroDivisionError
-    when 2 then NoMethodError
-    else RuntimeError
-  end
-  return result
-end
-
-def bar(arg)
-  $var = $var + "bar begin:"
-  1/0 if arg
-  if false
-    raise LoadError
-  end
-  $var = $var + "bar end:"
-end
-
-def foo(arg)
-  $var = $var + "foo begin:"
-  yield arg
-  $var = $var + "foo end:"
-rescue get_exception(0), NameError
-  $var = $var + "foo rescue:"
-ensure
-  $var = $var + "foo ensure:"
-end
-
-def zero_div(arg)
-  x = 5
-  foo(arg) { |i| bar(i) }
-  x + arg
-rescue get_exception(arg)
-  $var = $var + "zero_div rescue:"
-  return "divide by zero"
-end
-
-$var = "start1:"
-puts zero_div(1)
-puts $var
-$var = "start2:"
-puts zero_div(2)
-puts $var
-puts "done"

data/test/pm.rb

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-# Test Debugger.catchpoint and post-mortem handling
-def zero_div
-  x = 5
-  1/0
-end
-x = 2
-zero_div
-raise RuntimeError
-x = 3
-

data/test/raise.rb

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-
-raise "abc"

data/test/rdebug-save.1

@@ -1,7 +0,0 @@
-break gcd.rb:10
-break gcd.rb:12 if a > b
-set autoeval on
-set basename off
-set debuggertesting off
-set autolist off
-set autoirb off

data/test/runall

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-#-*- Ruby -*-
-debug_opt = '-d ' if $DEBUG or 'd' == ARGV[0]
-for file in Dir.glob("test-*.rb")  do 
-  puts "=" * 50
-  puts "== running #{file}..."
-  system("ruby #{file}");
-end
-if ARGV[0] == "really"
-   system("(cd test && ruby #{debug_opt}runall)")
-   system("(cd examples && ruby #{debug_opt}runall)")
-end

data/test/scope-var.rb

@@ -1,29 +0,0 @@
-require 'ruby_debug'
-def scope1(arg1, arg2)
-  s1_var1 = 123
-  s1_var2 = "scope1"
-  scope2
-end
-
-def scope2
-  s2_var1 = 456
-  s2_var2 = "scope2"
-  0.upto(5) do |i|
-    j = i * 10
-    scope3
-  end
-end
-
-def scope3
-  s3_var1 = 789
-  s3_var2 = "scope3"
-  puts eval("s3_var1", Debugger.current_context.frame_binding(0))
-  puts eval("i", Debugger.current_context.frame_binding(1))
-  puts eval("j", Debugger.current_context.frame_binding(1))
-  puts eval("s2_var1", Debugger.current_context.frame_binding(2))
-  puts eval("s1_var1", Debugger.current_context.frame_binding(3))
-  puts eval("s0_var1", Debugger.current_context.frame_binding(4))
-end
-
-s0_var1 = 1357;
-scope1(111, 222)

data/test/tdebug.rb

@@ -1,246 +0,0 @@
-#!/usr/bin/env ruby
-# -*- Ruby -*-
-# This is a hacked down copy of rdebug which can be used for testing
-# FIXME: use the real rdebug script - DRY.
-
-require 'stringio'
-require 'optparse'
-require "ostruct"
-
-TOP_SRC_DIR = File.join(File.dirname(__FILE__), "..") unless
-  defined?(TOP_SRC_DIR)
-
-$:.unshift File.join(TOP_SRC_DIR, "ext")
-$:.unshift File.join(TOP_SRC_DIR, "lib")
-
-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
-    if $0.frozen?
-      $0 = d0
-    else
-      $0[0..-1] = d0
-    end
-  end
-
-  # Record where we are we can know if the call stack has been
-  # truncated or not.
-  Debugger.start_sentinal=caller(0)[1]
-
-  bt = Debugger.debug_load(Debugger::PROG_SCRIPT, !options.nostop, false)
-  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
-
-options = OpenStruct.new(
-  'annotate'    => false,
-  'emacs'       => false,
-  'no-quit'     => false,
-  'no-stop'     => false,
-  'nx'          => false,
-  'post_mortem' => false,
-  'script'      => nil,
-  'tracing'     => false,
-  'verbose_long'=> false,
-  'wait'        => false
-)
-
-require "ruby-debug"
-
-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 |s|
-    Debugger.annotate = s
-  end
-  opts.on("-d", "--debug", "Set $DEBUG=true") {$DEBUG = true}
-  opts.on("--emacs-basic", "Activates basic Emacs mode") do
-    ENV['EMACS'] = '1'
-    options.emacs = 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("--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("-I", "--include PATH", String, "Add PATH to $LOAD_PATH") do |path|
-    $LOAD_PATH.unshift(path)
-  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("--script FILE", String, "Name of the script file to run") do |s|
-    options.script = s
-    unless File.exists?(options.script)
-      puts "Script file '#{options.script}' is not found"
-      exit
-    end
-  end
-  opts.on("-x", "--trace", "Turn on line tracing") {options.tracing = true}
-  ENV['EMACS'] = nil unless options.emacs
-  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
-
-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
-  end
-  Debugger::RDEBUG_SCRIPT = rdebug_path
-  Debugger::RDEBUG_FILE = __FILE__
-  Debugger::INITIAL_DIR = Dir.pwd
-  opts.parse! ARGV
-rescue StandardError => e
-  puts opts
-  puts
-  puts e.message
-  exit(-1)
-end
-
-if ARGV.empty?
-  exit if $VERBOSE and not options.verbose_long
-  puts opts
-  puts
-  puts 'Must specify a script to run'
-  exit(-1)
-end
-
-# save script name
-Debugger::PROG_SCRIPT = ARGV.shift
-
-# install interruption handler
-trap('INT') { Debugger.interrupt_last }
-
-# set options
-Debugger.wait_connection = false
-
-# Add Debugger trace hook.
-Debugger.start
-
-# start control thread
-Debugger.start_control(options.host, options.cport) if options.control
-
-# activate post-mortem
-Debugger.post_mortem if options.post_mortem
-
-# Set up an interface to read commands from a debugger script file.
-if options.script
-  Debugger.interface = Debugger::ScriptInterface.new(options.script,
-                                                     STDOUT, true)
-end
-options.nostop = true 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
-
-# load initrc script (e.g. .rdebugrc)
-Debugger.run_init_script(StringIO.new) unless options.nx
-
-# run startup script if specified
-if options.script
-  Debugger.run_script(options.script)
-end
-# activate post-mortem
-Debugger.post_mortem if options.post_mortem
-options.stop = false if options.tracing
-Debugger.tracing = options.tracing
-
-if options.noquit
-  if Debugger.started?
-    until Debugger.stop do end
-  end
-  debug_program(options)
-  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
-  debug_program(options)
-end