eval_error.c

   1 /* -*-c-*- */
   2 /*
   3  * included by eval.c
   4  */
   5
   6 #define write_warn(str, x) \
   7     (NIL_P(str) ? warn_print(x) : (void)rb_str_cat_cstr(str, x))
   8 #define write_warn2(str, x, l) \
   9     (NIL_P(str) ? warn_print2(x, l) : (void)rb_str_cat(str, x, l))
  10 #ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
  11 #define warn_print(x) RB_GNUC_EXTENSION_BLOCK(  \
  12     (__builtin_constant_p(x)) ?                 \
  13         rb_write_error2((x), (long)strlen(x)) : \
  14         rb_write_error(x)                       \
  15 )
  16 #else
  17 #define warn_print(x) rb_write_error(x)
  18 #endif
  19
  20 #define warn_print2(x,l) rb_write_error2((x),(l))
  21
  22 #define write_warn_str(str,x) NIL_P(str) ? rb_write_error_str(x) : (void)rb_str_concat((str), (x))
  23 #define warn_print_str(x) rb_write_error_str(x)
  24
  25 static VALUE error_pos_str(void);
  26
  27 static void
  28 error_pos(const VALUE str)
  29 {
  30     VALUE pos = error_pos_str();
  31     if (!NIL_P(pos)) {
  32         write_warn_str(str, pos);
  33     }
  34 }
  35
  36 static VALUE
  37 error_pos_str(void)
  38 {
  39     int sourceline;
  40     VALUE sourcefile = rb_source_location(&sourceline);
  41
  42     if (!NIL_P(sourcefile)) {
  43         ID caller_name;
  44         if (sourceline == 0) {
  45             return rb_sprintf("%"PRIsVALUE": ", sourcefile);
  46         }
  47         else if ((caller_name = rb_frame_callee()) != 0) {
  48             return rb_sprintf("%"PRIsVALUE":%d:in `%"PRIsVALUE"': ",
  49                               sourcefile, sourceline,
  50                               rb_id2str(caller_name));
  51         }
  52         else {
  53             return rb_sprintf("%"PRIsVALUE":%d: ", sourcefile, sourceline);
  54         }
  55     }
  56     return Qnil;
  57 }
  58
  59 static void
  60 set_backtrace(VALUE info, VALUE bt)
  61 {
  62     ID set_backtrace = rb_intern("set_backtrace");
  63
  64     if (rb_backtrace_p(bt)) {
  65         if (rb_method_basic_definition_p(CLASS_OF(info), set_backtrace)) {
  66             rb_exc_set_backtrace(info, bt);
  67             return;
  68         }
  69         else {
  70             bt = rb_backtrace_to_str_ary(bt);
  71         }
  72     }
  73     rb_check_funcall(info, set_backtrace, 1, &bt);
  74 }
  75
  76 static void
  77 error_print(rb_execution_context_t *ec)
  78 {
  79     rb_ec_error_print(ec, ec->errinfo);
  80 }
  81
  82 static void
  83 write_warnq(VALUE out, VALUE str, const char *ptr, long len)
  84 {
  85     if (NIL_P(out)) {
  86         const char *beg = ptr;
  87         const long olen = len;
  88         for (; len > 0; --len, ++ptr) {
  89             unsigned char c = *ptr;
  90             switch (c) {
  91               case '\n': case '\t': continue;
  92             }
  93             if (rb_iscntrl(c)) {
  94                 char buf[5];
  95                 const char *cc = 0;
  96                 if (ptr > beg) rb_write_error2(beg, ptr - beg);
  97                 beg = ptr + 1;
  98                 cc = ruby_escaped_char(c);
  99                 if (cc) {
 100                     rb_write_error2(cc, strlen(cc));
 101                 }
 102                 else {
 103                     rb_write_error2(buf, snprintf(buf, sizeof(buf), "\\x%02X", c));
 104                 }
 105             }
 106             else if (c == '\\') {
 107                 rb_write_error2(beg, ptr - beg + 1);
 108                 beg = ptr;
 109             }
 110         }
 111         if (ptr > beg) {
 112             if (beg == RSTRING_PTR(str) && olen == RSTRING_LEN(str))
 113                 rb_write_error_str(str);
 114             else
 115                 rb_write_error2(beg, ptr - beg);
 116         }
 117     }
 118     else {
 119         rb_str_cat(out, ptr, len);
 120     }
 121 }
 122
 123 #define CSI_BEGIN "\033["
 124 #define CSI_SGR "m"
 125
 126 static const char underline[] = CSI_BEGIN"1;4"CSI_SGR;
 127 static const char bold[] = CSI_BEGIN"1"CSI_SGR;
 128 static const char reset[] = CSI_BEGIN""CSI_SGR;
 129
 130 static void
 131 print_errinfo(const VALUE eclass, const VALUE errat, const VALUE emesg, const VALUE str, int highlight)
 132 {
 133     const char *einfo = "";
 134     long elen = 0;
 135     VALUE mesg;
 136
 137     if (emesg != Qundef) {
 138         if (NIL_P(errat) || RARRAY_LEN(errat) == 0 ||
 139             NIL_P(mesg = RARRAY_AREF(errat, 0))) {
 140             error_pos(str);
 141         }
 142         else {
 143             write_warn_str(str, mesg);
 144             write_warn(str, ": ");
 145         }
 146
 147         if (!NIL_P(emesg)) {
 148             einfo = RSTRING_PTR(emesg);
 149             elen = RSTRING_LEN(emesg);
 150         }
 151     }
 152
 153     if (eclass == rb_eRuntimeError && elen == 0) {
 154         if (highlight) write_warn(str, underline);
 155         write_warn(str, "unhandled exception");
 156         if (highlight) write_warn(str, reset);
 157         write_warn2(str, "\n", 1);
 158     }
 159     else {
 160         VALUE epath;
 161
 162         epath = rb_class_name(eclass);
 163         if (elen == 0) {
 164             if (highlight) write_warn(str, underline);
 165             write_warn_str(str, epath);
 166             if (highlight) write_warn(str, reset);
 167             write_warn(str, "\n");
 168         }
 169         else {
 170             /* emesg is a String instance */
 171             const char *tail = 0;
 172
 173             if (highlight) write_warn(str, bold);
 174             if (RSTRING_PTR(epath)[0] == '#')
 175                 epath = 0;
 176             if ((tail = memchr(einfo, '\n', elen)) != 0) {
 177                 write_warnq(str, emesg, einfo, tail - einfo);
 178                 tail++;         /* skip newline */
 179             }
 180             else {
 181                 write_warnq(str, emesg, einfo, elen);
 182             }
 183             if (epath) {
 184                 write_warn(str, " (");
 185                 if (highlight) write_warn(str, underline);
 186                 write_warn_str(str, epath);
 187                 if (highlight) {
 188                     write_warn(str, reset);
 189                     write_warn(str, bold);
 190                 }
 191                 write_warn2(str, ")", 1);
 192                 if (highlight) write_warn(str, reset);
 193                 write_warn2(str, "\n", 1);
 194             }
 195             if (tail && einfo+elen > tail) {
 196                 if (!highlight) {
 197                     write_warnq(str, emesg, tail, einfo+elen-tail);
 198                     if (einfo[elen-1] != '\n') write_warn2(str, "\n", 1);
 199                 }
 200                 else {
 201                     elen -= tail - einfo;
 202                     einfo = tail;
 203                     while (elen > 0) {
 204                         tail = memchr(einfo, '\n', elen);
 205                         if (!tail || tail > einfo) {
 206                             write_warn(str, bold);
 207                             write_warnq(str, emesg, einfo, tail ? tail-einfo : elen);
 208                             write_warn(str, reset);
 209                             if (!tail) {
 210                                 write_warn2(str, "\n", 1);
 211                                 break;
 212                             }
 213                         }
 214                         elen -= tail - einfo;
 215                         einfo = tail;
 216                         do ++tail; while (tail < einfo+elen && *tail == '\n');
 217                         write_warnq(str, emesg, einfo, tail-einfo);
 218                         elen -= tail - einfo;
 219                         einfo = tail;
 220                     }
 221                 }
 222             }
 223             else if (!epath) {
 224                 write_warn2(str, "\n", 1);
 225             }
 226         }
 227     }
 228 }
 229
 230 static void
 231 print_backtrace(const VALUE eclass, const VALUE errat, const VALUE str, int reverse, long backtrace_limit)
 232 {
 233     if (!NIL_P(errat)) {
 234         long i;
 235         long len = RARRAY_LEN(errat);
 236         const int threshold = 1000000000;
 237         int width = (len <= 1) ? INT_MIN : ((int)log10((double)(len > threshold ?
 238                                          ((len - 1) / threshold) :
 239                                          len - 1)) +
 240                      (len < threshold ? 0 : 9) + 1);
 241
 242         long skip_start = -1, skip_len = 0;
 243
 244         // skip for stackoverflow
 245         if (eclass == rb_eSysStackError) {
 246             long trace_head = 9;
 247             long trace_tail = 4;
 248             long trace_max = trace_head + trace_tail + 5;
 249             if (len > trace_max) {
 250                 skip_start = trace_head;
 251                 skip_len = len - trace_max + 5;
 252             }
 253         }
 254
 255         // skip for explicit limit
 256         if (backtrace_limit >= 0 && len > backtrace_limit + 2) {
 257             skip_start = backtrace_limit + 1;
 258             skip_len = len - skip_start;
 259         }
 260
 261         for (i = 1; i < len; i++) {
 262             if (i == skip_start) {
 263                 write_warn_str(str, rb_sprintf("\t ... %ld levels...\n", skip_len));
 264                 i += skip_len;
 265                 if (i >= len) break;
 266             }
 267             VALUE line = RARRAY_AREF(errat, reverse ? len - i : i);
 268             if (RB_TYPE_P(line, T_STRING)) {
 269                 VALUE bt = rb_str_new_cstr("\t");
 270                 if (reverse) rb_str_catf(bt, "%*ld: ", width, len - i);
 271                 write_warn_str(str, rb_str_catf(bt, "from %"PRIsVALUE"\n", line));
 272             }
 273         }
 274     }
 275 }
 276
 277 VALUE rb_get_message(VALUE exc);
 278
 279 static int
 280 shown_cause_p(VALUE cause, VALUE *shown_causes)
 281 {
 282     VALUE shown = *shown_causes;
 283     if (!shown) {
 284         *shown_causes = shown = rb_obj_hide(rb_ident_hash_new());
 285     }
 286     if (rb_hash_has_key(shown, cause)) return TRUE;
 287     rb_hash_aset(shown, cause, Qtrue);
 288     return FALSE;
 289 }
 290
 291 static void
 292 show_cause(VALUE errinfo, VALUE str, VALUE highlight, VALUE reverse, long backtrace_limit, VALUE *shown_causes)
 293 {
 294     VALUE cause = rb_attr_get(errinfo, id_cause);
 295     if (!NIL_P(cause) && rb_obj_is_kind_of(cause, rb_eException) &&
 296         !shown_cause_p(cause, shown_causes)) {
 297         volatile VALUE eclass = CLASS_OF(cause);
 298         VALUE errat = rb_get_backtrace(cause);
 299         VALUE emesg = rb_get_message(cause);
 300         if (reverse) {
 301             show_cause(cause, str, highlight, reverse, backtrace_limit, shown_causes);
 302             print_backtrace(eclass, errat, str, TRUE, backtrace_limit);
 303             print_errinfo(eclass, errat, emesg, str, highlight!=0);
 304         }
 305         else {
 306             print_errinfo(eclass, errat, emesg, str, highlight!=0);
 307             print_backtrace(eclass, errat, str, FALSE, backtrace_limit);
 308             show_cause(cause, str, highlight, reverse, backtrace_limit, shown_causes);
 309         }
 310     }
 311 }
 312
 313 void
 314 rb_error_write(VALUE errinfo, VALUE emesg, VALUE errat, VALUE str, VALUE highlight, VALUE reverse)
 315 {
 316     volatile VALUE eclass;
 317     VALUE shown_causes = 0;
 318     long backtrace_limit = rb_backtrace_length_limit;
 319
 320     if (NIL_P(errinfo))
 321         return;
 322
 323     if (errat == Qundef) {
 324         errat = Qnil;
 325     }
 326     eclass = CLASS_OF(errinfo);
 327     if (NIL_P(reverse)) reverse = Qfalse;
 328     if (NIL_P(highlight)) {
 329         VALUE tty = (VALUE)rb_stderr_tty_p();
 330         if (NIL_P(highlight)) highlight = tty;
 331     }
 332     if (reverse) {
 333         static const char traceback[] = "Traceback "
 334             "(most recent call last):\n";
 335         const int bold_part = rb_strlen_lit("Traceback");
 336         char buff[sizeof(traceback)+sizeof(bold)+sizeof(reset)-2], *p = buff;
 337         const char *msg = traceback;
 338         long len = sizeof(traceback) - 1;
 339         if (highlight) {
 340 #define APPEND(s, l) (memcpy(p, s, l), p += (l))
 341             APPEND(bold, sizeof(bold)-1);
 342             APPEND(traceback, bold_part);
 343             APPEND(reset, sizeof(reset)-1);
 344             APPEND(traceback + bold_part, sizeof(traceback)-bold_part-1);
 345 #undef APPEND
 346             len = p - (msg = buff);
 347         }
 348         write_warn2(str, msg, len);
 349         show_cause(errinfo, str, highlight, reverse, backtrace_limit, &shown_causes);
 350         print_backtrace(eclass, errat, str, TRUE, backtrace_limit);
 351         print_errinfo(eclass, errat, emesg, str, highlight!=0);
 352     }
 353     else {
 354         print_errinfo(eclass, errat, emesg, str, highlight!=0);
 355         print_backtrace(eclass, errat, str, FALSE, backtrace_limit);
 356         show_cause(errinfo, str, highlight, reverse, backtrace_limit, &shown_causes);
 357     }
 358 }
 359
 360 void
 361 rb_ec_error_print(rb_execution_context_t * volatile ec, volatile VALUE errinfo)
 362 {
 363     volatile uint8_t raised_flag = ec->raised_flag;
 364     volatile VALUE errat = Qundef;
 365     volatile VALUE emesg = Qundef;
 366     volatile bool written = false;
 367
 368     if (NIL_P(errinfo))
 369         return;
 370     rb_ec_raised_clear(ec);
 371
 372     EC_PUSH_TAG(ec);
 373     if (EC_EXEC_TAG() == TAG_NONE) {
 374         errat = rb_get_backtrace(errinfo);
 375     }
 376     if (emesg == Qundef) {
 377         emesg = Qnil;
 378         emesg = rb_get_message(errinfo);
 379     }
 380
 381     if (!written) {
 382         written = true;
 383         rb_error_write(errinfo, emesg, errat, Qnil, Qnil, Qfalse);
 384     }
 385
 386     EC_POP_TAG();
 387     ec->errinfo = errinfo;
 388     rb_ec_raised_set(ec, raised_flag);
 389 }
 390
 391 #define undef_mesg_for(v, k) rb_fstring_lit("undefined"v" method `%1$s' for "k" `%2$s'")
 392 #define undef_mesg(v) ( \
 393         is_mod ? \
 394         undef_mesg_for(v, "module") : \
 395         undef_mesg_for(v, "class"))
 396
 397 void
 398 rb_print_undef(VALUE klass, ID id, rb_method_visibility_t visi)
 399 {
 400     const int is_mod = RB_TYPE_P(klass, T_MODULE);
 401     VALUE mesg;
 402     switch (visi & METHOD_VISI_MASK) {
 403       case METHOD_VISI_UNDEF:
 404       case METHOD_VISI_PUBLIC:    mesg = undef_mesg(""); break;
 405       case METHOD_VISI_PRIVATE:   mesg = undef_mesg(" private"); break;
 406       case METHOD_VISI_PROTECTED: mesg = undef_mesg(" protected"); break;
 407       default: UNREACHABLE;
 408     }
 409     rb_name_err_raise_str(mesg, klass, ID2SYM(id));
 410 }
 411
 412 void
 413 rb_print_undef_str(VALUE klass, VALUE name)
 414 {
 415     const int is_mod = RB_TYPE_P(klass, T_MODULE);
 416     rb_name_err_raise_str(undef_mesg(""), klass, name);
 417 }
 418
 419 #define inaccessible_mesg_for(v, k) rb_fstring_lit("method `%1$s' for "k" `%2$s' is "v)
 420 #define inaccessible_mesg(v) ( \
 421         is_mod ? \
 422         inaccessible_mesg_for(v, "module") : \
 423         inaccessible_mesg_for(v, "class"))
 424
 425 void
 426 rb_print_inaccessible(VALUE klass, ID id, rb_method_visibility_t visi)
 427 {
 428     const int is_mod = RB_TYPE_P(klass, T_MODULE);
 429     VALUE mesg;
 430     switch (visi & METHOD_VISI_MASK) {
 431       case METHOD_VISI_UNDEF:
 432       case METHOD_VISI_PUBLIC:    mesg = inaccessible_mesg(""); break;
 433       case METHOD_VISI_PRIVATE:   mesg = inaccessible_mesg("private"); break;
 434       case METHOD_VISI_PROTECTED: mesg = inaccessible_mesg("protected"); break;
 435       default: UNREACHABLE;
 436     }
 437     rb_name_err_raise_str(mesg, klass, ID2SYM(id));
 438 }
 439
 440 static int
 441 sysexit_status(VALUE err)
 442 {
 443     VALUE st = rb_ivar_get(err, id_status);
 444     return NUM2INT(st);
 445 }
 446
 447 #define unknown_longjmp_status(status) \
 448     rb_bug("Unknown longjmp status %d", status)
 449
 450 static int
 451 error_handle(rb_execution_context_t *ec, int ex)
 452 {
 453     int status = EXIT_FAILURE;
 454
 455     if (rb_ec_set_raised(ec))
 456         return EXIT_FAILURE;
 457     switch (ex & TAG_MASK) {
 458       case 0:
 459         status = EXIT_SUCCESS;
 460         break;
 461
 462       case TAG_RETURN:
 463         error_pos(Qnil);
 464         warn_print("unexpected return\n");
 465         break;
 466       case TAG_NEXT:
 467         error_pos(Qnil);
 468         warn_print("unexpected next\n");
 469         break;
 470       case TAG_BREAK:
 471         error_pos(Qnil);
 472         warn_print("unexpected break\n");
 473         break;
 474       case TAG_REDO:
 475         error_pos(Qnil);
 476         warn_print("unexpected redo\n");
 477         break;
 478       case TAG_RETRY:
 479         error_pos(Qnil);
 480         warn_print("retry outside of rescue clause\n");
 481         break;
 482       case TAG_THROW:
 483         /* TODO: fix me */
 484         error_pos(Qnil);
 485         warn_print("unexpected throw\n");
 486         break;
 487       case TAG_RAISE: {
 488         VALUE errinfo = ec->errinfo;
 489         if (rb_obj_is_kind_of(errinfo, rb_eSystemExit)) {
 490             status = sysexit_status(errinfo);
 491         }
 492         else if (rb_obj_is_instance_of(errinfo, rb_eSignal) &&
 493                  rb_ivar_get(errinfo, id_signo) != INT2FIX(SIGSEGV)) {
 494             /* no message when exiting by signal */
 495         }
 496         else if (rb_obj_is_kind_of(errinfo, rb_eSystemCallError) &&
 497                  FIXNUM_P(rb_attr_get(errinfo, id_signo))) {
 498             /* no message when exiting by error to be mapped to signal */
 499         }
 500         else {
 501             rb_ec_error_print(ec, errinfo);
 502         }
 503         break;
 504       }
 505       case TAG_FATAL:
 506         error_print(ec);
 507         break;
 508       default:
 509         unknown_longjmp_status(ex);
 510         break;
 511     }
 512     rb_ec_reset_raised(ec);
 513     return status;
 514 }