byebug 1.8.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e50f515a828a79ec3a73e802a9b480b44d4aedb
-  data.tar.gz: 3a613a22f8a9a5e6805899f646efbd8e5f29c5eb
+  metadata.gz: bb2fb8a1795fb10ac0b9a08f34c9384590f2ed68
+  data.tar.gz: ddcc06fdb4be593c69905dc4a0277ea5bf2d945e
 SHA512:
-  metadata.gz: b1dea64be0bf3f4aa95986f80e4d468c810ce5ed6a3322a5a672d8db772548109a3c390d5a442bf0b91b6f934c2d6b18797b5782730b2b6f9a544f47ddb337f1
-  data.tar.gz: 7962816e1385499dce322487b27be5ec25e71f8134f65c8d6b2970ab19257ee998c9f34c2f3208fa64e8349a20ea3b0b050406be1806222b24b8ce6f9af95f1b
+  metadata.gz: bd5bec3e835cec6a85de603e4437e013f86fa5e9f239a243fcfa9540b17324a27a075b3a7c78520d2390d8a32e698f8939006e46fbe7f56e547bd008ceb73958
+  data.tar.gz: de559dec1bf1265a8e8cacb7431b1617a53ad10dafb24c4ae728714116c5d80580d52e180665fe46632578e8bb198bc9fe8240f989e815f56a80240883c5cad9

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 2.0.0
+
+* Various bug fixes
+* "Official" definition of a command API
+* Thread support
+
+
 ## 1.8.2
 
 * More user friendly regexps for commands
@@ -91,7 +98,7 @@ containing the character '%'
 
 ## 1.1.0
 
-* Post mortem support
+* Post-mortem support
 
 
 ## 1.0.3

data/GUIDE.md

@@ -589,7 +589,6 @@ byebug 1.6.1
 Usage: byebug [options] <script.rb> -- <script.rb parameters>
 
 Options:
- -A, --annotate LEVEL      Set annotation level
  -d, --debug               Set $DEBUG=true
  -I, --include PATH        Add PATH (single or multiple:path:list) to $LOAD_PATH
      --no-quit             Do not quit when script finishes
@@ -614,10 +613,6 @@ letter option name, such as `-h`. The list of options is detailed below:
 * **-h | --help**. It causes `byebug` to print some basic help and exit
 * **-v | --version**. It causes `byebug` to print its version number and
 exit.
-* **-A | --annotate <level>**. Set gdb-style annotation `level`, a number.
-Additional information is output automatically when program state is changed.
-This can be used by front-ends such as GNU Emacs to post this updated
-information without having to poll for it.
 * **-d | --debug**. Set `$DEBUG` to `true`. Compatible with Ruby's.
 * **-I | --include <path>**. Add `path` to load path. `path` can be a single
 path ar a colon separated path list.
@@ -674,8 +669,8 @@ puts "rocky's byebugrc run"
 Here are the default values in `options`
 
 ```
-#<OpenStruct annotate=nil, nx=false, quit=true, restart_script=nil, script=nil,
-             stop=true, tracing=false, verbose_long=false>
+#<OpenStruct nx=false, quit=true, restart_script=nil, script=nil, stop=true,
+             tracing=false, verbose_long=false>
 ```
 
 ### Command Files
@@ -819,9 +814,7 @@ be `(byebug:ctrl)` and in post-mortem debugging it will be
 `(byebug:post-mortem)`.
 
 Whenever `byebug` gives an error message such as for an invalid command or an invalid
-location position, it will generally preface the message with `***`. However if
-annotation mode is on then the message is put in a `begin-error` annotation and no
-`***` appears.
+location position, it will generally preface the message with `***`.
 
 ### Command Help
 
@@ -834,12 +827,11 @@ short list of named classes of commands
 Type "help <command-name>" for help on a specific command
 
 Available commands:
-backtrace  catch   continue  disable  down   enable  exit       frame
-info       jump    list      next     pp     putl    reload     save
-show       source  trace     up       where  break   condition  delete
-display    edit    eval      finish   help   irb     kill       method
-p          ps      quit      restart  set    skip    step       undisplay
-var
+backtrace  delete   enable  help  method  ps       save    step       where
+break      disable  eval    info  next    putl     set     trace
+catch      display  exit    irb   p       quit     show    undisplay
+condition  down     finish  kill  pp      reload   skip    up
+continue   edit     frame   list  pry     restart  source  var
 ```
 
 With a command name as `help` argument, `byebug` displays short information on how to
@@ -859,11 +851,11 @@ A number of commands, namely `info`, `set`, `show`, `enable` and `disable`, have
 sub-parameters or _subcommands_. When you ask for help for one of these commands, you
 will get help for all of the subcommands that command offers. Sometimes you may want
 help only on a subcommand and to do this just follow the command with its subcommand
-name. For example `help set annotate` will just give help about the annotate command.
-Furthermore it will give longer help than the summary information that appears when
-you ask for help. You don't need to list the full subcommand name, just enough
-letters to make that subcommand distinct from others will do. For example,
-`help set an` is the same as `help set annotate`.
+name. For example, `help info breakpoints`will just give help about the `info
+breakpoints` command. Furthermore it will give longer help than the summary
+information that appears when you ask for help. You don't need to list the full
+subcommand name, just enough of the letters to make that subcommand distinct from
+others will do. For example, `help info b` is the same as `help info breakpoints`.
 
 Some examples follow.
 
@@ -902,7 +894,7 @@ With an integer argument, list info on that breakpoint.
 ```
 
 ```bash
-(byebug) help info br
+(byebug) help info b
 Status of user-settable breakpoints.
 Without argument, list info about all breakpoints.
 With an integer argument, list info on that breakpoint.

data/README.md

@@ -8,8 +8,7 @@ _Debugging in Ruby 2.0_
 Byebug is a simple to use, feature rich debugger for Ruby 2.0. It uses the new
 TracePoint API for execution control and the new Debug Inspector API for call
 stack navigation, so it doesn't depend on internal core sources. It's developed
-as a C extension, so it's fast. And it has a full test suite so it's (I hope)
-reliable.
+as a C extension, so it's fast. And it has a full test suite so it's reliable.
 
 It allows you to see what is going on _inside_ a Ruby program while it executes
 and can do four main kinds of things to help you catch bugs in the act:
@@ -52,7 +51,7 @@ Former [debugger](https://github.com/cldwalker/debugger) or
 [ruby-debug](https://github.com/mark-moseley/ruby-debug) users, notice:
 
 * Some gems (rails, rspec) implement debugging flags (-d, --debugger) that early
-require and start the debugger. This flags are a performance penalty and Byebug
+require and start the debugger. These flags are a performance penalty and Byebug
 doesn't need them anymore so my recommendation is not to use them.
 * Stopping execution using the word `debugger` doesn't work anymore unless you
 explicitly alias it. Similarly, the startup configuration file is now called
@@ -66,7 +65,7 @@ no longer need to set them in the startup file.
 * Works on 2.0.0 and it doesn't on 1.9.x.
 * Has no MRI internal source code dependencies, just a clean API.
 * Fixes most of debugger's current open issues:
-  - Post mortem mode segfaulting.
+  - Post-mortem mode segfaulting.
   - Line number wrongly shown as zero in backtrace.
   - Line tracing.
   - Colon delimited include paths.
@@ -76,11 +75,72 @@ no longer need to set them in the startup file.
   - `byebug` can now be placed at the end of a block or method call.
 * Very actively mantained.
 * Editor agnostic: no external editor built-in support.
-* No thread support. Haven't had time to look at it and I don't know whether
-the new debugging API supports it yet.
 * Pry command is built-in. No need of external gem like debugger-pry.
 
 
+## Semantic Versioning
+
+Byebug tries to follow [semantic versioning](semver.org). Backwards
+compatibility doesn't seem like a critic issue for a debugger because it's not
+supposed to be used permanently by any program, let alone in production
+environments. However, I still like the idea of giving some meaning to version
+changes.
+
+Byebug's public API is determined by its set of commands
+
+    +-----------+----------+------------------------------------------------+
+    |  Command  | Aliases  |                  Subcommands                   |
+    +-----------+----------+------------------------------------------------+
+    | backtrace | bt|where |                                                |
+    | break     |          |                                                |
+    | catch     |          |                                                |
+    | condition |          |                                                |
+    | continue  |          |                                                |
+    | delete    |          |                                                |
+    | disable   |          | breakpoints|display                            |
+    | display   |          |                                                |
+    | down      |          |                                                |
+    | edit      |          |                                                |
+    | enable    |          | breakpoints|display                            |
+    | finish    |          |                                                |
+    | frame     |          |                                                |
+    | help      |          |                                                |
+    | info      |          | args|breakpoints|catch|display|file|files      |
+    |           |          | global_variables|instance_variables|line       |
+    |           |          | locals|program|stack|variables                 |
+    | irb       |          |                                                |
+    | kill      |          |                                                |
+    | list      |          |                                                |
+    | method    |          | instance|iv                                    |
+    | next      |          |                                                |
+    | p         | eval     |                                                |
+    | pp        |          |                                                |
+    | pry       |          |                                                |
+    | ps        |          |                                                |
+    | putl      |          |                                                |
+    | quit      | exit     |                                                |
+    | reload    |          |                                                |
+    | restart   |          |                                                |
+    | save      |          |                                                |
+    | set       |          | args|autoeval|autoirb|autolist|autoreload      |
+    |           |          | basename|callstyle|forcestep|fullpath|history  |
+    |           |          | linetrace|linetrace_plus|listsize|post_mortem  |
+    |           |          | stack_trace_on_error|testing|width             |
+    | show      |          | args|autoeval|autoirb|autolist|autoreload      |
+    |           |          | basename|callstyle|commands|forcestep|fullpath |
+    |           |          | history|linetrace|linetrace_plus|listsize      |
+    |           |          | post_mortem|stack_trace_on_error|width         |
+    | skip      |          |                                                |
+    | source    |          |                                                |
+    | step      |          |                                                |
+    | thread    |          | current|list|resume|stop|switch                |
+    | trace     |          |                                                |
+    | undisplay |          |                                                |
+    | up        |          |                                                |
+    | var       |          | class|constant|global|instance|local|ct        |
+    +-----------+----------+------------------------------------------------+
+
+
 ## Getting Started
 
 A handful of commands are enough to get started using `byebug`. The following
@@ -241,6 +301,8 @@ quit without being prompted, suffix the command with an exclamation mark, e.g.,
   `step`, `finish`, `continue` and `break` commands to pry using byebug.
 * [ruby-debug-passenger](https://github.com/davejamesmiller/ruby-debug-passenger)
 adds a rake task that restarts Passenger with byebug connected.
+* [minitest-byebug](https://github.com/kaspth/minitest-byebug) starts a byebug
+session on minitest failures.
 
 
 ## Credits
@@ -255,6 +317,7 @@ software, specially:
 * Dennis Ushakov, author of [debase](https://github.com/denofevil/debase), the
 starting point of this.
 * Logo by [Ivlichev Victor Petrovich](http://www.aha-soft.com/)
+* @kevjames3 for testing, bug reports and the interest in the project.
 
 [1]: https://badge.fury.io/rb/byebug.png
 [2]: http://badge.fury.io/rb/byebug

data/bin/byebug

@@ -12,12 +12,6 @@
 #
 #=== Options
 #
-#<tt>-A | --annotate</tt> <i>level</i>::
-#    Set gdb-style annotation to <i>level</i>, a number.  Additional information
-#    is output automatically when program state is changed. This can be used by
-#    front-ends such as GNU Emacs to post this updated information without
-#    having to poll for it.
-#
 #<tt>-d | --debug</tt>::
 #    Set $DEBUG true.
 #
@@ -74,11 +68,8 @@ def debug_program(options)
     puts output
     exit $?.exitstatus
   end
-  print "\032\032starting\n" if Byebug.annotate and Byebug.annotate > 2
-
   if bt = Byebug.debug_load(Byebug::PROG_SCRIPT, options.stop)
-    print bt.backtrace.map{|l| "\t#{l}"}.join("\n"), "\n"
-    print "Uncaught exception: #{bt}\n"
+    p bt, bt.backtrace
   end
 end
 
@@ -98,7 +89,6 @@ def whence_file(prog_script)
 end
 
 options = OpenStruct.new(
-  'annotate'           => Byebug.annotate,
   'nx'                 => false,
   'post_mortem'        => false,
   'quit'               => true,
@@ -119,8 +109,6 @@ EOB
     opts.separator ""
     opts.separator "Options:"
 
-    opts.on("-A", "--annotate LEVEL", Integer, "Set annotation level") {
-      |annotate| Byebug.annotate = annotate }
     opts.on("-d", "--debug", "Set $DEBUG=true") {
       $DEBUG = true }
     opts.on('-I', '--include PATH', String,
@@ -246,14 +234,9 @@ Byebug.tracing = options.tracing
 loop do
   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"
+  rescue Exception
+    p $!, $@
   end
-  print "The program finished.\n" unless Byebug.annotate.to_i > 1
 
   break if options.quit
 

data/ext/byebug/breakpoint.c

@@ -21,37 +21,78 @@ eval_expression(VALUE args)
   return rb_funcall2(rb_mKernel, idEval, 2, RARRAY_PTR(args));
 }
 
+/*
+ *  call-seq:
+ *    breakpoint.enabled? -> bool
+ *
+ *  Returns +true+ if breakpoint is enabled, false otherwise.
+ */
 static VALUE
-Breakpoint_hit_count(VALUE self)
+brkpt_enabled(VALUE self)
 {
   breakpoint_t *breakpoint;
 
   Data_Get_Struct(self, breakpoint_t, breakpoint);
-  return INT2FIX(breakpoint->hit_count);
+  return breakpoint->enabled;
 }
 
-
+/*
+ *  call-seq:
+ *    breakpoint.enabled = bool
+ *
+ *  Enables or disables breakpoint.
+ */
 static VALUE
-Breakpoint_hit_value(VALUE self)
+brkpt_set_enabled(VALUE self, VALUE bool)
 {
     breakpoint_t *breakpoint;
 
     Data_Get_Struct(self, breakpoint_t, breakpoint);
-    return INT2FIX(breakpoint->hit_value);
+    return breakpoint->enabled = bool;
 }
 
+/*
+ *  call-seq:
+ *    breakpoint.expr -> string
+ *
+ *  Returns a conditional expression which indicates when this breakpoint should
+ *  be activated.
+ */
 static VALUE
-Breakpoint_set_hit_value(VALUE self, VALUE value)
+brkpt_expr(VALUE self)
 {
-    breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint;
 
-    Data_Get_Struct(self, breakpoint_t, breakpoint);
-    breakpoint->hit_value = FIX2INT(value);
-    return value;
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  return breakpoint->expr;
+}
+
+/*
+ *  call-seq:
+ *    breakpoint.expr = string | nil
+ *
+ *  Sets or unsets the conditional expression which indicates when this
+ *  breakpoint should be activated.
+ */
+static VALUE
+brkpt_set_expr(VALUE self, VALUE expr)
+{
+  breakpoint_t *breakpoint;
+
+  Data_Get_Struct(self, breakpoint_t, breakpoint);
+  breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
+  return expr;
 }
 
+/*
+ *  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 or :modulo otherwise
+ */
 static VALUE
-Breakpoint_hit_condition(VALUE self)
+brkpt_hit_condition(VALUE self)
 {
   breakpoint_t *breakpoint;
 
@@ -70,8 +111,18 @@ Breakpoint_hit_condition(VALUE self)
   }
 }
 
+/*
+ *  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)
+brkpt_set_hit_condition(VALUE self, VALUE value)
 {
   breakpoint_t *breakpoint;
   ID id_value;
@@ -90,90 +141,78 @@ Breakpoint_set_hit_condition(VALUE self, VALUE value)
   return value;
 }
 
-static void
-Breakpoint_mark(breakpoint_t *breakpoint)
-{
-  rb_gc_mark(breakpoint->source);
-  rb_gc_mark(breakpoint->expr);
-}
-
-static VALUE
-Breakpoint_create(VALUE klass)
-{
-  breakpoint_t *breakpoint = ALLOC(breakpoint_t);
-
-  return Data_Wrap_Struct(klass, Breakpoint_mark, xfree, breakpoint);
-}
-
+/*
+ *  call-seq:
+ *    breakpoint.hit_count -> int
+ *
+ *  Returns the number of times this breakpoint has been hit.
+ */
 static VALUE
-Breakpoint_initialize(VALUE self, VALUE source, VALUE pos, VALUE expr)
+brkpt_hit_count(VALUE self)
 {
   breakpoint_t *breakpoint;
 
   Data_Get_Struct(self, breakpoint_t, breakpoint);
-
-  breakpoint->type = FIXNUM_P(pos) ? BP_POS_TYPE : BP_METHOD_TYPE;
-  if(breakpoint->type == BP_POS_TYPE)
-      breakpoint->pos.line = FIX2INT(pos);
-  else
-      breakpoint->pos.mid = SYM2ID(pos);
-
-  breakpoint->id = ++breakpoint_max;
-  breakpoint->source = StringValue(source);
-  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 Qnil;
+  return INT2FIX(breakpoint->hit_count);
 }
 
+/*
+ *  call-seq:
+ *    breakpoint.hit_value -> int
+ *
+ *  Returns the hit value of the breakpoint, namely, a value to build a
+ *  condition on the number of hits of the breakpoint.
+ */
 static VALUE
-Breakpoint_remove(VALUE self, VALUE breakpoints, VALUE id_value)
+brkpt_hit_value(VALUE self)
 {
-  int i;
-  int id;
-  VALUE breakpoint_object;
-  breakpoint_t *breakpoint;
-
-  if (breakpoints == Qnil) return Qnil;
-
-  id = FIX2INT(id_value);
+    breakpoint_t *breakpoint;
 
-  for(i = 0; i < RARRAY_LEN(breakpoints); i++)
-  {
-    breakpoint_object = rb_ary_entry(breakpoints, i);
-    Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
-    if(breakpoint->id == id)
-    {
-      rb_ary_delete_at(breakpoints, i);
-      return breakpoint_object;
-    }
-  }
-  return Qnil;
+    Data_Get_Struct(self, breakpoint_t, breakpoint);
+    return INT2FIX(breakpoint->hit_value);
 }
 
+/*
+ *  call-seq:
+ *    breakpoint.hit_value = int
+ *
+ *  Sets the hit value of the breakpoint. This allows the user to set conditions
+ *  on the number of hits to enable/disable the breakpoint.
+ */
 static VALUE
-Breakpoint_id(VALUE self)
+brkpt_set_hit_value(VALUE self, VALUE value)
 {
-  breakpoint_t *breakpoint;
+    breakpoint_t *breakpoint;
 
-  Data_Get_Struct(self, breakpoint_t, breakpoint);
-  return INT2FIX(breakpoint->id);
+    Data_Get_Struct(self, breakpoint_t, breakpoint);
+    breakpoint->hit_value = FIX2INT(value);
+    return value;
 }
 
+/*
+ *  call-seq:
+ *    breakpoint.id -> int
+ *
+ *  Returns the id of the breakpoint.
+ */
 static VALUE
-Breakpoint_source(VALUE self)
+brkpt_id(VALUE self)
 {
   breakpoint_t *breakpoint;
 
   Data_Get_Struct(self, breakpoint_t, breakpoint);
-  return breakpoint->source;
+  return INT2FIX(breakpoint->id);
 }
 
+/*
+ *  call-seq:
+ *    breakpoint.pos -> string or int
+ *
+ *   Returns the position of this breakpoint, either a method name or a line
+ *   number.
+ */
 static VALUE
-Breakpoint_pos(VALUE self)
+brkpt_pos(VALUE self)
 {
   breakpoint_t *breakpoint;
 
@@ -184,42 +223,83 @@ Breakpoint_pos(VALUE self)
     return INT2FIX(breakpoint->pos.line);
 }
 
-
+/*
+ *  call-seq:
+ *    breakpoint.source -> string
+ *
+ *  Returns the source file of the breakpoint.
+ */
 static VALUE
-Breakpoint_expr(VALUE self)
+brkpt_source(VALUE self)
 {
   breakpoint_t *breakpoint;
 
   Data_Get_Struct(self, breakpoint_t, breakpoint);
-  return breakpoint->expr;
+  return breakpoint->source;
+}
+
+static void
+mark_breakpoint(breakpoint_t *breakpoint)
+{
+  rb_gc_mark(breakpoint->source);
+  rb_gc_mark(breakpoint->expr);
 }
 
 static VALUE
-Breakpoint_set_expr(VALUE self, VALUE expr)
+brkpt_create(VALUE klass)
 {
-  breakpoint_t *breakpoint;
+  breakpoint_t *breakpoint = ALLOC(breakpoint_t);
 
-  Data_Get_Struct(self, breakpoint_t, breakpoint);
-  breakpoint->expr = NIL_P(expr) ? expr: StringValue(expr);
-  return expr;
+  return Data_Wrap_Struct(klass, mark_breakpoint, xfree, breakpoint);
 }
 
 static VALUE
-Breakpoint_enabled(VALUE self)
+brkpt_initialize(VALUE self, VALUE source, VALUE pos, VALUE expr)
 {
   breakpoint_t *breakpoint;
 
   Data_Get_Struct(self, breakpoint_t, breakpoint);
-  return breakpoint->enabled;
+
+  breakpoint->type = FIXNUM_P(pos) ? BP_POS_TYPE : BP_METHOD_TYPE;
+  if(breakpoint->type == BP_POS_TYPE)
+      breakpoint->pos.line = FIX2INT(pos);
+  else
+      breakpoint->pos.mid = SYM2ID(pos);
+
+  breakpoint->id = ++breakpoint_max;
+  breakpoint->source = StringValue(source);
+  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 Qnil;
 }
 
 static VALUE
-Breakpoint_set_enabled(VALUE self, VALUE bool)
+brkpt_remove(VALUE self, VALUE breakpoints, VALUE id_value)
 {
-    breakpoint_t *breakpoint;
+  int i;
+  int id;
+  VALUE breakpoint_object;
+  breakpoint_t *breakpoint;
 
-    Data_Get_Struct(self, breakpoint_t, breakpoint);
-    return breakpoint->enabled = bool;
+  if (breakpoints == Qnil) return Qnil;
+
+  id = FIX2INT(id_value);
+
+  for(i = 0; i < RARRAY_LEN(breakpoints); i++)
+  {
+    breakpoint_object = rb_ary_entry(breakpoints, i);
+    Data_Get_Struct(breakpoint_object, breakpoint_t, breakpoint);
+    if(breakpoint->id == id)
+    {
+      rb_ary_delete_at(breakpoints, i);
+      return breakpoint_object;
+    }
+  }
+  return Qnil;
 }
 
 int
@@ -422,26 +502,30 @@ find_breakpoint_by_method(VALUE breakpoints, VALUE klass, ID mid, VALUE binding,
   return Qnil;
 }
 
-extern void
+void
 Init_breakpoint(VALUE mByebug)
 {
   breakpoint_max = 0;
+
   cBreakpoint = rb_define_class_under(mByebug, "Breakpoint", rb_cObject);
-  rb_define_singleton_method(cBreakpoint, "remove", Breakpoint_remove, 2);
-  rb_define_method(cBreakpoint, "initialize", Breakpoint_initialize, 3);
-  rb_define_method(cBreakpoint, "id", Breakpoint_id, 0);
-  rb_define_method(cBreakpoint, "source", Breakpoint_source, 0);
-  rb_define_method(cBreakpoint, "pos", Breakpoint_pos, 0);
-  rb_define_method(cBreakpoint, "expr", Breakpoint_expr, 0);
-  rb_define_method(cBreakpoint, "expr=", Breakpoint_set_expr, 1);
-  rb_define_method(cBreakpoint, "hit_count", Breakpoint_hit_count, 0);
-  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, "enabled?", Breakpoint_enabled, 0);
-  rb_define_method(cBreakpoint, "enabled=", Breakpoint_set_enabled, 1);
-  rb_define_method(cBreakpoint, "hit_value", Breakpoint_hit_value, 0);
-  rb_define_method(cBreakpoint, "hit_value=", Breakpoint_set_hit_value, 1);
-  rb_define_alloc_func(cBreakpoint, Breakpoint_create);
+
+  rb_define_alloc_func(cBreakpoint, brkpt_create);
+  rb_define_method(cBreakpoint, "initialize", brkpt_initialize, 3);
+
+  rb_define_singleton_method(cBreakpoint, "remove", brkpt_remove, 2);
+
+  rb_define_method(cBreakpoint, "enabled?"      , brkpt_enabled          , 0);
+  rb_define_method(cBreakpoint, "enabled="      , brkpt_set_enabled      , 1);
+  rb_define_method(cBreakpoint, "expr"          , brkpt_expr             , 0);
+  rb_define_method(cBreakpoint, "expr="         , brkpt_set_expr         , 1);
+  rb_define_method(cBreakpoint, "hit_count"     , brkpt_hit_count        , 0);
+  rb_define_method(cBreakpoint, "hit_condition" , brkpt_hit_condition    , 0);
+  rb_define_method(cBreakpoint, "hit_condition=", brkpt_set_hit_condition, 1);
+  rb_define_method(cBreakpoint, "hit_value"     , brkpt_hit_value        , 0);
+  rb_define_method(cBreakpoint, "hit_value="    , brkpt_set_hit_value    , 1);
+  rb_define_method(cBreakpoint, "id"            , brkpt_id               , 0);
+  rb_define_method(cBreakpoint, "pos"           , brkpt_pos              , 0);
+  rb_define_method(cBreakpoint, "source"        , brkpt_source           , 0);
 
   idEval = rb_intern("eval");
 }