Module: Byebug

Defined in:

ext/byebug/byebug.c

Defined Under Namespace

Classes: Breakpoint

Class Method Summary

• ._start ⇒ Object
• .add_catchpoint(value) ⇒ Object
• .breakpoints ⇒ Object
• .catchpoints ⇒ Object
• .context ⇒ Object
• .debug_at_exit ⇒ Object
• .debug_load(*args) ⇒ Object
• .post_mortem=(value) ⇒ Object
• .post_mortem? ⇒ Boolean
• .remove_tracepoints ⇒ Object
• .setup_tracepoints ⇒ Object
• .started? ⇒ Boolean
• .tracing=(value) ⇒ Object
• .tracing? ⇒ Boolean

Class Method Details

._start ⇒ Object

# File 'ext/byebug/byebug.c', line 413

static VALUE
Byebug_start(VALUE self)
{
  VALUE result;

  if (BYEBUG_STARTED)
    result = Qfalse;
  else
  {
    Byebug_setup_tracepoints(self);
    result = Qtrue;
  }

  if (rb_block_given_p())
    rb_ensure(rb_yield, self, Byebug_stop, self);

  return result;
}

.add_catchpoint(value) ⇒ Object

# File 'ext/byebug/byebug.c', line 553

static VALUE
Byebug_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(catchpoints, rb_str_dup(value), INT2FIX(0));
  return value;
}

.breakpoints ⇒ Object

# File 'ext/byebug/byebug.c', line 539

static VALUE
Byebug_breakpoints(VALUE self)
{
  return breakpoints;
}

.catchpoints ⇒ Object

# File 'ext/byebug/byebug.c', line 545

static VALUE
Byebug_catchpoints(VALUE self)
{
  if (catchpoints == Qnil)
    rb_raise(rb_eRuntimeError, "Byebug.start is not called yet.");
  return catchpoints;
}

.context ⇒ Object

# File 'ext/byebug/byebug.c', line 53

static VALUE
Byebug_context(VALUE self)
{
  if (context == Qnil) {
    context = context_create();
  }
  return context;
}

.debug_at_exit ⇒ Object

# File 'ext/byebug/byebug.c', line 503

static VALUE
Byebug_at_exit(VALUE self)
{
  VALUE proc;
  if (!rb_block_given_p()) rb_raise(rb_eArgError, "called without a block");
  proc = rb_block_proc();
  rb_set_end_proc(debug_at_exit_i, proc);
  return proc;
}

.debug_load(*args) ⇒ Object

# File 'ext/byebug/byebug.c', line 447

static VALUE
Byebug_load(int argc, VALUE *argv, VALUE self)
{
  VALUE file, stop, context_obj;
  debug_context_t *dc;
  VALUE status = Qnil;
  int state = 0;

  if (rb_scan_args(argc, argv, "11", &file, &stop) == 1)
  {
    stop = Qfalse;
  }

  Byebug_start(self);

  context_obj = Byebug_context(self);
  Data_Get_Struct(context_obj, debug_context_t, dc);
  if (RTEST(stop)) dc->steps = 1;

  /* Resetting stack size */
  dc->stack_size = 0;

  /* Initializing $0 to the script's path */
  ruby_script(RSTRING_PTR(file));
  rb_load_protect(file, 0, &state);
  if (0 != state)
  {
    status = rb_errinfo();
    reset_stepping_stop_points(dc);
  }

  /* We should run all at_exit handler's in order to provide, for instance, a
   * chance to run all defined test cases */
  rb_exec_end_proc();

  return status;
}

.post_mortem=(value) ⇒ Object

# File 'ext/byebug/byebug.c', line 532

static VALUE
Byebug_set_post_mortem(VALUE self, VALUE value)
{
  post_mortem = RTEST(value) ? Qtrue : Qfalse;
  return value;
}

.post_mortem? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/byebug/byebug.c', line 526

static VALUE
Byebug_post_mortem(VALUE self)
{
  return post_mortem;
}

.remove_tracepoints ⇒ Object

# File 'ext/byebug/byebug.c', line 378

static VALUE
Byebug_remove_tracepoints(VALUE self)
{
  rb_tracepoint_disable(tpRaise);
  rb_tracepoint_disable(tpCReturn);
  rb_tracepoint_disable(tpReturn);
  rb_tracepoint_disable(tpCCall);
  rb_tracepoint_disable(tpCall);
  rb_tracepoint_disable(tpLine);

  context = Qnil;
  breakpoints = Qnil;
  catchpoints = Qnil;

  return Qnil;
}

.setup_tracepoints ⇒ Object

# File 'ext/byebug/byebug.c', line 336

static VALUE
Byebug_setup_tracepoints(VALUE self)
{
  if (catchpoints != Qnil) return Qnil;

  breakpoints = rb_ary_new();
  catchpoints = rb_hash_new();

  tpLine = rb_tracepoint_new(Qnil,
    RUBY_EVENT_LINE,
    process_line_event, NULL);

  tpCall = rb_tracepoint_new(Qnil,
    RUBY_EVENT_CALL | RUBY_EVENT_B_CALL | RUBY_EVENT_CLASS,
    process_call_event, NULL);

  tpCCall = rb_tracepoint_new(Qnil,
    RUBY_EVENT_C_CALL,
    process_c_call_event, NULL);

  tpReturn = rb_tracepoint_new(Qnil,
    RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN | RUBY_EVENT_END,
    process_return_event, NULL);

  tpCReturn = rb_tracepoint_new(Qnil,
    RUBY_EVENT_C_RETURN,
    process_c_return_event, NULL);

  tpRaise = rb_tracepoint_new(Qnil,
    RUBY_EVENT_RAISE,
    process_raise_event, NULL);

  rb_tracepoint_enable(tpLine);
  rb_tracepoint_enable(tpCall);
  rb_tracepoint_enable(tpCCall);
  rb_tracepoint_enable(tpReturn);
  rb_tracepoint_enable(tpCReturn);
  rb_tracepoint_enable(tpRaise);

  return Qnil;
}

.started? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/byebug/byebug.c', line 396

static VALUE
Byebug_started(VALUE self)
{
  return BYEBUG_STARTED;
}

.tracing=(value) ⇒ Object

# File 'ext/byebug/byebug.c', line 519

static VALUE
Byebug_set_tracing(VALUE self, VALUE value)
{
  tracing = RTEST(value) ? Qtrue : Qfalse;
  return value;
}

.tracing? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/byebug/byebug.c', line 513

static VALUE
Byebug_tracing(VALUE self)
{
  return tracing;
}