eval.c (c5994c60fd331f366f34d4b547284153f4ab8b97)

/**********************************************************************
 
  eval.c -
 
  $Author$
  created at: Thu Jun 10 14:22:17 JST 1993
 
  Copyright (C) 1993-2007 Yukihiro Matsumoto
  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
  Copyright (C) 2000  Information-technology Promotion Agency, Japan
 
**********************************************************************/
 
#include "ruby/internal/config.h"
 
#ifdef HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#endif
 
#include "eval_intern.h"
#include "internal.h"
#include "internal/class.h"
#include "internal/jit.h"
#include "internal/error.h"
#include "internal/eval.h"
#include "internal/gc.h"
#include "internal/hash.h"
#include "internal/inits.h"
#include "internal/io.h"
#include "internal/object.h"
#include "internal/thread.h"
#include "internal/variable.h"
#include "internal/vm.h"
#include "ruby/fiber/scheduler.h"
#include "iseq.h"
#include "probes.h"
#include "probes_helper.h"
#include "ruby/vm.h"
#include "vm_core.h"
#include "ractor_core.h"
#include "zjit.h"
 
NORETURN(static void rb_raise_jump(VALUE, VALUE));
void rb_ec_clear_current_thread_trace_func(const rb_execution_context_t *ec);
void rb_ec_clear_all_trace_func(const rb_execution_context_t *ec);
 
static int rb_ec_cleanup(rb_execution_context_t *ec, enum ruby_tag_type ex);
static int rb_ec_exec_node(rb_execution_context_t *ec, void *n);
 
VALUE rb_eLocalJumpError;
VALUE rb_eSysStackError;
 
ID ruby_static_id_signo, ruby_static_id_status;
extern ID ruby_static_id_cause;
#define id_cause ruby_static_id_cause
 
#define exception_error GET_VM()->special_exceptions[ruby_error_reenter]
 
#include "eval_error.c"
#include "eval_jump.c"
 
#define CLASS_OR_MODULE_P(obj) \
    (!SPECIAL_CONST_P(obj) && \
     (BUILTIN_TYPE(obj) == T_CLASS || BUILTIN_TYPE(obj) == T_MODULE))
 
int
ruby_setup(void)
{
    enum ruby_tag_type state;
 
    if (GET_VM())
        return 0;
 
    /*
     * Disable THP early before mallocs happen because we want this to
     * affect as many future pages as possible for CoW-friendliness
     */
#if defined(__linux__) && defined(PR_SET_THP_DISABLE)
    prctl(PR_SET_THP_DISABLE, 1, 0, 0, 0);
#endif
#if defined(_WIN32)
    rb_w32_init_long_paths();
#endif
    Init_BareVM();
    Init_default_shapes();
    rb_vm_encoded_insn_data_table_init();
    Init_enable_box();
    Init_vm_objects();
    Init_master_box();
    Init_fstring_table();
 
    EC_PUSH_TAG(GET_EC());
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        rb_call_inits();
        ruby_prog_init();
        GET_VM()->running = 1;
    }
    EC_POP_TAG();
 
    return state;
}
 
void
ruby_init(void)
{
    int state = ruby_setup();
    if (state) {
        if (RTEST(ruby_debug)) {
            rb_execution_context_t *ec = GET_EC();
            rb_ec_error_print(ec, ec->errinfo);
        }
        exit(EXIT_FAILURE);
    }
}
 
void *
ruby_options(int argc, char **argv)
{
    rb_execution_context_t *ec = GET_EC();
    enum ruby_tag_type state;
    void *volatile iseq = 0;
 
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        iseq = ruby_process_options(argc, argv);
    }
    else {
        rb_ec_clear_current_thread_trace_func(ec);
        int exitcode = error_handle(ec, ec->errinfo, state);
        ec->errinfo = Qnil; /* just been handled */
        iseq = (void *)INT2FIX(exitcode);
    }
    EC_POP_TAG();
    return iseq;
}
 
static void
rb_ec_fiber_scheduler_finalize(rb_execution_context_t *ec)
{
    enum ruby_tag_type state;
 
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        rb_fiber_scheduler_set(Qnil);
    }
    else {
        state = error_handle(ec, ec->errinfo, state);
    }
    EC_POP_TAG();
}
 
static void
rb_ec_teardown(rb_execution_context_t *ec)
{
    enum ruby_tag_type state = TAG_NONE;
    volatile VALUE trap_errinfo = Qnil;
 
    // If the user code defined a scheduler for the top level thread, run it:
    rb_ec_fiber_scheduler_finalize(ec);
 
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        rb_vm_trap_exit(rb_ec_vm_ptr(ec));
    }
    else {
        trap_errinfo = ec->errinfo;
        ec->errinfo = Qnil;
    }
    EC_POP_TAG();
    rb_ec_exec_end_proc(ec);
    if (!NIL_P(trap_errinfo)) {
        error_handle(ec, trap_errinfo, state);
        ec->errinfo = trap_errinfo;
    }
    rb_ec_clear_all_trace_func(ec);
}
 
static void
rb_ec_finalize(rb_execution_context_t *ec)
{
    ruby_sig_finalize();
    ec->errinfo = Qnil;
    rb_objspace_call_finalizer();
}
 
void
ruby_finalize(void)
{
    rb_execution_context_t *ec = GET_EC();
    rb_ec_teardown(ec);
    rb_ec_finalize(ec);
}
 
int
ruby_cleanup(int ex)
{
    return rb_ec_cleanup(GET_EC(), (enum ruby_tag_type)ex);
}
 
static int
rb_ec_cleanup(rb_execution_context_t *ec, enum ruby_tag_type ex)
{
    int state;
    volatile VALUE save_error = Qundef;
    volatile int sysex = EXIT_SUCCESS;
    volatile int signaled = 0;
    rb_thread_t *th = rb_ec_thread_ptr(ec);
    rb_thread_t *const volatile th0 = th;
    volatile int step = 0;
    volatile VALUE message = Qnil;
    VALUE buf;
 
    rb_threadptr_interrupt(th);
    rb_threadptr_check_signal(th);
 
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        RUBY_VM_CHECK_INTS(ec);
 
      step_0: step++;
        save_error = ec->errinfo;
        if (THROW_DATA_P(ec->errinfo)) ec->errinfo = Qnil;
 
        /* exits with failure but silently when an exception raised
         * here */
        rb_ec_teardown(ec);
 
      step_1: step++;
        VALUE err = ec->errinfo;
        volatile int mode0 = 0, mode1 = 0;
        if (err != save_error && !NIL_P(err)) {
            mode0 = exiting_split(err, &sysex, &signaled);
        }
 
        /* exceptions after here will be ignored */
 
        /* build error message including causes */
        err = ATOMIC_VALUE_EXCHANGE(save_error, Qnil);
 
        if (!NIL_P(err) && !THROW_DATA_P(err)) {
            mode1 = exiting_split(err, (mode0 & EXITING_WITH_STATUS) ? NULL : &sysex, &signaled);
            if (mode1 & EXITING_WITH_MESSAGE) {
                buf = rb_str_new(NULL, 0);
                rb_ec_error_print_detailed(ec, err, buf, Qundef);
                message = buf;
            }
        }
 
      step_2: step++;
        /* protect from Thread#raise */
        th->status = THREAD_KILLED;
 
        rb_ractor_terminate_all();
 
      step_3: step++;
        if (!NIL_P(buf = message)) {
            warn_print_str(buf);
        }
        else if (!NIL_OR_UNDEF_P(err = save_error) ||
                 (ex != TAG_NONE && !((mode0|mode1) & EXITING_WITH_STATUS))) {
            sysex = error_handle(ec, err, ex);
        }
    }
    else {
        th = th0;
        switch (step) {
          case 0: goto step_0;
          case 1: goto step_1;
          case 2: goto step_2;
          case 3: goto step_3;
        }
    }
 
    rb_ec_finalize(ec);
 
    /* unlock again if finalizer took mutexes. */
    rb_threadptr_unlock_all_locking_mutexes(th);
    th = th0;
    EC_POP_TAG();
    th = th0;
    rb_thread_stop_timer_thread();
    ruby_vm_destruct(th->vm);
    // For YJIT, call this after ruby_vm_destruct() frees jit_cont for the root fiber.
    rb_jit_cont_finish();
 
    if (signaled) ruby_default_signal(signaled);
 
    return sysex;
}
 
static int
rb_ec_exec_node(rb_execution_context_t *ec, void *n)
{
    volatile int state;
    rb_iseq_t *iseq = (rb_iseq_t *)n;
    if (!n) return 0;
 
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        rb_iseq_eval_main(iseq);
    }
    EC_POP_TAG();
    return state;
}
 
void
ruby_stop(int ex)
{
    exit(ruby_cleanup(ex));
}
 
int
ruby_executable_node(void *n, int *status)
{
    VALUE v = (VALUE)n;
    int s;
 
    switch (v) {
      case Qtrue:  s = EXIT_SUCCESS; break;
      case Qfalse: s = EXIT_FAILURE; break;
      default:
        if (!FIXNUM_P(v)) return TRUE;
        s = FIX2INT(v);
    }
    if (status) *status = s;
    return FALSE;
}
 
int
ruby_run_node(void *n)
{
    rb_execution_context_t *ec = GET_EC();
    int status;
    if (!ruby_executable_node(n, &status)) {
        rb_ec_cleanup(ec, (NIL_P(ec->errinfo) ? TAG_NONE : TAG_RAISE));
        return status;
    }
    return rb_ec_cleanup(ec, rb_ec_exec_node(ec, n));
}
 
int
ruby_exec_node(void *n)
{
    return rb_ec_exec_node(GET_EC(), n);
}
 
/*
 *  call-seq:
 *     Module.nesting -> array
 *
 *  Returns nested module as an array of Module objects:
 *
 *    module M0
 *      def self.speak = Module.nesting
 *      module M1
 *        def self.speak = Module.nesting
 *        module M2
 *          def self.speak = Module.nesting
 *        end
 *      end
 *    end
 *    M0.speak             # => [M0]
 *    M0.speak.first.class # => Module
 *    M0::M1.speak         # => [M0::M1, M0]
 *    M0::M1::M2.speak     # => [M0::M1::M2, M0::M1, M0]
 *
 */
 
static VALUE
rb_mod_nesting(VALUE _)
{
    VALUE ary = rb_ary_new();
    const rb_cref_t *cref = rb_vm_cref();
 
    while (cref && CREF_NEXT(cref)) {
        VALUE klass = CREF_CLASS(cref);
        if (!CREF_PUSHED_BY_EVAL(cref) &&
            !NIL_P(klass)) {
            rb_ary_push(ary, klass);
        }
        cref = CREF_NEXT(cref);
    }
    return ary;
}
 
/*
 *  call-seq:
 *     Module.constants   -> array
 *     Module.constants(inherited)   -> array
 *
 *  In the first form, returns an array of the names of all
 *  constants accessible from the point of call.
 *  This list includes the names of all modules and classes
 *  defined in the global scope.
 *
 *     Module.constants.first(4)
 *        # => [:ARGF, :ARGV, :ArgumentError, :Array]
 *
 *     Module.constants.include?(:SEEK_SET)   # => false
 *
 *     class IO
 *       Module.constants.include?(:SEEK_SET) # => true
 *     end
 *
 *  The second form calls the instance method +constants+.
 */
 
static VALUE
rb_mod_s_constants(int argc, VALUE *argv, VALUE mod)
{
    const rb_cref_t *cref = rb_vm_cref();
    VALUE klass;
    VALUE cbase = 0;
    void *data = 0;
 
    if (argc > 0 || mod != rb_cModule) {
        return rb_mod_constants(argc, argv, mod);
    }
 
    while (cref) {
        klass = CREF_CLASS(cref);
        if (!CREF_PUSHED_BY_EVAL(cref) &&
            !NIL_P(klass)) {
            data = rb_mod_const_at(CREF_CLASS(cref), data);
            if (!cbase) {
                cbase = klass;
            }
        }
        cref = CREF_NEXT(cref);
    }
 
    if (cbase) {
        data = rb_mod_const_of(cbase, data);
    }
    return rb_const_list(data);
}
 
void
rb_class_modify_check(VALUE klass)
{
    if (SPECIAL_CONST_P(klass)) {
        Check_Type(klass, T_CLASS);
    }
    if (RB_TYPE_P(klass, T_MODULE)) {
        // TODO: shouldn't this only happen in a few places?
        rb_class_set_initialized(klass);
    }
    if (OBJ_FROZEN(klass)) {
        if (RCLASS_SINGLETON_P(klass)) {
            klass = RCLASS_ATTACHED_OBJECT(klass);
        }
        rb_error_frozen_object(klass);
    }
    rb_class_owner_check(klass);
}
 
NORETURN(static void rb_longjmp(rb_execution_context_t *, enum ruby_tag_type, volatile VALUE, VALUE));
static VALUE get_errinfo(void);
#define get_ec_errinfo(ec) rb_ec_get_errinfo(ec)
 
static VALUE
exc_setup_cause(VALUE exc, VALUE cause)
{
#if OPT_SUPPORT_JOKE
    if (NIL_P(cause)) {
        ID id_true_cause;
        CONST_ID(id_true_cause, "true_cause");
 
        cause = rb_attr_get(rb_eFatal, id_true_cause);
        if (NIL_P(cause)) {
            cause = rb_exc_new_cstr(rb_eFatal, "because using such Ruby");
            rb_ivar_set(cause, id_cause, INT2FIX(42)); /* the answer */
            OBJ_FREEZE(cause);
            rb_ivar_set(rb_eFatal, id_true_cause, cause);
        }
    }
#endif
    if (!NIL_P(cause) && cause != exc) {
        rb_ivar_set(exc, id_cause, cause);
        if (!rb_ivar_defined(cause, id_cause)) {
            rb_ivar_set(cause, id_cause, Qnil);
        }
    }
    return exc;
}
 
static inline VALUE
exc_setup_message(const rb_execution_context_t *ec, VALUE mesg, VALUE *cause)
{
    int nocause = 0;
    int nocircular = 0;
 
    if (NIL_P(mesg)) {
        mesg = ec->errinfo;
        if (INTERNAL_EXCEPTION_P(mesg)) EC_JUMP_TAG(ec, TAG_FATAL);
        nocause = 1;
    }
    if (NIL_P(mesg)) {
        mesg = rb_exc_new(rb_eRuntimeError, 0, 0);
        nocause = 0;
        nocircular = 1;
    }
    if (UNDEF_P(*cause)) {
        if (nocause) {
            *cause = Qnil;
            nocircular = 1;
        }
        else if (!rb_ivar_defined(mesg, id_cause)) {
            *cause = get_ec_errinfo(ec);
        }
        else {
            nocircular = 1;
        }
    }
    else if (!NIL_P(*cause) && !rb_obj_is_kind_of(*cause, rb_eException)) {
        rb_raise(rb_eTypeError, "exception object expected");
    }
 
    if (!nocircular && !NIL_P(*cause) && !UNDEF_P(*cause) && *cause != mesg) {
#if 0 /* maybe critical for some cases */
        rb_exc_check_circular_cause(*cause);
#else
        VALUE c = *cause;
        while (!NIL_P(c)) {
            if (c == mesg) {
                rb_raise(rb_eArgError, "circular causes");
            }
            if (THROW_DATA_P(c)) {
                break;
            }
            c = rb_attr_get(c, id_cause);
        }
#endif
    }
    return mesg;
}
 
static void
setup_exception(rb_execution_context_t *ec, enum ruby_tag_type tag, volatile VALUE mesg, VALUE cause)
{
    VALUE e;
    int line;
    const char *file = rb_source_location_cstr(&line);
    const char *const volatile file0 = file;
 
    if ((file && !NIL_P(mesg)) || !UNDEF_P(cause))  {
        volatile int state = 0;
 
        EC_PUSH_TAG(ec);
        if (EC_EXEC_TAG() == TAG_NONE && !(state = rb_ec_set_raised(ec))) {
            VALUE bt = rb_get_backtrace(mesg);
            if (!NIL_P(bt) || UNDEF_P(cause)) {
                if (OBJ_FROZEN(mesg)) {
                    mesg = rb_obj_dup(mesg);
                }
            }
            if (!UNDEF_P(cause) && !THROW_DATA_P(cause)) {
                exc_setup_cause(mesg, cause);
            }
            if (NIL_P(bt)) {
                VALUE at = rb_ec_backtrace_object(ec);
                rb_ivar_set(mesg, idBt_locations, at);
                set_backtrace(mesg, at);
            }
            rb_ec_reset_raised(ec);
        }
        EC_POP_TAG();
        file = file0;
        if (state) goto fatal;
    }
 
    if (!NIL_P(mesg)) {
        ec->errinfo = mesg;
    }
 
    if (RTEST(ruby_debug) && !NIL_P(e = ec->errinfo) &&
        !rb_obj_is_kind_of(e, rb_eSystemExit)) {
        enum ruby_tag_type state;
 
        mesg = e;
        EC_PUSH_TAG(ec);
        if ((state = EC_EXEC_TAG()) == TAG_NONE) {
            ec->errinfo = Qnil;
            e = rb_obj_as_string(mesg);
            ec->errinfo = mesg;
            if (file && line) {
                e = rb_sprintf("Exception '%"PRIsVALUE"' at %s:%d - %"PRIsVALUE"\n",
                               rb_obj_class(mesg), file, line, e);
            }
            else if (file) {
                e = rb_sprintf("Exception '%"PRIsVALUE"' at %s - %"PRIsVALUE"\n",
                               rb_obj_class(mesg), file, e);
            }
            else {
                e = rb_sprintf("Exception '%"PRIsVALUE"' - %"PRIsVALUE"\n",
                               rb_obj_class(mesg), e);
            }
            warn_print_str(e);
        }
        EC_POP_TAG();
        if (state == TAG_FATAL && ec->errinfo == exception_error) {
            ec->errinfo = mesg;
        }
        else if (state) {
            rb_ec_reset_raised(ec);
            EC_JUMP_TAG(ec, state);
        }
    }
 
    if (rb_ec_set_raised(ec)) {
        goto fatal;
    }
 
    if (tag != TAG_FATAL) {
        RUBY_DTRACE_HOOK(RAISE, rb_obj_classname(ec->errinfo));
        EXEC_EVENT_HOOK(ec, RUBY_EVENT_RAISE, ec->cfp->self, 0, 0, 0, mesg);
    }
    return;
 
  fatal:
    ec->errinfo = exception_error;
    rb_ec_reset_raised(ec);
    EC_JUMP_TAG(ec, TAG_FATAL);
}
 
void
rb_ec_setup_exception(const rb_execution_context_t *ec, VALUE mesg, VALUE cause)
{
    if (UNDEF_P(cause)) {
        cause = get_ec_errinfo(ec);
    }
    if (cause != mesg) {
        if (THROW_DATA_P(cause)) {
            cause = Qnil;
        }
 
        rb_ivar_set(mesg, id_cause, cause);
    }
}
 
static void
rb_longjmp(rb_execution_context_t *ec, enum ruby_tag_type tag, volatile VALUE mesg, VALUE cause)
{
    mesg = exc_setup_message(ec, mesg, &cause);
    setup_exception(ec, tag, mesg, cause);
    rb_ec_raised_clear(ec);
    EC_JUMP_TAG(ec, tag);
}
 
static VALUE make_exception(int argc, const VALUE *argv, int isstr);
 
NORETURN(static void rb_exc_exception(VALUE mesg, enum ruby_tag_type tag, VALUE cause));
 
static void
rb_exc_exception(VALUE mesg, enum ruby_tag_type tag, VALUE cause)
{
    if (!NIL_P(mesg)) {
        mesg = make_exception(1, &mesg, FALSE);
    }
    rb_longjmp(GET_EC(), tag, mesg, cause);
}
 
void
rb_exc_raise(VALUE mesg)
{
    rb_exc_exception(mesg, TAG_RAISE, Qundef);
}
 
void
rb_exc_fatal(VALUE mesg)
{
    rb_exc_exception(mesg, TAG_FATAL, Qnil);
}
 
void
rb_interrupt(void)
{
    rb_exc_raise(rb_exc_new(rb_eInterrupt, 0, 0));
}
 
static int
extract_raise_options(int argc, VALUE *argv, VALUE *cause)
{
    // Keyword arguments:
    static ID keywords[1] = {0};
    if (!keywords[0]) {
        CONST_ID(keywords[0], "cause");
    }
 
    if (argc > 0) {
        VALUE options;
        argc = rb_scan_args(argc, argv, "*:", NULL, &options);
 
        if (!NIL_P(options)) {
            if (!RHASH_EMPTY_P(options)) {
                // Extract optional cause keyword argument, leaving any other options alone:
                rb_get_kwargs(options, keywords, 0, -2, cause);
 
                // If there were any other options, add them back to the arguments:
                if (!RHASH_EMPTY_P(options)) argv[argc++] = options;
            }
        }
    }
 
    return argc;
}
 
VALUE
rb_exception_setup(int argc, VALUE *argv)
{
    rb_execution_context_t *ec = GET_EC();
 
    // Extract cause keyword argument:
    VALUE cause = Qundef;
    argc = extract_raise_options(argc, argv, &cause);
 
    // Validate cause-only case:
    if (argc == 0 && !UNDEF_P(cause)) {
        rb_raise(rb_eArgError, "only cause is given with no arguments");
    }
 
    // Create exception:
    VALUE exception;
    if (argc == 0) {
        exception = rb_exc_new(rb_eRuntimeError, 0, 0);
    }
    else {
        exception = rb_make_exception(argc, argv);
    }
 
    VALUE resolved_cause = Qnil;
 
    // Resolve cause with validation:
    if (UNDEF_P(cause)) {
        // No explicit cause - use automatic cause chaining from calling context:
        resolved_cause = rb_ec_get_errinfo(ec);
 
        // Prevent self-referential cause (e.g. `raise $!`):
        if (resolved_cause == exception) {
            resolved_cause = Qnil;
        }
    }
    else if (NIL_P(cause)) {
        // Explicit nil cause - prevent chaining:
        resolved_cause = Qnil;
    }
    else {
        // Explicit cause - validate and assign:
        if (!rb_obj_is_kind_of(cause, rb_eException)) {
            rb_raise(rb_eTypeError, "exception object expected");
        }
 
        if (cause == exception) {
            // Prevent self-referential cause (e.g. `raise error, cause: error`) - although I'm not sure this is good behaviour, it's inherited from `Kernel#raise`.
            resolved_cause = Qnil;
        }
        else {
            // Check for circular causes:
            VALUE current_cause = cause;
            while (!NIL_P(current_cause)) {
                // We guarantee that the cause chain is always terminated. Then, creating an exception with an existing cause is not circular as long as exception is not an existing cause of any other exception.
                if (current_cause == exception) {
                    rb_raise(rb_eArgError, "circular causes");
                }
                if (THROW_DATA_P(current_cause)) {
                    break;
                }
                current_cause = rb_attr_get(current_cause, id_cause);
            }
            resolved_cause = cause;
        }
    }
 
    // Apply cause to exception object (duplicate if frozen):
    if (!UNDEF_P(resolved_cause)) {
        if (OBJ_FROZEN(exception)) {
            exception = rb_obj_dup(exception);
        }
        rb_ivar_set(exception, id_cause, resolved_cause);
    }
 
    return exception;
}
 
VALUE
rb_f_raise(int argc, VALUE *argv)
{
    VALUE cause = Qundef;
    argc = extract_raise_options(argc, argv, &cause);
 
    VALUE exception;
 
    // Bare re-raise case:
    if (argc == 0) {
        // Cause was extracted, but no arguments were provided:
        if (!UNDEF_P(cause)) {
            rb_raise(rb_eArgError, "only cause is given with no arguments");
        }
 
        // Otherwise, re-raise the current exception:
        exception = get_errinfo();
        if (!NIL_P(exception)) {
            argc = 1;
            argv = &exception;
        }
    }
 
    rb_raise_jump(rb_make_exception(argc, argv), cause);
 
    UNREACHABLE_RETURN(Qnil);
}
 
/*
 *  call-seq:
 *    raise(exception, message = exception.to_s, backtrace = nil, cause: $!)
 *    raise(message = nil, cause: $!)
 *
 *  Raises an exception;
 *  see {Exceptions}[rdoc-ref:exceptions.md].
 *
 *  Argument +exception+ sets the class of the new exception;
 *  it should be class Exception or one of its subclasses
 *  (most commonly, RuntimeError or StandardError),
 *  or an instance of one of those classes:
 *
 *    begin
 *      raise(StandardError)
 *    rescue => x
 *      p x.class
 *    end
 *    # => StandardError
 *
 *  Argument +message+ sets the stored message in the new exception,
 *  which may be retrieved by method Exception#message;
 *  the message must be
 *  a {string-convertible object}[rdoc-ref:implicit_conversion.rdoc@String-Convertible+Objects]
 *  or +nil+:
 *
 *    begin
 *      raise(StandardError, 'Boom')
 *    rescue => x
 *      p x.message
 *    end
 *    # => "Boom"
 *
 *  If argument +message+ is not given,
 *  the message is the exception class name.
 *
 *  See {Messages}[rdoc-ref:exceptions.md@Messages].
 *
 *  Argument +backtrace+ might be used to modify the backtrace of the new exception,
 *  as reported by Exception#backtrace and Exception#backtrace_locations;
 *  the backtrace must be an array of Thread::Backtrace::Location, an array of
 *  strings, a single string, or +nil+.
 *
 *  Using the array of Thread::Backtrace::Location instances is the most consistent option
 *  and should be preferred when possible. The necessary value might be obtained
 *  from #caller_locations, or copied from Exception#backtrace_locations of another
 *  error:
 *
 *    begin
 *      do_some_work()
 *    rescue ZeroDivisionError => ex
 *      raise(LogicalError, "You have an error in your math", ex.backtrace_locations)
 *    end
 *
 *  The ways, both Exception#backtrace and Exception#backtrace_locations of the
 *  raised error are set to the same backtrace.
 *
 *  When the desired stack of locations is not available and should
 *  be constructed from scratch, an array of strings or a singular
 *  string can be used. In this case, only Exception#backtrace is set:
 *
 *    begin
 *      raise(StandardError, 'Boom', %w[dsl.rb:3 framework.rb:1])
 *    rescue => ex
 *      p ex.backtrace
 *      # => ["dsl.rb:3", "framework.rb:1"]
 *      p ex.backtrace_locations
 *      # => nil
 *    end
 *
 *  If argument +backtrace+ is not given,
 *  the backtrace is set according to an array of Thread::Backtrace::Location objects,
 *  as derived from the call stack.
 *
 *  See {Backtraces}[rdoc-ref:exceptions.md@Backtraces].
 *
 *  Keyword argument +cause+ sets the stored cause in the new exception,
 *  which may be retrieved by method Exception#cause;
 *  the cause must be an exception object (Exception or one of its subclasses),
 *  or +nil+:
 *
 *    begin
 *      raise(StandardError, cause: RuntimeError.new)
 *    rescue => x
 *      p x.cause
 *    end
 *    # => #<RuntimeError: RuntimeError>
 *
 *  If keyword argument +cause+ is not given,
 *  the cause is the value of <tt>$!</tt>.
 *
 *  See {Cause}[rdoc-ref:exceptions.md@Cause].
 *
 *  In the alternate calling sequence,
 *  where argument +exception+ _not_ given,
 *  raises a new exception of the class given by <tt>$!</tt>,
 *  or of class RuntimeError if <tt>$!</tt> is +nil+:
 *
 *    begin
 *      raise
 *    rescue => x
 *      p x
 *    end
 *    # => RuntimeError
 *
 *  With argument +exception+ not given,
 *  argument +message+ and keyword argument +cause+ may be given,
 *  but argument +backtrace+ may not be given.
 *
 *  +cause+ can not be given as an only argument.
 *
 */
 
static VALUE
f_raise(int c, VALUE *v, VALUE _)
{
    return rb_f_raise(c, v);
}
 
static VALUE
make_exception(int argc, const VALUE *argv, int isstr)
{
    VALUE mesg, exc;
 
    mesg = Qnil;
    switch (argc) {
      case 0:
        return Qnil;
      case 1:
        exc = argv[0];
        if (isstr &&! NIL_P(exc)) {
            mesg = rb_check_string_type(exc);
            if (!NIL_P(mesg)) {
                return rb_exc_new3(rb_eRuntimeError, mesg);
            }
        }
 
      case 2:
      case 3:
        break;
      default:
        rb_error_arity(argc, 0, 3);
    }
    if (NIL_P(mesg)) {
        mesg = rb_check_funcall(argv[0], idException, argc != 1, &argv[1]);
    }
    if (UNDEF_P(mesg)) {
        rb_raise(rb_eTypeError, "exception class/object expected");
    }
    if (!rb_obj_is_kind_of(mesg, rb_eException)) {
        rb_raise(rb_eTypeError, "exception object expected");
    }
    if (argc == 3) {
        set_backtrace(mesg, argv[2]);
    }
 
    return mesg;
}
 
VALUE
rb_make_exception(int argc, const VALUE *argv)
{
    return make_exception(argc, argv, TRUE);
}
 
static void
rb_raise_jump(VALUE mesg, VALUE cause)
{
    rb_execution_context_t *ec = GET_EC();
    const rb_control_frame_t *cfp = ec->cfp;
    const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
    VALUE klass = me->owner;
    VALUE self = cfp->self;
    ID mid = me->called_id;
 
    rb_vm_pop_frame(ec);
    EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, self, me->def->original_id, mid, klass, Qnil);
 
    rb_longjmp(ec, TAG_RAISE, mesg, cause);
}
 
void
rb_jump_tag(int tag)
{
    if (UNLIKELY(tag < TAG_RETURN || tag > TAG_FATAL)) {
        unknown_longjmp_status(tag);
    }
    EC_JUMP_TAG(GET_EC(), tag);
}
 
int
rb_block_given_p(void)
{
    if (rb_vm_frame_block_handler(GET_EC()->cfp) == VM_BLOCK_HANDLER_NONE) {
        return FALSE;
    }
    else {
        return TRUE;
    }
}
 
int rb_vm_cframe_keyword_p(const rb_control_frame_t *cfp);
 
int
rb_keyword_given_p(void)
{
    return rb_vm_cframe_keyword_p(GET_EC()->cfp);
}
 
VALUE rb_eThreadError;
 
void
rb_need_block(void)
{
    if (!rb_block_given_p()) {
        rb_vm_localjump_error("no block given", Qnil, 0);
    }
}
 
VALUE
rb_rescue2(VALUE (* b_proc) (VALUE), VALUE data1,
           VALUE (* r_proc) (VALUE, VALUE), VALUE data2, ...)
{
    va_list ap;
    va_start(ap, data2);
    VALUE ret = rb_vrescue2(b_proc, data1, r_proc, data2, ap);
    va_end(ap);
    return ret;
}
 
VALUE
rb_vrescue2(VALUE (* b_proc) (VALUE), VALUE data1,
            VALUE (* r_proc_arg) (VALUE, VALUE), VALUE data2_arg,
            va_list args)
{
    enum ruby_tag_type state;
    rb_execution_context_t * volatile ec = GET_EC();
    rb_control_frame_t *volatile cfp = ec->cfp;
    VALUE (* volatile r_proc)(VALUE, VALUE) = r_proc_arg;
    volatile VALUE data2 = data2_arg;
    volatile VALUE result = Qfalse;
    volatile VALUE e_info = ec->errinfo;
 
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
      retry_entry:
        result = (*b_proc) (data1);
    }
    else if (result) {
        /* escape from r_proc */
        if (state == TAG_RETRY) {
            state = TAG_NONE;
            ec->errinfo = Qnil;
            result = Qfalse;
            goto retry_entry;
        }
    }
    else {
        rb_vm_rewind_cfp(ec, cfp);
 
        if (state == TAG_RAISE) {
            int handle = FALSE;
            VALUE eclass;
            va_list ap;
 
            result = Qnil;
            /* reuses args when raised again after retrying in r_proc */
            va_copy(ap, args);
            while ((eclass = va_arg(ap, VALUE)) != 0) {
                if (rb_obj_is_kind_of(ec->errinfo, eclass)) {
                    handle = TRUE;
                    break;
                }
            }
            va_end(ap);
 
            if (handle) {
                state = TAG_NONE;
                if (r_proc) {
                    result = (*r_proc) (data2, ec->errinfo);
                }
                ec->errinfo = e_info;
            }
        }
    }
    EC_POP_TAG();
    if (state)
        EC_JUMP_TAG(ec, state);
 
    return result;
}
 
VALUE
rb_rescue(VALUE (* b_proc)(VALUE), VALUE data1,
          VALUE (* r_proc)(VALUE, VALUE), VALUE data2)
{
    return rb_rescue2(b_proc, data1, r_proc, data2, rb_eStandardError,
                      (VALUE)0);
}
 
VALUE
rb_protect(VALUE (* proc) (VALUE), VALUE data, int *pstate_arg)
{
    volatile VALUE result = Qnil;
    volatile enum ruby_tag_type state;
    rb_execution_context_t * volatile ec = GET_EC();
    rb_control_frame_t *volatile cfp = ec->cfp;
    int * volatile pstate = pstate_arg;
 
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        result = (*proc)(data);
    }
    else {
        rb_vm_rewind_cfp(ec, cfp);
    }
    EC_POP_TAG();
 
    if (pstate != NULL) *pstate = state;
    return result;
}
 
VALUE
rb_ec_ensure(rb_execution_context_t *ec_arg, VALUE (*b_proc)(VALUE), VALUE data1, VALUE (*e_proc_arg)(VALUE), VALUE data2_arg)
{
    enum ruby_tag_type state;
    rb_execution_context_t * volatile ec = ec_arg;
    VALUE (* volatile e_proc)(VALUE) = e_proc_arg;
    volatile VALUE data2 = data2_arg;
    volatile VALUE result = Qnil;
    VALUE errinfo;
    EC_PUSH_TAG(ec);
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        result = (*b_proc) (data1);
    }
    EC_POP_TAG();
    errinfo = ec->errinfo;
    if (!NIL_P(errinfo) && !RB_TYPE_P(errinfo, T_OBJECT)) {
        ec->errinfo = Qnil;
    }
    (*e_proc)(data2);
    ec->errinfo = errinfo;
    if (state)
        EC_JUMP_TAG(ec, state);
    return result;
}
 
VALUE
rb_ensure(VALUE (*b_proc)(VALUE), VALUE data1, VALUE (*e_proc)(VALUE), VALUE data2)
{
    return rb_ec_ensure(GET_EC(), b_proc, data1, e_proc, data2);
}
 
static ID
frame_func_id(const rb_control_frame_t *cfp)
{
    const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
 
    if (me) {
        return me->def->original_id;
    }
    else {
        return 0;
    }
}
 
static ID
frame_called_id(rb_control_frame_t *cfp)
{
    const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(cfp);
 
    if (me) {
        return me->called_id;
    }
    else {
        return 0;
    }
}
 
ID
rb_frame_this_func(void)
{
    return frame_func_id(GET_EC()->cfp);
}
 
ID
rb_frame_callee(void)
{
    return frame_called_id(GET_EC()->cfp);
}
 
static rb_control_frame_t *
previous_frame(const rb_execution_context_t *ec)
{
    rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp);
    /* check if prev_cfp can be accessible */
    if ((void *)(ec->vm_stack + ec->vm_stack_size) == (void *)(prev_cfp)) {
        return 0;
    }
    return prev_cfp;
}
 
static ID
prev_frame_callee(void)
{
    rb_control_frame_t *prev_cfp = previous_frame(GET_EC());
    if (!prev_cfp) return 0;
    return frame_called_id(prev_cfp);
}
 
static ID
prev_frame_func(void)
{
    rb_control_frame_t *prev_cfp = previous_frame(GET_EC());
    if (!prev_cfp) return 0;
    return frame_func_id(prev_cfp);
}
 
ID
rb_frame_last_func(void)
{
    const rb_execution_context_t *ec = GET_EC();
    const rb_control_frame_t *cfp = ec->cfp;
    ID mid;
 
    while (!(mid = frame_func_id(cfp)) &&
           (cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp),
            !RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)));
    return mid;
}
 
/*
 *  call-seq:
 *     append_features(mod)   -> mod
 *
 *  When this module is included in another, Ruby calls
 *  #append_features in this module, passing it the receiving module
 *  in _mod_. Ruby's default implementation is to add the constants,
 *  methods, and module variables of this module to _mod_ if this
 *  module has not already been added to _mod_ or one of its
 *  ancestors. See also Module#include.
 */
 
static VALUE
rb_mod_append_features(VALUE module, VALUE include)
{
    if (!CLASS_OR_MODULE_P(include)) {
        Check_Type(include, T_CLASS);
    }
    rb_include_module(include, module);
 
    return module;
}
 
static VALUE refinement_import_methods(int argc, VALUE *argv, VALUE refinement);
 
/*
 *  call-seq:
 *     include(module, ...)    -> self
 *
 *  Invokes Module.append_features on each parameter in reverse order.
 */
 
static VALUE
rb_mod_include(int argc, VALUE *argv, VALUE module)
{
    int i;
    ID id_append_features, id_included;
 
    CONST_ID(id_append_features, "append_features");
    CONST_ID(id_included, "included");
 
    if (BUILTIN_TYPE(module) == T_MODULE && FL_TEST(module, RMODULE_IS_REFINEMENT)) {
        rb_raise(rb_eTypeError, "Refinement#include has been removed");
    }
 
    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    for (i = 0; i < argc; i++) {
        Check_Type(argv[i], T_MODULE);
        if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
            rb_raise(rb_eTypeError, "Cannot include refinement");
        }
    }
    while (argc--) {
        rb_funcallv_uncached(argv[argc], id_append_features, 1, &module);
        rb_funcallv_uncached(argv[argc], id_included, 1, &module);
    }
    return module;
}
 
/*
 *  call-seq:
 *     prepend_features(mod)   -> mod
 *
 *  When this module is prepended in another, Ruby calls
 *  #prepend_features in this module, passing it the receiving module
 *  in _mod_. Ruby's default implementation is to overlay the
 *  constants, methods, and module variables of this module to _mod_
 *  if this module has not already been added to _mod_ or one of its
 *  ancestors. See also Module#prepend.
 */
 
static VALUE
rb_mod_prepend_features(VALUE module, VALUE prepend)
{
    if (!CLASS_OR_MODULE_P(prepend)) {
        Check_Type(prepend, T_CLASS);
    }
    rb_prepend_module(prepend, module);
 
    return module;
}
 
/*
 *  call-seq:
 *     prepend(module, ...)    -> self
 *
 *  Invokes Module.prepend_features on each parameter in reverse order.
 */
 
static VALUE
rb_mod_prepend(int argc, VALUE *argv, VALUE module)
{
    int i;
    ID id_prepend_features, id_prepended;
 
    if (BUILTIN_TYPE(module) == T_MODULE && FL_TEST(module, RMODULE_IS_REFINEMENT)) {
        rb_raise(rb_eTypeError, "Refinement#prepend has been removed");
    }
 
    CONST_ID(id_prepend_features, "prepend_features");
    CONST_ID(id_prepended, "prepended");
 
    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    for (i = 0; i < argc; i++) {
        Check_Type(argv[i], T_MODULE);
        if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
            rb_raise(rb_eTypeError, "Cannot prepend refinement");
        }
    }
    while (argc--) {
        rb_funcallv_uncached(argv[argc], id_prepend_features, 1, &module);
        rb_funcallv_uncached(argv[argc], id_prepended, 1, &module);
    }
    return module;
}
 
static void
ensure_class_or_module(VALUE obj)
{
    if (!RB_TYPE_P(obj, T_CLASS) && !RB_TYPE_P(obj, T_MODULE)) {
        rb_raise(rb_eTypeError,
                 "wrong argument type %"PRIsVALUE" (expected Class or Module)",
                 rb_obj_class(obj));
    }
}
 
static VALUE
hidden_identity_hash_new(void)
{
    VALUE hash = rb_ident_hash_new();
 
    RBASIC_CLEAR_CLASS(hash); /* hide from ObjectSpace */
    return hash;
}
 
static VALUE
refinement_superclass(VALUE superclass)
{
    if (RB_TYPE_P(superclass, T_MODULE)) {
        /* FIXME: Should ancestors of superclass be used here? */
        return rb_include_class_new(RCLASS_ORIGIN(superclass), rb_cBasicObject);
    }
    else {
        return superclass;
    }
}
 
static void
rb_using_refinement(rb_cref_t *cref, VALUE klass, VALUE module)
{
    VALUE iclass, c, superclass = klass;
 
    ensure_class_or_module(klass);
    Check_Type(module, T_MODULE);
    if (NIL_P(CREF_REFINEMENTS(cref))) {
        CREF_REFINEMENTS_SET(cref, hidden_identity_hash_new());
    }
    else {
        if (CREF_OMOD_SHARED(cref)) {
            CREF_REFINEMENTS_SET(cref, rb_hash_dup(CREF_REFINEMENTS(cref)));
            CREF_OMOD_SHARED_UNSET(cref);
        }
        if (!NIL_P(c = rb_hash_lookup(CREF_REFINEMENTS(cref), klass))) {
            superclass = c;
            while (c && RB_TYPE_P(c, T_ICLASS)) {
                if (RBASIC(c)->klass == module) {
                    /* already used refinement */
                    return;
                }
                c = RCLASS_SUPER(c);
            }
        }
    }
    superclass = refinement_superclass(superclass);
    c = iclass = rb_include_class_new(module, superclass);
    RCLASS_SET_REFINED_CLASS(c, klass);
 
    RCLASS_WRITE_M_TBL(c, RCLASS_M_TBL(module));
 
    rb_class_subclass_add(klass, iclass);
 
    rb_hash_aset(CREF_REFINEMENTS(cref), klass, iclass);
}
 
static int
using_refinement(VALUE klass, VALUE module, VALUE arg)
{
    rb_cref_t *cref = (rb_cref_t *) arg;
 
    rb_using_refinement(cref, klass, module);
    return ST_CONTINUE;
}
 
void
rb_using_module_recursive(rb_cref_t *cref, VALUE klass)
{
    ID id_refinements;
    VALUE super, module, refinements;
 
    super = RCLASS_SUPER(klass);
    if (super) {
        rb_using_module_recursive(cref, super);
    }
    switch (BUILTIN_TYPE(klass)) {
      case T_MODULE:
        module = klass;
        break;
 
      case T_ICLASS:
        module = RBASIC(klass)->klass;
        break;
 
      default:
        rb_raise(rb_eTypeError, "wrong argument type %s (expected Module)",
                 rb_obj_classname(klass));
        break;
    }
    CONST_ID(id_refinements, "__refinements__");
    refinements = rb_attr_get(module, id_refinements);
    if (NIL_P(refinements)) return;
    rb_hash_foreach(refinements, using_refinement, (VALUE) cref);
}
 
static void
rb_using_module(rb_cref_t *cref, VALUE module)
{
    Check_Type(module, T_MODULE);
    rb_using_module_recursive(cref, module);
    rb_clear_all_refinement_method_cache();
}
 
/*
 *  call-seq:
 *     target    -> class_or_module
 *
 *  Return the class or module refined by the receiver.
 *
 *     module M
 *       refine String do
 *       end
 *     end
 *
 *     M.refinements[0].target # => String
 */
VALUE
rb_refinement_module_get_refined_class(VALUE module)
{
    ID id_refined_class;
 
    CONST_ID(id_refined_class, "__refined_class__");
    return rb_attr_get(module, id_refined_class);
}
 
static void
add_activated_refinement(VALUE activated_refinements,
                         VALUE klass, VALUE refinement)
{
    VALUE iclass, c, superclass = klass;
 
    if (!NIL_P(c = rb_hash_lookup(activated_refinements, klass))) {
        superclass = c;
        while (c && RB_TYPE_P(c, T_ICLASS)) {
            if (RBASIC(c)->klass == refinement) {
                /* already used refinement */
                return;
            }
            c = RCLASS_SUPER(c);
        }
    }
    superclass = refinement_superclass(superclass);
    c = iclass = rb_include_class_new(refinement, superclass);
    RCLASS_SET_REFINED_CLASS(c, klass);
    rb_class_subclass_add(klass, iclass);
    refinement = RCLASS_SUPER(refinement);
    while (refinement && refinement != klass) {
        c = rb_class_set_super(c, rb_include_class_new(refinement, RCLASS_SUPER(c)));
        RCLASS_SET_REFINED_CLASS(c, klass);
        rb_class_subclass_add(klass, c);
        refinement = RCLASS_SUPER(refinement);
    }
    rb_hash_aset(activated_refinements, klass, iclass);
}
 
void
rb_refinement_setup(struct rb_refinements_data *data, VALUE module, VALUE klass)
{
    VALUE refinement;
    ID id_refinements, id_activated_refinements,
       id_refined_class, id_defined_at;
    VALUE refinements, activated_refinements;
 
    CONST_ID(id_refinements, "__refinements__");
    refinements = rb_attr_get(module, id_refinements);
    if (NIL_P(refinements)) {
        refinements = hidden_identity_hash_new();
        rb_ivar_set(module, id_refinements, refinements);
    }
    CONST_ID(id_activated_refinements, "__activated_refinements__");
    activated_refinements = rb_attr_get(module, id_activated_refinements);
    if (NIL_P(activated_refinements)) {
        activated_refinements = hidden_identity_hash_new();
        rb_ivar_set(module, id_activated_refinements,
                    activated_refinements);
    }
    refinement = rb_hash_lookup(refinements, klass);
    if (NIL_P(refinement)) {
        VALUE superclass = refinement_superclass(klass);
        refinement = rb_refinement_new();
        rb_class_set_super(refinement, superclass);
        RUBY_ASSERT(BUILTIN_TYPE(refinement) == T_MODULE);
        FL_SET(refinement, RMODULE_IS_REFINEMENT);
        CONST_ID(id_refined_class, "__refined_class__");
        rb_ivar_set(refinement, id_refined_class, klass);
        CONST_ID(id_defined_at, "__defined_at__");
        rb_ivar_set(refinement, id_defined_at, module);
        rb_hash_aset(refinements, klass, refinement);
        add_activated_refinement(activated_refinements, klass, refinement);
    }
 
    data->refinement = refinement;
    data->refinements = activated_refinements;
}
 
/*
 *  call-seq:
 *     refine(mod) { block }   -> module
 *
 *  Refine <i>mod</i> in the receiver.
 *
 *  Returns a module, where refined methods are defined.
 */
 
static VALUE
rb_mod_refine(VALUE module, VALUE klass)
{
    /* module is the receiver of #refine, klass is a module to be refined (`mod` in the doc) */
    rb_thread_t *th = GET_THREAD();
    VALUE block_handler = rb_vm_frame_block_handler(th->ec->cfp);
    struct rb_refinements_data data;
 
    if (block_handler == VM_BLOCK_HANDLER_NONE) {
        rb_raise(rb_eArgError, "no block given");
    }
    if (vm_block_handler_type(block_handler) != block_handler_type_iseq) {
        rb_raise(rb_eArgError, "can't pass a Proc as a block to Module#refine");
    }
 
    ensure_class_or_module(klass);
 
    // refine installs refined method entries into the target's method table, and
    // rb_refinement_setup writes the refinement tables into the receiver
    rb_class_owner_check(module);
    rb_class_owner_check(klass);
 
    rb_refinement_setup(&data, module, klass);
 
    rb_yield_refine_block(data.refinement, data.refinements);
    return data.refinement;
}
 
static void
ignored_block(VALUE module, const char *klass)
{
    const char *anon = "";
    Check_Type(module, T_MODULE);
    if (!RTEST(rb_search_class_path(module))) {
        anon = ", maybe for Module.new";
    }
    rb_warn("%s""using doesn't call the given block""%s.", klass, anon);
}
 
/* Reject `using` anywhere inside a refined proc's body: the procs sharing
 * the memoized iseq copy (and its call caches) must all run under the same
 * refinement set. */
static void
check_not_refined_proc_scope(const char *using_name)
{
    const rb_cref_t *cref;
    for (cref = rb_vm_cref(); cref; cref = CREF_NEXT(cref)) {
        if (CREF_REFINED_PROC(cref)) {
            rb_raise(rb_eRuntimeError,
                     "%s is not permitted in a proc with refinements", using_name);
        }
    }
}
 
/*
 *  call-seq:
 *     using(module)    -> self
 *
 *  Import class refinements from <i>module</i> into the current class or
 *  module definition.
 */
 
static VALUE
mod_using(VALUE self, VALUE module)
{
    rb_control_frame_t *prev_cfp = previous_frame(GET_EC());
 
    if (prev_frame_func()) {
        rb_raise(rb_eRuntimeError,
                 "Module#using is not permitted in methods");
    }
    if (prev_cfp && prev_cfp->self != self) {
        rb_raise(rb_eRuntimeError, "Module#using is not called on self");
    }
    if (rb_block_given_p()) {
        ignored_block(module, "Module#");
    }
    check_not_refined_proc_scope("Module#using");
    rb_using_module(rb_vm_cref_replace_with_duplicated_cref(), module);
    return self;
}
 
 
/*
 *  call-seq:
 *     refinements -> array
 *
 *  Returns an array of +Refinement+ defined within the receiver.
 *
 *     module A
 *       refine Integer do
 *       end
 *
 *       refine String do
 *       end
 *     end
 *
 *     p A.refinements
 *
 *  <em>produces:</em>
 *
 *     [#<refinement:Integer@A>, #<refinement:String@A>]
 */
static VALUE
mod_refinements(VALUE self)
{
    ID id_refinements;
    VALUE refinements;
 
    CONST_ID(id_refinements, "__refinements__");
    refinements = rb_attr_get(self, id_refinements);
    if (NIL_P(refinements)) {
        return rb_ary_new();
    }
    return rb_hash_values(refinements);
}
 
static int
used_modules_i(VALUE _, VALUE mod, VALUE ary)
{
    ID id_defined_at;
    CONST_ID(id_defined_at, "__defined_at__");
    while (BUILTIN_TYPE(rb_class_of(mod)) == T_MODULE && FL_TEST(rb_class_of(mod), RMODULE_IS_REFINEMENT)) {
        rb_ary_push(ary, rb_attr_get(rb_class_of(mod), id_defined_at));
        mod = RCLASS_SUPER(mod);
    }
    return ST_CONTINUE;
}
 
/*
 *  call-seq:
 *     used_modules -> array
 *
 *  Returns an array of all modules used in the current scope. The ordering
 *  of modules in the resulting array is not defined.
 *
 *     module A
 *       refine Object do
 *       end
 *     end
 *
 *     module B
 *       refine Object do
 *       end
 *     end
 *
 *     using A
 *     using B
 *     p Module.used_modules
 *
 *  <em>produces:</em>
 *
 *     [B, A]
 */
static VALUE
rb_mod_s_used_modules(VALUE _)
{
    const rb_cref_t *cref = rb_vm_cref();
    VALUE ary = rb_ary_new();
 
    while (cref) {
        if (!NIL_P(CREF_REFINEMENTS(cref))) {
            rb_hash_foreach(CREF_REFINEMENTS(cref), used_modules_i, ary);
        }
        cref = CREF_NEXT(cref);
    }
 
    return rb_funcall(ary, rb_intern("uniq"), 0);
}
 
static int
used_refinements_i(VALUE _, VALUE mod, VALUE ary)
{
    while (BUILTIN_TYPE(rb_class_of(mod)) == T_MODULE && FL_TEST(rb_class_of(mod), RMODULE_IS_REFINEMENT)) {
        rb_ary_push(ary, rb_class_of(mod));
        mod = RCLASS_SUPER(mod);
    }
    return ST_CONTINUE;
}
 
/*
 *  call-seq:
 *     used_refinements -> array
 *
 *  Returns an array of all modules used in the current scope. The ordering
 *  of modules in the resulting array is not defined.
 *
 *     module A
 *       refine Object do
 *       end
 *     end
 *
 *     module B
 *       refine Object do
 *       end
 *     end
 *
 *     using A
 *     using B
 *     p Module.used_refinements
 *
 *  <em>produces:</em>
 *
 *     [#<refinement:Object@B>, #<refinement:Object@A>]
 */
static VALUE
rb_mod_s_used_refinements(VALUE _)
{
    const rb_cref_t *cref = rb_vm_cref();
    VALUE ary = rb_ary_new();
 
    while (cref) {
        if (!NIL_P(CREF_REFINEMENTS(cref))) {
            rb_hash_foreach(CREF_REFINEMENTS(cref), used_refinements_i, ary);
        }
        cref = CREF_NEXT(cref);
    }
 
    return ary;
}
 
struct refinement_import_methods_arg {
    rb_cref_t *cref;
    VALUE refinement;
    VALUE module;
};
 
/* vm.c */
rb_cref_t *rb_vm_cref_dup_without_refinements(const rb_cref_t *cref);
 
static enum rb_id_table_iterator_result
refinement_import_methods_i(ID key, VALUE value, void *data)
{
    const rb_method_entry_t *me = (const rb_method_entry_t *)value;
    struct refinement_import_methods_arg *arg = (struct refinement_import_methods_arg *)data;
 
    if (me->def->type != VM_METHOD_TYPE_ISEQ) {
        rb_raise(rb_eArgError, "Can't import method which is not defined with Ruby code: %"PRIsVALUE"#%"PRIsVALUE, rb_class_path(arg->module), rb_id2str(key));
    }
    rb_cref_t *new_cref = rb_vm_cref_dup_without_refinements(me->def->body.iseq.cref);
    CREF_REFINEMENTS_SET(new_cref, CREF_REFINEMENTS(arg->cref));
    rb_add_method_iseq(arg->refinement, key, me->def->body.iseq.iseqptr, new_cref, METHOD_ENTRY_VISI(me));
    return ID_TABLE_CONTINUE;
}
 
/*
 * Note: docs for the method are in class.c
 */
 
static VALUE
refinement_import_methods(int argc, VALUE *argv, VALUE refinement)
{
    int i;
    struct refinement_import_methods_arg arg;
 
    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    for (i = 0; i < argc; i++) {
        Check_Type(argv[i], T_MODULE);
        if (RCLASS_SUPER(argv[i])) {
            rb_warn("%"PRIsVALUE" has ancestors, but Refinement#import_methods doesn't import their methods", rb_class_path(argv[i]));
        }
    }
    arg.cref = rb_vm_cref_replace_with_duplicated_cref();
    arg.refinement = refinement;
    for (i = 0; i < argc; i++) {
        arg.module = argv[i];
        struct rb_id_table *m_tbl = RCLASS_M_TBL(argv[i]);
        if (!m_tbl) continue;
        rb_id_table_foreach(m_tbl, refinement_import_methods_i, &arg);
    }
    return refinement;
}
 
void
rb_obj_call_init(VALUE obj, int argc, const VALUE *argv)
{
    rb_obj_call_init_kw(obj, argc, argv, RB_NO_KEYWORDS);
}
 
void
rb_obj_call_init_kw(VALUE obj, int argc, const VALUE *argv, int kw_splat)
{
    PASS_PASSED_BLOCK_HANDLER();
    rb_funcallv_kw(obj, idInitialize, argc, argv, kw_splat);
}
 
void
rb_extend_object(VALUE obj, VALUE module)
{
    rb_include_module(rb_singleton_class(obj), module);
}
 
/*
 *  call-seq:
 *     extend_object(obj)    -> obj
 *
 *  Extends the specified object by adding this module's constants and
 *  methods (which are added as singleton methods). This is the callback
 *  method used by Object#extend.
 *
 *     module Picky
 *       def Picky.extend_object(o)
 *         if String === o
 *           puts "Can't add Picky to a String"
 *         else
 *           puts "Picky added to #{o.class}"
 *           super
 *         end
 *       end
 *     end
 *     (s = Array.new).extend Picky  # Call Object.extend
 *     (s = "quick brown fox").extend Picky
 *
 *  <em>produces:</em>
 *
 *     Picky added to Array
 *     Can't add Picky to a String
 */
 
static VALUE
rb_mod_extend_object(VALUE mod, VALUE obj)
{
    rb_extend_object(obj, mod);
    return obj;
}
 
/*
 *  call-seq:
 *     obj.extend(module, ...)    -> obj
 *
 *  Adds to _obj_ the instance methods from each module given as a
 *  parameter.
 *
 *     module Mod
 *       def hello
 *         "Hello from Mod.\n"
 *       end
 *     end
 *
 *     class Klass
 *       def hello
 *         "Hello from Klass.\n"
 *       end
 *     end
 *
 *     k = Klass.new
 *     k.hello         #=> "Hello from Klass.\n"
 *     k.extend(Mod)   #=> #<Klass:0x401b3bc8>
 *     k.hello         #=> "Hello from Mod.\n"
 */
 
static VALUE
rb_obj_extend(int argc, VALUE *argv, VALUE obj)
{
    int i;
    ID id_extend_object, id_extended;
 
    CONST_ID(id_extend_object, "extend_object");
    CONST_ID(id_extended, "extended");
 
    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    for (i = 0; i < argc; i++) {
        Check_Type(argv[i], T_MODULE);
        if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
            rb_raise(rb_eTypeError, "Cannot extend object with refinement");
        }
    }
    while (argc--) {
        rb_funcallv_uncached(argv[argc], id_extend_object, 1, &obj);
        rb_funcallv_uncached(argv[argc], id_extended, 1, &obj);
    }
    return obj;
}
 
VALUE
rb_top_main_class(const char *method)
{
    VALUE klass = GET_THREAD()->top_wrapper;
 
    if (!klass) return rb_cObject;
    rb_warning("main.%s in the wrapped load is effective only in wrapper module", method);
    return klass;
}
 
/*
 *  call-seq:
 *     include(module, ...)   -> self
 *
 *  Invokes Module.append_features on each parameter in turn.
 *  Effectively adds the methods and constants in each module to the
 *  receiver.
 */
 
static VALUE
top_include(int argc, VALUE *argv, VALUE self)
{
    return rb_mod_include(argc, argv, rb_top_main_class("include"));
}
 
/*
 *  call-seq:
 *     using(module)    -> self
 *
 *  Import class refinements from <i>module</i> into the scope where
 *  #using is called.
 */
 
static VALUE
top_using(VALUE self, VALUE module)
{
    const rb_cref_t *cref = CREF_NEXT(rb_vm_cref());
    rb_control_frame_t *prev_cfp = previous_frame(GET_EC());
    rb_thread_t *th = GET_THREAD();
 
    if ((th->top_wrapper ? CREF_NEXT(cref) : cref) ||
        (prev_cfp && rb_vm_frame_method_entry(prev_cfp))) {
        rb_raise(rb_eRuntimeError, "main.using is permitted only at toplevel");
    }
    if (rb_block_given_p()) {
        ignored_block(module, "main.");
    }
    check_not_refined_proc_scope("main.using");
    rb_using_module(rb_vm_cref_replace_with_duplicated_cref(), module);
    return self;
}
 
static const VALUE *
errinfo_place(const rb_execution_context_t *ec)
{
    const rb_control_frame_t *cfp = ec->cfp;
    const rb_control_frame_t *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
 
    while (RUBY_VM_VALID_CONTROL_FRAME_P(cfp, end_cfp)) {
        if (VM_FRAME_RUBYFRAME_P(cfp)) {
            if (ISEQ_BODY(CFP_ISEQ(cfp))->type == ISEQ_TYPE_RESCUE) {
                return &cfp->ep[VM_ENV_INDEX_LAST_LVAR];
            }
            else if (ISEQ_BODY(CFP_ISEQ(cfp))->type == ISEQ_TYPE_ENSURE &&
                     !THROW_DATA_P(cfp->ep[VM_ENV_INDEX_LAST_LVAR]) &&
                     !FIXNUM_P(cfp->ep[VM_ENV_INDEX_LAST_LVAR])) {
                return &cfp->ep[VM_ENV_INDEX_LAST_LVAR];
            }
        }
        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
    }
    return 0;
}
 
VALUE
rb_ec_get_errinfo(const rb_execution_context_t *ec)
{
    const VALUE *ptr = errinfo_place(ec);
    if (ptr) {
        return *ptr;
    }
    else {
        return ec->errinfo;
    }
}
 
static VALUE
get_errinfo(void)
{
    return get_ec_errinfo(GET_EC());
}
 
static VALUE
errinfo_getter(ID id, VALUE *_)
{
    return get_errinfo();
}
 
VALUE
rb_errinfo(void)
{
    return GET_EC()->errinfo;
}
 
void
rb_set_errinfo(VALUE err)
{
    if (!NIL_P(err) && !rb_obj_is_kind_of(err, rb_eException)) {
        rb_raise(rb_eTypeError, "assigning non-exception to $!");
    }
    GET_EC()->errinfo = err;
}
 
static VALUE
errat_getter(ID id, VALUE *_)
{
    VALUE err = get_errinfo();
    if (!NIL_P(err)) {
        return rb_get_backtrace(err);
    }
    else {
        return Qnil;
    }
}
 
static void
errat_setter(VALUE val, ID id, VALUE *var)
{
    VALUE err = get_errinfo();
    if (NIL_P(err)) {
        rb_raise(rb_eArgError, "$! not set");
    }
    set_backtrace(err, val);
}
 
/*
 *  call-seq:
 *     __method__         -> symbol
 *
 *  Returns the name at the definition of the current method as a
 *  Symbol.
 *  If called outside of a method, it returns <code>nil</code>.
 *
 */
 
static VALUE
rb_f_method_name(VALUE _)
{
    ID fname = prev_frame_func(); /* need *method* ID */
 
    if (fname) {
        return ID2SYM(fname);
    }
    else {
        return Qnil;
    }
}
 
/*
 *  call-seq:
 *     __callee__         -> symbol
 *
 *  Returns the called name of the current method as a Symbol.
 *  If called outside of a method, it returns <code>nil</code>.
 *
 */
 
static VALUE
rb_f_callee_name(VALUE _)
{
    ID fname = prev_frame_callee(); /* need *callee* ID */
 
    if (fname) {
        return ID2SYM(fname);
    }
    else {
        return Qnil;
    }
}
 
/*
 *  call-seq:
 *     __dir__         -> string
 *
 *  Returns the canonicalized absolute path of the directory of the file from
 *  which this method is called. It means symlinks in the path is resolved.
 *  If <code>__FILE__</code> is <code>nil</code>, it returns <code>nil</code>.
 *  The return value equals to <code>File.dirname(File.realpath(__FILE__))</code>.
 *
 */
static VALUE
f_current_dirname(VALUE _)
{
    VALUE base = rb_current_realfilepath();
    if (NIL_P(base)) {
        return Qnil;
    }
    base = rb_file_dirname(base);
    return base;
}
 
/*
 *  call-seq:
 *     global_variables    -> array
 *
 *  Returns an array of the names of global variables. This includes
 *  special regexp global variables such as <tt>$~</tt> and <tt>$+</tt>,
 *  but does not include the numbered regexp global variables (<tt>$1</tt>,
 *  <tt>$2</tt>, etc.).
 *
 *     global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
 */
 
static VALUE
f_global_variables(VALUE _)
{
    return rb_f_global_variables();
}
 
/*
 *  call-seq:
 *     trace_var(symbol, cmd )             -> nil
 *     trace_var(symbol) {|val| block }    -> nil
 *
 *  Controls tracing of assignments to global variables. The parameter
 *  +symbol+ identifies the variable (as either a string name or a
 *  symbol identifier). _cmd_ (which may be a string or a
 *  +Proc+ object) or block is executed whenever the variable
 *  is assigned. The block or +Proc+ object receives the
 *  variable's new value as a parameter. Also see
 *  #untrace_var.
 *
 *     trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
 *     $_ = "hello"
 *     $_ = ' there'
 *
 *  <em>produces:</em>
 *
 *     $_ is now 'hello'
 *     $_ is now ' there'
 */
 
static VALUE
f_trace_var(int c, const VALUE *a, VALUE _)
{
    return rb_f_trace_var(c, a);
}
 
/*
 *  call-seq:
 *     untrace_var(symbol [, cmd] )   -> array or nil
 *
 *  Removes tracing for the specified command on the given global
 *  variable and returns +nil+. If no command is specified,
 *  removes all tracing for that variable and returns an array
 *  containing the commands actually removed.
 */
 
static VALUE
f_untrace_var(int c, const VALUE *a, VALUE _)
{
    return rb_f_untrace_var(c, a);
}
 
void
Init_eval(void)
{
    rb_define_virtual_variable("$@", errat_getter, errat_setter);
    rb_define_virtual_variable("$!", errinfo_getter, 0);
 
    rb_gvar_ractor_local("$@");
    rb_gvar_ractor_local("$!");
 
    rb_gvar_box_dynamic("$@");
    rb_gvar_box_dynamic("$!");
 
    rb_define_global_function("raise", f_raise, -1);
    rb_define_global_function("fail", f_raise, -1);
 
    rb_define_global_function("global_variables", f_global_variables, 0);
 
    rb_define_global_function("__method__", rb_f_method_name, 0);
    rb_define_global_function("__callee__", rb_f_callee_name, 0);
    rb_define_global_function("__dir__", f_current_dirname, 0);
 
    rb_define_method(rb_cModule, "include", rb_mod_include, -1);
    rb_define_method(rb_cModule, "prepend", rb_mod_prepend, -1);
 
    rb_define_private_method(rb_cModule, "append_features", rb_mod_append_features, 1);
    rb_define_private_method(rb_cModule, "extend_object", rb_mod_extend_object, 1);
    rb_define_private_method(rb_cModule, "prepend_features", rb_mod_prepend_features, 1);
    rb_define_private_method(rb_cModule, "refine", rb_mod_refine, 1);
    rb_define_private_method(rb_cModule, "using", mod_using, 1);
    rb_define_method(rb_cModule, "refinements", mod_refinements, 0);
    rb_define_singleton_method(rb_cModule, "used_modules",
                               rb_mod_s_used_modules, 0);
    rb_define_singleton_method(rb_cModule, "used_refinements",
                               rb_mod_s_used_refinements, 0);
    rb_undef_method(rb_cClass, "refine");
    rb_define_private_method(rb_cRefinement, "import_methods", refinement_import_methods, -1);
    rb_define_method(rb_cRefinement, "target", rb_refinement_module_get_refined_class, 0);
    rb_undef_method(rb_cRefinement, "append_features");
    rb_undef_method(rb_cRefinement, "prepend_features");
    rb_undef_method(rb_cRefinement, "extend_object");
 
    rb_undef_method(rb_cClass, "module_function");
 
    Init_vm_eval();
    Init_eval_method();
 
    rb_define_singleton_method(rb_cModule, "nesting", rb_mod_nesting, 0);
    rb_define_singleton_method(rb_cModule, "constants", rb_mod_s_constants, -1);
 
    rb_define_private_method(rb_singleton_class(rb_vm_top_self()),
                             "include", top_include, -1);
    rb_define_private_method(rb_singleton_class(rb_vm_top_self()),
                             "using", top_using, 1);
 
    rb_define_method(rb_mKernel, "extend", rb_obj_extend, -1);
 
    rb_define_global_function("trace_var", f_trace_var, -1);
    rb_define_global_function("untrace_var", f_untrace_var, -1);
 
    rb_vm_register_special_exception(ruby_error_reenter, rb_eFatal, "exception reentered");
    rb_vm_register_special_exception(ruby_error_stackfatal, rb_eFatal, "machine stack overflow in critical region");
 
    id_signo = rb_intern_const("signo");
    id_status = rb_intern_const("status");
}
 
int
rb_errno(void)
{
    return *rb_orig_errno_ptr();
}
 
void
rb_errno_set(int e)
{
    *rb_orig_errno_ptr() = e;
}
 
int *
rb_errno_ptr(void)
{
    return rb_orig_errno_ptr();
}