зеркало из https://github.com/github/ruby.git
326 строки
7.2 KiB
C
326 строки
7.2 KiB
C
/* -*-c-*- */
|
|
/*
|
|
* included by eval.c
|
|
*/
|
|
|
|
#if defined(__GNUC__) && !defined(__PCC__)
|
|
#define warn_print(x) __extension__ ( \
|
|
{ \
|
|
(__builtin_constant_p(x)) ? \
|
|
rb_write_error2((x), (long)strlen(x)) : \
|
|
rb_write_error(x); \
|
|
})
|
|
#else
|
|
#define warn_print(x) rb_write_error(x)
|
|
#endif
|
|
#define warn_print2(x,l) rb_write_error2((x),(l))
|
|
#define warn_print_str(x) rb_write_error_str(x)
|
|
|
|
static VALUE error_pos_str(void);
|
|
|
|
static void
|
|
error_pos(void)
|
|
{
|
|
VALUE str = error_pos_str();
|
|
if (!NIL_P(str)) {
|
|
warn_print_str(str);
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
error_pos_str(void)
|
|
{
|
|
int sourceline;
|
|
VALUE sourcefile = rb_source_location(&sourceline);
|
|
|
|
if (sourcefile) {
|
|
ID caller_name;
|
|
if (sourceline == 0) {
|
|
return rb_sprintf("%"PRIsVALUE": ", sourcefile);
|
|
}
|
|
else if ((caller_name = rb_frame_callee()) != 0) {
|
|
return rb_sprintf("%"PRIsVALUE":%d:in `%"PRIsVALUE"': ",
|
|
sourcefile, sourceline,
|
|
rb_id2str(caller_name));
|
|
}
|
|
else {
|
|
return rb_sprintf("%"PRIsVALUE":%d: ", sourcefile, sourceline);
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
static VALUE
|
|
get_backtrace(VALUE info)
|
|
{
|
|
if (NIL_P(info))
|
|
return Qnil;
|
|
info = rb_funcall(info, rb_intern("backtrace"), 0);
|
|
if (NIL_P(info))
|
|
return Qnil;
|
|
return rb_check_backtrace(info);
|
|
}
|
|
|
|
VALUE
|
|
rb_get_backtrace(VALUE info)
|
|
{
|
|
return get_backtrace(info);
|
|
}
|
|
|
|
VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt);
|
|
|
|
static void
|
|
set_backtrace(VALUE info, VALUE bt)
|
|
{
|
|
ID set_backtrace = rb_intern("set_backtrace");
|
|
|
|
if (rb_backtrace_p(bt)) {
|
|
if (rb_method_basic_definition_p(CLASS_OF(info), set_backtrace)) {
|
|
rb_exc_set_backtrace(info, bt);
|
|
return;
|
|
}
|
|
else {
|
|
bt = rb_backtrace_to_str_ary(bt);
|
|
}
|
|
}
|
|
rb_funcall(info, rb_intern("set_backtrace"), 1, bt);
|
|
}
|
|
|
|
static void
|
|
error_print(rb_thread_t *th)
|
|
{
|
|
volatile VALUE errat = Qundef;
|
|
VALUE errinfo = th->errinfo;
|
|
int raised_flag = th->raised_flag;
|
|
volatile VALUE eclass = Qundef, e = Qundef;
|
|
const char *volatile einfo;
|
|
volatile long elen;
|
|
VALUE mesg;
|
|
|
|
if (NIL_P(errinfo))
|
|
return;
|
|
rb_thread_raised_clear(th);
|
|
|
|
TH_PUSH_TAG(th);
|
|
if (TH_EXEC_TAG() == 0) {
|
|
errat = get_backtrace(errinfo);
|
|
}
|
|
else if (errat == Qundef) {
|
|
errat = Qnil;
|
|
}
|
|
else if (eclass == Qundef || e != Qundef) {
|
|
goto error;
|
|
}
|
|
else {
|
|
goto no_message;
|
|
}
|
|
if (NIL_P(errat) || RARRAY_LEN(errat) == 0 ||
|
|
NIL_P(mesg = RARRAY_AREF(errat, 0))) {
|
|
error_pos();
|
|
}
|
|
else {
|
|
warn_print_str(mesg);
|
|
warn_print(": ");
|
|
}
|
|
|
|
eclass = CLASS_OF(errinfo);
|
|
if (eclass != Qundef &&
|
|
(e = rb_check_funcall(errinfo, rb_intern("message"), 0, 0)) != Qundef &&
|
|
(RB_TYPE_P(e, T_STRING) || !NIL_P(e = rb_check_string_type(e)))) {
|
|
einfo = RSTRING_PTR(e);
|
|
elen = RSTRING_LEN(e);
|
|
}
|
|
else {
|
|
no_message:
|
|
einfo = "";
|
|
elen = 0;
|
|
}
|
|
if (eclass == rb_eRuntimeError && elen == 0) {
|
|
warn_print("unhandled exception\n");
|
|
}
|
|
else {
|
|
VALUE epath;
|
|
|
|
epath = rb_class_name(eclass);
|
|
if (elen == 0) {
|
|
warn_print_str(epath);
|
|
warn_print("\n");
|
|
}
|
|
else {
|
|
const char *tail = 0;
|
|
long len = elen;
|
|
|
|
if (RSTRING_PTR(epath)[0] == '#')
|
|
epath = 0;
|
|
if ((tail = memchr(einfo, '\n', elen)) != 0) {
|
|
len = tail - einfo;
|
|
tail++; /* skip newline */
|
|
}
|
|
warn_print_str(tail ? rb_str_subseq(e, 0, len) : e);
|
|
if (epath) {
|
|
warn_print(" (");
|
|
warn_print_str(epath);
|
|
warn_print(")\n");
|
|
}
|
|
if (tail) {
|
|
warn_print_str(rb_str_subseq(e, tail - einfo, elen - len - 1));
|
|
}
|
|
if (tail ? einfo[elen-1] != '\n' : !epath) warn_print2("\n", 1);
|
|
}
|
|
}
|
|
|
|
if (!NIL_P(errat)) {
|
|
long i;
|
|
long len = RARRAY_LEN(errat);
|
|
int skip = eclass == rb_eSysStackError;
|
|
|
|
#define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5)
|
|
#define TRACE_HEAD 8
|
|
#define TRACE_TAIL 5
|
|
|
|
for (i = 1; i < len; i++) {
|
|
VALUE line = RARRAY_AREF(errat, i);
|
|
if (RB_TYPE_P(line, T_STRING)) {
|
|
warn_print_str(rb_sprintf("\tfrom %"PRIsVALUE"\n", line));
|
|
}
|
|
if (skip && i == TRACE_HEAD && len > TRACE_MAX) {
|
|
warn_print_str(rb_sprintf("\t ... %ld levels...\n",
|
|
len - TRACE_HEAD - TRACE_TAIL));
|
|
i = len - TRACE_TAIL;
|
|
}
|
|
}
|
|
}
|
|
error:
|
|
TH_POP_TAG();
|
|
th->errinfo = errinfo;
|
|
rb_thread_raised_set(th, raised_flag);
|
|
}
|
|
|
|
void
|
|
ruby_error_print(void)
|
|
{
|
|
error_print(GET_THREAD());
|
|
}
|
|
|
|
#define undef_mesg_for(v, k) rb_fstring_cstr("undefined"v" method `%1$s' for "k" `%2$s'")
|
|
#define undef_mesg(v) ( \
|
|
is_mod ? \
|
|
undef_mesg_for(v, "module") : \
|
|
undef_mesg_for(v, "class"))
|
|
|
|
void
|
|
rb_print_undef(VALUE klass, ID id, rb_method_visibility_t visi)
|
|
{
|
|
const int is_mod = RB_TYPE_P(klass, T_MODULE);
|
|
VALUE mesg;
|
|
switch (visi & METHOD_VISI_MASK) {
|
|
case METHOD_VISI_UNDEF:
|
|
case METHOD_VISI_PUBLIC: mesg = undef_mesg(""); break;
|
|
case METHOD_VISI_PRIVATE: mesg = undef_mesg(" private"); break;
|
|
case METHOD_VISI_PROTECTED: mesg = undef_mesg(" protected"); break;
|
|
default: UNREACHABLE;
|
|
}
|
|
rb_name_err_raise_str(mesg, klass, ID2SYM(id));
|
|
}
|
|
|
|
void
|
|
rb_print_undef_str(VALUE klass, VALUE name)
|
|
{
|
|
const int is_mod = RB_TYPE_P(klass, T_MODULE);
|
|
rb_name_err_raise_str(undef_mesg(""), klass, name);
|
|
}
|
|
|
|
#define inaccessible_mesg_for(v, k) rb_fstring_cstr("method `%1$s' for "k" `%2$s' is "v)
|
|
#define inaccessible_mesg(v) ( \
|
|
is_mod ? \
|
|
inaccessible_mesg_for(v, "module") : \
|
|
inaccessible_mesg_for(v, "class"))
|
|
|
|
void
|
|
rb_print_inaccessible(VALUE klass, ID id, rb_method_visibility_t visi)
|
|
{
|
|
const int is_mod = RB_TYPE_P(klass, T_MODULE);
|
|
VALUE mesg;
|
|
switch (visi & METHOD_VISI_MASK) {
|
|
case METHOD_VISI_UNDEF:
|
|
case METHOD_VISI_PUBLIC: mesg = inaccessible_mesg(""); break;
|
|
case METHOD_VISI_PRIVATE: mesg = inaccessible_mesg(" private"); break;
|
|
case METHOD_VISI_PROTECTED: mesg = inaccessible_mesg(" protected"); break;
|
|
default: UNREACHABLE;
|
|
}
|
|
rb_name_err_raise_str(mesg, klass, ID2SYM(id));
|
|
}
|
|
|
|
static int
|
|
sysexit_status(VALUE err)
|
|
{
|
|
VALUE st = rb_ivar_get(err, id_status);
|
|
return NUM2INT(st);
|
|
}
|
|
|
|
#define unknown_longjmp_status(status) \
|
|
rb_bug("Unknown longjmp status %d", status)
|
|
|
|
static int
|
|
error_handle(int ex)
|
|
{
|
|
int status = EXIT_FAILURE;
|
|
rb_thread_t *th = GET_THREAD();
|
|
|
|
if (rb_threadptr_set_raised(th))
|
|
return EXIT_FAILURE;
|
|
switch (ex & TAG_MASK) {
|
|
case 0:
|
|
status = EXIT_SUCCESS;
|
|
break;
|
|
|
|
case TAG_RETURN:
|
|
error_pos();
|
|
warn_print("unexpected return\n");
|
|
break;
|
|
case TAG_NEXT:
|
|
error_pos();
|
|
warn_print("unexpected next\n");
|
|
break;
|
|
case TAG_BREAK:
|
|
error_pos();
|
|
warn_print("unexpected break\n");
|
|
break;
|
|
case TAG_REDO:
|
|
error_pos();
|
|
warn_print("unexpected redo\n");
|
|
break;
|
|
case TAG_RETRY:
|
|
error_pos();
|
|
warn_print("retry outside of rescue clause\n");
|
|
break;
|
|
case TAG_THROW:
|
|
/* TODO: fix me */
|
|
error_pos();
|
|
warn_print("unexpected throw\n");
|
|
break;
|
|
case TAG_RAISE: {
|
|
VALUE errinfo = th->errinfo;
|
|
if (rb_obj_is_kind_of(errinfo, rb_eSystemExit)) {
|
|
status = sysexit_status(errinfo);
|
|
}
|
|
else if (rb_obj_is_instance_of(errinfo, rb_eSignal) &&
|
|
rb_ivar_get(errinfo, id_signo) != INT2FIX(SIGSEGV)) {
|
|
/* no message when exiting by signal */
|
|
}
|
|
else {
|
|
error_print(th);
|
|
}
|
|
break;
|
|
}
|
|
case TAG_FATAL:
|
|
error_print(th);
|
|
break;
|
|
default:
|
|
unknown_longjmp_status(ex);
|
|
break;
|
|
}
|
|
rb_threadptr_reset_raised(th);
|
|
return status;
|
|
}
|