src/error.c

   1 /*
   2 ** error.c - Exception class
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <errno.h>
   8 #include <stdlib.h>
   9 #include <mruby.h>
  10 #include <mruby/array.h>
  11 #include <mruby/irep.h>
  12 #include <mruby/proc.h>
  13 #include <mruby/string.h>
  14 #include <mruby/variable.h>
  15 #include <mruby/error.h>
  16 #include <mruby/class.h>
  17 #include <mruby/throw.h>
  18 #include <mruby/internal.h>
  19 #include <mruby/presym.h>
  20
  21 void
  22 mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg)
  23 {
  24   if (!mrb_string_p(mesg)) {
  25     mesg = mrb_obj_as_string(mrb, mesg);
  26   }
  27   exc->mesg = mrb_basic_ptr(mesg);
  28   mrb_field_write_barrier_value(mrb, (struct RBasic*)exc, mesg);
  29 }
  30
  31 mrb_value
  32 mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc)
  33 {
  34   if (exc->mesg == NULL) return mrb_nil_value();
  35   return mrb_obj_value(exc->mesg);
  36 }
  37
  38 MRB_API mrb_value
  39 mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str)
  40 {
  41   mrb_ensure_string_type(mrb, str);
  42
  43   struct RException *e = MRB_OBJ_ALLOC(mrb, MRB_TT_EXCEPTION, c);
  44   mrb_value exc = mrb_obj_value(e);
  45   mrb_exc_mesg_set(mrb, e, str);
  46   return exc;
  47 }
  48
  49 MRB_API mrb_value
  50 mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, mrb_int len)
  51 {
  52   return mrb_exc_new_str(mrb, c, mrb_str_new(mrb, ptr, len));
  53 }
  54
  55 /*
  56  * call-seq:
  57  *    Exception.new(msg = nil)   ->  exception
  58  *
  59  *  Construct a new Exception object, optionally passing in
  60  *  a message.
  61  */
  62
  63 static mrb_value
  64 exc_initialize(mrb_state *mrb, mrb_value exc)
  65 {
  66   mrb_value mesg;
  67
  68   if (mrb_get_args(mrb, "|o", &mesg) == 1) {
  69     mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg);
  70   }
  71   return exc;
  72 }
  73
  74 /*
  75  *  Document-method: exception
  76  *
  77  *  call-seq:
  78  *     exc.exception(string)  ->  an_exception or exc
  79  *
  80  *  With no argument, or if the argument is the same as the receiver,
  81  *  return the receiver. Otherwise, create a new
  82  *  exception object of the same class as the receiver, but with a
  83  *  message equal to <code>string</code>.
  84  *
  85  */
  86
  87 static mrb_value
  88 exc_exception(mrb_state *mrb, mrb_value self)
  89 {
  90   mrb_value a;
  91   mrb_int argc = mrb_get_args(mrb, "|o", &a);
  92
  93   if (argc == 0) return self;
  94   if (mrb_obj_equal(mrb, self, a)) return self;
  95
  96   mrb_value exc = mrb_obj_clone(mrb, self);
  97   mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), a);
  98
  99   return exc;
 100 }
 101
 102 /*
 103  * call-seq:
 104  *   exception.to_s   ->  string
 105  *
 106  * Returns exception's message (or the name of the exception if
 107  * no message is set).
 108  */
 109
 110 static mrb_value
 111 exc_to_s(mrb_state *mrb, mrb_value exc)
 112 {
 113   mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc));
 114
 115   if (!mrb_string_p(mesg)) {
 116     return mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc));
 117   }
 118   struct RObject *p = mrb_obj_ptr(mesg);
 119   if (!p->c) {
 120     p->c = mrb->string_class;
 121   }
 122   return mesg;
 123 }
 124
 125 /*
 126  * call-seq:
 127  *   exception.inspect   -> string
 128  *
 129  * Returns this exception's file name, line number,
 130  * message and class name.
 131  * If file name or line number is not set,
 132  * returns message and class name.
 133  */
 134
 135 mrb_value
 136 mrb_exc_inspect(mrb_state *mrb, mrb_value exc)
 137 {
 138   mrb_value cname = mrb_mod_to_s(mrb, mrb_obj_value(mrb_obj_class(mrb, exc)));
 139   mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc)); /* string or nil */
 140   return (mrb_nil_p(mesg)||RSTRING_LEN(mesg)==0) ? cname : mrb_format(mrb, "%v (%v)", mesg, cname);
 141 }
 142
 143 void mrb_keep_backtrace(mrb_state *mrb, mrb_value exc);
 144
 145 static void
 146 set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace)
 147 {
 148   if (!mrb_array_p(backtrace)) {
 149   type_err:
 150     mrb_raise(mrb, E_TYPE_ERROR, "backtrace must be Array of String");
 151   }
 152   else {
 153     const mrb_value *p = RARRAY_PTR(backtrace);
 154     const mrb_value *pend = p + RARRAY_LEN(backtrace);
 155
 156     while (p < pend) {
 157       if (!mrb_string_p(*p)) goto type_err;
 158       p++;
 159     }
 160   }
 161   mrb_exc_ptr(exc)->backtrace = mrb_basic_ptr(backtrace);
 162   mrb_field_write_barrier_value(mrb, mrb_basic_ptr(exc), backtrace);
 163 }
 164
 165 static mrb_value
 166 exc_set_backtrace(mrb_state *mrb, mrb_value exc)
 167 {
 168   mrb_value backtrace = mrb_get_arg1(mrb);
 169
 170   set_backtrace(mrb, exc, backtrace);
 171   return backtrace;
 172 }
 173
 174 void
 175 mrb_exc_set(mrb_state *mrb, mrb_value exc)
 176 {
 177   if (mrb_nil_p(exc)) {
 178     mrb->exc = 0;
 179   }
 180   else {
 181     mrb->exc = mrb_obj_ptr(exc);
 182     if (mrb->gc.arena_idx > 0 &&
 183         (struct RBasic*)mrb->exc == mrb->gc.arena[mrb->gc.arena_idx-1]) {
 184       mrb->gc.arena_idx--;
 185     }
 186     if (!mrb->gc.out_of_memory && !mrb_frozen_p(mrb->exc)) {
 187       mrb_keep_backtrace(mrb, exc);
 188     }
 189   }
 190 }
 191
 192 static mrb_noreturn void
 193 exc_throw(mrb_state *mrb, mrb_value exc)
 194 {
 195   if (!mrb->jmp) {
 196     mrb_print_error(mrb);
 197     abort();
 198   }
 199   MRB_THROW(mrb->jmp);
 200 }
 201
 202 MRB_API mrb_noreturn void
 203 mrb_exc_raise(mrb_state *mrb, mrb_value exc)
 204 {
 205   if (mrb_break_p(exc)) {
 206     mrb->exc = mrb_obj_ptr(exc);
 207   }
 208   else {
 209     if (mrb_type(exc) != MRB_TT_EXCEPTION) {
 210       mrb_raise(mrb, E_TYPE_ERROR, "exception object expected");
 211     }
 212     mrb_exc_set(mrb, exc);
 213   }
 214   exc_throw(mrb, exc);
 215 }
 216
 217 MRB_API mrb_noreturn void
 218 mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg)
 219 {
 220   mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mrb_str_new_cstr(mrb, msg)));
 221 }
 222
 223 /*
 224  * <code>vsprintf</code> like formatting.
 225  *
 226  * The syntax of a format sequence is as follows.
 227  *
 228  *   %[modifier]specifier
 229  *
 230  * The modifiers are:
 231  *
 232  *   ----------+------------------------------------------------------------
 233  *   Modifier  | Meaning
 234  *   ----------+------------------------------------------------------------
 235  *       !     | Convert to string by corresponding `inspect` instead of
 236  *             | corresponding `to_s`.
 237  *   ----------+------------------------------------------------------------
 238  *
 239  * The specifiers are:
 240  *
 241  *   ----------+----------------+--------------------------------------------
 242  *   Specifier | Argument Type  | Note
 243  *   ----------+----------------+--------------------------------------------
 244  *       c     | char           |
 245  *       d     | int            |
 246  *       f     | mrb_float      |
 247  *       i     | mrb_int        |
 248  *       l     | char*, size_t  | Arguments are string and length.
 249  *       n     | mrb_sym        |
 250  *       s     | char*          | Argument is NUL terminated string.
 251  *       t     | mrb_value      | Convert to type (class) of object.
 252  *      v,S    | mrb_value      |
 253  *       C     | struct RClass* |
 254  *       T     | mrb_value      | Convert to real type (class) of object.
 255  *       Y     | mrb_value      | Same as `!v` if argument is `true`, `false`
 256  *             |                | or `nil`, otherwise same as `T`.
 257  *       %     | -              | Convert to percent sign itself (no argument
 258  *             |                | taken).
 259  *   ----------+----------------+--------------------------------------------
 260  */
 261 MRB_API mrb_value
 262 mrb_vformat(mrb_state *mrb, const char *format, va_list ap)
 263 {
 264   const char *chars, *p = format, *b = format, *e;
 265   char ch;
 266   size_t len;
 267   mrb_int i;
 268   struct RClass *cls;
 269   mrb_bool inspect = FALSE;
 270   mrb_value result = mrb_str_new_capa(mrb, 128), obj, str;
 271   int ai = mrb_gc_arena_save(mrb);
 272
 273   while (*p) {
 274     const char c = *p++;
 275     e = p;
 276     if (c == '%') {
 277       if (*p == '!') {
 278         inspect = TRUE;
 279         p++;
 280       }
 281       if (!*p) break;
 282       switch (*p) {
 283         case 'c':
 284           ch = (char)va_arg(ap, int);
 285           chars = &ch;
 286           len = 1;
 287           goto L_cat;
 288         case 'd': case 'i':
 289 #if MRB_INT_MAX < INT_MAX
 290           i = (mrb_int)va_arg(ap, int);
 291 #else
 292           i = *p == 'd' ? (mrb_int)va_arg(ap, int) : va_arg(ap, mrb_int);
 293 #endif
 294           obj = mrb_int_value(mrb, i);
 295           goto L_cat_obj;
 296 #ifndef MRB_NO_FLOAT
 297         case 'f':
 298           obj = mrb_float_value(mrb, (mrb_float)va_arg(ap, double));
 299           goto L_cat_obj;
 300 #endif
 301         case 'l':
 302           chars = va_arg(ap, char*);
 303           len = va_arg(ap, size_t);
 304         L_cat:
 305           if (inspect) {
 306             obj = mrb_str_new(mrb, chars, len);
 307             goto L_cat_obj;
 308           }
 309         L_cat_plain:
 310           mrb_str_cat(mrb, result, b,  e - b - 1);
 311           mrb_str_cat(mrb, result, chars, len);
 312           b = ++p;
 313           mrb_gc_arena_restore(mrb, ai);
 314           break;
 315         case 'n':
 316 #if UINT32_MAX < INT_MAX
 317           obj = mrb_symbol_value((mrb_sym)va_arg(ap, int));
 318 #else
 319           obj = mrb_symbol_value(va_arg(ap, mrb_sym));
 320 #endif
 321           goto L_cat_obj;
 322         case 's':
 323           chars = va_arg(ap, char*);
 324           len = strlen(chars);
 325           goto L_cat;
 326         case 't':
 327           cls = mrb_class(mrb, va_arg(ap, mrb_value));
 328           goto L_cat_class;
 329         case 'v': case 'S':
 330           obj = va_arg(ap, mrb_value);
 331         L_cat_obj:
 332           str = (inspect ? mrb_inspect : mrb_obj_as_string)(mrb, obj);
 333           if (mrb_type(str) != MRB_TT_STRING) {
 334             chars = "void (no string conversion)";
 335             len = strlen(chars);
 336           }
 337           else {
 338             chars = RSTRING_PTR(str);
 339             len = RSTRING_LEN(str);
 340           }
 341           goto L_cat_plain;
 342         case 'C':
 343           cls = va_arg(ap, struct RClass*);
 344         L_cat_class:
 345           obj = mrb_obj_value(cls);
 346           goto L_cat_obj;
 347         case 'T':
 348           obj = va_arg(ap, mrb_value);
 349         L_cat_real_class_of:
 350           cls = mrb_obj_class(mrb, obj);
 351           goto L_cat_class;
 352         case 'Y':
 353           obj = va_arg(ap, mrb_value);
 354           if (!mrb_test(obj) || mrb_true_p(obj)) {
 355             inspect = TRUE;
 356             goto L_cat_obj;
 357           }
 358           else {
 359             goto L_cat_real_class_of;
 360           }
 361         case '%':
 362         L_cat_current:
 363           chars = p;
 364           len = 1;
 365           goto L_cat_plain;
 366         default:
 367           mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
 368       }
 369     }
 370     else if (c == '\\') {
 371       if (!*p) break;
 372       goto L_cat_current;
 373
 374     }
 375   }
 376
 377   mrb_str_cat(mrb, result, b, p - b);
 378   return result;
 379 }
 380
 381 MRB_API mrb_value
 382 mrb_format(mrb_state *mrb, const char *format, ...)
 383 {
 384   va_list ap;
 385
 386   va_start(ap, format);
 387
 388   mrb_value str = mrb_vformat(mrb, format, ap);
 389   va_end(ap);
 390
 391   return str;
 392 }
 393
 394 static mrb_value
 395 error_va(mrb_state *mrb, struct RClass *c, const char *fmt, va_list ap)
 396 {
 397   return mrb_exc_new_str(mrb, c, mrb_vformat(mrb, fmt, ap));
 398 }
 399
 400 MRB_API mrb_noreturn void
 401 mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
 402 {
 403   va_list ap;
 404
 405   va_start(ap, fmt);
 406
 407   mrb_value exc = error_va(mrb, c, fmt, ap);
 408   va_end(ap);
 409
 410   mrb_exc_raise(mrb, exc);
 411 }
 412
 413 MRB_API mrb_noreturn void
 414 mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...)
 415 {
 416   va_list ap;
 417
 418   va_start(ap, fmt);
 419
 420   mrb_value exc = error_va(mrb, E_NAME_ERROR, fmt, ap);
 421   va_end(ap);
 422   mrb_iv_set(mrb, exc, MRB_IVSYM(name), mrb_symbol_value(id));
 423   mrb_exc_raise(mrb, exc);
 424 }
 425
 426 MRB_API void
 427 mrb_warn(mrb_state *mrb, const char *fmt, ...)
 428 {
 429 #ifndef MRB_NO_STDIO
 430   va_list ap;
 431
 432   va_start(ap, fmt);
 433
 434   mrb_value str = mrb_vformat(mrb, fmt, ap);
 435   fputs("warning: ", stderr);
 436   fwrite(RSTRING_PTR(str), RSTRING_LEN(str), 1, stderr);
 437   putc('\n', stderr);
 438   va_end(ap);
 439 #endif
 440 }
 441
 442 MRB_API mrb_noreturn void
 443 mrb_bug(mrb_state *mrb, const char *mesg)
 444 {
 445 #ifndef MRB_NO_STDIO
 446   fputs("bug: ", stderr);
 447   fputs(mesg, stderr);
 448   fputs("\n", stderr);
 449 #endif
 450   exit(EXIT_FAILURE);
 451 }
 452
 453 mrb_value
 454 mrb_make_exception(mrb_state *mrb, mrb_value exc, mrb_value mesg)
 455 {
 456   mrb_int n = 1;
 457
 458   if (mrb_nil_p(mesg)) {
 459     n = 0;
 460   }
 461   if (mrb_class_p(exc)) {
 462     exc = mrb_funcall_argv(mrb, exc, MRB_SYM(new), n, &mesg);
 463   }
 464   else if (mrb_exception_p(exc)) {
 465     if (n > 0) {
 466       exc = mrb_obj_clone(mrb, exc);
 467       mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg);
 468     }
 469   }
 470   else {
 471     mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected");
 472   }
 473   if (mrb_type(exc) != MRB_TT_EXCEPTION) {
 474     mrb_raise(mrb, E_EXCEPTION, "exception object expected");
 475   }
 476   return exc;
 477 }
 478
 479 MRB_API mrb_noreturn void
 480 mrb_sys_fail(mrb_state *mrb, const char *mesg)
 481 {
 482   if (mrb_class_defined_id(mrb, MRB_SYM(SystemCallError))) {
 483     struct RClass *sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError));
 484     mrb_int no = (mrb_int)errno;
 485     if (mesg != NULL) {
 486       mrb_funcall_id(mrb, mrb_obj_value(sce), MRB_SYM(_sys_fail), 2, mrb_fixnum_value(no), mrb_str_new_cstr(mrb, mesg));
 487     }
 488     else {
 489       mrb_funcall_id(mrb, mrb_obj_value(sce), MRB_SYM(_sys_fail), 1, mrb_fixnum_value(no));
 490     }
 491   }
 492
 493   mrb_raise(mrb, E_RUNTIME_ERROR, mesg);
 494 }
 495
 496 MRB_API mrb_noreturn void
 497 mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, char const* fmt, ...)
 498 {
 499   va_list ap;
 500
 501   va_start(ap, fmt);
 502
 503   mrb_value exc = error_va(mrb, E_NOMETHOD_ERROR, fmt, ap);
 504   va_end(ap);
 505   mrb_iv_set(mrb, exc, MRB_IVSYM(name), mrb_symbol_value(id));
 506   mrb_iv_set(mrb, exc, MRB_IVSYM(args), args);
 507   mrb_exc_raise(mrb, exc);
 508 }
 509
 510 static mrb_noreturn void
 511 frozen_error(mrb_state *mrb, mrb_value v)
 512 {
 513   mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %T", v);
 514 }
 515
 516 MRB_API mrb_noreturn void
 517 mrb_frozen_error(mrb_state *mrb, void *frozen_obj)
 518 {
 519   frozen_error(mrb, mrb_obj_value(frozen_obj));
 520 }
 521
 522 MRB_API void
 523 mrb_check_frozen(mrb_state *mrb, void *o)
 524 {
 525   if (mrb_frozen_p((struct RBasic*)o)) {
 526     mrb_frozen_error(mrb, o);
 527   }
 528 }
 529
 530 MRB_API void
 531 mrb_check_frozen_value(mrb_state *mrb, mrb_value v)
 532 {
 533   if (mrb_immediate_p(v) || mrb_frozen_p(mrb_basic_ptr(v))) {
 534     frozen_error(mrb, v);
 535   }
 536 }
 537
 538 MRB_API mrb_noreturn void
 539 mrb_argnum_error(mrb_state *mrb, mrb_int argc, int min, int max)
 540 {
 541 #define FMT(exp) "wrong number of arguments (given %i, expected " exp ")"
 542   if (min == max)
 543     mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d"), argc, min);
 544   else if (max < 0)
 545     mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d+"), argc, min);
 546   else
 547     mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d..%d"), argc, min, max);
 548 #undef FMT
 549 }
 550
 551 void mrb_core_init_printabort(void);
 552
 553 int
 554 mrb_core_init_protect(mrb_state *mrb, void (*body)(mrb_state*, void*), void *opaque)
 555 {
 556   struct mrb_jmpbuf *prev_jmp = mrb->jmp;
 557   struct mrb_jmpbuf c_jmp;
 558   volatile int err = 1;
 559
 560   MRB_TRY(&c_jmp) {
 561     mrb->jmp = &c_jmp;
 562     body(mrb, opaque);
 563     err = 0;
 564   } MRB_CATCH(&c_jmp) {
 565     if (mrb->exc) {
 566       mrb_print_error(mrb);
 567       mrb->exc = NULL;
 568     }
 569     else {
 570       mrb_core_init_printabort();
 571     }
 572   } MRB_END_EXC(&c_jmp);
 573
 574   mrb->jmp = prev_jmp;
 575
 576   return err;
 577 }
 578
 579 mrb_noreturn void
 580 mrb_core_init_abort(mrb_state *mrb)
 581 {
 582   mrb->exc = NULL;
 583   exc_throw(mrb, mrb_nil_value());
 584 }
 585
 586 void
 587 mrb_protect_atexit(mrb_state *mrb)
 588 {
 589   if (mrb->atexit_stack_len > 0) {
 590     if (mrb->c && mrb->c->ci) {
 591       // Even if the call stack is incomplete due to some fault, atexit to be executed at the top level is desirable.
 592       // Clean-up also makes it easier to collect unnecessary objects.
 593       mrb_callinfo zero = { 0 };
 594       struct mrb_context *c = mrb->c = mrb->root_c;
 595       c->ci = c->cibase;
 596       *c->ci = zero;
 597       c->ci->stack = c->stbase;
 598       mrb_gc_arena_restore(mrb, 0);
 599     }
 600
 601     struct mrb_jmpbuf *prev_jmp = mrb->jmp;
 602     struct mrb_jmpbuf c_jmp;
 603     int i = mrb->atexit_stack_len;
 604     while (i > 0) {
 605       MRB_TRY(&c_jmp) {
 606         mrb->jmp = &c_jmp;
 607         do {
 608           mrb->atexit_stack[--i](mrb);
 609           mrb_gc_arena_restore(mrb, 0);
 610         } while (i > 0);
 611         mrb->jmp = prev_jmp;
 612       } MRB_CATCH(&c_jmp) {
 613         mrb->jmp = prev_jmp;
 614         /* ignore atexit errors */
 615         mrb_gc_arena_restore(mrb, 0);
 616       } MRB_END_EXC(&c_jmp);
 617     }
 618 #ifndef MRB_FIXED_STATE_ATEXIT_STACK
 619     mrb_free(mrb, mrb->atexit_stack);
 620 #endif
 621   }
 622 }
 623
 624 mrb_noreturn void
 625 mrb_raise_nomemory(mrb_state *mrb)
 626 {
 627   if (mrb->nomem_err) {
 628     mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
 629   }
 630   else {
 631     mrb_core_init_abort(mrb);
 632   }
 633 }
 634
 635 MRB_API void
 636 mrb_print_error(mrb_state *mrb)
 637 {
 638 #ifndef MRB_NO_STDIO
 639   if (mrb->jmp == NULL) {
 640     struct mrb_jmpbuf c_jmp;
 641     MRB_TRY(&c_jmp) {
 642       mrb->jmp = &c_jmp;
 643       mrb_print_backtrace(mrb);
 644     } MRB_CATCH(&c_jmp) {
 645       /* ignore exception during print_backtrace() */
 646     } MRB_END_EXC(&c_jmp);
 647     mrb->jmp = NULL;
 648   }
 649   else {
 650     mrb_print_backtrace(mrb);
 651   }
 652 #endif
 653 }
 654
 655 /* clear error status in the mrb_state structure */
 656 MRB_API void
 657 mrb_clear_error(mrb_state *mrb)
 658 {
 659   mrb->exc = NULL;
 660 }
 661
 662 /* returns TRUE if error in the previous call; internally calls mrb_clear_error() */
 663 MRB_API mrb_bool
 664 mrb_check_error(mrb_state *mrb)
 665 {
 666   if (mrb->exc) {
 667     mrb_clear_error(mrb);
 668     return TRUE;
 669   }
 670   return FALSE;
 671 }
 672
 673 void
 674 mrb_init_exception(mrb_state *mrb)
 675 {
 676   struct RClass *exception = mrb->eException_class = mrb_define_class_id(mrb, MRB_SYM(Exception), mrb->object_class); /* 15.2.22 */
 677   MRB_SET_INSTANCE_TT(exception, MRB_TT_EXCEPTION);
 678   mrb_define_class_method_id(mrb, exception, MRB_SYM(exception), mrb_instance_new,  MRB_ARGS_OPT(1));
 679   mrb_define_method_id(mrb, exception, MRB_SYM(exception),       exc_exception,     MRB_ARGS_OPT(1));
 680   mrb_define_method_id(mrb, exception, MRB_SYM(initialize),      exc_initialize,    MRB_ARGS_OPT(1));
 681   mrb_define_method_id(mrb, exception, MRB_SYM(to_s),            exc_to_s,          MRB_ARGS_NONE());
 682   mrb_define_method_id(mrb, exception, MRB_SYM(inspect),         mrb_exc_inspect,   MRB_ARGS_NONE());
 683   mrb_define_method_id(mrb, exception, MRB_SYM(backtrace),       mrb_exc_backtrace, MRB_ARGS_NONE());
 684   mrb_define_method_id(mrb, exception, MRB_SYM(set_backtrace),   exc_set_backtrace, MRB_ARGS_REQ(1));
 685
 686   mrb->eStandardError_class = mrb_define_class_id(mrb, MRB_SYM(StandardError), mrb->eException_class); /* 15.2.23 */
 687   mrb_define_class_id(mrb, MRB_SYM(RuntimeError), E_STANDARD_ERROR);          /* 15.2.28 */
 688   struct RClass *script_error = mrb_define_class_id(mrb, MRB_SYM(ScriptError), exception);   /* 15.2.37 */
 689   mrb_define_class_id(mrb, MRB_SYM(SyntaxError), script_error);               /* 15.2.38 */
 690   struct RClass *stack_error = mrb_define_class_id(mrb, MRB_SYM(SystemStackError), exception);
 691   mrb->stack_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, stack_error, "stack level too deep"));
 692
 693   struct RClass *nomem_error = mrb_define_class_id(mrb, MRB_SYM(NoMemoryError), exception);
 694   mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "Out of memory"));
 695 #ifdef MRB_GC_FIXED_ARENA
 696   mrb->arena_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "arena overflow error"));
 697 #endif
 698 }