ruby-debug-base 0.10.5.rc1-java → 0.10.5.rc2-java

data/Rakefile

@@ -7,82 +7,33 @@ require 'rake/testtask'
 require 'rake/extensiontask'
 require 'rake/javaextensiontask'
 
-$:.push File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "ruby-debug-base/version"
 
-SO_NAME = "ruby_debug.so"
-ROOT_DIR = File.dirname(__FILE__)
-
-# ------- Default Package ----------
-COMMON_FILES = FileList[
-  'AUTHORS',
-  'CHANGES',
-  'LICENSE',
-  'README',
-  'Rakefile',
-]                        
-
-CLI_TEST_FILE_LIST = FileList['test/cli/commands/unit/*.rb',
-                              'test/cli/commands/*_test.rb', 
-                              'test/cli/**/*_test.rb', 
-                              'test/test-*.rb'] 
-CLI_FILES = COMMON_FILES + FileList[
-  "cli/**/*",
-  'ChangeLog',
-  'bin/*',
-  'doc/rdebug.1',
-  'test/rdebug-save.1',
-  'test/**/data/*.cmd',
-  'test/**/data/*.right',
-  'test/**/example/*.rb',
-  'test/config.yaml',
-  'test/**/*.rb',
-  'rdbg.rb',
-   CLI_TEST_FILE_LIST
-]
-
-BASE_TEST_FILE_LIST = FileList['test/base/*.rb']
-
-BASE_FILES = COMMON_FILES + FileList[
-  'ext/breakpoint.c',
-  'ext/extconf.rb',
-  'ext/ruby_debug.c',
-  'ext/ruby_debug.h',
-  'ext/win32/*',
-  'lib/ruby-debug-base.rb',
-  'lib/ruby-debug-base/version.rb',
-  BASE_TEST_FILE_LIST,
-]
-
-ext = File.join(ROOT_DIR, 'ext')
-
-desc "Test everything."
-Rake::TestTask.new(:test) do |t|
-  t.libs += %W(#{ROOT_DIR}/lib #{ROOT_DIR}/cli)
-  t.libs << ext if File.exist?(ext)
-  t.test_files = CLI_TEST_FILE_LIST
-  t.options = '--verbose' if $VERBOSE
-  t.ruby_opts << "--debug" if defined?(JRUBY_VERSION)
-end
-
-task :test => :test_base if File.exist?(ext)
-
-desc "Test ruby-debug-base."
-Rake::TestTask.new(:test_base) do |t|
-  t.libs += ['./ext', './lib']
-  t.test_files = FileList[BASE_TEST_FILE_LIST]
-  t.options = '--verbose' if $VERBOSE
-  t.ruby_opts << "--debug" if defined?(JRUBY_VERSION)
-end
+namespace :test do
+  desc "Test ruby-debug-base"
+  Rake::TestTask.new(:base => :compile) do |t|
+    t.libs += %w(./ext ./lib)
+    t.test_files = FileList['test/base/*.rb']
+    t.options = '--verbose' if $VERBOSE
+    t.ruby_opts << "--debug" if defined?(JRUBY_VERSION)
+  end
 
-if defined?(JRUBY_VERSION)
-  task :test_base => 'jruby:compile:java'
-else
-  task :test_base => :compile
+  desc "Test ruby-debug"
+  Rake::TestTask.new(:cli => :compile) do |t|
+    t.libs += %W(./lib ./cli ./ext)
+    t.test_files = FileList['test/cli/commands/unit/*.rb',
+                            'test/cli/commands/*_test.rb',
+                            'test/cli/**/*_test.rb',
+                            'test/test-*.rb']
+    t.options = '--verbose' if $VERBOSE
+    t.ruby_opts << "--debug" if defined?(JRUBY_VERSION)
+  end
 end
 
-desc "Test everything - same as test."
-task :check => :test
+desc "Test everything"
+task :test => %w(test:base test:cli)
 
 desc "Create a GNU-style ChangeLog via svn2cl"
 task :ChangeLog do
@@ -91,123 +42,24 @@ task :ChangeLog do
   system('git log --pretty --numstat --summary lib | git2cl > lib/ChangeLog')
 end
 
-# Base GEM Specification
-base_spec = Gem::Specification.new do |spec|
-  spec.name = "ruby-debug-base"
-  
-  spec.homepage = "http://rubyforge.org/projects/ruby-debug/"
-  spec.summary = "Fast Ruby debugger - core component"
-  spec.description = <<-EOF
-ruby-debug is a fast implementation of the standard Ruby debugger debug.rb.
-It is implemented by utilizing a new Ruby C API hook. The core component 
-provides support that front-ends can build on. It provides breakpoint 
-handling, bindings for stack frames among other things.
-EOF
-
-  spec.version = Debugger::VERSION
+base_spec = Gem::Specification.load("ruby-debug-base.gemspec")
+cli_spec  = Gem::Specification.load("ruby-debug.gemspec")
 
-  spec.author = "Kent Sibilev"
-  spec.email = "ksibilev@yahoo.com"
-  spec.platform = Gem::Platform::RUBY
-  spec.require_path = "lib"
-  spec.extensions = ["ext/extconf.rb"]
-  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.add_development_dependency('rake-compiler')
-
-  spec.test_files = FileList[BASE_TEST_FILE_LIST]
-  
-  # rdoc
-  spec.has_rdoc = true
-  spec.extra_rdoc_files = ['README', 'ext/ruby_debug.c']
-end
-
-cli_spec = Gem::Specification.new do |spec|
-  spec.name = "ruby-debug"
-  
-  spec.homepage = "http://rubyforge.org/projects/ruby-debug/"
-  spec.summary = "Command line interface (CLI) for ruby-debug-base"
-  spec.description = <<-EOF
-A generic command line interface for ruby-debug.
-EOF
-
-  spec.version = Debugger::VERSION
-
-  spec.author = "Kent Sibilev"
-  spec.email = "ksibilev@yahoo.com"
-  spec.platform = Gem::Platform::RUBY
-  spec.require_path = "cli"
-  spec.bindir = "bin"
-  spec.executables = ["rdebug"]
-  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', "~> #{Debugger::VERSION}.0")
-  
-  # FIXME: work out operational logistics for this
-  # spec.test_files = FileList[CLI_TEST_FILE_LIST]
-
-  # rdoc
-  spec.has_rdoc = true
-  spec.extra_rdoc_files = ['README']
-end
-
-# Rake task to build the default package
-Gem::PackageTask.new(base_spec) do |pkg|
-  pkg.need_tar = true
-end
-Gem::PackageTask.new(cli_spec) do |pkg|
-  pkg.need_tar = true
+if defined?(JRUBY_VERSION)
+  Rake::JavaExtensionTask.new('ruby_debug', base_spec) do |t|
+    t.ext_dir = "src"
+  end
+else
+  Rake::ExtensionTask.new('ruby_debug', base_spec) do |t|
+    t.ext_dir = "ext"
+  end
 end
 
-Rake::ExtensionTask.new('ruby_debug', base_spec) do |t|
-  t.ext_dir = "ext"
-end
+Gem::PackageTask.new(base_spec) {}
+Gem::PackageTask.new(cli_spec) {}
 
 task :default => :test
 
-# Windows specification
-win_spec = base_spec.clone
-win_spec.extensions = []
-## win_spec.platform = Gem::Platform::WIN32 # deprecated
-win_spec.platform = 'mswin32'
-win_spec.files += ["lib/#{SO_NAME}"]
-
-desc "Create Windows Gem"
-task :win32_gem do
-  # Copy the win32 extension the top level directory
-  current_dir = File.expand_path(File.dirname(__FILE__))
-  source = File.join(current_dir, "ext", "win32", SO_NAME)
-  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"
-  mv(gem_file, "pkg/#{gem_file}")
-
-  # 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.
-  ruby_debug_path = File.expand_path(File.dirname(__FILE__))
-
-  Rake::SshDirPublisher.new("kent@rubyforge.org",
-        "/var/www/gforge-projects/ruby-debug", ruby_debug_path)
-end
-
 desc "Remove built files"
 task :clean do
   cd "ext" do
@@ -221,7 +73,6 @@ task :clean do
   rm 'lib/ruby_debug.jar' if File.exists?("lib/ruby_debug.jar")
 end
 
-# ---------  RDoc Documentation ------
 desc "Generate rdoc documentation"
 RDoc::Task.new("rdoc") do |rdoc|
   rdoc.rdoc_dir = 'doc/rdoc'
@@ -238,59 +89,3 @@ RDoc::Task.new("rdoc") do |rdoc|
                           'README',
                           '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
-
-def install_gem(spec, *opts)
-  args = ['gem', 'install', "pkg/#{spec.name}-#{spec.version}.gem"] + opts
-  args.unshift 'sudo' unless 0 == Process.uid || ENV['rvm_path']
-  system(*args)
-end
-
-desc 'Install locally'
-task :install => :package do
-  Dir.chdir(File::dirname(__FILE__)) do
-    # ri and rdoc take lots of time
-    install_gem(base_spec, '--no-ri', '--no-rdoc')
-    install_gem(cli_spec, '--no-ri', '--no-rdoc')
-  end
-end    
-
-task :install_full => :package do
-  Dir.chdir(File::dirname(__FILE__)) do
-    install_gem(base_spec)
-    install_gem(cli_spec)
-  end
-end    
-
-namespace :jruby do
-  jruby_spec = base_spec.clone
-  jruby_spec.platform   = "java"
-  jruby_spec.files      = jruby_spec.files.reject {|f| f =~ /^ext/ }
-  jruby_spec.files     += ['lib/ruby_debug.jar']
-  jruby_spec.extensions = []
-
-  Gem::PackageTask.new(jruby_spec) {}
-
-  Rake::JavaExtensionTask.new('ruby_debug') do |t|
-    t.ext_dir = "src"
-  end
-end

data/ext/breakpoint.c

@@ -0,0 +1,582 @@
+#include "ruby_debug.h"
+
+VALUE rdebug_breakpoints = Qnil;
+VALUE rdebug_catchpoints;
+
+static VALUE cBreakpoint;
+static ID    idEval;
+
+static VALUE
+eval_expression(VALUE args)
+{
+    return rb_funcall2(rb_mKernel, idEval, 2, RARRAY(args)->ptr);
+}
+
+int
+check_breakpoint_hit_condition(VALUE breakpoint)
+{
+    debug_breakpoint_t *debug_breakpoint;
+    
+    if(breakpoint == Qnil)
+        return 0;
+    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+
+    debug_breakpoint->hit_count++;
+    if (!Qtrue == debug_breakpoint->enabled) return 0;
+    switch(debug_breakpoint->hit_condition)
+    {
+        case HIT_COND_NONE:
+            return 1;
+        case HIT_COND_GE:
+        {
+            if(debug_breakpoint->hit_count >= debug_breakpoint->hit_value)
+                return 1;
+            break;
+        }
+        case HIT_COND_EQ:
+        {
+            if(debug_breakpoint->hit_count == debug_breakpoint->hit_value)
+                return 1;
+            break;
+        }
+        case HIT_COND_MOD:
+        {
+            if(debug_breakpoint->hit_count % debug_breakpoint->hit_value == 0)
+                return 1;
+            break;
+        }
+    }
+    return 0;
+}
+
+static int
+check_breakpoint_by_pos(VALUE breakpoint, char *file, int line)
+{
+    debug_breakpoint_t *debug_breakpoint;
+
+    if(breakpoint == Qnil)
+        return 0;
+    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+    if (!Qtrue == debug_breakpoint->enabled) return 0;
+    if(debug_breakpoint->type != BP_POS_TYPE)
+        return 0;
+    if(debug_breakpoint->pos.line != line)
+        return 0;
+    if(filename_cmp(debug_breakpoint->source, file))
+        return 1;
+    return 0;
+}
+
+int
+check_breakpoint_by_method(VALUE breakpoint, VALUE klass, ID mid, VALUE self)
+{
+    debug_breakpoint_t *debug_breakpoint;
+
+    if(breakpoint == Qnil)
+        return 0;
+    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+    if (!Qtrue == debug_breakpoint->enabled) return 0;
+    if(debug_breakpoint->type != BP_METHOD_TYPE)
+        return 0;
+    if(debug_breakpoint->pos.mid != mid)
+        return 0;
+    if(classname_cmp(debug_breakpoint->source, klass))
+        return 1;
+    if ((rb_type(self) == T_CLASS) &&
+        classname_cmp(debug_breakpoint->source, self))
+        return 1;
+    return 0;
+}
+
+VALUE
+check_breakpoints_by_pos(debug_context_t *debug_context, char *file, int line)
+{
+    VALUE breakpoint;
+    int i;
+
+    if(!CTX_FL_TEST(debug_context, CTX_FL_ENABLE_BKPT))
+        return Qnil;
+    
+    if(check_breakpoint_by_pos(debug_context->breakpoint, file, line))
+        return debug_context->breakpoint;
+
+    if(RARRAY(rdebug_breakpoints)->len == 0)
+        return Qnil;
+    for(i = 0; i < RARRAY(rdebug_breakpoints)->len; i++)
+    {
+        breakpoint = rb_ary_entry(rdebug_breakpoints, i);
+        if(check_breakpoint_by_pos(breakpoint, file, line))
+            return breakpoint;
+    }
+    return Qnil;
+}
+
+VALUE
+check_breakpoints_by_method(debug_context_t *debug_context, VALUE klass, ID mid, VALUE self)
+{
+    VALUE breakpoint;
+    int i;
+
+    if(!CTX_FL_TEST(debug_context, CTX_FL_ENABLE_BKPT))
+        return Qnil;
+        
+    if(check_breakpoint_by_method(debug_context->breakpoint, klass, mid, self))
+        return debug_context->breakpoint;
+
+    if(RARRAY(rdebug_breakpoints)->len == 0)
+        return Qnil;
+    for(i = 0; i < RARRAY(rdebug_breakpoints)->len; i++)
+    {
+        breakpoint = rb_ary_entry(rdebug_breakpoints, i);
+        if(check_breakpoint_by_method(breakpoint, klass, mid, self))
+            return breakpoint;
+    }
+    return Qnil;
+}
+
+int
+check_breakpoint_expression(VALUE breakpoint, VALUE binding)
+{
+    debug_breakpoint_t *debug_breakpoint;
+    VALUE args, expr_result;
+
+    Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+    if(NIL_P(debug_breakpoint->expr))
+        return 1;
+
+    args = rb_ary_new3(2, debug_breakpoint->expr, binding);
+    expr_result = rb_protect(eval_expression, args, 0);
+    return RTEST(expr_result);
+}
+
+static void
+breakpoint_mark(void *data)
+{
+    debug_breakpoint_t *breakpoint;
+    breakpoint = (debug_breakpoint_t *)data;
+    rb_gc_mark(breakpoint->source);
+    rb_gc_mark(breakpoint->expr);
+}
+
+VALUE
+create_breakpoint_from_args(int argc, VALUE *argv, int id)
+{
+    VALUE source, pos, expr;
+    debug_breakpoint_t *breakpoint;
+    int type;
+
+    if(rb_scan_args(argc, argv, "21", &source, &pos, &expr) == 2)
+    {
+        expr = Qnil;
+    }
+    type = FIXNUM_P(pos) ? BP_POS_TYPE : BP_METHOD_TYPE;
+    if(type == BP_POS_TYPE)
+        source = StringValue(source);
+    else
+        pos = StringValue(pos);
+    breakpoint = ALLOC(debug_breakpoint_t);
+    breakpoint->id = id;
+    breakpoint->source = source;
+    breakpoint->type = type;
+    if(type == BP_POS_TYPE)
+        breakpoint->pos.line = FIX2INT(pos);
+    else
+        breakpoint->pos.mid = rb_intern(RSTRING(pos)->ptr);
+    breakpoint->enabled = Qtrue;
+    breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
+    breakpoint->hit_count = 0;
+    breakpoint->hit_value = 0;
+    breakpoint->hit_condition = HIT_COND_NONE;
+    return Data_Wrap_Struct(cBreakpoint, breakpoint_mark, xfree, breakpoint);
+}
+
+/*
+ *   call-seq:
+ *      Debugger.remove_breakpoint(id) -> breakpoint
+ *
+ *   Removes breakpoint by its id.
+ *   <i>id</i> is an identificator of a breakpoint.
+ */
+VALUE
+rdebug_remove_breakpoint(VALUE self, VALUE id_value)
+{
+    int i;
+    int id;
+    VALUE breakpoint;
+    debug_breakpoint_t *debug_breakpoint;
+
+    id = FIX2INT(id_value);
+
+    for( i = 0; i < RARRAY(rdebug_breakpoints)->len; i += 1 )
+    {
+        breakpoint = rb_ary_entry(rdebug_breakpoints, i);
+        Data_Get_Struct(breakpoint, debug_breakpoint_t, debug_breakpoint);
+        if(debug_breakpoint->id == id)
+        {
+            rb_ary_delete_at(rdebug_breakpoints, i);
+            return breakpoint;
+        }
+    }
+    return Qnil;
+}
+
+/*
+ *   call-seq:
+ *      Debugger.catchpoints -> hash
+ *
+ *   Returns a current catchpoints, which is a hash exception names that will
+ *   trigger a debugger when raised. The values are the number of times taht
+ *   catchpoint was hit, initially 0.
+ */
+VALUE
+debug_catchpoints(VALUE self)
+{
+    debug_check_started();
+
+    return rdebug_catchpoints;
+}
+
+/*
+ *   call-seq:
+ *      Debugger.catchpoint(string) -> string
+ *
+ *   Sets catchpoint. Returns the string passed.
+ */
+VALUE
+rdebug_add_catchpoint(VALUE self, VALUE value)
+{
+    debug_check_started();
+
+    if (TYPE(value) != T_STRING) {
+        rb_raise(rb_eTypeError, "value of a catchpoint must be String");
+    }
+    rb_hash_aset(rdebug_catchpoints, rb_str_dup(value), INT2FIX(0));
+    return value;
+}
+
+/*
+ *   call-seq:
+ *      context.breakpoint -> Breakpoint
+ *
+ *   Returns a context-specific temporary Breakpoint object.
+ */
+VALUE
+context_breakpoint(VALUE self)
+{
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    return debug_context->breakpoint;
+}
+
+/*
+ *   call-seq:
+ *      context.set_breakpoint(source, pos, condition = nil) -> breakpoint
+ *
+ *   Sets a context-specific temporary breakpoint, which can be used to implement
+ *   'Run to Cursor' debugger function. When this breakpoint is reached, it will be
+ *   cleared out.
+ *
+ *   <i>source</i> is a name of a file or a class.
+ *   <i>pos</i> is a line number or a method name if <i>source</i> is a class name.
+ *   <i>condition</i> is a string which is evaluated to +true+ when this breakpoint
+ *   is activated.
+ */
+VALUE
+context_set_breakpoint(int argc, VALUE *argv, VALUE self)
+{
+    VALUE result;
+    debug_context_t *debug_context;
+
+    debug_check_started();
+
+    Data_Get_Struct(self, debug_context_t, debug_context);
+    result = create_breakpoint_from_args(argc, argv, 0);
+    debug_context->breakpoint = result;
+    return result;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.enabled?
+ *
+ *   Returns whether breakpoint is enabled or not.
+ */
+static VALUE
+breakpoint_enabled(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return breakpoint->enabled;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.enabled = bool
+ *
+ *   Enables or disables breakpoint.
+ */
+static VALUE
+breakpoint_set_enabled(VALUE self, VALUE bool)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return breakpoint->enabled = bool;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.source -> string
+ *
+ *   Returns a source of the breakpoint.
+ */
+static VALUE
+breakpoint_source(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return breakpoint->source;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.source = string
+ *
+ *   Sets the source of the breakpoint.
+ */
+static VALUE
+breakpoint_set_source(VALUE self, VALUE value)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    breakpoint->source = StringValue(value);
+    return value;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.pos -> string or int
+ *
+ *   Returns the position of this breakpoint.
+ */
+static VALUE
+breakpoint_pos(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    if(breakpoint->type == BP_METHOD_TYPE)
+        return rb_str_new2(rb_id2name(breakpoint->pos.mid));
+    else
+        return INT2FIX(breakpoint->pos.line);
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.pos = string or int
+ *
+ *   Sets the position of this breakpoint.
+ */
+static VALUE
+breakpoint_set_pos(VALUE self, VALUE value)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    if(breakpoint->type == BP_METHOD_TYPE)
+    {
+        breakpoint->pos.mid = rb_to_id(StringValue(value));
+    }
+    else
+        breakpoint->pos.line = FIX2INT(value);
+    return value;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.expr -> string
+ *
+ *   Returns a codition expression when this breakpoint should be activated.
+ */
+static VALUE
+breakpoint_expr(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return breakpoint->expr;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.expr = string | nil
+ *
+ *   Sets the codition expression when this breakpoint should be activated.
+ */
+static VALUE
+breakpoint_set_expr(VALUE self, VALUE expr)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
+    return expr;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.id -> int
+ *
+ *   Returns id of the breakpoint.
+ */
+static VALUE
+breakpoint_id(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return INT2FIX(breakpoint->id);
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.hit_count -> int
+ *
+ *   Returns the hit count of the breakpoint.
+ */
+static VALUE
+breakpoint_hit_count(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return INT2FIX(breakpoint->hit_count);
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.hit_value -> int
+ *
+ *   Returns the hit value of the breakpoint.
+ */
+static VALUE
+breakpoint_hit_value(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    return INT2FIX(breakpoint->hit_value);
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.hit_value = int
+ *
+ *   Sets the hit value of the breakpoint.
+ */
+static VALUE
+breakpoint_set_hit_value(VALUE self, VALUE value)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    breakpoint->hit_value = FIX2INT(value);
+    return value;
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.hit_condition -> symbol
+ *
+ *   Returns the hit condition of the breakpoint:
+ *
+ *   +nil+ if it is an unconditional breakpoint, or
+ *   :greater_or_equal, :equal, :modulo
+ */
+static VALUE
+breakpoint_hit_condition(VALUE self)
+{
+    debug_breakpoint_t *breakpoint;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    switch(breakpoint->hit_condition)
+    {
+        case HIT_COND_GE:
+            return ID2SYM(rb_intern("greater_or_equal"));
+        case HIT_COND_EQ:
+            return ID2SYM(rb_intern("equal"));
+        case HIT_COND_MOD:
+            return ID2SYM(rb_intern("modulo"));
+        case HIT_COND_NONE:
+        default:
+            return Qnil;
+    }
+}
+
+/*
+ *   call-seq:
+ *      breakpoint.hit_condition = symbol
+ *
+ *   Sets the hit condition of the breakpoint which must be one of the following values:
+ *
+ *   +nil+ if it is an unconditional breakpoint, or
+ *   :greater_or_equal(:ge), :equal(:eq), :modulo(:mod)
+ */
+static VALUE
+breakpoint_set_hit_condition(VALUE self, VALUE value)
+{
+    debug_breakpoint_t *breakpoint;
+    ID id_value;
+
+    Data_Get_Struct(self, debug_breakpoint_t, breakpoint);
+    id_value = rb_to_id(value);
+    
+    if(rb_intern("greater_or_equal") == id_value || rb_intern("ge") == id_value)
+        breakpoint->hit_condition = HIT_COND_GE;
+    else if(rb_intern("equal") == id_value || rb_intern("eq") == id_value)
+        breakpoint->hit_condition = HIT_COND_EQ;
+    else if(rb_intern("modulo") == id_value || rb_intern("mod") == id_value)
+        breakpoint->hit_condition = HIT_COND_MOD;
+    else
+        rb_raise(rb_eArgError, "Invalid condition parameter");
+    return value;
+}
+
+/*
+ *   Document-class: Breakpoint
+ *
+ *   == Summary
+ *
+ *   This class represents a breakpoint. It defines position of the breakpoint and
+ *   condition when this breakpoint should be triggered.
+ */
+void
+Init_breakpoint()
+{
+    cBreakpoint = rb_define_class_under(mDebugger, "Breakpoint", rb_cObject);
+    rb_define_method(cBreakpoint, "enabled=", breakpoint_set_enabled, 1);
+    rb_define_method(cBreakpoint, "enabled?", breakpoint_enabled, 0);
+    rb_define_method(cBreakpoint, "expr", breakpoint_expr, 0);
+    rb_define_method(cBreakpoint, "expr=", breakpoint_set_expr, 1);
+    rb_define_method(cBreakpoint, "hit_condition", breakpoint_hit_condition, 0);
+    rb_define_method(cBreakpoint, "hit_condition=", breakpoint_set_hit_condition, 1);
+    rb_define_method(cBreakpoint, "hit_count", breakpoint_hit_count, 0);
+    rb_define_method(cBreakpoint, "hit_value", breakpoint_hit_value, 0);
+    rb_define_method(cBreakpoint, "hit_value=", breakpoint_set_hit_value, 1);
+    rb_define_method(cBreakpoint, "id", breakpoint_id, 0);
+    rb_define_method(cBreakpoint, "pos", breakpoint_pos, 0);
+    rb_define_method(cBreakpoint, "pos=", breakpoint_set_pos, 1);
+    rb_define_method(cBreakpoint, "source", breakpoint_source, 0);
+    rb_define_method(cBreakpoint, "source=", breakpoint_set_source, 1);
+    idEval             = rb_intern("eval");
+    rdebug_catchpoints = rb_hash_new();
+
+}
+
+

data/ext/ruby_debug.h

@@ -0,0 +1,123 @@
+#include <ruby.h>
+/* Context info */
+enum ctx_stop_reason {CTX_STOP_NONE, CTX_STOP_STEP, CTX_STOP_BREAKPOINT, 
+		      CTX_STOP_CATCHPOINT};
+
+/* Context flags */
+#define CTX_FL_SUSPEND      (1<<1)
+#define CTX_FL_TRACING      (1<<2)
+#define CTX_FL_SKIPPED      (1<<3)
+#define CTX_FL_IGNORE       (1<<4)
+#define CTX_FL_DEAD         (1<<5)
+#define CTX_FL_WAS_RUNNING  (1<<6)
+#define CTX_FL_ENABLE_BKPT  (1<<7)
+#define CTX_FL_STEPPED      (1<<8)
+#define CTX_FL_FORCE_MOVE   (1<<9)
+
+#define CTX_FL_TEST(c,f)  ((c)->flags & (f))
+#define CTX_FL_SET(c,f)   do { (c)->flags |= (f); } while (0)
+#define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
+
+typedef struct {
+    int argc;         /* Number of arguments a frame should have. */
+    VALUE binding;
+    ID id;
+    ID orig_id;
+    int line;
+    const char * file;
+    short dead;
+    VALUE self;
+    VALUE arg_ary;
+    union {
+        struct {
+            struct FRAME *frame;
+            struct SCOPE *scope;
+            struct RVarmap *dyna_vars;
+        } runtime;
+        struct {
+            VALUE args;
+            VALUE locals;
+	    VALUE arg_ary;
+        } copy;
+    } info;
+} debug_frame_t;
+
+typedef struct {
+    VALUE thread_id;
+    int thnum;
+    int flags;
+    enum ctx_stop_reason stop_reason;
+    int stop_next;
+    int dest_frame;
+    int stop_line;
+    int stop_frame;
+    int stack_size;
+    int stack_len;
+    debug_frame_t *frames;
+    const char * last_file;
+    int last_line;
+    VALUE breakpoint;
+} debug_context_t;
+
+/* variables in ruby_debug.c */
+extern VALUE mDebugger;
+extern VALUE rdebug_breakpoints;
+extern VALUE rdebug_catchpoints;
+extern VALUE rdebug_threads_tbl;
+
+/* routines in ruby_debug.c */
+extern int  filename_cmp(VALUE source, char *file);
+
+#define IS_STARTED  (rdebug_threads_tbl != Qnil)
+static inline void
+debug_check_started()
+{
+    if(!IS_STARTED)
+    {
+        rb_raise(rb_eRuntimeError, "Debugger.start is not called yet.");
+    }
+}
+
+static inline int
+classname_cmp(VALUE name, VALUE klass)
+{
+    VALUE class_name = (Qnil == name) ? rb_str_new2("main") : name;
+    return (klass != Qnil 
+	    && rb_str_cmp(class_name, rb_mod_name(klass)) == 0);
+}
+
+/* Breakpoint information */
+enum bp_type {BP_POS_TYPE, BP_METHOD_TYPE};
+enum hit_condition {HIT_COND_NONE, HIT_COND_GE, HIT_COND_EQ, HIT_COND_MOD};
+
+typedef struct {
+    int   id;
+    enum bp_type type;
+    VALUE source;
+    union
+    {
+        int line;
+        ID  mid;
+    } pos;
+    VALUE expr;
+    VALUE enabled;
+    int hit_count;
+    int hit_value;
+    enum hit_condition hit_condition;
+} debug_breakpoint_t;
+
+/* routines in breakpoint.c */
+extern int   check_breakpoint_expression(VALUE breakpoint, VALUE binding);
+extern int   check_breakpoint_hit_condition(VALUE breakpoint);
+extern VALUE check_breakpoints_by_method(debug_context_t *debug_context, 
+    VALUE klass, ID mid, VALUE self);
+extern VALUE check_breakpoints_by_pos(debug_context_t *debug_context, 
+    char *file, int line);
+extern VALUE create_breakpoint_from_args(int argc, VALUE *argv, int id);
+extern VALUE context_breakpoint(VALUE self);
+extern VALUE context_set_breakpoint(int argc, VALUE *argv, VALUE self);
+extern VALUE rdebug_add_catchpoint(VALUE self, VALUE value);
+extern VALUE debug_catchpoints(VALUE self);
+extern VALUE rdebug_remove_breakpoint(VALUE self, VALUE id_value);
+
+extern void Init_breakpoint();

data/lib/ruby-debug-base/version.rb

@@ -1,3 +1,3 @@
 module Debugger
-  VERSION = "0.10.5.rc1"
+  VERSION = "0.10.5.rc2"
 end

metadata

@@ -2,7 +2,7 @@
 name: ruby-debug-base
 version: !ruby/object:Gem::Version 
   prerelease: 7
-  version: 0.10.5.rc1
+  version: 0.10.5.rc2
 platform: java
 authors: 
   - Kent Sibilev
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-19 00:00:00 -07:00
-default_executable: 
+date: 2012-07-19 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: linecache
@@ -19,13 +18,13 @@ dependencies:
     requirement: &id001 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
-        - - ">="
+        - - ~>
           - !ruby/object:Gem::Version 
-            version: "0.3"
+            version: "0.46"
     type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
-    name: rake-compiler
+    name: rake
     prerelease: false
     requirement: &id002 !ruby/object:Gem::Requirement 
       none: false
@@ -35,10 +34,32 @@ dependencies:
             version: "0"
     type: :development
     version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: rdoc
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: rake-compiler
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ~>
+          - !ruby/object:Gem::Version 
+            version: 0.8.1
+    type: :development
+    version_requirements: *id004
 description: |
   ruby-debug is a fast implementation of the standard Ruby debugger debug.rb.
-  It is implemented by utilizing a new Ruby C API hook. The core component 
-  provides support that front-ends can build on. It provides breakpoint 
+  It is implemented by utilizing a new Ruby C API hook. The core component
+  provides support that front-ends can build on. It provides breakpoint
   handling, bindings for stack frames among other things.
 
 email: ksibilev@yahoo.com
@@ -55,18 +76,14 @@ files:
   - LICENSE
   - README
   - Rakefile
+  - ext/breakpoint.c
+  - ext/extconf.rb
+  - ext/ruby_debug.c
+  - ext/ruby_debug.h
   - lib/ruby-debug-base.rb
   - lib/ruby-debug-base/version.rb
-  - test/base/base.rb
-  - test/base/binding.rb
-  - test/base/catchpoint.rb
-  - test/base/load.rb
-  - test/base/reload_bug.rb
-  - ext/ruby_debug.c
-  - ext/extconf.rb
   - lib/ruby_debug.jar
-has_rdoc: true
-homepage: http://rubyforge.org/projects/ruby-debug/
+homepage: https://github.com/ruby-debug/
 licenses: []
 
 post_install_message: 
@@ -79,7 +96,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.2
+        version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
@@ -88,14 +105,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
         version: 1.3.1
 requirements: []
 
-rubyforge_project: ruby-debug
-rubygems_version: 1.5.1
+rubyforge_project: 
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Fast Ruby debugger - core component
-test_files: 
-  - test/base/base.rb
-  - test/base/binding.rb
-  - test/base/catchpoint.rb
-  - test/base/load.rb
-  - test/base/reload_bug.rb
+test_files: []
+

data/test/base/base.rb

@@ -1,77 +0,0 @@
-#!/usr/bin/env ruby
-require File.expand_path("../../helper", __FILE__)
-
-# Some tests of Debugger module in C extension ruby_debug 
-class TestRubyDebug < Test::Unit::TestCase
-  def test_version
-    assert(defined?(Debugger::VERSION))
-  end
-
-  # test current_context
-  def test_current_context
-    assert_equal(false, Debugger.started?, 
-                 'debugger should not initially be started.')
-    Debugger.start_
-    assert(Debugger.started?, 
-           'debugger should now be started.')
-    assert_equal(__LINE__, Debugger.current_context.frame_line)
-    assert_equal(nil, Debugger.current_context.frame_args_info,
-                 'no frame args info.')
-    assert_equal(Debugger.current_context.frame_file, 
-                 Debugger.current_context.frame_file(0))
-    assert_equal(File.basename(__FILE__),
-                 File.basename(Debugger.current_context.frame_file))
-    assert_raises(ArgumentError) {Debugger.current_context.frame_file(1, 2)}
-    assert_raises(ArgumentError) {Debugger.current_context.frame_file(10)}
-    assert_equal(1, Debugger.current_context.stack_size)
-    assert_equal(TestRubyDebug, Debugger.current_context.frame_class)
-    assert_equal(false, Debugger.current_context.dead?, 'Not dead yet!')
-  ensure
-    Debugger.stop
-    assert_equal(false, Debugger.started?, 
-                 'Debugger should no longer be started.')
-  end
-
-  # Test initial variables and setting/getting state.
-  def test_debugger_base
-    assert_equal(false, Debugger.started?, 
-                 'Debugger should not initially be started.')
-    Debugger.start_
-    assert(Debugger.started?, 
-           'Debugger should now be started.')
-    assert_equal(false, Debugger.debug,
-                 'Debug variable should not be set.')
-    assert_equal(false, Debugger.post_mortem?,
-                 'Post mortem debugging should not be set.')
-    a = Debugger.contexts
-    assert_equal(1, a.size, 
-                 'There should only be one context.')
-    assert_equal(Array, a.class, 
-                 'Context should be an array.')
-  ensure
-    Debugger.stop
-    assert_equal(false, Debugger.started?, 
-                 'debugger should no longer be started.')
-  end
-
-  # Test breakpoint handling
-  def test_breakpoints
-    Debugger.start_
-    assert_equal(0, Debugger.breakpoints.size,
-                 'There should not be any breakpoints set.')
-    brk = Debugger.add_breakpoint(__FILE__, 1)
-    assert_equal(Debugger::Breakpoint, brk.class,
-                 'Breakpoint should have been set and returned.')
-    assert_equal(1, Debugger.breakpoints.size,
-                 'There should now be one breakpoint set.')
-    Debugger.remove_breakpoint(0)
-    assert_equal(1, Debugger.breakpoints.size,
-                 'There should still be one breakpoint set.')
-    Debugger.remove_breakpoint(1)
-    assert_equal(0, Debugger.breakpoints.size,
-                 'There should no longer be any breakpoints set.')
-  ensure
-    Debugger.stop
-  end
-end
-

data/test/base/binding.rb

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-require File.expand_path("../../helper", __FILE__)
-
-# Test binding_n command
-class TestBinding < Test::Unit::TestCase
-  def test_basic
-    def inside_fn
-      s = 'some other string'
-      b2 = Kernel::binding_n(1)
-      y2 = eval('s', b2)
-      assert_equal('this is a test', y2)
-    end
-    s = 'this is a test'
-    Debugger.start
-    b = Kernel::binding_n(0)
-    y = eval('s', b)
-    assert_equal(s, y)
-    inside_fn
-  ensure
-    Debugger.stop
-  end
-end

data/test/base/catchpoint.rb

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-require File.expand_path("../../helper", __FILE__)
-
-# Test catchpoint in C ruby_debug extension.
-  
-class TestRubyDebugCatchpoint < Test::Unit::TestCase
-  def test_catchpoints
-    assert_raise(RuntimeError) {Debugger.catchpoints}
-    Debugger.start_
-    assert_equal({}, Debugger.catchpoints)
-    Debugger.add_catchpoint('ZeroDivisionError')
-    assert_equal({'ZeroDivisionError' => 0}, Debugger.catchpoints)
-    Debugger.add_catchpoint('RuntimeError')
-    assert_equal(['RuntimeError', 'ZeroDivisionError'], 
-                 Debugger.catchpoints.keys.sort)
-  ensure
-    Debugger.stop
-  end
-end

data/test/base/load.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-require File.expand_path("../../helper", __FILE__)
-
-# Test of Debugger.debug_load in C extension ruby_debug.so
-class TestDebugLoad < Test::Unit::TestCase
-  class << self
-    def at_line(file, line)
-      @@at_line = [File.basename(file), line]
-    end
-  end
-
-  class Debugger::Context
-    def at_line(file, line)
-      TestDebugLoad::at_line(file, line)
-    end
-  end
-
-  def test_debug_load
-    src_dir = File.dirname(__FILE__)
-    prog_script = File.join(src_dir, '..', 'example', 'gcd.rb')
-
-    # Without stopping
-    bt = Debugger.debug_load(prog_script, false)
-    assert_equal(nil, bt)
-    assert(Debugger.started?)
-    Debugger.stop
-
-    # With stopping
-    bt = Debugger.debug_load(prog_script, true)
-    assert_equal(nil, bt)
-    assert_equal(['gcd.rb', 4], @@at_line)
-    assert(Debugger.started?)
-    Debugger.stop
-
-    # Test that we get a proper backtrace on a script that raises 'abc'
-    prog_script = File.join(src_dir, '..', 'example', 'raise.rb')
-    bt = Debugger.debug_load(prog_script, false)
-    assert_equal('abc', bt.to_s)
-    assert(Debugger.started?)
-    Debugger.stop
-  ensure
-    Debugger.stop if Debugger.started?
-  end
-end

data/test/base/reload_bug.rb

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-require File.expand_path("../../helper", __FILE__)
-
-class TestReloadBug < Test::Unit::TestCase
-  def test_reload_bug
-    assert_equal({}, Debugger::source_reload)
-  end
-end