ruby-debug-base193 0.0.1

data/Rakefile

@@ -0,0 +1,266 @@
+#!/usr/bin/env rake
+# -*- Ruby -*-
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('ruby_debug')
+
+SO_NAME = "ruby_debug.so"
+
+# ------- Default Package ----------
+RUBY_DEBUG_VERSION = open("ext/ruby_debug/ruby_debug.c") do |f| 
+  f.grep(/^#define DEBUG_VERSION/).first[/"(.+)"/,1]
+end
+
+RUBY_DEBUG_TEENY = ".0"
+RUBY_DEBUG_BASE_TEENY = ".0"
+
+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/**/data/*.cmd',
+  'test/**/data/*.right',
+  'test/**/*.rb',
+  'rdbg.rb',
+   CLI_TEST_FILE_LIST
+]
+
+BASE_TEST_FILE_LIST = %w(
+  test/base/base.rb 
+  test/base/binding.rb 
+  test/base/catchpoint.rb)
+BASE_FILES = COMMON_FILES + FileList[
+  'ext/ruby_debug/breakpoint.c',
+  'ext/ruby_debug/extconf.rb',
+  'ext/ruby_debug/ruby_debug.c',
+  'ext/ruby_debug/ruby_debug.h',
+  'ext/win32/*',
+  'lib/**/*',
+  BASE_TEST_FILE_LIST,
+]
+
+desc "Test everything."
+task :test => :test_base do 
+  Rake::TestTask.new(:test) do |t|
+    t.libs << './ext'
+    t.libs << './lib'
+    t.libs << './cli'
+    t.test_files = CLI_TEST_FILE_LIST
+    t.verbose = true
+  end
+end
+
+desc "Test ruby-debug-base."
+task :test_base => :lib do 
+  Rake::TestTask.new(:test_base) do |t|
+    t.libs << './ext'
+    t.libs << './lib'
+    t.test_files = FileList[BASE_TEST_FILE_LIST]
+    t.verbose = true
+  end
+end
+
+desc "Test everything - same as test."
+task :check => :test
+
+desc "Create the core ruby-debug shared library extension"
+task :lib do
+  Dir.chdir("ext") do
+    system("#{Gem.ruby} extconf.rb && make")
+  end
+end
+
+desc "Compile Emacs code"
+task :emacs => "emacs/rdebug.elc"
+file "emacs/rdebug.elc" => ["emacs/elisp-comp", "emacs/rdebug.el"] do
+  Dir.chdir("emacs") do
+    system("./elisp-comp ./rdebug.el")
+  end
+end
+
+desc "Create a GNU-style ChangeLog via svn2cl"
+task :ChangeLog do
+  system("svn2cl --authors=svn2cl_usermap svn://rubyforge.org/var/svn/ruby-debug/trunk")
+  system("svn2cl --authors=svn2cl_usermap svn://rubyforge.org/var/svn/ruby-debug/trunk/ext -o ext/ChangeLog")
+  system("svn2cl --authors=svn2cl_usermap svn://rubyforge.org/var/svn/ruby-debug/trunk/lib -o lib/ChangeLog")
+end
+
+# Base GEM Specification
+base_spec = Gem::Specification.new do |spec|
+  spec.name = "ruby-debug-base19"
+  
+  spec.homepage = "http://rubyforge.org/projects/ruby-debug19/"
+  spec.summary = "Fast Ruby debugger - core component"
+  spec.description = <<-EOF
+ruby-debug-base19 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 = RUBY_DEBUG_VERSION + RUBY_DEBUG_BASE_TEENY
+
+  spec.authors = ["Kent Sibilev", "Mark Moseley"]
+  spec.email = "mark@fast-software.com"
+  spec.platform = Gem::Platform::RUBY
+  spec.require_path = "lib"
+  spec.extensions = ["ext/ruby_debug/extconf.rb"]
+  spec.files = BASE_FILES.to_a  
+
+  spec.required_ruby_version = '>= 1.8.2'
+  spec.date = Time.now
+  spec.rubyforge_project = 'ruby-debug19'
+  spec.add_dependency('ruby_core_source', '>= 0.1.4')
+  spec.add_dependency('linecache19', '>= 0.5.11')
+  
+  spec.test_files = FileList[BASE_TEST_FILE_LIST]
+  
+  # rdoc
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = ['README', 'ext/ruby_debug/ruby_debug.c']
+end
+
+cli_spec = Gem::Specification.new do |spec|
+  spec.name = "ruby-debug19"
+  
+  spec.homepage = "http://rubyforge.org/projects/ruby-debug19/"
+  spec.summary = "Command line interface (CLI) for ruby-debug-base19"
+  spec.description = <<-EOF
+A generic command line interface for ruby-debug.
+EOF
+
+  spec.version = RUBY_DEBUG_VERSION + RUBY_DEBUG_TEENY
+
+  spec.authors = ["Kent Sibilev", "Mark Moseley"]
+  spec.email = "mark@fast-software.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.3.1')
+  spec.add_dependency('linecache19', '>= 0.5.11')
+  spec.add_dependency('ruby-debug-base19', '>= 0.12.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
+Rake::GemPackageTask.new(base_spec) do |pkg|
+  pkg.need_tar = true
+end
+Rake::GemPackageTask.new(cli_spec) do |pkg|
+  pkg.need_tar = true
+end
+
+task :default => [:package]
+
+# 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
+    if File.exists?("Makefile")
+      sh "make clean"
+      rm  "Makefile"
+    end
+    derived_files = Dir.glob(".o") + Dir.glob("*.so")
+    rm derived_files unless derived_files.empty?
+  end
+end
+
+# ---------  RDoc Documentation ------
+desc "Generate rdoc documentation"
+Rake::RDocTask.new("rdoc") do |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.title    = "ruby-debug"
+  # Show source inline with line numbers
+  rdoc.options << "--inline-source" << "--line-numbers"
+  # Make the readme file the start page for the generated html
+  rdoc.options << '--main' << 'README'
+  rdoc.rdoc_files.include('bin/**/*',
+                          'cli/ruby-debug/commands/*.rb',
+                          'lib/**/*.rb',
+                          'ext/**/ruby_debug.c',
+                          '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

data/ext/ruby_debug/breakpoint.c

@@ -0,0 +1,578 @@
+#include <ruby.h>
+#include <stdio.h>
+#include <vm_core.h>
+#include <iseq.h>
+#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_PTR(args));
+}
+
+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, const 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, const 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_LEN(rdebug_breakpoints) == 0)
+        return Qnil;
+    for(i = 0; i < RARRAY_LEN(rdebug_breakpoints); 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_LEN(rdebug_breakpoints) == 0)
+        return Qnil;
+    for(i = 0; i < RARRAY_LEN(rdebug_breakpoints); 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_PTR(pos));
+    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_LEN(rdebug_breakpoints); 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)
+{
+    return rdebug_catchpoints;
+}
+
+/*
+ *   call-seq:
+ *      Debugger.catchpoint(string) -> string
+ *
+ *   Sets catchpoint. Returns the string passed.
+ */
+VALUE
+rdebug_add_catchpoint(VALUE self, VALUE value)
+{
+    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;
+
+    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;
+
+    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();
+
+}
+
+