static void
call_event(VALUE trace_point, void *data)
{
VALUE breakpoint, klass, msym, mid, binding, self, file, line;
EVENT_SETUP
dc->calced_stack_size++;
if (CTX_FL_TEST(dc, CTX_FL_STOP_ON_RET))
dc->steps_out = dc->steps_out <= 0 ? -1 : dc->steps_out + 1;
EVENT_COMMON
breakpoint = Qnil;
klass = rb_tracearg_defined_class(trace_arg);
msym = rb_tracearg_method_id(trace_arg);
mid = NIL_P(msym) ? Qnil : SYM2ID(msym);
binding = rb_tracearg_binding(trace_arg);
self = rb_tracearg_self(trace_arg);
file = rb_tracearg_path(trace_arg);
line = rb_tracearg_lineno(trace_arg);
breakpoint = find_breakpoint_by_method(breakpoints, klass, mid, binding, self);
if (breakpoint != Qnil)
{
call_at_breakpoint(context, dc, breakpoint);
call_at_line(context, dc, file, line);
}
cleanup(dc);
}
static void
eval_trace_callback(void *data, rb_trace_arg_t *trace_arg)
{
rb_event_flag_t event;
VALUE evaluator;
VALUE klass;
VALUE obj;
VALUE method_id;
ID trace_func_cb_id;
ID trace_c_func_cb_id;
CONST_ID(trace_func_cb_id, "trace_func_callback");
CONST_ID(trace_c_func_cb_id, "trace_c_func_callback");
event = rb_tracearg_event_flag(trace_arg);
evaluator = (VALUE)data;
obj = rb_tracearg_self(trace_arg);
method_id = rb_tracearg_method_id(trace_arg);
klass = rb_tracearg_defined_class(trace_arg);
if (event & RUBY_EVENT_CALL) {
rb_funcall(evaluator, trace_func_cb_id, 3, obj, klass, method_id);
}
if (event & RUBY_EVENT_C_CALL) {
rb_funcall(evaluator, trace_c_func_cb_id, 3, obj, klass, method_id);
}
return;
}
static void
call_event(VALUE trace_point, void *data)
{
VALUE breakpoint, klass, mid, binding, self, file, line;
EVENT_SETUP
dc->calced_stack_size++;
EVENT_COMMON
breakpoint = Qnil;
klass = rb_tracearg_defined_class(trace_arg);
mid = SYM2ID(rb_tracearg_method_id(trace_arg));
binding = rb_tracearg_binding(trace_arg);
self = rb_tracearg_self(trace_arg);
file = rb_tracearg_path(trace_arg);
line = rb_tracearg_lineno(trace_arg);
breakpoint = find_breakpoint_by_method(breakpoints, klass, mid, binding, self);
if (breakpoint != Qnil)
{
call_at_breakpoint(context, dc, breakpoint);
call_at_line(context, dc, file, line);
}
cleanup(dc);
}
static void
line_event(VALUE trace_point, void *data)
{
VALUE breakpoint, file, line, binding, self;
int moved = 0;
EVENT_SETUP
breakpoint = Qnil;
file = rb_tracearg_path(trace_arg);
line = rb_tracearg_lineno(trace_arg);
binding = rb_tracearg_binding(trace_arg);
self = rb_tracearg_self(trace_arg);
EVENT_COMMON
if (dc->calced_stack_size == 0) dc->calced_stack_size++;
if (dc->last_line != rb_tracearg_lineno(trace_arg) ||
dc->last_file != rb_tracearg_path(trace_arg))
{
moved = 1;
}
if (RTEST(tracing))
call_at_tracing(context, dc, file, line);
if (moved || !CTX_FL_TEST(dc, CTX_FL_FORCE_MOVE))
{
dc->steps = dc->steps <= 0 ? -1 : dc->steps - 1;
if (dc->calced_stack_size <= dc->dest_frame)
{
dc->lines = dc->lines <= 0 ? -1 : dc->lines - 1;
if (dc->calced_stack_size < dc->dest_frame)
{
dc->dest_frame = dc->calced_stack_size;
rb_funcall(mByebug, rb_intern("puts"), 1,
rb_str_new2("Next went up a frame because previous frame finished\n"));
}
}
}
if (dc->steps == 0 || dc->lines == 0 ||
(CTX_FL_TEST(dc, CTX_FL_ENABLE_BKPT) &&
(!NIL_P(
breakpoint = find_breakpoint_by_pos(bb_breakpoints(self), file, line, binding)))))
{
call_at_line_check(context, dc, breakpoint, file, line);
}
cleanup(dc);
}
static VALUE
tracepoint_inspect(VALUE self)
{
rb_tp_t *tp = tpptr(self);
rb_trace_arg_t *trace_arg = GET_THREAD()->trace_arg;
if (trace_arg) {
switch (trace_arg->event) {
case RUBY_EVENT_LINE:
case RUBY_EVENT_SPECIFIED_LINE:
{
VALUE sym = rb_tracearg_method_id(trace_arg);
if (NIL_P(sym))
goto default_inspect;
return rb_sprintf("#<TracePoint:%"PRIsVALUE"@%"PRIsVALUE":%d in `%"PRIsVALUE"'>",
rb_tracearg_event(trace_arg),
rb_tracearg_path(trace_arg),
FIX2INT(rb_tracearg_lineno(trace_arg)),
sym);
}
case RUBY_EVENT_CALL:
case RUBY_EVENT_C_CALL:
case RUBY_EVENT_RETURN:
case RUBY_EVENT_C_RETURN:
return rb_sprintf("#<TracePoint:%"PRIsVALUE" `%"PRIsVALUE"'@%"PRIsVALUE":%d>",
rb_tracearg_event(trace_arg),
rb_tracearg_method_id(trace_arg),
rb_tracearg_path(trace_arg),
FIX2INT(rb_tracearg_lineno(trace_arg)));
case RUBY_EVENT_THREAD_BEGIN:
case RUBY_EVENT_THREAD_END:
return rb_sprintf("#<TracePoint:%"PRIsVALUE" %"PRIsVALUE">",
rb_tracearg_event(trace_arg),
rb_tracearg_self(trace_arg));
default:
default_inspect:
return rb_sprintf("#<TracePoint:%"PRIsVALUE"@%"PRIsVALUE":%d>",
rb_tracearg_event(trace_arg),
rb_tracearg_path(trace_arg),
FIX2INT(rb_tracearg_lineno(trace_arg)));
}
}
else {
return rb_sprintf("#<TracePoint:%s>", tp->tracing ? "enabled" : "disabled");
}
}
static void
call_event(VALUE trace_point, void *data)
{
VALUE brkpnt, klass, msym, mid, binding, self, file, line;
EVENT_SETUP;
if (dc->calced_stack_size <= dc->dest_frame)
CTX_FL_UNSET(dc, CTX_FL_IGNORE_STEPS);
dc->calced_stack_size++;
dc->steps_out = dc->steps_out <= 0 ? -1 : dc->steps_out + 1;
/* nil method_id means we are at top level so there can't be a method
* breakpoint here. Just leave then. */
msym = rb_tracearg_method_id(trace_arg);
if (NIL_P(msym))
{
EVENT_TEARDOWN;
return;
}
mid = SYM2ID(msym);
klass = rb_tracearg_defined_class(trace_arg);
binding = rb_tracearg_binding(trace_arg);
self = rb_tracearg_self(trace_arg);
file = rb_tracearg_path(trace_arg);
line = rb_tracearg_lineno(trace_arg);
brkpnt = Qnil;
if (!NIL_P(breakpoints))
brkpnt = find_breakpoint_by_method(breakpoints, klass, mid, binding, self);
if (!NIL_P(brkpnt))
{
call_at_breakpoint(context, dc, brkpnt);
call_at_line(context, dc, file, line);
}
EVENT_TEARDOWN;
}
/*
* Return the trace object during event
*
* Same as TracePoint#binding:
* trace.binding.eval('self')
*/
static VALUE
tracepoint_attr_self(VALUE tpval)
{
return rb_tracearg_self(get_trace_arg());
}
