load.c (b709bdb3e37451bb1103b50fb280968dbf038103)

/*
 * load methods from eval.c
 */
 
#include "dln.h"
#include "eval_intern.h"
#include "internal.h"
#include "internal/box.h"
#include "internal/dir.h"
#include "internal/error.h"
#include "internal/eval.h"
#include "internal/file.h"
#include "internal/hash.h"
#include "internal/load.h"
#include "internal/ruby_parser.h"
#include "internal/thread.h"
#include "internal/variable.h"
#include "iseq.h"
#include "prism_compile.h"
#include "probes.h"
#include "darray.h"
#include "ruby/encoding.h"
#include "ruby/util.h"
#include "ractor_core.h"
#include "vm_core.h"
 
#define IS_RBEXT(e) (strcmp((e), ".rb") == 0)
#define IS_SOEXT(e) (strcmp((e), ".so") == 0 || strcmp((e), ".o") == 0)
#define IS_DLEXT(e) (strcmp((e), DLEXT) == 0)
 
enum {
    loadable_ext_rb = (0+ /* .rb extension is the first in both tables */
                       1) /* offset by rb_find_file_ext() */
};
 
static const char *const loadable_ext[] = {
    ".rb", DLEXT,
    0
};
 
static const char *const ruby_ext[] = {
    ".rb",
    0
};
 
enum expand_type {
    EXPAND_ALL,
    EXPAND_RELATIVE,
    EXPAND_HOME,
    EXPAND_NON_CACHE
};
 
/* Construct expanded load path and store it to cache.
   We rebuild load path partially if the cache is invalid.
   We don't cache non string object and expand it every time. We ensure that
   string objects in $LOAD_PATH are frozen.
 */
static void
rb_construct_expanded_load_path(rb_box_t *box, enum expand_type type, int *has_relative, int *has_non_cache, rb_len_t *maxlen_out)
{
    VALUE load_path = box->load_path;
    VALUE expanded_load_path = box->expanded_load_path;
    VALUE snapshot;
    VALUE ary;
    rb_len_t i, maxlen = 0;
 
    ary = rb_ary_hidden_new(RARRAY_LEN(load_path));
    for (i = 0; i < RARRAY_LEN(load_path); ++i) {
        VALUE path, as_str, expanded_path;
        int is_string, non_cache;
        char *as_cstr;
        as_str = path = RARRAY_AREF(load_path, i);
        is_string = RB_TYPE_P(path, T_STRING) ? 1 : 0;
        non_cache = !is_string ? 1 : 0;
        as_str = rb_get_path_check_to_string(path);
        as_cstr = RSTRING_PTR(as_str);
 
        if (!non_cache) {
            if ((type == EXPAND_RELATIVE &&
                    rb_is_absolute_path(as_cstr)) ||
                (type == EXPAND_HOME &&
                    (!as_cstr[0] || as_cstr[0] != '~')) ||
                (type == EXPAND_NON_CACHE)) {
                    /* Use cached expanded path. */
                    expanded_path = RARRAY_AREF(expanded_load_path, i);
                    rb_len_t len = RSTRING_LEN(expanded_path);
                    if (len > maxlen) maxlen = len;
                    rb_ary_push(ary, expanded_path);
                    continue;
            }
        }
        if (!*has_relative && !rb_is_absolute_path(as_cstr))
            *has_relative = 1;
        if (!*has_non_cache && non_cache)
            *has_non_cache = 1;
        /* Freeze only string object. We expand other objects every time. */
        if (is_string)
            rb_str_freeze(path);
        as_str = rb_get_path_check_convert(as_str);
        expanded_path = rb_check_realpath(Qnil, as_str, NULL);
        if (NIL_P(expanded_path)) expanded_path = as_str;
        rb_len_t len = RSTRING_LEN(expanded_path);
        if (len > maxlen) maxlen = len;
        rb_ary_push(ary, rb_fstring(expanded_path));
    }
    rb_ary_freeze(ary);
    box->expanded_load_path = ary;
    snapshot = box->load_path_snapshot;
    load_path = box->load_path;
    *maxlen_out = maxlen;
    rb_ary_replace(snapshot, load_path);
}
 
static VALUE
get_expanded_load_path(rb_box_t *box)
{
    VALUE check_cache;
    const VALUE non_cache = Qtrue;
    const VALUE load_path_snapshot = box->load_path_snapshot;
    const VALUE load_path = box->load_path;
    rb_len_t maxlen = 0;
 
    if (!rb_ary_shared_with_p(load_path_snapshot, load_path)) {
        /* The load path was modified. Rebuild the expanded load path. */
        int has_relative = 0, has_non_cache = 0;
        rb_construct_expanded_load_path(box, EXPAND_ALL, &has_relative, &has_non_cache, &maxlen);
        if (has_relative) {
            box->load_path_check_cache = rb_dir_getwd_ospath();
        }
        else if (has_non_cache) {
            /* Non string object. */
            box->load_path_check_cache = non_cache;
        }
        else {
            box->load_path_check_cache = 0;
        }
    }
    else if ((check_cache = box->load_path_check_cache) == non_cache) {
        int has_relative = 1, has_non_cache = 1;
        /* Expand only non-cacheable objects. */
        rb_construct_expanded_load_path(box, EXPAND_NON_CACHE,
                                        &has_relative, &has_non_cache, &maxlen);
    }
    else if (check_cache) {
        int has_relative = 1, has_non_cache = 1;
        VALUE cwd = rb_dir_getwd_ospath();
        if (!rb_str_equal(check_cache, cwd)) {
            /* Current working directory or filesystem encoding was changed.
               Expand relative load path and non-cacheable objects again. */
            box->load_path_check_cache = cwd;
            rb_construct_expanded_load_path(box, EXPAND_RELATIVE,
                                            &has_relative, &has_non_cache, &maxlen);
        }
        else {
            /* Expand only tilde (User HOME) and non-cacheable objects. */
            rb_construct_expanded_load_path(box, EXPAND_HOME,
                                            &has_relative, &has_non_cache, &maxlen);
        }
    }
    if (maxlen) {
        box->expanded_load_path_maxlen = maxlen;
    }
    return box->expanded_load_path;
}
 
VALUE
rb_get_expanded_load_path(rb_len_t *maxlen)
{
    rb_box_t *box = (rb_box_t *)rb_loading_box();
    VALUE load_path = get_expanded_load_path((rb_box_t *)box);
    if (maxlen) {
        *maxlen = box->expanded_load_path_maxlen;
    }
    return load_path;
}
 
static VALUE
load_path_getter(ID _x, VALUE * _y)
{
    return rb_loading_box()->load_path;
}
 
static VALUE
get_LOADED_FEATURES(ID _x, VALUE *_y)
{
    return rb_loading_box()->loaded_features;
}
 
static void
reset_loaded_features_snapshot(const rb_box_t *box)
{
    VALUE snapshot = box->loaded_features_snapshot;
    VALUE loaded_features = box->loaded_features;
    rb_ary_replace(snapshot, loaded_features);
}
 
static struct st_table *
get_loaded_features_index_raw(const rb_box_t *box)
{
    return box->loaded_features_index;
}
 
static st_data_t
feature_key(const char *str, size_t len)
{
    return st_hash(str, len, 0xfea7009e);
}
 
static bool
is_rbext_path(VALUE feature_path)
{
    rb_len_t len = RSTRING_LEN(feature_path);
    rb_len_t rbext_len = rb_strlen_lit(".rb");
    if (len <= rbext_len) return false;
    return IS_RBEXT(RSTRING_PTR(feature_path) + len - rbext_len);
}
 
typedef rb_darray(long) feature_indexes_t;
 
struct features_index_add_single_args {
    const rb_box_t *box;
    VALUE offset;
    bool rb;
};
 
static int
features_index_add_single_callback(st_data_t *key, st_data_t *value, st_data_t raw_args, int existing)
{
    struct features_index_add_single_args *args = (struct features_index_add_single_args *)raw_args;
    const rb_box_t *box = args->box;
    VALUE offset = args->offset;
    bool rb = args->rb;
 
    if (existing) {
        VALUE this_feature_index = *value;
 
        if (FIXNUM_P(this_feature_index)) {
            VALUE loaded_features = box->loaded_features;
            VALUE this_feature_path = RARRAY_AREF(loaded_features, FIX2LONG(this_feature_index));
 
            feature_indexes_t feature_indexes;
            rb_darray_make(&feature_indexes, 2);
            int top = (rb && !is_rbext_path(this_feature_path)) ? 1 : 0;
            rb_darray_set(feature_indexes, top^0, FIX2LONG(this_feature_index));
            rb_darray_set(feature_indexes, top^1, FIX2LONG(offset));
 
            RUBY_ASSERT(rb_darray_size(feature_indexes) == 2);
            // assert feature_indexes does not look like a special const
            RUBY_ASSERT(!SPECIAL_CONST_P((VALUE)feature_indexes));
 
            *value = (st_data_t)feature_indexes;
        }
        else {
            feature_indexes_t feature_indexes = (feature_indexes_t)this_feature_index;
            long pos = -1;
 
            if (rb) {
                VALUE loaded_features = box->loaded_features;
                for (size_t i = 0; i < rb_darray_size(feature_indexes); ++i) {
                    long idx = rb_darray_get(feature_indexes, i);
                    VALUE this_feature_path = RARRAY_AREF(loaded_features, idx);
                    Check_Type(this_feature_path, T_STRING);
                    if (!is_rbext_path(this_feature_path)) {
                        pos = i;
                        break;
                    }
                }
            }
 
            rb_darray_append(&feature_indexes, FIX2LONG(offset));
            /* darray may realloc which will change the pointer */
            *value = (st_data_t)feature_indexes;
 
            if (pos >= 0) {
                long *ptr = rb_darray_data_ptr(feature_indexes);
                long len = rb_darray_size(feature_indexes);
                MEMMOVE(ptr + pos + 1, ptr + pos, long, len - pos - 1);
                ptr[pos] = FIX2LONG(offset);
            }
        }
    }
    else {
        *value = offset;
    }
 
    return ST_CONTINUE;
}
 
static void
features_index_add_single(const rb_box_t *box, const char* str, size_t len, VALUE offset, bool rb)
{
    struct st_table *features_index;
    st_data_t short_feature_key;
 
    Check_Type(offset, T_FIXNUM);
    short_feature_key = feature_key(str, len);
 
    features_index = get_loaded_features_index_raw(box);
 
    struct features_index_add_single_args args = {
        .box = box,
        .offset = offset,
        .rb = rb,
    };
 
    st_update(features_index, short_feature_key, features_index_add_single_callback, (st_data_t)&args);
}
 
/* Add to the loaded-features index all the required entries for
   `feature`, located at `offset` in $LOADED_FEATURES.  We add an
   index entry at each string `short_feature` for which
     feature == "#{prefix}#{short_feature}#{ext}"
   where `ext` is empty or matches %r{^\.[^./]*$}, and `prefix` is empty
   or ends in '/'.  This maintains the invariant that `rb_feature_p()`
   relies on for its fast lookup.
*/
static void
features_index_add(const rb_box_t *box, VALUE feature, VALUE offset)
{
    RUBY_ASSERT(rb_ractor_main_p());
 
    const char *feature_str, *feature_end, *ext, *p;
    bool rb = false;
 
    feature_str = StringValuePtr(feature);
    feature_end = feature_str + RSTRING_LEN(feature);
 
    for (ext = feature_end; ext > feature_str; ext--)
        if (*ext == '.' || *ext == '/')
            break;
    if (*ext != '.')
        ext = NULL;
    else
        rb = IS_RBEXT(ext);
    /* Now `ext` points to the only string matching %r{^\.[^./]*$} that is
       at the end of `feature`, or is NULL if there is no such string. */
 
    p = ext ? ext : feature_end;
    while (1) {
        p--;
        while (p >= feature_str && *p != '/')
            p--;
        if (p < feature_str)
            break;
        /* Now *p == '/'.  We reach this point for every '/' in `feature`. */
        features_index_add_single(box, p + 1, feature_end - p - 1, offset, false);
        if (ext) {
            features_index_add_single(box, p + 1, ext - p - 1, offset, rb);
        }
    }
    features_index_add_single(box, feature_str, feature_end - feature_str, offset, false);
    if (ext) {
        features_index_add_single(box, feature_str, ext - feature_str, offset, rb);
    }
}
 
static int
loaded_features_index_clear_i(st_data_t key, st_data_t val, st_data_t arg)
{
    VALUE obj = (VALUE)val;
    if (!SPECIAL_CONST_P(obj)) {
        rb_darray_free_sized((void *)obj, long);
    }
    return ST_DELETE;
}
 
static st_table *
get_loaded_features_index(const rb_box_t *box)
{
    int i;
    VALUE features = box->loaded_features;
    const VALUE snapshot = box->loaded_features_snapshot;
 
    if (!rb_ary_shared_with_p(snapshot, features)) {
        /* The sharing was broken; something (other than us in rb_provide_feature())
           modified loaded_features.  Rebuild the index. */
        st_foreach(box->loaded_features_index, loaded_features_index_clear_i, 0);
 
        VALUE realpaths = box->loaded_features_realpaths;
        VALUE realpath_map = box->loaded_features_realpath_map;
        VALUE previous_realpath_map = rb_hash_dup(realpath_map);
        rb_hash_clear(realpaths);
        rb_hash_clear(realpath_map);
 
        /* We have to make a copy of features here because the StringValue call
         * below could call a Ruby method, which could modify $LOADED_FEATURES
         * and cause it to be corrupt. */
        features = rb_ary_resurrect(features);
        for (i = 0; i < RARRAY_LEN(features); i++) {
            VALUE entry, as_str;
            as_str = entry = rb_ary_entry(features, i);
            StringValue(as_str);
            as_str = rb_fstring(as_str);
            if (as_str != entry)
                rb_ary_store(features, i, as_str);
            features_index_add(box, as_str, INT2FIX(i));
        }
        /* The user modified $LOADED_FEATURES, so we should restore the changes. */
        if (!rb_ary_shared_with_p(features, box->loaded_features)) {
            rb_ary_replace(box->loaded_features, features);
        }
        reset_loaded_features_snapshot(box);
 
        features = box->loaded_features_snapshot;
        rb_len_t j = RARRAY_LEN(features);
        for (i = 0; i < j; i++) {
            VALUE as_str = rb_ary_entry(features, i);
            VALUE realpath = rb_hash_aref(previous_realpath_map, as_str);
            if (NIL_P(realpath)) {
                realpath = rb_check_realpath(Qnil, as_str, NULL);
                if (NIL_P(realpath)) realpath = as_str;
                realpath = rb_fstring(realpath);
            }
            rb_hash_aset(realpaths, realpath, Qtrue);
            rb_hash_aset(realpath_map, as_str, realpath);
        }
    }
    return box->loaded_features_index;
}
 
/* This searches `load_path` for a value such that
     name == "#{load_path[i]}/#{feature}"
   if `feature` is a suffix of `name`, or otherwise
     name == "#{load_path[i]}/#{feature}#{ext}"
   for an acceptable string `ext`.  It returns
   `load_path[i].to_str` if found, else 0.
 
   If type is 's', then `ext` is acceptable only if IS_DLEXT(ext);
   if 'r', then only if IS_RBEXT(ext); otherwise `ext` may be absent
   or have any value matching `%r{^\.[^./]*$}`.
*/
static VALUE
loaded_feature_path(const char *name, rb_len_t vlen, const char *feature, rb_len_t len,
                    int type, VALUE load_path)
{
    rb_len_t i;
    rb_len_t plen;
    const char *e;
 
    if (vlen < len+1) return 0;
    if (strchr(feature, '.') && !strncmp(name+(vlen-len), feature, len)) {
        plen = vlen - len;
    }
    else {
        for (e = name + vlen; name != e && *e != '.' && *e != '/'; --e);
        if (*e != '.' ||
            e-name < len ||
            strncmp(e-len, feature, len))
            return 0;
        plen = e - name - len;
    }
    if (plen > 0 && name[plen-1] != '/') {
        return 0;
    }
    if (type == 's' ? !IS_DLEXT(&name[plen+len]) :
        type == 'r' ? !IS_RBEXT(&name[plen+len]) :
        0) {
        return 0;
    }
    /* Now name == "#{prefix}/#{feature}#{ext}" where ext is acceptable
       (possibly empty) and prefix is some string of length plen. */
 
    if (plen > 0) --plen;       /* exclude '.' */
    for (i = 0; i < RARRAY_LEN(load_path); ++i) {
        VALUE p = RARRAY_AREF(load_path, i);
        const char *s = StringValuePtr(p);
        rb_len_t n = RSTRING_LEN(p);
 
        if (n != plen) continue;
        if (n && strncmp(name, s, n)) continue;
        return p;
    }
    return 0;
}
 
struct loaded_feature_searching {
    const char *name;
    rb_len_t len;
    int type;
    VALUE load_path;
    const char *result;
};
 
static int
loaded_feature_path_i(st_data_t v, st_data_t b, st_data_t f)
{
    const char *s = (const char *)v;
    struct loaded_feature_searching *fp = (struct loaded_feature_searching *)f;
    VALUE p = loaded_feature_path(s, strlen(s), fp->name, fp->len,
                                  fp->type, fp->load_path);
    if (!p) return ST_CONTINUE;
    fp->result = s;
    return ST_STOP;
}
 
/*
 * Returns the type of already provided feature.
 * 'r': ruby script (".rb")
 * 's': shared object (".so"/"."DLEXT)
 * 'u': unsuffixed
 */
static int
rb_feature_p(const rb_box_t *box, const char *feature, const char *ext, int rb, int expanded, const char **fn)
{
    VALUE features, this_feature_index = Qnil, v, p, load_path = 0;
    const char *f, *e;
    rb_len_t i, len, elen, n;
    st_table *loading_tbl, *features_index;
    st_data_t data;
    st_data_t key;
    int type;
 
    if (fn) *fn = 0;
    if (ext) {
        elen = strlen(ext);
        len = strlen(feature) - elen;
        type = rb ? 'r' : 's';
    }
    else {
        len = strlen(feature);
        elen = 0;
        type = 0;
    }
    features = box->loaded_features;
    features_index = get_loaded_features_index(box);
 
    key = feature_key(feature, strlen(feature));
    /* We search `features` for an entry such that either
         "#{features[i]}" == "#{load_path[j]}/#{feature}#{e}"
       for some j, or
         "#{features[i]}" == "#{feature}#{e}"
       Here `e` is an "allowed" extension -- either empty or one
       of the extensions accepted by IS_RBEXT, IS_SOEXT, or
       IS_DLEXT.  Further, if `ext && rb` then `IS_RBEXT(e)`,
       and if `ext && !rb` then `IS_SOEXT(e) || IS_DLEXT(e)`.
 
       If `expanded`, then only the latter form (without load_path[j])
       is accepted.  Otherwise either form is accepted, *unless* `ext`
       is false and an otherwise-matching entry of the first form is
       preceded by an entry of the form
         "#{features[i2]}" == "#{load_path[j2]}/#{feature}#{e2}"
       where `e2` matches %r{^\.[^./]*$} but is not an allowed extension.
       After a "distractor" entry of this form, only entries of the
       form "#{feature}#{e}" are accepted.
 
       In `rb_provide_feature()` and `get_loaded_features_index()` we
       maintain an invariant that the array `this_feature_index` will
       point to every entry in `features` which has the form
         "#{prefix}#{feature}#{e}"
       where `e` is empty or matches %r{^\.[^./]*$}, and `prefix` is empty
       or ends in '/'.  This includes both match forms above, as well
       as any distractors, so we may ignore all other entries in `features`.
     */
    if (st_lookup(features_index, key, &data) && !NIL_P(this_feature_index = (VALUE)data)) {
        for (size_t i = 0; ; i++) {
            long index;
            if (FIXNUM_P(this_feature_index)) {
                if (i > 0) break;
                index = FIX2LONG(this_feature_index);
            }
            else {
                feature_indexes_t feature_indexes = (feature_indexes_t)this_feature_index;
                if (i >= rb_darray_size(feature_indexes)) break;
                index = rb_darray_get(feature_indexes, i);
            }
 
            if (index >= RARRAY_LEN(features)) continue;
            v = RARRAY_AREF(features, index);
            f = StringValuePtr(v);
            if ((n = RSTRING_LEN(v)) < len) continue;
            if (strncmp(f, feature, len) != 0) {
                if (expanded) continue;
                if (!load_path) load_path = get_expanded_load_path((rb_box_t *)box);
                if (!(p = loaded_feature_path(f, n, feature, len, type, load_path)))
                    continue;
                expanded = 1;
                f += RSTRING_LEN(p) + 1;
            }
            if (!*(e = f + len)) {
                if (ext) continue;
                return 'u';
            }
            if (*e != '.') continue;
            if ((!rb || !ext) && (IS_SOEXT(e) || IS_DLEXT(e))) {
                return 's';
            }
            if ((rb || !ext) && (IS_RBEXT(e))) {
                return 'r';
            }
        }
    }
 
    loading_tbl = box->loading_table;
    f = 0;
    if (!expanded && !rb_is_absolute_path(feature)) {
        struct loaded_feature_searching fs;
        fs.name = feature;
        fs.len = len;
        fs.type = type;
        fs.load_path = load_path ? load_path : get_expanded_load_path((rb_box_t *)box);
        fs.result = 0;
        st_foreach(loading_tbl, loaded_feature_path_i, (st_data_t)&fs);
        if ((f = fs.result) != 0) {
            if (fn) *fn = f;
            goto loading;
        }
    }
    if (st_get_key(loading_tbl, (st_data_t)feature, &data)) {
        if (fn) *fn = (const char*)data;
        goto loading;
    }
    else {
        VALUE bufstr;
        char *buf;
        static const char so_ext[][4] = {
            ".so", ".o",
        };
 
        if (ext && *ext) return 0;
        bufstr = rb_str_tmp_new(len + DLEXT_MAXLEN);
        buf = RSTRING_PTR(bufstr);
        MEMCPY(buf, feature, char, len);
        for (i = 0; (e = loadable_ext[i]) != 0; i++) {
            strlcpy(buf + len, e, DLEXT_MAXLEN + 1);
            if (st_get_key(loading_tbl, (st_data_t)buf, &data)) {
                rb_str_resize(bufstr, 0);
                if (fn) *fn = (const char*)data;
                return i ? 's' : 'r';
            }
        }
        for (i = 0; i < numberof(so_ext); i++) {
            strlcpy(buf + len, so_ext[i], DLEXT_MAXLEN + 1);
            if (st_get_key(loading_tbl, (st_data_t)buf, &data)) {
                rb_str_resize(bufstr, 0);
                if (fn) *fn = (const char*)data;
                return 's';
            }
        }
        rb_str_resize(bufstr, 0);
    }
    return 0;
 
  loading:
    if (!ext) return 'u';
    return !IS_RBEXT(ext) ? 's' : 'r';
}
 
int
rb_provided(const char *feature)
{
    return rb_feature_provided(feature, 0);
}
 
static int
feature_provided(rb_box_t *box, const char *feature, const char **loading)
{
    const char *ext = strrchr(feature, '.');
    VALUE fullpath = 0;
 
    if (*feature == '.' &&
        (feature[1] == '/' || strncmp(feature+1, "./", 2) == 0)) {
        fullpath = rb_file_expand_path_fast(rb_get_path(rb_str_new2(feature)), Qnil);
        feature = RSTRING_PTR(fullpath);
    }
    if (ext && !strchr(ext, '/')) {
        if (IS_RBEXT(ext)) {
            if (rb_feature_p(box, feature, ext, TRUE, FALSE, loading)) return TRUE;
            return FALSE;
        }
        else if (IS_SOEXT(ext) || IS_DLEXT(ext)) {
            if (rb_feature_p(box, feature, ext, FALSE, FALSE, loading)) return TRUE;
            return FALSE;
        }
    }
    if (rb_feature_p(box, feature, 0, TRUE, FALSE, loading))
        return TRUE;
    RB_GC_GUARD(fullpath);
    return FALSE;
}
 
int
rb_feature_provided(const char *feature, const char **loading)
{
    rb_box_t *box = (rb_box_t *)rb_current_box();
    return feature_provided(box, feature, loading);
}
 
static void
rb_provide_feature(const rb_box_t *box, VALUE feature)
{
    VALUE features;
 
    features = box->loaded_features;
    if (OBJ_FROZEN(features)) {
        rb_raise(rb_eRuntimeError,
                 "$LOADED_FEATURES is frozen; cannot append feature");
    }
    feature = rb_fstring(feature);
 
    get_loaded_features_index(box);
    // If loaded_features and loaded_features_snapshot share the same backing
    // array, pushing into it would cause the whole array to be copied.
    // To avoid this we first clear loaded_features_snapshot.
    rb_ary_clear(box->loaded_features_snapshot);
    rb_ary_push(features, feature);
    features_index_add(box, feature, INT2FIX(RARRAY_LEN(features)-1));
    reset_loaded_features_snapshot(box);
}
 
void
rb_provide(const char *feature)
{
    /*
     * rb_provide() must use rb_current_box to store provided features
     * in the current box's loaded_features, etc.
     */
    rb_provide_feature(rb_current_box(), rb_fstring_cstr(feature));
}
 
NORETURN(static void load_failed(VALUE));
 
static inline VALUE
realpath_internal_cached(VALUE hash, VALUE path)
{
    VALUE ret = rb_hash_aref(hash, path);
    if(RTEST(ret)) {
        return ret;
    }
 
    VALUE realpath = rb_realpath_internal(Qnil, path, 1);
    rb_hash_aset(hash, rb_fstring(path), rb_fstring(realpath));
    return realpath;
}
 
struct load_prism_args {
    pm_parse_result_t result;
    VALUE fname;
    VALUE realpath_map;
    const rb_iseq_t *iseq;
    VALUE error;
};
 
static VALUE
load_prism_parse(VALUE args_ptr)
{
    struct load_prism_args *args = (struct load_prism_args *)args_ptr;
    pm_parse_result_t *result = &args->result;
    VALUE fname = args->fname;
 
    VALUE error = pm_load_parse_file(result, fname, NULL);
    if (error != Qnil) {
        args->error = error;
        return Qnil;
    }
 
    int error_state;
    args->iseq = pm_iseq_new_top(&result->node, rb_fstring_lit("<top (required)>"), fname,
                                 realpath_internal_cached(args->realpath_map, fname), NULL, &error_state);
    if (error_state) {
        RUBY_ASSERT(args->iseq == NULL);
        rb_jump_tag(error_state);
    }
 
    return Qnil;
}
 
static VALUE
load_prism_free_result(VALUE args_ptr)
{
    struct load_prism_args *args = (struct load_prism_args *)args_ptr;
    pm_parse_result_free(&args->result);
    return Qnil;
}
 
static inline void
load_iseq_eval(rb_execution_context_t *ec, VALUE fname)
{
    const rb_box_t *box = rb_loading_box();
    const rb_iseq_t *iseq = rb_iseq_load_iseq(fname);
 
    if (!iseq) {
        rb_execution_context_t *ec = GET_EC();
        VALUE v = rb_vm_push_frame_fname(ec, fname);
 
        VALUE realpath_map = box->loaded_features_realpath_map;
 
        if (rb_ruby_prism_p()) {
            struct load_prism_args args = {
                .fname = fname,
                .realpath_map = realpath_map,
                .iseq = NULL,
                .error = Qnil,
            };
            pm_parse_result_init(&args.result);
            args.result.node.coverage_enabled = 1;
 
            /* The parse result must be freed even if parsing or compiling
             * raises (e.g. an asynchronously raised IOError while reading a
             * pipe), so wrap it in rb_ensure. */
            rb_ensure(load_prism_parse, (VALUE)&args, load_prism_free_result, (VALUE)&args);
 
            if (args.error != Qnil) {
                rb_vm_pop_frame(ec);
                RB_GC_GUARD(v);
                rb_exc_raise(args.error);
            }
 
            iseq = args.iseq;
        }
        else {
            rb_ast_t *ast;
            VALUE ast_value;
            VALUE parser = rb_parser_new();
            rb_parser_set_context(parser, NULL, FALSE);
            ast_value = rb_parser_load_file(parser, fname);
            ast = rb_ruby_ast_data_get(ast_value);
 
            iseq = rb_iseq_new_top(ast_value, rb_fstring_lit("<top (required)>"),
                                   fname, realpath_internal_cached(realpath_map, fname), NULL);
            rb_ast_dispose(ast);
        }
 
        rb_vm_pop_frame(ec);
        RB_GC_GUARD(v);
    }
    rb_exec_event_hook_script_compiled(ec, iseq, Qnil);
 
    rb_iseq_eval(iseq, box);
}
 
static inline enum ruby_tag_type
load_wrapping(rb_execution_context_t *ec, VALUE fname, VALUE load_wrapper)
{
    enum ruby_tag_type state;
    rb_box_t *box;
    rb_thread_t *th = rb_ec_thread_ptr(ec);
    volatile VALUE wrapper = th->top_wrapper;
    volatile VALUE self = th->top_self;
#if !defined __GNUC__
    rb_thread_t *volatile th0 = th;
#endif
 
    ec->errinfo = Qnil; /* ensure */
 
    /* load in module as toplevel */
    if (BOX_OBJ_P(load_wrapper)) {
        box = rb_get_box_t(load_wrapper);
        if (!box->top_self) {
            box->top_self = rb_obj_clone(rb_vm_top_self());
        }
        th->top_self = box->top_self;
    }
    else {
        th->top_self = rb_obj_clone(rb_vm_top_self());
    }
    th->top_wrapper = load_wrapper;
    rb_extend_object(th->top_self, th->top_wrapper);
 
    EC_PUSH_TAG(ec);
    state = EC_EXEC_TAG();
    if (state == TAG_NONE) {
        load_iseq_eval(ec, fname);
    }
    EC_POP_TAG();
 
#if !defined __GNUC__
    th = th0;
    fname = RB_GC_GUARD(fname);
#endif
    th->top_self = self;
    th->top_wrapper = wrapper;
    return state;
}
 
static inline void
raise_load_if_failed(rb_execution_context_t *ec, enum ruby_tag_type state)
{
    if (state) {
        rb_vm_jump_tag_but_local_jump(state);
    }
 
    if (!NIL_P(ec->errinfo)) {
        rb_exc_raise(ec->errinfo);
    }
}
 
static void
rb_load_internal(VALUE fname, VALUE wrap)
{
    VALUE box_value;
    rb_execution_context_t *ec = GET_EC();
    const rb_box_t *box = rb_loading_box();
    enum ruby_tag_type state = TAG_NONE;
    if (RTEST(wrap)) {
        if (!RB_TYPE_P(wrap, T_MODULE)) {
            wrap = rb_module_new();
        }
        state = load_wrapping(ec, fname, wrap);
    }
    else if (BOX_OPTIONAL_P(box)) {
        box_value = box->box_object;
        state = load_wrapping(ec, fname, box_value);
    }
    else {
        load_iseq_eval(ec, fname);
    }
    raise_load_if_failed(ec, state);
}
 
void
rb_load(VALUE fname, int wrap)
{
    VALUE tmp = rb_find_file(FilePathValue(fname));
    if (!tmp) load_failed(fname);
    rb_load_internal(tmp, RBOOL(wrap));
}
 
void
rb_load_protect(VALUE fname, int wrap, int *pstate)
{
    enum ruby_tag_type state;
 
    EC_PUSH_TAG(GET_EC());
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        rb_load(fname, wrap);
    }
    EC_POP_TAG();
 
    if (state != TAG_NONE) *pstate = state;
}
 
VALUE
rb_load_entrypoint(VALUE fname, VALUE wrap)
{
    VALUE path, orig_fname;
 
    orig_fname = rb_get_path_check_to_string(fname);
    fname = rb_str_encode_ospath(orig_fname);
    RUBY_DTRACE_HOOK(LOAD_ENTRY, RSTRING_PTR(orig_fname));
 
    path = rb_find_file(fname);
    if (!path) {
        if (!rb_file_load_ok(RSTRING_PTR(fname)))
            load_failed(orig_fname);
        path = fname;
    }
    rb_load_internal(path, wrap);
 
    RUBY_DTRACE_HOOK(LOAD_RETURN, RSTRING_PTR(orig_fname));
 
    return Qtrue;
}
 
/*
 *  call-seq:
 *     load(filename, wrap=false)   -> true
 *
 *  Loads and executes the Ruby program in the file _filename_.
 *
 *  If the filename is an absolute path (e.g. starts with '/'), the file
 *  will be loaded directly using the absolute path.
 *
 *  If the filename is an explicit relative path (e.g. starts with './' or
 *  '../'), the file will be loaded using the relative path from the current
 *  directory.
 *
 *  Otherwise, the file will be searched for in the library
 *  directories listed in <code>$LOAD_PATH</code> (<code>$:</code>).
 *  If the file is found in a directory, it will attempt to load the file
 *  relative to that directory.  If the file is not found in any of the
 *  directories in <code>$LOAD_PATH</code>, the file will be loaded using
 *  the relative path from the current directory.
 *
 *  If the file doesn't exist when there is an attempt to load it, a
 *  LoadError will be raised.
 *
 *  If the optional _wrap_ parameter is +true+, the loaded script will
 *  be executed under an anonymous module. If the optional _wrap_ parameter
 *  is a module, the loaded script will be executed under the given module.
 *  In no circumstance will any local variables in the loaded file be
 *  propagated to the loading environment.
 */
 
static VALUE
rb_f_load(int argc, VALUE *argv, VALUE _)
{
    VALUE fname, wrap;
    rb_scan_args(argc, argv, "11", &fname, &wrap);
    return rb_load_entrypoint(fname, wrap);
}
 
static char *
load_lock(const rb_box_t *box, const char *ftptr, bool warn)
{
    st_data_t data;
    st_table *loading_tbl = box->loading_table;
 
    if (!st_lookup(loading_tbl, (st_data_t)ftptr, &data)) {
        /* partial state */
        ftptr = ruby_strdup(ftptr);
        data = (st_data_t)rb_thread_shield_new();
        st_insert(loading_tbl, (st_data_t)ftptr, data);
        return (char *)ftptr;
    }
 
    if (warn && rb_thread_shield_owned((VALUE)data)) {
        VALUE warning = rb_warning_string("loading in progress, circular require considered harmful - %s", ftptr);
        rb_backtrace_each(rb_str_append, warning);
        rb_warning("%"PRIsVALUE, warning);
    }
    switch (rb_thread_shield_wait((VALUE)data)) {
      case Qfalse:
      case Qnil:
        return 0;
    }
    return (char *)ftptr;
}
 
static int
release_thread_shield(st_data_t *key, st_data_t *value, st_data_t done, int existing)
{
    VALUE thread_shield = (VALUE)*value;
    if (!existing) return ST_STOP;
    if (done) {
        rb_thread_shield_destroy(thread_shield);
        /* Delete the entry even if there are waiting threads, because they
         * won't load the file and won't delete the entry. */
    }
    else if (rb_thread_shield_release(thread_shield)) {
        /* still in-use */
        return ST_CONTINUE;
    }
    xfree((char *)*key);
    return ST_DELETE;
}
 
static void
load_unlock(const rb_box_t *box, const char *ftptr, int done)
{
    if (ftptr) {
        st_data_t key = (st_data_t)ftptr;
        st_table *loading_tbl = box->loading_table;
 
        st_update(loading_tbl, key, release_thread_shield, done);
    }
}
 
static VALUE rb_require_string_internal(VALUE fname, bool resurrect);
 
/*
 *  call-seq:
 *     require(name)    -> true or false
 *
 *  Loads the given +name+, returning +true+ if successful and +false+ if the
 *  feature is already loaded.
 *
 *  If the filename neither resolves to an absolute path nor starts with
 *  './' or '../', the file will be searched for in the library
 *  directories listed in <code>$LOAD_PATH</code> (<code>$:</code>).
 *  If the filename starts with './' or '../', resolution is based on Dir.pwd.
 *
 *  If the filename has the extension ".rb", it is loaded as a source file; if
 *  the extension is ".so", ".o", or the default shared library extension on
 *  the current platform, Ruby loads the shared library as a Ruby extension.
 *  Otherwise, Ruby tries adding ".rb", ".so", and so on to the name until
 *  found.  If the file named cannot be found, a LoadError will be raised.
 *
 *  For Ruby extensions the filename given may use ".so" or ".o".  For example,
 *  on macOS the socket extension is "socket.bundle" and
 *  <code>require 'socket.so'</code> will load the socket extension.
 *
 *  The absolute path of the loaded file is added to
 *  <code>$LOADED_FEATURES</code> (<code>$"</code>).  A file will not be
 *  loaded again if its path already appears in <code>$"</code>.  For example,
 *  <code>require 'a'; require './a'</code> will not load <code>a.rb</code>
 *  again.
 *
 *    require "my-library.rb"
 *    require "db-driver"
 *
 *  Any constants or globals within the loaded source file will be available
 *  in the calling program's global namespace. However, local variables will
 *  not be propagated to the loading environment.
 *
 */
 
VALUE
rb_f_require(VALUE obj, VALUE fname)
{
    return rb_require_string(fname);
}
 
VALUE
rb_require_relative_entrypoint(VALUE fname)
{
    VALUE base = rb_current_realfilepath();
    if (NIL_P(base)) {
        rb_loaderror("cannot infer basepath");
    }
    base = rb_file_dirname(base);
    return rb_require_string_internal(rb_file_absolute_path(fname, base), false);
}
 
/*
 * call-seq:
 *   require_relative(string) -> true or false
 *
 * Ruby tries to load the library named _string_ relative to the directory
 * containing the requiring file.  If the file does not exist a LoadError is
 * raised. Returns +true+ if the file was loaded and +false+ if the file was
 * already loaded before.
 */
static VALUE
rb_f_require_relative(VALUE obj, VALUE fname)
{
    return rb_require_relative_entrypoint(fname);
}
 
static char *
find_ext(VALUE str, char **ptr, const char **end)
{
    rb_len_t len = RSTRING_LEN(str);
    *ptr = RSTRING_PTR(str);
    *end = *ptr + len;
    return memrchr(*ptr, '.', len);
}
 
static bool
ext_equal(const char *ext, const char *end, const char *suffix, size_t len)
{
    return (size_t)(end - ext) == len && memcmp(ext, suffix, len) == 0;
}
 
#define EXT_RB_P(ext, end) ext_equal(ext, end, ".rb", rb_strlen_lit(".rb"))
#define EXT_SO_P(ext, end) (ext_equal(ext, end, ".so", rb_strlen_lit(".so")) || \
                            ext_equal(ext, end, ".o", rb_strlen_lit(".o")))
#define EXT_DLEXT_P(ext, end) ext_equal(ext, end, DLEXT, rb_strlen_lit(DLEXT))
 
typedef int (*feature_func)(const rb_box_t *box, const char *feature, const char *ext, int rb, int expanded, const char **fn);
 
static int
search_required(const rb_box_t *box, VALUE fname, volatile VALUE *path, feature_func rb_feature_p)
{
    VALUE tmp;
    char *ext, *ftptr;
    int ft = 0;
    const char *ftend, *loading;
 
    *path = 0;
    ext = find_ext(fname, &ftptr, &ftend);
    if (ext && !memchr(ext, '/', ftend - ext)) {
        if (EXT_RB_P(ext, ftend)) {
            if (rb_feature_p(box, ftptr, ext, TRUE, FALSE, &loading)) {
                if (loading) *path = rb_filesystem_str_new_cstr(loading);
                return 'r';
            }
            if ((tmp = rb_find_file(fname)) != 0) {
                ext = find_ext(tmp, &ftptr, &ftend);
                if (!rb_feature_p(box, ftptr, ext, TRUE, TRUE, &loading) || loading)
                    *path = tmp;
                return 'r';
            }
            return 0;
        }
        else if (EXT_SO_P(ext, ftend)) {
            if (rb_feature_p(box, ftptr, ext, FALSE, FALSE, &loading)) {
                if (loading) *path = rb_filesystem_str_new_cstr(loading);
                return 's';
            }
            tmp = rb_str_subseq(fname, 0, ext - RSTRING_PTR(fname));
            rb_str_cat2(tmp, DLEXT);
            OBJ_FREEZE(tmp);
            if ((tmp = rb_find_file(tmp)) != 0) {
                ext = find_ext(tmp, &ftptr, &ftend);
                if (!rb_feature_p(box, ftptr, ext, FALSE, TRUE, &loading) || loading)
                    *path = tmp;
                return 's';
            }
        }
        else if (EXT_DLEXT_P(ext, ftend)) {
            if (rb_feature_p(box, ftptr, ext, FALSE, FALSE, &loading)) {
                if (loading) *path = rb_filesystem_str_new_cstr(loading);
                return 's';
            }
            if ((tmp = rb_find_file(fname)) != 0) {
                ext = find_ext(tmp, &ftptr, &ftend);
                if (!rb_feature_p(box, ftptr, ext, FALSE, TRUE, &loading) || loading)
                    *path = tmp;
                return 's';
            }
        }
    }
    else if ((ft = rb_feature_p(box, ftptr, 0, FALSE, FALSE, &loading)) == 'r') {
        if (loading) *path = rb_filesystem_str_new_cstr(loading);
        return 'r';
    }
    tmp = fname;
    const unsigned int type = rb_find_file_ext(&tmp, ft == 's' ? ruby_ext : loadable_ext);
 
    // Check if it's a statically linked extension when
    // not already a feature and not found as a dynamic library.
    if (!ft && type != loadable_ext_rb) {
        rb_vm_t *vm = GET_VM();
        if (vm->static_ext_inits.num_entries) {
            VALUE lookup_name = tmp;
            // Append ".so" if not already present so for example "etc" can find "etc.so".
            // We always register statically linked extensions with a ".so" extension.
            // See encinit.c and extinit.c (generated at build-time).
            if (!ext) {
                lookup_name = rb_str_dup(lookup_name);
                rb_str_cat_cstr(lookup_name, ".so");
            }
            ftptr = RSTRING_PTR(lookup_name);
            if (st_lookup(&vm->static_ext_inits, (st_data_t)ftptr, NULL)) {
                *path = rb_filesystem_str_new_cstr(ftptr);
                RB_GC_GUARD(lookup_name);
                return 's';
            }
        }
    }
 
    switch (type) {
      case 0:
        if (ft)
            goto feature_present;
        ftptr = RSTRING_PTR(tmp);
        return rb_feature_p(box, ftptr, 0, FALSE, TRUE, 0);
 
      default:
        if (ft) {
            goto feature_present;
        }
        /* fall through */
      case loadable_ext_rb:
        ext = find_ext(tmp, &ftptr, &ftend);
        if (rb_feature_p(box, ftptr, ext, type == loadable_ext_rb, TRUE, &loading) && !loading)
            break;
        *path = tmp;
    }
    return type > loadable_ext_rb ? 's' : 'r';
 
  feature_present:
    if (loading) *path = rb_filesystem_str_new_cstr(loading);
    return ft;
}
 
static void
load_failed(VALUE fname)
{
    rb_load_fail(fname, "cannot load such file");
}
 
static VALUE
load_ext(VALUE path, VALUE fname)
{
    VALUE loaded = path;
    const rb_box_t *box = rb_loading_box();
    VALUE cleanup = 0;
    if (BOX_USER_P(box)) {
        loaded = rb_box_local_extension(box->box_object, path, &cleanup);
    }
    rb_scope_visibility_set(METHOD_VISI_PUBLIC);
    void *handle = dln_load_feature(RSTRING_PTR(loaded), RSTRING_PTR(fname));
    if (cleanup) {
        rb_box_cleanup_local_extension(cleanup);
        rb_box_defer_unload_local_extension(handle);
    }
    RB_GC_GUARD(loaded);
    RB_GC_GUARD(fname);
    return (VALUE)handle;
}
 
static VALUE
run_static_ext_init(VALUE vm_ptr, VALUE feature_value)
{
    rb_vm_t *vm = (rb_vm_t *)vm_ptr;
    const char *feature = RSTRING_PTR(feature_value);
    st_data_t key = (st_data_t)feature;
    st_data_t init_func;
 
    if (st_delete(&vm->static_ext_inits, &key, &init_func)) {
        ((void (*)(void))init_func)();
        return Qtrue;
    }
    return Qfalse;
}
 
static int
no_feature_p(const rb_box_t *box, const char *feature, const char *ext, int rb, int expanded, const char **fn)
{
    return 0;
}
 
// Documented in doc/language/globals.md
VALUE
rb_resolve_feature_path(VALUE klass, VALUE fname)
{
    VALUE path;
    int found;
    VALUE sym;
    const rb_box_t *box = rb_loading_box();
 
    fname = rb_get_path(fname);
    path = rb_str_encode_ospath(fname);
    found = search_required(box, path, &path, no_feature_p);
 
    switch (found) {
      case 'r':
        sym = ID2SYM(rb_intern("rb"));
        break;
      case 's':
        sym = ID2SYM(rb_intern("so"));
        break;
      default:
        return Qnil;
    }
 
    return rb_ary_new_from_args(2, sym, path);
}
 
static void
ext_config_push(rb_thread_t *th, volatile struct rb_ext_config *prev)
{
    *prev = th->ext_config;
    th->ext_config = (struct rb_ext_config){0};
}
 
static void
ext_config_pop(rb_thread_t *th, volatile struct rb_ext_config *prev)
{
    th->ext_config = *prev;
}
 
void
rb_ext_ractor_safe(bool flag)
{
    GET_THREAD()->ext_config.ractor_safe = flag;
}
 
/*
 * returns
 *  0: if already loaded (false)
 *  1: successfully loaded (true)
 * <0: not found (LoadError)
 * >1: exception
 */
static int
require_internal(rb_execution_context_t *ec, VALUE fname, int exception, bool warn)
{
    volatile int result = -1;
    rb_thread_t *th = rb_ec_thread_ptr(ec);
    const rb_box_t *box = rb_loading_box();
    volatile const struct {
        VALUE wrapper, self, errinfo;
        rb_execution_context_t *ec;
        const rb_box_t *box;
    } saved = {
        th->top_wrapper, th->top_self, ec->errinfo,
        ec, box,
    };
    enum ruby_tag_type state;
    char *volatile ftptr = 0;
    VALUE path;
    volatile VALUE saved_path;
    volatile VALUE realpath = 0;
    VALUE realpaths = box->loaded_features_realpaths;
    VALUE realpath_map = box->loaded_features_realpath_map;
    volatile bool reset_ext_config = false;
    volatile struct rb_ext_config prev_ext_config;
 
    path = rb_str_encode_ospath(fname);
    RUBY_DTRACE_HOOK(REQUIRE_ENTRY, RSTRING_PTR(fname));
    saved_path = path;
 
    EC_PUSH_TAG(ec);
    ec->errinfo = Qnil; /* ensure */
    th->top_wrapper = 0;
    if ((state = EC_EXEC_TAG()) == TAG_NONE) {
        VALUE handle;
        int found;
 
        RUBY_DTRACE_HOOK(FIND_REQUIRE_ENTRY, RSTRING_PTR(fname));
        found = search_required(box, path, &saved_path, rb_feature_p);
        RUBY_DTRACE_HOOK(FIND_REQUIRE_RETURN, RSTRING_PTR(fname));
        path = saved_path;
 
        if (found) {
            if (!path || !(ftptr = load_lock(box, RSTRING_PTR(path), warn))) {
                result = 0;
            }
            else if (!*ftptr) {
                result = TAG_RETURN;
            }
            else if (found == 's' && RTEST(rb_vm_call_cfunc_in_box(Qnil, run_static_ext_init, (VALUE)th->vm, path, path, box))) {
                result = TAG_RETURN;
            }
            else if (RTEST(rb_hash_aref(realpaths,
                                        realpath = realpath_internal_cached(realpath_map, path)))) {
                result = 0;
            }
            else {
                switch (found) {
                  case 'r':
                    load_iseq_eval(saved.ec, path);
                    break;
 
                  case 's':
                    reset_ext_config = true;
                    ext_config_push(th, &prev_ext_config);
                    handle = rb_vm_call_cfunc_in_box(box->top_self, load_ext, path, fname, path, box);
                    rb_hash_aset(box->ruby_dln_libmap, path, PTR2NUM(handle));
                    break;
                }
                result = TAG_RETURN;
            }
        }
    }
    EC_POP_TAG();
 
    ec = saved.ec;
    box = saved.box;
    rb_thread_t *th2 = rb_ec_thread_ptr(ec);
    th2->top_self = saved.self;
    th2->top_wrapper = saved.wrapper;
    if (reset_ext_config) ext_config_pop(th2, &prev_ext_config);
 
    path = saved_path;
    if (ftptr) load_unlock(box, RSTRING_PTR(path), !state);
 
    if (state) {
        if (state == TAG_FATAL || state == TAG_THROW) {
            EC_JUMP_TAG(ec, state);
        }
        else if (exception) {
            /* usually state == TAG_RAISE only, except for
             * rb_iseq_load_iseq in load_iseq_eval case */
            VALUE exc = rb_vm_make_jump_tag_but_local_jump(state, Qundef);
            if (!NIL_P(exc)) ec->errinfo = exc;
            return TAG_RAISE;
        }
        else if (state == TAG_RETURN) {
            return TAG_RAISE;
        }
        RB_GC_GUARD(fname);
        /* never TAG_RETURN */
        return state;
    }
    if (!NIL_P(ec->errinfo)) {
        if (!exception) return TAG_RAISE;
        rb_exc_raise(ec->errinfo);
    }
 
    if (result == TAG_RETURN) {
        rb_provide_feature(box, path);
        VALUE real = realpath;
        if (real) {
            real = rb_fstring(real);
            rb_hash_aset(realpaths, real, Qtrue);
        }
    }
    ec->errinfo = saved.errinfo;
 
    RUBY_DTRACE_HOOK(REQUIRE_RETURN, RSTRING_PTR(fname));
 
    return result;
}
 
int
rb_require_internal_silent(VALUE fname)
{
    if (!rb_ractor_main_p()) {
        return NUM2INT(rb_ractor_require(fname, true));
    }
 
    rb_execution_context_t *ec = GET_EC();
    return require_internal(ec, fname, 1, false);
}
 
int
rb_require_internal(VALUE fname)
{
    rb_execution_context_t *ec = GET_EC();
    return require_internal(ec, fname, 1, RTEST(ruby_verbose));
}
 
int
ruby_require_internal(const char *fname, unsigned int len)
{
    struct RString fake = {RBASIC_INIT};
    VALUE str = rb_setup_fake_str(&fake, fname, len, 0);
    rb_execution_context_t *ec = GET_EC();
    int result = require_internal(ec, str, 0, RTEST(ruby_verbose));
    rb_set_errinfo(Qnil);
    return result == TAG_RETURN ? 1 : result ? -1 : 0;
}
 
VALUE
rb_require_string(VALUE fname)
{
    return rb_require_string_internal(FilePathValue(fname), false);
}
 
static VALUE
rb_require_string_internal(VALUE fname, bool resurrect)
{
    rb_execution_context_t *ec = GET_EC();
 
    // main ractor check
    if (!rb_ractor_main_p()) {
        if (resurrect) fname = rb_str_resurrect(fname);
        return rb_ractor_require(fname, false);
    }
    else {
        int result = require_internal(ec, fname, 1, RTEST(ruby_verbose));
 
        if (result > TAG_RETURN) {
            EC_JUMP_TAG(ec, result);
        }
        if (result < 0) {
            if (resurrect) fname = rb_str_resurrect(fname);
            load_failed(fname);
        }
 
        return RBOOL(result);
    }
}
 
VALUE
rb_require(const char *fname)
{
    struct RString fake = {RBASIC_INIT};
    VALUE str = rb_setup_fake_str(&fake, fname, strlen(fname), 0);
    return rb_require_string_internal(str, true);
}
 
static int
register_init_ext(st_data_t *key, st_data_t *value, st_data_t init, int existing)
{
    const char *name = (char *)*key;
    if (existing) {
        /* already registered */
        rb_warn("%s is already registered", name);
    }
    else {
        *value = (st_data_t)init;
    }
    return ST_CONTINUE;
}
 
// Private API for statically linked extensions.
// Used with the ext/Setup file, the --with-setup and
// --with-static-linked-ext configuration option, etc.
void
ruby_init_ext(const char *name, void (*init)(void))
{
    rb_vm_t *vm = GET_VM();
    const rb_box_t *box = rb_loading_box();
 
    if (feature_provided((rb_box_t *)box, name, 0))
        return;
 
    st_update(&vm->static_ext_inits, (st_data_t)name, register_init_ext, (st_data_t)init);
}
 
/*
 *  call-seq:
 *     mod.autoload(const, filename)   -> nil
 *
 *  Registers _filename_ to be loaded (using Kernel::require)
 *  the first time that _const_ (which may be a String or
 *  a symbol) is accessed in the namespace of _mod_.
 *
 *     module A
 *     end
 *     A.autoload(:B, "b")
 *     A::B.doit            # autoloads "b"
 *
 *  If _const_ in _mod_ is defined as autoload, the file name to be
 *  loaded is replaced with _filename_.  If _const_ is defined but not
 *  as autoload, does nothing.
 *
 *  Files that are currently being loaded must not be registered for
 *  autoload.
 */
 
static VALUE
rb_mod_autoload(VALUE mod, VALUE sym, VALUE file)
{
    ID id = rb_to_id(sym);
 
    FilePathValue(file);
    rb_autoload_str(mod, id, file);
    return Qnil;
}
 
/*
 *  call-seq:
 *     mod.autoload_relative(const, filename)   -> nil
 *
 *  Registers _filename_ to be loaded (using Kernel::require)
 *  the first time that _const_ (which may be a String or
 *  a symbol) is accessed in the namespace of _mod_. The _filename_
 *  is interpreted as relative to the directory of the file where
 *  autoload_relative is called.
 *
 *     module A
 *     end
 *     A.autoload_relative(:B, "b.rb")
 *
 *  If _const_ in _mod_ is defined as autoload, the file name to be
 *  loaded is replaced with _filename_.  If _const_ is defined but not
 *  as autoload, does nothing.
 *
 *  The relative path is converted to an absolute path, which is what
 *  will be returned by Module#autoload? for the constant.
 *
 *  Raises LoadError if called without file context (e.g., from eval).
 */
 
static VALUE
rb_mod_autoload_relative(VALUE mod, VALUE sym, VALUE file)
{
    ID id = rb_to_id(sym);
    VALUE base, absolute_path;
 
    FilePathValue(file);
 
    base = rb_current_realfilepath();
    if (NIL_P(base)) {
        rb_loaderror("cannot infer basepath (autoload_relative called without file context)");
    }
    base = rb_file_dirname(base);
    absolute_path = rb_file_absolute_path(file, base);
 
    rb_autoload_str(mod, id, absolute_path);
    return Qnil;
}
 
/*
 *  call-seq:
 *     mod.autoload?(name, inherit=true)   -> String or nil
 *
 *  Returns _filename_ to be loaded if _name_ is registered as
 *  +autoload+ in the namespace of _mod_ or one of its ancestors.
 *
 *     module A
 *     end
 *     A.autoload(:B, "b")
 *     A.autoload?(:B)            #=> "b"
 *
 *  If +inherit+ is false, the lookup only checks the autoloads in the receiver:
 *
 *     class A
 *       autoload :CONST, "const.rb"
 *     end
 *
 *     class B < A
 *     end
 *
 *     B.autoload?(:CONST)          #=> "const.rb", found in A (ancestor)
 *     B.autoload?(:CONST, false)   #=> nil, not found in B itself
 *
 */
 
static VALUE
rb_mod_autoload_p(int argc, VALUE *argv, VALUE mod)
{
    int recur = (rb_check_arity(argc, 1, 2) == 1) ? TRUE : RTEST(argv[1]);
    VALUE sym = argv[0];
 
    ID id = rb_check_id(&sym);
    if (!id) {
        return Qnil;
    }
    return rb_autoload_at_p(mod, id, recur);
}
 
/*
 *  call-seq:
 *     autoload(const, filename)   -> nil
 *
 *  Registers _filename_ to be loaded (using Kernel::require)
 *  the first time that _const_ (which may be a String or
 *  a symbol) is accessed.
 *
 *     autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
 *
 *  If _const_ is defined as autoload, the file name to be loaded is
 *  replaced with _filename_.  If _const_ is defined but not as
 *  autoload, does nothing.
 *
 *  Files that are currently being loaded must not be registered for
 *  autoload.
 */
 
static VALUE
rb_f_autoload(VALUE obj, VALUE sym, VALUE file)
{
    VALUE klass = rb_class_real(rb_vm_cbase());
    if (!klass) {
        rb_raise(rb_eTypeError, "Can not set autoload on singleton class");
    }
    return rb_mod_autoload(klass, sym, file);
}
 
/*
 *  call-seq:
 *     autoload_relative(const, filename)   -> nil
 *
 *  Registers _filename_ to be loaded (using Kernel::require)
 *  the first time that _const_ (which may be a String or
 *  a symbol) is accessed. The _filename_ is interpreted as
 *  relative to the directory of the file where autoload_relative
 *  is called.
 *
 *     autoload_relative(:MyModule, "my_module.rb")
 *
 *  If _const_ is defined as autoload, the file name to be loaded is
 *  replaced with _filename_.  If _const_ is defined but not as
 *  autoload, does nothing.
 *
 *  The relative path is converted to an absolute path, which is what
 *  will be returned by Kernel#autoload? for the constant.
 *
 *  Raises LoadError if called without file context (e.g., from eval).
 */
 
static VALUE
rb_f_autoload_relative(VALUE obj, VALUE sym, VALUE file)
{
    VALUE klass = rb_class_real(rb_vm_cbase());
    if (!klass) {
        rb_raise(rb_eTypeError, "Can not set autoload on singleton class");
    }
    return rb_mod_autoload_relative(klass, sym, file);
}
 
/*
 *  call-seq:
 *     autoload?(name, inherit=true)   -> String or nil
 *
 *  Returns _filename_ to be loaded if _name_ is registered as
 *  +autoload+ in the current namespace or one of its ancestors.
 *
 *     autoload(:B, "b")
 *     autoload?(:B)            #=> "b"
 *
 *     module C
 *       autoload(:D, "d")
 *       autoload?(:D)          #=> "d"
 *       autoload?(:B)          #=> nil
 *     end
 *
 *     class E
 *       autoload(:F, "f")
 *       autoload?(:F)          #=> "f"
 *       autoload?(:B)          #=> "b"
 *     end
 */
 
static VALUE
rb_f_autoload_p(int argc, VALUE *argv, VALUE obj)
{
    /* use rb_vm_cbase() as same as rb_f_autoload. */
    VALUE klass = rb_vm_cbase();
    if (NIL_P(klass)) {
        return Qnil;
    }
    return rb_mod_autoload_p(argc, argv, klass);
}
 
void *
rb_ext_resolve_symbol(const char* fname, const char* symbol)
{
    VALUE handle;
    VALUE resolved;
    VALUE path;
    const char *ext;
    VALUE fname_str = rb_str_new_cstr(fname);
    const rb_box_t *box = rb_loading_box();
 
    resolved = rb_resolve_feature_path((VALUE)NULL, fname_str);
    if (NIL_P(resolved)) {
        ext = strrchr(fname, '.');
        if (!ext || !IS_SOEXT(ext)) {
            rb_str_cat_cstr(fname_str, ".so");
        }
        if (rb_feature_p(box, fname, 0, FALSE, FALSE, 0)) {
            return dln_symbol(NULL, symbol);
        }
        return NULL;
    }
    if (RARRAY_LEN(resolved) != 2 || rb_ary_entry(resolved, 0) != ID2SYM(rb_intern("so"))) {
        return NULL;
    }
    path = rb_ary_entry(resolved, 1);
    handle = rb_hash_lookup(box->ruby_dln_libmap, path);
    if (NIL_P(handle)) {
        return NULL;
    }
    return dln_symbol(NUM2PTR(handle), symbol);
}
 
void
Init_load(void)
{
    static const char var_load_path[] = "$:";
    ID id_load_path = rb_intern2(var_load_path, sizeof(var_load_path)-1);
 
    rb_define_hooked_variable(var_load_path, 0, load_path_getter, rb_gvar_readonly_setter);
    rb_gvar_box_ready(var_load_path);
    rb_alias_variable(rb_intern_const("$-I"), id_load_path);
    rb_alias_variable(rb_intern_const("$LOAD_PATH"), id_load_path);
 
    rb_define_virtual_variable("$\"", get_LOADED_FEATURES, 0);
    rb_gvar_box_ready("$\"");
    rb_define_virtual_variable("$LOADED_FEATURES", get_LOADED_FEATURES, 0); // TODO: rb_alias_variable ?
    rb_gvar_box_ready("$LOADED_FEATURES");
 
    rb_define_global_function("load", rb_f_load, -1);
    rb_define_global_function("require", rb_f_require, 1);
    rb_define_global_function("require_relative", rb_f_require_relative, 1);
    rb_define_method(rb_cModule, "autoload", rb_mod_autoload, 2);
    rb_define_method(rb_cModule, "autoload_relative", rb_mod_autoload_relative, 2);
    rb_define_method(rb_cModule, "autoload?", rb_mod_autoload_p, -1);
    rb_define_global_function("autoload", rb_f_autoload, 2);
    rb_define_global_function("autoload_relative", rb_f_autoload_relative, 2);
    rb_define_global_function("autoload?", rb_f_autoload_p, -1);
}