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