enclave 0.1.0

data/ext/enclave/mruby/src/error.c

@@ -0,0 +1,937 @@
+/*
+** error.c - Exception class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#include <errno.h>
+#include <stdlib.h>
+#include <mruby.h>
+#include <mruby/array.h>
+#include <mruby/irep.h>
+#include <mruby/proc.h>
+#include <mruby/string.h>
+#include <mruby/variable.h>
+#include <mruby/error.h>
+#include <mruby/class.h>
+#include <mruby/throw.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+void
+mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg)
+{
+  if (!mrb_string_p(mesg)) {
+    mesg = mrb_obj_as_string(mrb, mesg);
+  }
+  exc->mesg = mrb_basic_ptr(mesg);
+  mrb_field_write_barrier_value(mrb, (struct RBasic*)exc, mesg);
+}
+
+mrb_value
+mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc)
+{
+  if (exc->mesg == NULL) return mrb_nil_value();
+  return mrb_obj_value(exc->mesg);
+}
+
+MRB_API mrb_value
+mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str)
+{
+  mrb_ensure_string_type(mrb, str);
+
+  struct RException *e = MRB_OBJ_ALLOC(mrb, MRB_TT_EXCEPTION, c);
+  mrb_value exc = mrb_obj_value(e);
+  mrb_exc_mesg_set(mrb, e, str);
+  return exc;
+}
+
+MRB_API mrb_value
+mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, mrb_int len)
+{
+  return mrb_exc_new_str(mrb, c, mrb_str_new(mrb, ptr, len));
+}
+
+/*
+ * call-seq:
+ *    Exception.new(msg = nil)   ->  exception
+ *
+ *  Construct a new Exception object, optionally passing in
+ *  a message.
+ */
+
+static mrb_value
+exc_initialize(mrb_state *mrb, mrb_value exc)
+{
+  mrb_value mesg;
+
+  if (mrb_get_args(mrb, "|o", &mesg) == 1) {
+    mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg);
+  }
+  return exc;
+}
+
+/*
+ *  Document-method: exception
+ *
+ *  call-seq:
+ *     exc.exception(string)  ->  an_exception or exc
+ *
+ *  With no argument, or if the argument is the same as the receiver,
+ *  return the receiver. Otherwise, create a new
+ *  exception object of the same class as the receiver, but with a
+ *  message equal to `string`.
+ *
+ */
+
+static mrb_value
+exc_exception(mrb_state *mrb, mrb_value self)
+{
+  mrb_value a;
+  mrb_int argc = mrb_get_args(mrb, "|o", &a);
+
+  if (argc == 0) return self;
+  if (mrb_obj_equal(mrb, self, a)) return self;
+
+  mrb_value exc = mrb_obj_clone(mrb, self);
+  mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), a);
+
+  return exc;
+}
+
+/*
+ * call-seq:
+ *   exception.to_s   ->  string
+ *
+ * Returns exception's message (or the name of the exception if
+ * no message is set).
+ */
+
+static mrb_value
+exc_to_s(mrb_state *mrb, mrb_value exc)
+{
+  mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc));
+
+  if (!mrb_string_p(mesg)) {
+    return mrb_str_new_cstr(mrb, mrb_obj_classname(mrb, exc));
+  }
+  struct RObject *p = mrb_obj_ptr(mesg);
+  if (!p->c) {
+    p->c = mrb->string_class;
+  }
+  return mesg;
+}
+
+/*
+ * call-seq:
+ *   exception.inspect   -> string
+ *
+ * Returns this exception's filename, line number,
+ * message and class name.
+ * If filename or line number is not set,
+ * returns message and class name.
+ */
+
+mrb_value
+mrb_exc_inspect(mrb_state *mrb, mrb_value exc)
+{
+  mrb_value cname = mrb_mod_to_s(mrb, mrb_obj_value(mrb_obj_class(mrb, exc)));
+  mrb_value mesg = mrb_exc_mesg_get(mrb, mrb_exc_ptr(exc)); /* string or nil */
+  return (mrb_nil_p(mesg)||RSTRING_LEN(mesg)==0) ? cname : mrb_format(mrb, "#<%v: %v>", cname, mesg);
+}
+
+mrb_value
+mrb_exc_get_output(mrb_state *mrb, struct RObject *exc)
+{
+  mrb_value cname = mrb_mod_to_s(mrb, mrb_obj_value(mrb_class_real(exc->c)));
+  mrb_value mesg = mrb_exc_mesg_get(mrb, (struct RException*)exc); /* string or nil */
+  return (mrb_nil_p(mesg)||RSTRING_LEN(mesg)==0) ? cname : mrb_format(mrb, "%v (%v)", mesg, cname);
+}
+
+void mrb_keep_backtrace(mrb_state *mrb, mrb_value exc);
+
+static void
+set_backtrace(mrb_state *mrb, mrb_value exc, mrb_value backtrace)
+{
+  if (!mrb_array_p(backtrace)) {
+  type_err:
+    mrb_raise(mrb, E_TYPE_ERROR, "backtrace must be Array of String");
+  }
+  else {
+    const mrb_value *p = RARRAY_PTR(backtrace);
+    const mrb_value *pend = p + RARRAY_LEN(backtrace);
+
+    while (p < pend) {
+      if (!mrb_string_p(*p)) goto type_err;
+      p++;
+    }
+  }
+  mrb_exc_ptr(exc)->backtrace = mrb_basic_ptr(backtrace);
+  mrb_field_write_barrier_value(mrb, mrb_basic_ptr(exc), backtrace);
+}
+
+static mrb_value
+exc_set_backtrace(mrb_state *mrb, mrb_value exc)
+{
+  mrb_value backtrace = mrb_get_arg1(mrb);
+
+  set_backtrace(mrb, exc, backtrace);
+  return backtrace;
+}
+
+void
+mrb_exc_set(mrb_state *mrb, mrb_value exc)
+{
+  if (mrb_nil_p(exc)) {
+    mrb->exc = 0;
+  }
+  else {
+    mrb->exc = mrb_obj_ptr(exc);
+    if (mrb->gc.arena_idx > 0 &&
+        (struct RBasic*)mrb->exc == mrb->gc.arena[mrb->gc.arena_idx-1]) {
+      mrb->gc.arena_idx--;
+    }
+    if (!mrb->gc.out_of_memory && !mrb_frozen_p(mrb->exc)) {
+      mrb_keep_backtrace(mrb, exc);
+    }
+  }
+}
+
+static mrb_noreturn void
+exc_throw(mrb_state *mrb, mrb_value exc)
+{
+  if (!mrb->jmp) {
+    mrb_print_error(mrb);
+    abort();
+  }
+  MRB_THROW(mrb->jmp);
+}
+
+/*
+ * Raises the given exception object.
+ *
+ * This function sets the provided exception object as the current
+ * exception in the mruby state and then triggers the exception
+ * handling mechanism (longjmp).
+ *
+ * If the provided object is a 'break' object, it's handled specially.
+ * If it's not an exception object, a TypeError is raised.
+ *
+ * mrb: The mruby state.
+ * exc: The exception object to raise.
+ */
+MRB_API mrb_noreturn void
+mrb_exc_raise(mrb_state *mrb, mrb_value exc)
+{
+  if (mrb_break_p(exc)) {
+    mrb->exc = mrb_obj_ptr(exc);
+  }
+  else {
+    if (mrb_type(exc) != MRB_TT_EXCEPTION) {
+      mrb_raise(mrb, E_TYPE_ERROR, "exception object expected");
+    }
+    mrb_exc_set(mrb, exc);
+  }
+  exc_throw(mrb, exc);
+}
+
+/*
+ * Creates a new exception of class `c` with the message `msg` and raises it.
+ *
+ * This is a convenience function that combines creating an exception
+ * from a C string and then raising it.
+ *
+ * mrb: The mruby state.
+ * c:   The exception class to instantiate.
+ * msg: The C string message for the exception.
+ */
+MRB_API mrb_noreturn void
+mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg)
+{
+  mrb_exc_raise(mrb, mrb_exc_new_str(mrb, c, mrb_str_new_cstr(mrb, msg)));
+}
+
+/*
+ * Formats arguments according to a format string, similar to vsprintf.
+ * This function is the core of mruby's string formatting capabilities.
+ * It takes a format string and a va_list of arguments and returns a
+ * new mruby string with the formatted result.
+ *
+ * The format string supports various specifiers to control how arguments
+ * are converted to strings.
+ *
+ * Format Sequence Syntax:
+ *   %[modifier]specifier
+ *
+ * Modifier:
+ *   !  : Use the 'inspect' method for conversion instead of 'to_s'.
+ *
+ * Specifiers:
+ *   c  : char
+ *   d  : int (decimal)
+ *   i  : mrb_int (decimal)
+ *   f  : mrb_float
+ *   l  : char* and size_t (string with length)
+ *   n  : mrb_sym (symbol name)
+ *   s  : char* (NUL-terminated C string)
+ *   t  : mrb_value (type/class of the object)
+ *   v,S: mrb_value (converted using to_s or inspect based on '!')
+ *   C  : struct RClass* (class name)
+ *   T  : mrb_value (real type/class of the object)
+ *   Y  : mrb_value (uses 'inspect' if true, false, or nil, otherwise same as 'T')
+ *   %  : Literal '%' character (no argument consumed)
+ *
+ * mrb: The mruby state.
+ * format: The format string.
+ * ap: The va_list of arguments.
+ *
+ * Returns a new mrb_value string containing the formatted output.
+ * Raises ArgumentError if the format string is malformed.
+ */
+MRB_API mrb_value
+mrb_vformat(mrb_state *mrb, const char *format, va_list ap)
+{
+  const char *chars, *p = format, *b = format, *e;
+  char ch;
+  size_t len;
+  mrb_int i;
+  struct RClass *cls;
+  mrb_bool inspect = FALSE;
+  mrb_value result = mrb_str_new_capa(mrb, 128), obj, str;
+  int ai = mrb_gc_arena_save(mrb);
+
+  while (*p) {
+    const char c = *p++;
+    e = p;
+    if (c == '%') {
+      if (*p == '!') {
+        inspect = TRUE;
+        p++;
+      }
+      if (!*p) break;
+      switch (*p) {
+        case 'c':
+          ch = (char)va_arg(ap, int);
+          chars = &ch;
+          len = 1;
+          goto L_cat;
+        case 'd': case 'i':
+#if MRB_INT_MAX < INT_MAX
+          i = (mrb_int)va_arg(ap, int);
+#else
+          i = *p == 'd' ? (mrb_int)va_arg(ap, int) : va_arg(ap, mrb_int);
+#endif
+          obj = mrb_int_value(mrb, i);
+          goto L_cat_obj;
+#ifndef MRB_NO_FLOAT
+        case 'f':
+          obj = mrb_float_value(mrb, (mrb_float)va_arg(ap, double));
+          goto L_cat_obj;
+#endif
+        case 'l':
+          chars = va_arg(ap, char*);
+          len = va_arg(ap, size_t);
+        L_cat:
+          if (inspect) {
+            obj = mrb_str_new(mrb, chars, len);
+            goto L_cat_obj;
+          }
+        L_cat_plain:
+          mrb_str_cat(mrb, result, b,  e - b - 1);
+          mrb_str_cat(mrb, result, chars, len);
+          b = ++p;
+          mrb_gc_arena_restore(mrb, ai);
+          break;
+        case 'n':
+#if UINT32_MAX < INT_MAX
+          obj = mrb_symbol_value((mrb_sym)va_arg(ap, int));
+#else
+          obj = mrb_symbol_value(va_arg(ap, mrb_sym));
+#endif
+          goto L_cat_obj;
+        case 's':
+          chars = va_arg(ap, char*);
+          if (chars == NULL) chars = "(null)";
+          len = strlen(chars);
+          goto L_cat;
+        case 't':
+          cls = mrb_class(mrb, va_arg(ap, mrb_value));
+          goto L_cat_class;
+        case 'v': case 'S':
+          obj = va_arg(ap, mrb_value);
+        L_cat_obj:
+          str = (inspect ? mrb_inspect : mrb_obj_as_string)(mrb, obj);
+          if (mrb_type(str) != MRB_TT_STRING) {
+            chars = "void (no string conversion)";
+            len = strlen(chars);
+          }
+          else {
+            chars = RSTRING_PTR(str);
+            len = RSTRING_LEN(str);
+          }
+          goto L_cat_plain;
+        case 'C':
+          cls = va_arg(ap, struct RClass*);
+        L_cat_class:
+          obj = mrb_obj_value(cls);
+          goto L_cat_obj;
+        case 'T':
+          obj = va_arg(ap, mrb_value);
+        L_cat_real_class_of:
+          cls = mrb_obj_class(mrb, obj);
+          goto L_cat_class;
+        case 'Y':
+          obj = va_arg(ap, mrb_value);
+          if (!mrb_test(obj) || mrb_true_p(obj)) {
+            inspect = TRUE;
+            goto L_cat_obj;
+          }
+          else {
+            goto L_cat_real_class_of;
+          }
+        case '%':
+        L_cat_current:
+          chars = p;
+          len = 1;
+          goto L_cat_plain;
+        default:
+          mrb_raisef(mrb, E_ARGUMENT_ERROR, "malformed format string - %%%c", *p);
+      }
+    }
+    else if (c == '\\') {
+      if (!*p) break;
+      goto L_cat_current;
+
+    }
+  }
+
+  mrb_str_cat(mrb, result, b, p - b);
+  return result;
+}
+
+/*
+ * Formats arguments according to a format string, similar to sprintf.
+ *
+ * This function takes a format string and a variable number of arguments,
+ * then calls mrb_vformat to perform the actual formatting.
+ * See mrb_vformat for details on the format string specifiers.
+ *
+ * mrb: The mruby state.
+ * format: The format string.
+ * ...: Variable arguments to be formatted.
+ *
+ * Returns a new mrb_value string containing the formatted output.
+ */
+MRB_API mrb_value
+mrb_format(mrb_state *mrb, const char *format, ...)
+{
+  va_list ap;
+
+  va_start(ap, format);
+
+  mrb_value str = mrb_vformat(mrb, format, ap);
+  va_end(ap);
+
+  return str;
+}
+
+static mrb_value
+error_va(mrb_state *mrb, struct RClass *c, const char *fmt, va_list ap)
+{
+  return mrb_exc_new_str(mrb, c, mrb_vformat(mrb, fmt, ap));
+}
+
+/*
+ * Creates a new exception of class `c` with a formatted message and raises it.
+ *
+ * This function formats a message string using `fmt` and the subsequent
+ * variable arguments, then creates an exception of class `c` with this
+ * message, and finally raises the exception.
+ * See mrb_vformat for details on the format string specifiers.
+ *
+ * mrb: The mruby state.
+ * c:   The exception class to instantiate.
+ * fmt: The format string for the exception message.
+ * ...: Variable arguments for the format string.
+ */
+MRB_API mrb_noreturn void
+mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+
+  mrb_value exc = error_va(mrb, c, fmt, ap);
+  va_end(ap);
+
+  mrb_exc_raise(mrb, exc);
+}
+
+/*
+ * Raises a NameError exception with a formatted message.
+ *
+ * This function creates a NameError exception. The message is generated
+ * from `fmt` and the variable arguments. The symbol `id` (e.g., the name
+ * of a missing constant or variable) is associated with the exception object
+ * via an instance variable named 'name'.
+ * See mrb_vformat for details on the format string specifiers.
+ *
+ * mrb: The mruby state.
+ * id:  The symbol representing the name that caused the error.
+ * fmt: The format string for the exception message.
+ * ...: Variable arguments for the format string.
+ */
+MRB_API mrb_noreturn void
+mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+
+  mrb_value exc = error_va(mrb, E_NAME_ERROR, fmt, ap);
+  va_end(ap);
+  mrb_iv_set(mrb, exc, MRB_IVSYM(name), mrb_symbol_value(id));
+  mrb_exc_raise(mrb, exc);
+}
+
+/*
+ * Prints a warning message to stderr.
+ *
+ * The message is formatted using `fmt` and the subsequent variable arguments.
+ * The output is prefixed with "warning: " and followed by a newline.
+ * This function does nothing if MRB_NO_STDIO is defined.
+ * See mrb_vformat for details on the format string specifiers.
+ *
+ * mrb: The mruby state.
+ * fmt: The format string for the warning message.
+ * ...: Variable arguments for the format string.
+ */
+MRB_API void
+mrb_warn(mrb_state *mrb, const char *fmt, ...)
+{
+#ifndef MRB_NO_STDIO
+  va_list ap;
+
+  va_start(ap, fmt);
+
+  mrb_value str = mrb_vformat(mrb, fmt, ap);
+  fputs("warning: ", stderr);
+  fwrite(RSTRING_PTR(str), RSTRING_LEN(str), 1, stderr);
+  putc('\n', stderr);
+  va_end(ap);
+#endif
+}
+
+/*
+ * Reports an internal mruby bug, prints a message to stderr, and terminates the program.
+ *
+ * This function is called when an unexpected internal error occurs within mruby.
+ * It prints the given message prefixed with "bug: " to stderr and then
+ * calls exit(EXIT_FAILURE).
+ * If MRB_NO_STDIO is defined, the message is not printed, but the program still exits.
+ *
+ * mrb: The mruby state (currently unused in the function body but part of the API).
+ * mesg: The C string message describing the bug.
+ */
+MRB_API mrb_noreturn void
+mrb_bug(mrb_state *mrb, const char *mesg)
+{
+#ifndef MRB_NO_STDIO
+  fputs("bug: ", stderr);
+  fputs(mesg, stderr);
+  fputs("\n", stderr);
+#endif
+  exit(EXIT_FAILURE);
+}
+
+mrb_value
+mrb_make_exception(mrb_state *mrb, mrb_value exc, mrb_value mesg)
+{
+  mrb_int n = 1;
+
+  if (mrb_nil_p(mesg)) {
+    n = 0;
+  }
+  if (mrb_class_p(exc)) {
+    exc = mrb_funcall_argv(mrb, exc, MRB_SYM(new), n, &mesg);
+  }
+  else if (mrb_exception_p(exc)) {
+    if (n > 0) {
+      exc = mrb_obj_clone(mrb, exc);
+      mrb_exc_mesg_set(mrb, mrb_exc_ptr(exc), mesg);
+    }
+  }
+  else {
+    mrb_raise(mrb, E_TYPE_ERROR, "exception class/object expected");
+  }
+  if (mrb_type(exc) != MRB_TT_EXCEPTION) {
+    mrb_raise(mrb, E_EXCEPTION, "exception object expected");
+  }
+  return exc;
+}
+
+/*
+ * Raises a SystemCallError if available, otherwise a RuntimeError,
+ * based on the current `errno` value.
+ *
+ * If the SystemCallError class is defined, this function attempts to call
+ * its `_sys_fail` method with the current `errno` and an optional
+ * message. This typically results in a SystemCallError being raised.
+ *
+ * If SystemCallError is not defined, or if the call to `_sys_fail`
+ * itself fails (which shouldn't happen in normal circumstances but leads
+ * to mrb_raise), it falls back to raising a RuntimeError with the
+ * given message (or a default message if `mesg` is NULL, though the
+ * current implementation would pass NULL to mrb_raise which might be
+ * an issue).
+ *
+ * mrb: The mruby state.
+ * mesg: An optional C string message to append to the error. If NULL,
+ *       a default message or no message might be used depending on the
+ *       error path.
+ */
+MRB_API mrb_noreturn void
+mrb_sys_fail(mrb_state *mrb, const char *mesg)
+{
+  if (mrb_class_defined_id(mrb, MRB_SYM(SystemCallError))) {
+    struct RClass *sce = mrb_class_get_id(mrb, MRB_SYM(SystemCallError));
+    mrb_int no = (mrb_int)errno;
+    if (mesg != NULL) {
+      mrb_funcall_id(mrb, mrb_obj_value(sce), MRB_SYM(_sys_fail), 2, mrb_fixnum_value(no), mrb_str_new_cstr(mrb, mesg));
+    }
+    else {
+      mrb_funcall_id(mrb, mrb_obj_value(sce), MRB_SYM(_sys_fail), 1, mrb_fixnum_value(no));
+    }
+  }
+
+  mrb_raise(mrb, E_RUNTIME_ERROR, mesg);
+}
+
+/*
+ * Raises a NoMethodError exception with a formatted message.
+ *
+ * This function creates a NoMethodError. The message is generated from
+ * `fmt` and the variable arguments. The symbol `id` (the name of the
+ * missing method) and `args` (the arguments passed to the method)
+ * are associated with the exception object via instance variables
+ * named 'name' and 'args', respectively.
+ * See mrb_vformat for details on the format string specifiers.
+ *
+ * mrb:  The mruby state.
+ * id:   The symbol representing the name of the undefined method.
+ * args: The arguments that were passed to the method call.
+ * fmt:  The format string for the exception message.
+ * ...:  Variable arguments for the format string.
+ */
+MRB_API mrb_noreturn void
+mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, char const* fmt, ...)
+{
+  va_list ap;
+
+  va_start(ap, fmt);
+
+  mrb_value exc = error_va(mrb, E_NOMETHOD_ERROR, fmt, ap);
+  va_end(ap);
+  mrb_iv_set(mrb, exc, MRB_IVSYM(name), mrb_symbol_value(id));
+  mrb_iv_set(mrb, exc, MRB_IVSYM(args), args);
+  mrb_exc_raise(mrb, exc);
+}
+
+static mrb_noreturn void
+frozen_error(mrb_state *mrb, mrb_value v)
+{
+  mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %T", v);
+}
+
+/*
+ * Raises a FrozenError for the given frozen object.
+ *
+ * This function is called when an attempt is made to modify an object
+ * that has been frozen. It constructs and raises a FrozenError,
+ * indicating the specific object that could not be modified.
+ *
+ * mrb:        The mruby state.
+ * frozen_obj: A pointer to the RBasic structure of the frozen object.
+ */
+MRB_API mrb_noreturn void
+mrb_frozen_error(mrb_state *mrb, void *frozen_obj)
+{
+  frozen_error(mrb, mrb_obj_value(frozen_obj));
+}
+
+/*
+ * Checks if the given object is frozen. If it is, raises a FrozenError.
+ *
+ * This utility function is used before attempting an operation that
+ * would modify an object, to ensure that the operation is allowed.
+ *
+ * mrb: The mruby state.
+ * o:   A pointer to the RBasic structure of the object to check.
+ */
+MRB_API void
+mrb_check_frozen(mrb_state *mrb, void *o)
+{
+  if (mrb_frozen_p((struct RBasic*)o)) {
+    mrb_frozen_error(mrb, o);
+  }
+}
+
+/*
+ * Checks if the given mrb_value refers to a frozen object.
+ * If it is frozen, or if it's an immediate value (which are implicitly
+ * unmodifiable in a way that would trigger a FrozenError for heap objects),
+ * this function raises a FrozenError.
+ *
+ * Note: The check `mrb_immediate_p(v)` combined with `frozen_error`
+ * might be misleading. Immediate values are not "frozen" in the same
+ * sense as heap objects. This function effectively raises a FrozenError
+ * if an attempt is made to modify an immediate value or a
+ * heap-allocated object that is explicitly frozen.
+ *
+ * mrb: The mruby state.
+ * v:   The mrb_value to check.
+ */
+MRB_API void
+mrb_check_frozen_value(mrb_state *mrb, mrb_value v)
+{
+  if (mrb_immediate_p(v) || mrb_frozen_p(mrb_basic_ptr(v))) {
+    frozen_error(mrb, v);
+  }
+}
+
+/*
+ * Raises an ArgumentError indicating a mismatch in the number of arguments.
+ *
+ * This function is used to report errors when a method receives an
+ * incorrect number of arguments. It formats a message specifying the
+ * number of arguments received (`argc`) and the expected number,
+ * which can be an exact number (`min` == `max`), a minimum (`max` < 0),
+ * or a range (`min` to `max`).
+ *
+ * mrb: The mruby state.
+ * argc: The number of arguments actually received.
+ * min: The minimum number of arguments expected.
+ * max: The maximum number of arguments expected. If negative, it means
+ *      `min` or more arguments are expected.
+ */
+MRB_API mrb_noreturn void
+mrb_argnum_error(mrb_state *mrb, mrb_int argc, int min, int max)
+{
+#define FMT(exp) "wrong number of arguments (given %i, expected " exp ")"
+  if (min == max)
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d"), argc, min);
+  else if (max < 0)
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d+"), argc, min);
+  else
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, FMT("%d..%d"), argc, min, max);
+#undef FMT
+}
+
+void mrb_core_init_printabort(mrb_state *mrb);
+
+int
+mrb_core_init_protect(mrb_state *mrb, void (*body)(mrb_state*, void*), void *opaque)
+{
+  struct mrb_jmpbuf *prev_jmp = mrb->jmp;
+  struct mrb_jmpbuf c_jmp;
+  volatile int err = 1;
+
+  MRB_TRY(&c_jmp) {
+    mrb->jmp = &c_jmp;
+    body(mrb, opaque);
+    err = 0;
+  } MRB_CATCH(&c_jmp) {
+    /* Leave mrb->exc set for caller to inspect */
+  } MRB_END_EXC(&c_jmp);
+
+  mrb->jmp = prev_jmp;
+
+  return err;
+}
+
+mrb_noreturn void
+mrb_core_init_abort(mrb_state *mrb)
+{
+  mrb->exc = NULL;
+  exc_throw(mrb, mrb_nil_value());
+}
+
+void
+mrb_protect_atexit(mrb_state *mrb)
+{
+  if (mrb->atexit_stack_len > 0) {
+    if (mrb->c && mrb->c->ci) {
+      // Even if the call stack is incomplete due to some fault, atexit to be executed at the top level is desirable.
+      // Clean-up also makes it easier to collect unnecessary objects.
+      mrb_callinfo zero = { 0 };
+      struct mrb_context *c = mrb->c = mrb->root_c;
+      mrb_gc_arena_restore(mrb, 0);
+
+      if (c->ci == c->cibase) {
+        // Since there is no problem with the ci, the env object is detached normally.
+        struct REnv *e = mrb_vm_ci_env(c->ci);
+        *c->ci = zero;
+        c->ci->stack = c->stbase;
+        if (e) {
+          c->ci->u.env = NULL;
+          mrb_env_unshare(mrb, e, TRUE);
+        }
+      }
+      else {
+        // Any env objects on the ci that are in the process of being executed are destroyed.
+        do {
+          struct REnv *e = mrb_vm_ci_env(c->ci);
+          if (e) {
+            e->stack = NULL;
+            MRB_ENV_SET_LEN(e, 0);
+            MRB_ENV_SET_BIDX(e, 0);
+            MRB_ENV_CLOSE(e);
+          }
+        } while (c->ci-- > c->cibase);
+        c->ci = c->cibase;
+        *c->ci = zero;
+        c->ci->stack = c->stbase;
+      }
+    }
+
+    struct mrb_jmpbuf *prev_jmp = mrb->jmp;
+    struct mrb_jmpbuf c_jmp;
+    int i = mrb->atexit_stack_len;
+    while (i > 0) {
+      MRB_TRY(&c_jmp) {
+        mrb->jmp = &c_jmp;
+        do {
+          mrb->atexit_stack[--i](mrb);
+          mrb_gc_arena_restore(mrb, 0);
+        } while (i > 0);
+        mrb->jmp = prev_jmp;
+      } MRB_CATCH(&c_jmp) {
+        mrb->jmp = prev_jmp;
+        /* ignore atexit errors */
+        mrb_gc_arena_restore(mrb, 0);
+      } MRB_END_EXC(&c_jmp);
+    }
+#ifndef MRB_FIXED_STATE_ATEXIT_STACK
+    mrb_free(mrb, mrb->atexit_stack);
+#endif
+  }
+}
+
+mrb_noreturn void
+mrb_raise_nomemory(mrb_state *mrb)
+{
+  if (mrb->nomem_err) {
+    mrb_exc_raise(mrb, mrb_obj_value(mrb->nomem_err));
+  }
+  else {
+    mrb_core_init_abort(mrb);
+  }
+}
+
+/*
+ * Prints the current exception and its backtrace to stderr.
+ *
+ * If an exception is set in the mruby state (`mrb->exc`), this function
+ * attempts to print its details, including the class name, message,
+ * and backtrace.
+ * It takes precautions to handle potential errors during the backtrace
+ * printing itself, especially if called from a context without an active
+ * jump buffer (e.g., top-level error).
+ * This function does nothing if MRB_NO_STDIO is defined.
+ *
+ * mrb: The mruby state.
+ */
+MRB_API void
+mrb_print_error(mrb_state *mrb)
+{
+#ifndef MRB_NO_STDIO
+  if (!mrb) {
+    /* mrb_open() returned NULL - allocation failed */
+    fputs("Failed to allocate mrb_state\n", stderr);
+    return;
+  }
+  if (mrb->jmp == NULL) {
+    struct mrb_jmpbuf c_jmp;
+    MRB_TRY(&c_jmp) {
+      mrb->jmp = &c_jmp;
+      mrb_print_backtrace(mrb);
+    } MRB_CATCH(&c_jmp) {
+      /* ignore exception during print_backtrace() */
+    } MRB_END_EXC(&c_jmp);
+    mrb->jmp = NULL;
+  }
+  else {
+    mrb_print_backtrace(mrb);
+  }
+#endif
+}
+
+/*
+ * Clears the current exception status in the mruby state.
+ *
+ * After this function is called, `mrb->exc` will be NULL, indicating
+ * that there is no pending exception.
+ *
+ * mrb: The mruby state.
+ */
+MRB_API void
+mrb_clear_error(mrb_state *mrb)
+{
+  mrb->exc = NULL;
+}
+
+/* returns TRUE if error in the previous call; internally calls mrb_clear_error() */
+MRB_API mrb_bool
+mrb_check_error(mrb_state *mrb)
+{
+  if (mrb->exc) {
+    mrb_clear_error(mrb);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+/* ---------------------------*/
+static const mrb_mt_entry exception_rom_entries[] = {
+  MRB_MT_ENTRY(exc_exception,     MRB_SYM(exception), MRB_ARGS_OPT(1)),
+  MRB_MT_ENTRY(exc_initialize, MRB_SYM(initialize),    MRB_ARGS_OPT(1) | MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(exc_to_s,          MRB_SYM(to_s),        MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(exc_to_s,          MRB_SYM(message),     MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(mrb_exc_inspect,   MRB_SYM(inspect),     MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(mrb_exc_backtrace, MRB_SYM(backtrace),   MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(exc_set_backtrace, MRB_SYM(set_backtrace), MRB_ARGS_REQ(1)),
+};
+
+void
+mrb_init_exception(mrb_state *mrb)
+{
+  struct RClass *exception = mrb->eException_class = mrb_define_class_id(mrb, MRB_SYM(Exception), mrb->object_class); /* 15.2.22 */
+  MRB_SET_INSTANCE_TT(exception, MRB_TT_EXCEPTION);
+  mrb_define_class_method_id(mrb, exception, MRB_SYM(exception), mrb_instance_new,  MRB_ARGS_OPT(1));
+  MRB_MT_INIT_ROM(mrb, exception, exception_rom_entries);
+
+  mrb->eStandardError_class = mrb_define_class_id(mrb, MRB_SYM(StandardError), mrb->eException_class); /* 15.2.23 */
+  mrb_define_class_id(mrb, MRB_SYM(ArgumentError), E_STANDARD_ERROR);                                  /* 15.2.24 */
+  mrb_define_class_id(mrb, MRB_SYM(LocalJumpError), E_STANDARD_ERROR);                                 /* 15.2.25 */
+  struct RClass *range_error = mrb_define_class_id(mrb, MRB_SYM(RangeError), E_STANDARD_ERROR);        /* 15.2.26 */
+  mrb_define_class_id(mrb, MRB_SYM(FloatDomainError), range_error);
+  mrb_define_class_id(mrb, MRB_SYM(RegexpError), E_STANDARD_ERROR);                                    /* 15.2.27 */
+  struct RClass *runtime_error = mrb_define_class_id(mrb, MRB_SYM(RuntimeError), E_STANDARD_ERROR);    /* 15.2.28 */
+  mrb_define_class_id(mrb, MRB_SYM(FrozenError), runtime_error);
+  mrb_define_class_id(mrb, MRB_SYM(TypeError), E_STANDARD_ERROR);                                      /* 15.2.29 */
+  mrb_define_class_id(mrb, MRB_SYM(ZeroDivisionError), E_STANDARD_ERROR);                              /* 15.2.30 */
+  struct RClass *script_error = mrb_define_class_id(mrb, MRB_SYM(ScriptError), exception);             /* 15.2.37 */
+  mrb_define_class_id(mrb, MRB_SYM(NotImplementedError), script_error);
+  mrb_define_class_id(mrb, MRB_SYM(SyntaxError), script_error);                                        /* 15.2.38 */
+  struct RClass *index_error = mrb_define_class_id(mrb, MRB_SYM(IndexError), E_STANDARD_ERROR);        /* 15.2.33 */
+  mrb_define_class_id(mrb, MRB_SYM(KeyError), index_error);
+  mrb_define_class_id(mrb, MRB_SYM(NoMatchingPatternError), E_STANDARD_ERROR);                         /* pattern matching */
+  struct RClass *stack_error = mrb_define_class_id(mrb, MRB_SYM(SystemStackError), exception);
+  mrb->stack_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, stack_error, "stack level too deep"));
+
+  struct RClass *nomem_error = mrb_define_class_id(mrb, MRB_SYM(NoMemoryError), exception);
+  mrb->nomem_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "Out of memory"));
+#ifdef MRB_GC_FIXED_ARENA
+  mrb->arena_err = mrb_obj_ptr(mrb_exc_new_lit(mrb, nomem_error, "arena overflow error"));
+#endif
+}