Bug #15885 » 0001-Single-raise-tracepoint-event-when-exception-inside-.patch
eval_intern.h | ||
---|---|---|
NORETURN(void rb_print_undef_str(VALUE, VALUE));
|
||
NORETURN(void rb_print_inaccessible(VALUE, ID, rb_method_visibility_t));
|
||
NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
|
||
#if 0
|
||
NORETURN(void rb_vm_jump_tag_but_local_jump(int));
|
||
#endif
|
||
VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);
|
||
rb_cref_t *rb_vm_cref(void);
|
load.c | ||
---|---|---|
NORETURN(static void load_failed(VALUE));
|
||
static int
|
||
static inline void
|
||
rb_load_internal0(rb_execution_context_t *ec, VALUE fname, int wrap)
|
||
{
|
||
enum ruby_tag_type state;
|
||
... | ... | |
th->top_wrapper = wrapper;
|
||
if (state) {
|
||
/* usually state == TAG_RAISE only, except for
|
||
* rb_iseq_load_iseq case */
|
||
VALUE exc = rb_vm_make_jump_tag_but_local_jump(state, Qundef);
|
||
if (NIL_P(exc)) return state;
|
||
th->ec->errinfo = exc;
|
||
return TAG_RAISE;
|
||
rb_vm_jump_tag_but_local_jump(state);
|
||
}
|
||
if (!NIL_P(th->ec->errinfo)) {
|
||
/* exception during load */
|
||
return TAG_RAISE;
|
||
rb_exc_raise(th->ec->errinfo);
|
||
}
|
||
return state;
|
||
}
|
||
static void
|
||
rb_load_internal(VALUE fname, int wrap)
|
||
{
|
||
rb_execution_context_t *ec = GET_EC();
|
||
int state = rb_load_internal0(ec, fname, wrap);
|
||
if (state) {
|
||
if (state == TAG_RAISE) rb_exc_raise(ec->errinfo);
|
||
EC_JUMP_TAG(ec, state);
|
||
}
|
||
}
|
||
static VALUE
|
||
file_to_load(VALUE fname)
|
||
{
|
||
VALUE tmp = rb_find_file(FilePathValue(fname));
|
||
if (!tmp) load_failed(fname);
|
||
return tmp;
|
||
rb_load_internal0(ec, fname, wrap);
|
||
}
|
||
void
|
||
rb_load(VALUE fname, int wrap)
|
||
{
|
||
rb_load_internal(file_to_load(fname), wrap);
|
||
VALUE tmp = rb_find_file(FilePathValue(fname));
|
||
if (!tmp) load_failed(fname);
|
||
rb_load_internal(tmp, wrap);
|
||
}
|
||
void
|
||
rb_load_protect(VALUE fname, int wrap, int *pstate)
|
||
{
|
||
enum ruby_tag_type state;
|
||
volatile VALUE path = 0;
|
||
EC_PUSH_TAG(GET_EC());
|
||
if ((state = EC_EXEC_TAG()) == TAG_NONE) {
|
||
path = file_to_load(fname);
|
||
rb_load(fname, wrap);
|
||
}
|
||
EC_POP_TAG();
|
||
if (state == TAG_NONE) state = rb_load_internal0(GET_EC(), path, wrap);
|
||
if (state != TAG_NONE) *pstate = state;
|
||
}
|
||
... | ... | |
else {
|
||
switch (found) {
|
||
case 'r':
|
||
state = rb_load_internal0(ec, path, 0);
|
||
rb_load_internal(path, 0);
|
||
break;
|
||
case 's':
|
||
... | ... | |
rb_ary_push(ruby_dln_librefs, LONG2NUM(handle));
|
||
break;
|
||
}
|
||
if (!state) {
|
||
rb_provide_feature(path);
|
||
result = TAG_RETURN;
|
||
}
|
||
rb_provide_feature(path);
|
||
result = TAG_RETURN;
|
||
}
|
||
}
|
||
}
|
test/ruby/test_settracefunc.rb | ||
---|---|---|
ary
|
||
end
|
||
def test_single_raise_inside_load
|
||
events = []
|
||
tmpdir = Dir.mktmpdir
|
||
path = "#{tmpdir}/hola.rb"
|
||
File.open(path, "w") { |f| f.write("raise") }
|
||
TracePoint.new(:raise){|tp| next if !target_thread?; events << [tp.event]}.enable{
|
||
load path rescue nil
|
||
}
|
||
assert_equal [[:raise]], events
|
||
ensure
|
||
FileUtils.rmtree(tmpdir)
|
||
end
|
||
def f_raise
|
||
raise
|
||
rescue
|
vm.c | ||
---|---|---|
return make_localjump_error(mesg, val, state);
|
||
}
|
||
#if 0
|
||
void
|
||
rb_vm_jump_tag_but_local_jump(int state)
|
||
{
|
||
... | ... | |
if (!NIL_P(exc)) rb_exc_raise(exc);
|
||
EC_JUMP_TAG(GET_EC(), state);
|
||
}
|
||
#endif
|
||
static rb_control_frame_t *
|
||
next_not_local_frame(rb_control_frame_t *cfp)
|