2006-12-31 10:02:22 -05:00
|
|
|
/*
|
|
|
|
* load methods from eval.c
|
|
|
|
*/
|
|
|
|
|
* common.mk: clean up
- remove blockinlining.$(OBJEXT) to built
- make ENCODING_H_INCLDUES variable (include/ruby/encoding.h)
- make VM_CORE_H_INCLUDES variable (vm_core.h)
- simplify rules.
- make depends rule to output depend status using gcc -MM.
* include/ruby/mvm.h, include/ruby/vm.h: rename mvm.h to vm.h.
* include/ruby.h: ditto.
* load.c: add inclusion explicitly.
* enumerator.c, object.c, parse.y, thread.c, vm_dump.c:
remove useless inclusion.
* eval_intern.h: cleanup inclusion.
* vm_core.h: rb_thread_t should be defined in this file.
* vm_evalbody.c, vm_exec.c: rename vm_evalbody.c to vm_exec.c.
* vm.h, vm_exec.h: rename vm.h to vm_exec.h.
* insnhelper.h, vm_insnhelper.h: rename insnhelper.h to vm_insnhelper.h.
* vm.c, vm_insnhelper.c, vm_insnhelper.h:
- rename vm_eval() to vm_exec_core().
- rename vm_eval_body() to vm_exec().
- cleanup include order.
* vm_method.c: fix comment.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19466 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-09-22 20:20:28 -04:00
|
|
|
#include "dln.h"
|
2006-12-31 10:02:22 -05:00
|
|
|
#include "eval_intern.h"
|
2019-12-04 03:16:30 -05:00
|
|
|
#include "internal.h"
|
|
|
|
#include "internal/dir.h"
|
|
|
|
#include "internal/error.h"
|
|
|
|
#include "internal/file.h"
|
|
|
|
#include "internal/load.h"
|
|
|
|
#include "internal/parse.h"
|
|
|
|
#include "internal/thread.h"
|
|
|
|
#include "internal/variable.h"
|
2018-12-06 08:42:32 -05:00
|
|
|
#include "iseq.h"
|
2019-12-04 03:16:30 -05:00
|
|
|
#include "probes.h"
|
|
|
|
#include "ruby/encoding.h"
|
|
|
|
#include "ruby/util.h"
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2015-07-21 03:09:36 -04:00
|
|
|
static VALUE ruby_dln_librefs;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2011-05-22 08:52:18 -04:00
|
|
|
#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)
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2007-05-03 09:19:11 -04:00
|
|
|
static const char *const loadable_ext[] = {
|
|
|
|
".rb", DLEXT,
|
|
|
|
0
|
|
|
|
};
|
|
|
|
|
2021-07-27 16:55:21 -04:00
|
|
|
static const char *const ruby_ext[] = {
|
|
|
|
".rb",
|
|
|
|
0
|
|
|
|
};
|
|
|
|
|
2012-11-05 10:27:08 -05:00
|
|
|
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.
|
2012-11-06 17:00:12 -05:00
|
|
|
We don't cache non string object and expand it every time. We ensure that
|
2012-11-05 10:27:08 -05:00
|
|
|
string objects in $LOAD_PATH are frozen.
|
|
|
|
*/
|
2012-11-05 10:27:05 -05:00
|
|
|
static void
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_construct_expanded_load_path(rb_vm_t *vm, enum expand_type type, int *has_relative, int *has_non_cache)
|
2008-12-11 21:00:55 -05:00
|
|
|
{
|
2012-11-05 10:27:05 -05:00
|
|
|
VALUE load_path = vm->load_path;
|
2012-11-05 10:27:08 -05:00
|
|
|
VALUE expanded_load_path = vm->expanded_load_path;
|
2010-03-12 20:34:38 -05:00
|
|
|
VALUE ary;
|
2008-12-11 21:00:55 -05:00
|
|
|
long i;
|
|
|
|
|
2013-03-08 19:03:40 -05:00
|
|
|
ary = rb_ary_tmp_new(RARRAY_LEN(load_path));
|
2008-12-11 21:00:55 -05:00
|
|
|
for (i = 0; i < RARRAY_LEN(load_path); ++i) {
|
2012-11-05 10:27:05 -05:00
|
|
|
VALUE path, as_str, expanded_path;
|
2012-11-05 10:27:08 -05:00
|
|
|
int is_string, non_cache;
|
|
|
|
char *as_cstr;
|
2013-05-13 05:56:22 -04:00
|
|
|
as_str = path = RARRAY_AREF(load_path, i);
|
2012-11-05 10:27:08 -05:00
|
|
|
is_string = RB_TYPE_P(path, T_STRING) ? 1 : 0;
|
|
|
|
non_cache = !is_string ? 1 : 0;
|
2019-09-20 22:06:22 -04:00
|
|
|
as_str = rb_get_path_check_to_string(path);
|
2012-11-05 10:27:08 -05:00
|
|
|
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. */
|
2013-05-13 05:56:22 -04:00
|
|
|
rb_ary_push(ary, RARRAY_AREF(expanded_load_path, i));
|
2012-11-05 10:27:08 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!*has_relative && !rb_is_absolute_path(as_cstr))
|
|
|
|
*has_relative = 1;
|
|
|
|
if (!*has_non_cache && non_cache)
|
|
|
|
*has_non_cache = 1;
|
2012-11-06 17:00:12 -05:00
|
|
|
/* Freeze only string object. We expand other objects every time. */
|
2012-11-05 10:27:08 -05:00
|
|
|
if (is_string)
|
|
|
|
rb_str_freeze(path);
|
2019-09-20 22:06:22 -04:00
|
|
|
as_str = rb_get_path_check_convert(as_str);
|
2019-12-02 18:12:57 -05:00
|
|
|
expanded_path = rb_check_realpath(Qnil, as_str, NULL);
|
2017-09-21 03:29:20 -04:00
|
|
|
if (NIL_P(expanded_path)) expanded_path = as_str;
|
2015-07-15 20:03:40 -04:00
|
|
|
rb_ary_push(ary, rb_fstring(expanded_path));
|
2008-12-11 21:00:55 -05:00
|
|
|
}
|
|
|
|
rb_obj_freeze(ary);
|
2012-11-05 10:27:05 -05:00
|
|
|
vm->expanded_load_path = ary;
|
|
|
|
rb_ary_replace(vm->load_path_snapshot, vm->load_path);
|
|
|
|
}
|
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
static VALUE
|
|
|
|
get_expanded_load_path(rb_vm_t *vm)
|
2012-11-05 10:27:05 -05:00
|
|
|
{
|
2012-11-05 10:27:08 -05:00
|
|
|
const VALUE non_cache = Qtrue;
|
|
|
|
|
2012-11-05 10:27:05 -05:00
|
|
|
if (!rb_ary_shared_with_p(vm->load_path_snapshot, vm->load_path)) {
|
2012-11-05 10:27:08 -05:00
|
|
|
/* The load path was modified. Rebuild the expanded load path. */
|
|
|
|
int has_relative = 0, has_non_cache = 0;
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_construct_expanded_load_path(vm, EXPAND_ALL, &has_relative, &has_non_cache);
|
2012-11-05 10:27:08 -05:00
|
|
|
if (has_relative) {
|
2017-11-11 23:45:51 -05:00
|
|
|
vm->load_path_check_cache = rb_dir_getwd_ospath();
|
2012-11-05 10:27:08 -05:00
|
|
|
}
|
|
|
|
else if (has_non_cache) {
|
|
|
|
/* Non string object. */
|
|
|
|
vm->load_path_check_cache = non_cache;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
vm->load_path_check_cache = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (vm->load_path_check_cache == non_cache) {
|
|
|
|
int has_relative = 1, has_non_cache = 1;
|
|
|
|
/* Expand only non-cacheable objects. */
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_construct_expanded_load_path(vm, EXPAND_NON_CACHE,
|
2012-11-05 10:27:08 -05:00
|
|
|
&has_relative, &has_non_cache);
|
|
|
|
}
|
|
|
|
else if (vm->load_path_check_cache) {
|
|
|
|
int has_relative = 1, has_non_cache = 1;
|
2017-11-11 23:45:51 -05:00
|
|
|
VALUE cwd = rb_dir_getwd_ospath();
|
2012-11-05 10:27:08 -05:00
|
|
|
if (!rb_str_equal(vm->load_path_check_cache, cwd)) {
|
|
|
|
/* Current working directory or filesystem encoding was changed.
|
|
|
|
Expand relative load path and non-cacheable objects again. */
|
|
|
|
vm->load_path_check_cache = cwd;
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_construct_expanded_load_path(vm, EXPAND_RELATIVE,
|
2012-11-05 10:27:08 -05:00
|
|
|
&has_relative, &has_non_cache);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Expand only tilde (User HOME) and non-cacheable objects. */
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_construct_expanded_load_path(vm, EXPAND_HOME,
|
2012-11-05 10:27:08 -05:00
|
|
|
&has_relative, &has_non_cache);
|
|
|
|
}
|
2012-11-05 10:27:05 -05:00
|
|
|
}
|
|
|
|
return vm->expanded_load_path;
|
2008-12-11 21:00:55 -05:00
|
|
|
}
|
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
VALUE
|
|
|
|
rb_get_expanded_load_path(void)
|
|
|
|
{
|
|
|
|
return get_expanded_load_path(GET_VM());
|
|
|
|
}
|
|
|
|
|
2008-04-30 05:03:03 -04:00
|
|
|
static VALUE
|
2019-08-26 22:16:52 -04:00
|
|
|
load_path_getter(ID id, VALUE * p)
|
2008-04-30 05:03:03 -04:00
|
|
|
{
|
2019-08-26 22:16:52 -04:00
|
|
|
rb_vm_t *vm = (void *)p;
|
2008-04-30 05:03:03 -04:00
|
|
|
return vm->load_path;
|
|
|
|
}
|
|
|
|
|
2007-02-13 21:19:02 -05:00
|
|
|
static VALUE
|
2021-09-16 12:20:10 -04:00
|
|
|
get_loaded_features(rb_vm_t *vm)
|
2007-02-13 21:19:02 -05:00
|
|
|
{
|
2021-09-16 12:20:10 -04:00
|
|
|
return vm->loaded_features;
|
2007-02-13 21:19:02 -05:00
|
|
|
}
|
|
|
|
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
static VALUE
|
2021-09-16 12:20:10 -04:00
|
|
|
get_loaded_features_realpaths(rb_vm_t *vm)
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
{
|
2021-09-16 12:20:10 -04:00
|
|
|
return vm->loaded_features_realpaths;
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
}
|
|
|
|
|
2019-08-26 22:16:52 -04:00
|
|
|
static VALUE
|
2019-08-27 01:21:18 -04:00
|
|
|
get_LOADED_FEATURES(ID _x, VALUE *_y)
|
2019-08-26 22:16:52 -04:00
|
|
|
{
|
2021-09-16 12:20:10 -04:00
|
|
|
return get_loaded_features(GET_VM());
|
2019-08-26 22:16:52 -04:00
|
|
|
}
|
|
|
|
|
2012-11-05 10:27:01 -05:00
|
|
|
static void
|
2021-09-16 12:20:10 -04:00
|
|
|
reset_loaded_features_snapshot(rb_vm_t *vm)
|
2012-11-05 10:27:01 -05:00
|
|
|
{
|
|
|
|
rb_ary_replace(vm->loaded_features_snapshot, vm->loaded_features);
|
|
|
|
}
|
|
|
|
|
2013-03-22 04:38:51 -04:00
|
|
|
static struct st_table *
|
2021-09-16 12:20:10 -04:00
|
|
|
get_loaded_features_index_raw(rb_vm_t *vm)
|
2012-11-05 10:27:01 -05:00
|
|
|
{
|
2021-09-16 12:20:10 -04:00
|
|
|
return vm->loaded_features_index;
|
2012-11-05 10:27:01 -05:00
|
|
|
}
|
|
|
|
|
2007-05-03 09:19:11 -04:00
|
|
|
static st_table *
|
2021-09-16 12:20:10 -04:00
|
|
|
get_loading_table(rb_vm_t *vm)
|
2007-05-03 09:19:11 -04:00
|
|
|
{
|
2021-09-16 12:20:10 -04:00
|
|
|
return vm->loading_table;
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
|
|
|
|
2018-02-14 13:38:33 -05:00
|
|
|
static st_data_t
|
|
|
|
feature_key(const char *str, size_t len)
|
|
|
|
{
|
|
|
|
return st_hash(str, len, 0xfea7009e);
|
|
|
|
}
|
|
|
|
|
2021-07-12 12:03:26 -04:00
|
|
|
static bool
|
|
|
|
is_rbext_path(VALUE feature_path)
|
|
|
|
{
|
|
|
|
long len = RSTRING_LEN(feature_path);
|
|
|
|
long rbext_len = rb_strlen_lit(".rb");
|
|
|
|
if (len <= rbext_len) return false;
|
|
|
|
return IS_RBEXT(RSTRING_PTR(feature_path) + len - rbext_len);
|
|
|
|
}
|
|
|
|
|
2012-11-05 10:27:01 -05:00
|
|
|
static void
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add_single(rb_vm_t *vm, const char* str, size_t len, VALUE offset, bool rb)
|
2012-11-05 10:27:01 -05:00
|
|
|
{
|
2013-03-22 04:38:51 -04:00
|
|
|
struct st_table *features_index;
|
|
|
|
VALUE this_feature_index = Qnil;
|
2018-02-14 13:38:33 -05:00
|
|
|
st_data_t short_feature_key;
|
2021-07-13 11:51:53 -04:00
|
|
|
st_data_t data;
|
2013-03-22 04:38:51 -04:00
|
|
|
|
|
|
|
Check_Type(offset, T_FIXNUM);
|
2018-02-14 13:38:33 -05:00
|
|
|
short_feature_key = feature_key(str, len);
|
2013-03-22 04:38:51 -04:00
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index = get_loaded_features_index_raw(vm);
|
2021-07-13 11:51:53 -04:00
|
|
|
if (!st_lookup(features_index, short_feature_key, &data) ||
|
|
|
|
NIL_P(this_feature_index = (VALUE)data)) {
|
2018-02-14 13:38:33 -05:00
|
|
|
st_insert(features_index, short_feature_key, (st_data_t)offset);
|
2013-03-08 18:37:02 -05:00
|
|
|
}
|
2021-09-11 00:45:22 -04:00
|
|
|
else if (FIXNUM_P(this_feature_index)) {
|
2021-09-16 12:20:10 -04:00
|
|
|
VALUE loaded_features = get_loaded_features(vm);
|
2021-07-12 12:03:26 -04:00
|
|
|
VALUE this_feature_path = RARRAY_AREF(loaded_features, FIX2LONG(this_feature_index));
|
2013-03-08 18:37:02 -05:00
|
|
|
VALUE feature_indexes[2];
|
2021-07-12 12:03:26 -04:00
|
|
|
int top = (rb && !is_rbext_path(this_feature_path)) ? 1 : 0;
|
|
|
|
feature_indexes[top^0] = this_feature_index;
|
|
|
|
feature_indexes[top^1] = offset;
|
2013-12-03 03:13:31 -05:00
|
|
|
this_feature_index = (VALUE)xcalloc(1, sizeof(struct RArray));
|
|
|
|
RBASIC(this_feature_index)->flags = T_ARRAY; /* fake VALUE, do not mark/sweep */
|
2013-03-08 18:37:02 -05:00
|
|
|
rb_ary_cat(this_feature_index, feature_indexes, numberof(feature_indexes));
|
2018-02-14 13:38:33 -05:00
|
|
|
st_insert(features_index, short_feature_key, (st_data_t)this_feature_index);
|
2012-11-05 10:27:01 -05:00
|
|
|
}
|
2013-03-08 18:37:02 -05:00
|
|
|
else {
|
2021-07-12 12:03:26 -04:00
|
|
|
long pos = -1;
|
|
|
|
|
2013-03-08 18:37:02 -05:00
|
|
|
Check_Type(this_feature_index, T_ARRAY);
|
2021-07-12 12:03:26 -04:00
|
|
|
if (rb) {
|
2021-09-16 12:20:10 -04:00
|
|
|
VALUE loaded_features = get_loaded_features(vm);
|
2021-07-12 12:03:26 -04:00
|
|
|
for (long i = 0; i < RARRAY_LEN(this_feature_index); ++i) {
|
|
|
|
VALUE idx = RARRAY_AREF(this_feature_index, i);
|
|
|
|
VALUE this_feature_path = RARRAY_AREF(loaded_features, FIX2LONG(idx));
|
|
|
|
Check_Type(this_feature_path, T_STRING);
|
|
|
|
if (!is_rbext_path(this_feature_path)) {
|
|
|
|
/* as this_feature_index is a fake VALUE, `push` (which
|
|
|
|
* doesn't wb_unprotect like as rb_ary_splice) first,
|
|
|
|
* then rotate partially. */
|
|
|
|
pos = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-03-08 18:37:02 -05:00
|
|
|
rb_ary_push(this_feature_index, offset);
|
2021-07-12 12:03:26 -04:00
|
|
|
if (pos >= 0) {
|
|
|
|
VALUE *ptr = (VALUE *)RARRAY_CONST_PTR_TRANSIENT(this_feature_index);
|
|
|
|
long len = RARRAY_LEN(this_feature_index);
|
|
|
|
MEMMOVE(ptr + pos, ptr + pos + 1, VALUE, len - pos - 1);
|
|
|
|
ptr[pos] = offset;
|
|
|
|
}
|
2013-03-08 18:37:02 -05:00
|
|
|
}
|
2012-11-05 10:27:01 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
2015-08-12 19:43:41 -04:00
|
|
|
feature == "#{prefix}#{short_feature}#{ext}"
|
|
|
|
where `ext` is empty or matches %r{^\.[^./]*$}, and `prefix` is empty
|
2012-11-05 10:27:01 -05:00
|
|
|
or ends in '/'. This maintains the invariant that `rb_feature_p()`
|
|
|
|
relies on for its fast lookup.
|
|
|
|
*/
|
|
|
|
static void
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add(rb_vm_t *vm, VALUE feature, VALUE offset)
|
2012-11-05 10:27:01 -05:00
|
|
|
{
|
|
|
|
const char *feature_str, *feature_end, *ext, *p;
|
2021-07-12 12:03:26 -04:00
|
|
|
bool rb = false;
|
2012-11-05 10:27:01 -05:00
|
|
|
|
|
|
|
feature_str = StringValuePtr(feature);
|
|
|
|
feature_end = feature_str + RSTRING_LEN(feature);
|
|
|
|
|
|
|
|
for (ext = feature_end; ext > feature_str; ext--)
|
2016-12-08 21:59:55 -05:00
|
|
|
if (*ext == '.' || *ext == '/')
|
|
|
|
break;
|
2012-11-05 10:27:01 -05:00
|
|
|
if (*ext != '.')
|
2016-12-08 21:59:55 -05:00
|
|
|
ext = NULL;
|
2021-07-12 12:03:26 -04:00
|
|
|
else
|
|
|
|
rb = IS_RBEXT(ext);
|
2012-11-05 10:27:01 -05:00
|
|
|
/* 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`. */
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add_single(vm, p + 1, feature_end - p - 1, offset, false);
|
2012-11-05 10:27:01 -05:00
|
|
|
if (ext) {
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add_single(vm, p + 1, ext - p - 1, offset, rb);
|
2012-11-05 10:27:01 -05:00
|
|
|
}
|
|
|
|
}
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add_single(vm, feature_str, feature_end - feature_str, offset, false);
|
2012-11-05 10:27:01 -05:00
|
|
|
if (ext) {
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add_single(vm, feature_str, ext - feature_str, offset, rb);
|
2012-11-05 10:27:01 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-03-22 04:38:51 -04:00
|
|
|
static int
|
|
|
|
loaded_features_index_clear_i(st_data_t key, st_data_t val, st_data_t arg)
|
|
|
|
{
|
2013-12-03 03:13:31 -05:00
|
|
|
VALUE obj = (VALUE)val;
|
|
|
|
if (!SPECIAL_CONST_P(obj)) {
|
|
|
|
rb_ary_free(obj);
|
2018-05-21 17:40:54 -04:00
|
|
|
ruby_sized_xfree((void *)obj, sizeof(struct RArray));
|
2013-12-03 03:13:31 -05:00
|
|
|
}
|
2013-03-22 04:38:51 -04:00
|
|
|
return ST_DELETE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static st_table *
|
2021-09-16 12:20:10 -04:00
|
|
|
get_loaded_features_index(rb_vm_t *vm)
|
2012-11-05 10:27:01 -05:00
|
|
|
{
|
|
|
|
VALUE features;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!rb_ary_shared_with_p(vm->loaded_features_snapshot, vm->loaded_features)) {
|
|
|
|
/* The sharing was broken; something (other than us in rb_provide_feature())
|
|
|
|
modified loaded_features. Rebuild the index. */
|
2013-03-22 04:38:51 -04:00
|
|
|
st_foreach(vm->loaded_features_index, loaded_features_index_clear_i, 0);
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
|
|
|
|
VALUE realpaths = vm->loaded_features_realpaths;
|
|
|
|
rb_hash_clear(realpaths);
|
2012-11-05 10:27:01 -05:00
|
|
|
features = vm->loaded_features;
|
|
|
|
for (i = 0; i < RARRAY_LEN(features); i++) {
|
|
|
|
VALUE entry, as_str;
|
|
|
|
as_str = entry = rb_ary_entry(features, i);
|
|
|
|
StringValue(as_str);
|
2015-07-15 20:03:40 -04:00
|
|
|
as_str = rb_fstring(rb_str_freeze(as_str));
|
2012-11-05 10:27:01 -05:00
|
|
|
if (as_str != entry)
|
|
|
|
rb_ary_store(features, i, as_str);
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add(vm, as_str, INT2FIX(i));
|
2012-11-05 10:27:01 -05:00
|
|
|
}
|
2021-09-16 12:20:10 -04:00
|
|
|
reset_loaded_features_snapshot(vm);
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
|
|
|
|
features = rb_ary_dup(vm->loaded_features_snapshot);
|
|
|
|
long j = RARRAY_LEN(features);
|
|
|
|
for (i = 0; i < j; i++) {
|
|
|
|
VALUE as_str = rb_ary_entry(features, i);
|
|
|
|
VALUE realpath = rb_check_realpath(Qnil, as_str, NULL);
|
|
|
|
if (NIL_P(realpath)) realpath = as_str;
|
|
|
|
rb_hash_aset(realpaths, rb_fstring(realpath), Qtrue);
|
|
|
|
}
|
2012-11-05 10:27:01 -05:00
|
|
|
}
|
|
|
|
return vm->loaded_features_index;
|
|
|
|
}
|
|
|
|
|
2012-11-05 10:24:03 -05:00
|
|
|
/* 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{^\.[^./]*$}`.
|
|
|
|
*/
|
2007-11-06 01:52:01 -05:00
|
|
|
static VALUE
|
2007-11-06 02:37:49 -05:00
|
|
|
loaded_feature_path(const char *name, long vlen, const char *feature, long len,
|
2007-11-08 22:56:38 -05:00
|
|
|
int type, VALUE load_path)
|
2007-11-06 01:52:01 -05:00
|
|
|
{
|
|
|
|
long i;
|
2011-05-31 17:56:01 -04:00
|
|
|
long plen;
|
|
|
|
const char *e;
|
|
|
|
|
2012-11-05 10:24:07 -05:00
|
|
|
if (vlen < len+1) return 0;
|
2015-05-16 15:02:38 -04:00
|
|
|
if (strchr(feature, '.') && !strncmp(name+(vlen-len), feature, len)) {
|
2013-05-23 04:35:34 -04:00
|
|
|
plen = vlen - len;
|
2012-10-29 05:31:50 -04:00
|
|
|
}
|
|
|
|
else {
|
2011-05-31 17:56:01 -04:00
|
|
|
for (e = name + vlen; name != e && *e != '.' && *e != '/'; --e);
|
2012-10-29 05:31:50 -04:00
|
|
|
if (*e != '.' ||
|
2011-05-31 17:56:01 -04:00
|
|
|
e-name < len ||
|
2012-10-29 05:31:50 -04:00
|
|
|
strncmp(e-len, feature, len))
|
2011-05-31 17:56:01 -04:00
|
|
|
return 0;
|
2013-05-23 04:35:34 -04:00
|
|
|
plen = e - name - len;
|
2011-05-31 17:56:01 -04:00
|
|
|
}
|
2013-05-23 04:35:34 -04:00
|
|
|
if (plen > 0 && name[plen-1] != '/') {
|
2013-03-08 00:47:52 -05:00
|
|
|
return 0;
|
|
|
|
}
|
2013-05-23 04:35:34 -04:00
|
|
|
if (type == 's' ? !IS_DLEXT(&name[plen+len]) :
|
|
|
|
type == 'r' ? !IS_RBEXT(&name[plen+len]) :
|
2013-03-08 00:47:52 -05:00
|
|
|
0) {
|
|
|
|
return 0;
|
2012-11-05 10:24:03 -05:00
|
|
|
}
|
|
|
|
/* Now name == "#{prefix}/#{feature}#{ext}" where ext is acceptable
|
|
|
|
(possibly empty) and prefix is some string of length plen. */
|
|
|
|
|
2013-05-23 04:35:34 -04:00
|
|
|
if (plen > 0) --plen; /* exclude '.' */
|
2007-11-06 02:37:49 -05:00
|
|
|
for (i = 0; i < RARRAY_LEN(load_path); ++i) {
|
2013-05-13 05:56:22 -04:00
|
|
|
VALUE p = RARRAY_AREF(load_path, i);
|
2007-11-06 01:52:01 -05:00
|
|
|
const char *s = StringValuePtr(p);
|
|
|
|
long n = RSTRING_LEN(p);
|
|
|
|
|
2012-10-29 05:31:50 -04:00
|
|
|
if (n != plen) continue;
|
2012-11-05 10:24:03 -05:00
|
|
|
if (n && strncmp(name, s, n)) continue;
|
|
|
|
return p;
|
2007-11-06 01:52:01 -05:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct loaded_feature_searching {
|
|
|
|
const char *name;
|
|
|
|
long len;
|
2007-11-08 22:56:38 -05:00
|
|
|
int type;
|
2007-11-06 02:37:49 -05:00
|
|
|
VALUE load_path;
|
2007-11-06 01:52:01 -05:00
|
|
|
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;
|
2007-11-08 22:56:38 -05:00
|
|
|
VALUE p = loaded_feature_path(s, strlen(s), fp->name, fp->len,
|
|
|
|
fp->type, fp->load_path);
|
2007-11-06 01:52:01 -05:00
|
|
|
if (!p) return ST_CONTINUE;
|
|
|
|
fp->result = s;
|
|
|
|
return ST_STOP;
|
|
|
|
}
|
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
static int
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_feature_p(rb_vm_t *vm, const char *feature, const char *ext, int rb, int expanded, const char **fn)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2013-03-23 20:04:43 -04:00
|
|
|
VALUE features, this_feature_index = Qnil, v, p, load_path = 0;
|
2007-05-03 09:19:11 -04:00
|
|
|
const char *f, *e;
|
2007-11-06 01:52:01 -05:00
|
|
|
long i, len, elen, n;
|
2013-03-22 04:38:51 -04:00
|
|
|
st_table *loading_tbl, *features_index;
|
2007-12-24 03:06:16 -05:00
|
|
|
st_data_t data;
|
2018-02-14 13:38:33 -05:00
|
|
|
st_data_t key;
|
2007-11-08 22:56:38 -05:00
|
|
|
int type;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2007-12-24 03:06:16 -05:00
|
|
|
if (fn) *fn = 0;
|
2006-12-31 10:02:22 -05:00
|
|
|
if (ext) {
|
|
|
|
elen = strlen(ext);
|
2009-01-29 02:32:07 -05:00
|
|
|
len = strlen(feature) - elen;
|
2007-11-08 22:56:38 -05:00
|
|
|
type = rb ? 'r' : 's';
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
len = strlen(feature);
|
|
|
|
elen = 0;
|
2007-11-08 22:56:38 -05:00
|
|
|
type = 0;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
2021-09-16 12:20:10 -04:00
|
|
|
features = get_loaded_features(vm);
|
|
|
|
features_index = get_loaded_features_index(vm);
|
2012-11-05 10:27:01 -05:00
|
|
|
|
2018-02-14 13:38:33 -05:00
|
|
|
key = feature_key(feature, strlen(feature));
|
2012-11-05 10:27:01 -05:00
|
|
|
/* 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`.
|
|
|
|
*/
|
2021-07-13 11:51:53 -04:00
|
|
|
if (st_lookup(features_index, key, &data) && !NIL_P(this_feature_index = (VALUE)data)) {
|
2013-03-08 18:54:41 -05:00
|
|
|
for (i = 0; ; i++) {
|
|
|
|
VALUE entry;
|
|
|
|
long index;
|
|
|
|
if (RB_TYPE_P(this_feature_index, T_ARRAY)) {
|
|
|
|
if (i >= RARRAY_LEN(this_feature_index)) break;
|
2013-05-13 05:56:22 -04:00
|
|
|
entry = RARRAY_AREF(this_feature_index, i);
|
2013-03-08 18:54:41 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (i > 0) break;
|
|
|
|
entry = this_feature_index;
|
|
|
|
}
|
|
|
|
index = FIX2LONG(entry);
|
|
|
|
|
2013-05-13 05:56:22 -04:00
|
|
|
v = RARRAY_AREF(features, index);
|
2013-03-08 18:54:41 -05:00
|
|
|
f = StringValuePtr(v);
|
|
|
|
if ((n = RSTRING_LEN(v)) < len) continue;
|
|
|
|
if (strncmp(f, feature, len) != 0) {
|
|
|
|
if (expanded) continue;
|
2021-09-16 12:20:10 -04:00
|
|
|
if (!load_path) load_path = get_expanded_load_path(vm);
|
2013-03-08 18:54:41 -05:00
|
|
|
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';
|
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
}
|
2012-11-05 10:27:01 -05:00
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
loading_tbl = get_loading_table(vm);
|
2015-06-03 03:21:37 -04:00
|
|
|
f = 0;
|
|
|
|
if (!expanded) {
|
|
|
|
struct loaded_feature_searching fs;
|
|
|
|
fs.name = feature;
|
|
|
|
fs.len = len;
|
|
|
|
fs.type = type;
|
2021-09-16 12:20:10 -04:00
|
|
|
fs.load_path = load_path ? load_path : get_expanded_load_path(vm);
|
2015-06-03 03:21:37 -04:00
|
|
|
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;
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
2015-06-03 03:21:37 -04:00
|
|
|
}
|
|
|
|
if (st_get_key(loading_tbl, (st_data_t)feature, &data)) {
|
|
|
|
if (fn) *fn = (const char*)data;
|
2020-06-15 02:31:07 -04:00
|
|
|
goto loading;
|
2015-06-03 03:21:37 -04:00
|
|
|
}
|
|
|
|
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';
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
2015-06-03 03:21:37 -04:00
|
|
|
}
|
|
|
|
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';
|
2013-11-02 20:35:49 -04:00
|
|
|
}
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
2015-06-03 03:21:37 -04:00
|
|
|
rb_str_resize(bufstr, 0);
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
return 0;
|
2020-06-15 02:31:07 -04:00
|
|
|
|
|
|
|
loading:
|
|
|
|
if (!ext) return 'u';
|
|
|
|
return !IS_RBEXT(ext) ? 's' : 'r';
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
rb_provided(const char *feature)
|
2008-12-04 13:29:20 -05:00
|
|
|
{
|
|
|
|
return rb_feature_provided(feature, 0);
|
|
|
|
}
|
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
static int
|
|
|
|
feature_provided(rb_vm_t *vm, const char *feature, const char **loading)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2007-05-03 09:19:11 -04:00
|
|
|
const char *ext = strrchr(feature, '.');
|
2015-06-24 04:28:47 -04:00
|
|
|
VALUE fullpath = 0;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2008-04-07 14:39:28 -04:00
|
|
|
if (*feature == '.' &&
|
|
|
|
(feature[1] == '/' || strncmp(feature+1, "./", 2) == 0)) {
|
2012-11-05 10:27:08 -05:00
|
|
|
fullpath = rb_file_expand_path_fast(rb_get_path(rb_str_new2(feature)), Qnil);
|
2008-04-07 14:39:28 -04:00
|
|
|
feature = RSTRING_PTR(fullpath);
|
|
|
|
}
|
2007-05-03 09:19:11 -04:00
|
|
|
if (ext && !strchr(ext, '/')) {
|
2007-11-08 22:56:38 -05:00
|
|
|
if (IS_RBEXT(ext)) {
|
2021-09-16 12:20:10 -04:00
|
|
|
if (rb_feature_p(vm, feature, ext, TRUE, FALSE, loading)) return TRUE;
|
2009-07-18 04:05:32 -04:00
|
|
|
return FALSE;
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
|
|
|
else if (IS_SOEXT(ext) || IS_DLEXT(ext)) {
|
2021-09-16 12:20:10 -04:00
|
|
|
if (rb_feature_p(vm, feature, ext, FALSE, FALSE, loading)) return TRUE;
|
2009-07-18 04:05:32 -04:00
|
|
|
return FALSE;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
}
|
2021-09-16 12:20:10 -04:00
|
|
|
if (rb_feature_p(vm, feature, 0, TRUE, FALSE, loading))
|
2009-07-18 04:05:32 -04:00
|
|
|
return TRUE;
|
2015-06-24 04:28:47 -04:00
|
|
|
RB_GC_GUARD(fullpath);
|
2009-07-18 04:05:32 -04:00
|
|
|
return FALSE;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
int
|
|
|
|
rb_feature_provided(const char *feature, const char **loading)
|
|
|
|
{
|
|
|
|
return feature_provided(GET_VM(), feature, loading);
|
|
|
|
}
|
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
static void
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_provide_feature(rb_vm_t *vm, VALUE feature)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2012-11-05 10:27:01 -05:00
|
|
|
VALUE features;
|
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
features = get_loaded_features(vm);
|
2012-11-05 10:27:01 -05:00
|
|
|
if (OBJ_FROZEN(features)) {
|
2010-08-28 23:51:39 -04:00
|
|
|
rb_raise(rb_eRuntimeError,
|
|
|
|
"$LOADED_FEATURES is frozen; cannot append feature");
|
|
|
|
}
|
2012-11-05 10:27:01 -05:00
|
|
|
rb_str_freeze(feature);
|
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
get_loaded_features_index(vm);
|
2015-07-15 20:03:40 -04:00
|
|
|
rb_ary_push(features, rb_fstring(feature));
|
2021-09-16 12:20:10 -04:00
|
|
|
features_index_add(vm, feature, INT2FIX(RARRAY_LEN(features)-1));
|
|
|
|
reset_loaded_features_snapshot(vm);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
rb_provide(const char *feature)
|
|
|
|
{
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_provide_feature(GET_VM(), rb_fstring_cstr(feature));
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
2007-12-24 23:17:06 -05:00
|
|
|
NORETURN(static void load_failed(VALUE));
|
* this commit is a result of refactoring. only renaming functions,
moving definitions place, add/remove prototypes, deleting
unused variables and removing yarv.h.
This commit doesn't change any behavior of ruby/vm.
* yarv.h, common.mk: remove yarv.h (contents are moved to yarvcore.h).
* error.c, eval_intern.h: include yarvcore.h instead yarv.h
* rename some functions:
* debug.[ch]: debug_*() -> ruby_debug_*()
* iseq.c: iseq_*() -> rb_iseq_*(), ruby_iseq_disasm()
* iseq.c: node_name() -> ruby_node_name()
* vm.c: yarv_check_redefinition_opt_method() ->
rb_vm_check_redefinition_opt_method()
* some refactoring with checking -Wall.
* array.c: remove rb_ary_ptr() (unused) and remove unused
local variables.
* object.c: add a prototype of rb_mod_module_exec().
* eval_intern.h (ruby_cref): set it inline.
* eval_load.c (rb_load), yarvcore.c: yarv_load() -> rb_load_internal().
* parse.y: add a prototype of rb_parse_in_eval() (in eval.c).
* process.c: add a prototype of rb_thread_stop_timer_thread() (in thread.c).
* thread.c: remove raw_gets() function (unused) and fix some format
mismatch (format mismatchs have remained yet. this is todo).
* thread.c (rb_thread_wait_fd_rw): fix typo on label name.
* thread_pthread.ci: comment out codes with USE_THREAD_CACHE.
* vm.c (rb_svar, rb_backref_get, rb_backref_get,
rb_lastline_get, rb_lastline_set) : moved from yarvcore.c.
* vm.c (yarv_init_redefined_flag): add a prototype and rename
yarv_opt_method_table to vm_opt_method_table.
* vm.c (rb_thread_eval): moved from yarvcore.c.
* yarvcore.c: remove unused global variables and fix to use nsdr().
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11652 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-02-06 20:25:05 -05:00
|
|
|
|
2019-08-08 04:53:36 -04:00
|
|
|
static inline void
|
2019-08-08 09:17:22 -04:00
|
|
|
load_iseq_eval(rb_execution_context_t *ec, VALUE fname)
|
|
|
|
{
|
|
|
|
const rb_iseq_t *iseq = rb_iseq_load_iseq(fname);
|
|
|
|
|
|
|
|
if (!iseq) {
|
|
|
|
rb_ast_t *ast;
|
|
|
|
VALUE parser = rb_parser_new();
|
|
|
|
rb_parser_set_context(parser, NULL, FALSE);
|
|
|
|
ast = (rb_ast_t *)rb_parser_load_file(parser, fname);
|
|
|
|
iseq = rb_iseq_new_top(&ast->body, rb_fstring_lit("<top (required)>"),
|
|
|
|
fname, rb_realpath_internal(Qnil, fname, 1), NULL);
|
|
|
|
rb_ast_dispose(ast);
|
|
|
|
}
|
|
|
|
rb_exec_event_hook_script_compiled(ec, iseq, Qnil);
|
|
|
|
rb_iseq_eval(iseq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline enum ruby_tag_type
|
2021-10-18 11:50:10 -04:00
|
|
|
load_wrapping(rb_execution_context_t *ec, VALUE fname, VALUE load_wrapper)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2017-06-23 03:25:52 -04:00
|
|
|
enum ruby_tag_type state;
|
2017-11-07 00:45:46 -05:00
|
|
|
rb_thread_t *th = rb_ec_thread_ptr(ec);
|
2007-11-06 01:52:01 -05:00
|
|
|
volatile VALUE wrapper = th->top_wrapper;
|
|
|
|
volatile VALUE self = th->top_self;
|
2013-11-01 03:37:27 -04:00
|
|
|
#if !defined __GNUC__
|
2007-11-06 01:52:01 -05:00
|
|
|
rb_thread_t *volatile th0 = th;
|
|
|
|
#endif
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2019-08-08 08:08:00 -04:00
|
|
|
ec->errinfo = Qnil; /* ensure */
|
2007-02-25 11:29:26 -05:00
|
|
|
|
2021-10-18 11:50:10 -04:00
|
|
|
/* load in module as toplevel */
|
2019-08-17 10:33:12 -04:00
|
|
|
th->top_self = rb_obj_clone(rb_vm_top_self());
|
2021-10-18 11:50:10 -04:00
|
|
|
th->top_wrapper = load_wrapper;
|
2019-08-17 10:33:12 -04:00
|
|
|
rb_extend_object(th->top_self, th->top_wrapper);
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2019-08-08 08:08:00 -04:00
|
|
|
EC_PUSH_TAG(ec);
|
2017-12-05 22:16:08 -05:00
|
|
|
state = EC_EXEC_TAG();
|
2017-06-23 03:25:52 -04:00
|
|
|
if (state == TAG_NONE) {
|
2019-08-08 09:17:22 -04:00
|
|
|
load_iseq_eval(ec, fname);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
2017-10-26 07:02:13 -04:00
|
|
|
EC_POP_TAG();
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2013-11-01 03:37:27 -04:00
|
|
|
#if !defined __GNUC__
|
2007-11-06 01:52:01 -05:00
|
|
|
th = th0;
|
|
|
|
fname = RB_GC_GUARD(fname);
|
|
|
|
#endif
|
2007-02-25 11:29:26 -05:00
|
|
|
th->top_self = self;
|
|
|
|
th->top_wrapper = wrapper;
|
2019-08-08 09:17:22 -04:00
|
|
|
return state;
|
|
|
|
}
|
2007-02-25 11:29:26 -05:00
|
|
|
|
2019-08-08 09:17:22 -04:00
|
|
|
static inline void
|
|
|
|
raise_load_if_failed(rb_execution_context_t *ec, enum ruby_tag_type state)
|
|
|
|
{
|
2006-12-31 10:02:22 -05:00
|
|
|
if (state) {
|
2019-08-08 04:53:36 -04:00
|
|
|
rb_vm_jump_tag_but_local_jump(state);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
2019-08-08 08:08:00 -04:00
|
|
|
if (!NIL_P(ec->errinfo)) {
|
|
|
|
rb_exc_raise(ec->errinfo);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-01 03:37:27 -04:00
|
|
|
static void
|
2021-10-18 11:50:10 -04:00
|
|
|
rb_load_internal(VALUE fname, VALUE wrap)
|
2013-11-01 03:37:27 -04:00
|
|
|
{
|
2017-11-07 00:45:46 -05:00
|
|
|
rb_execution_context_t *ec = GET_EC();
|
2019-08-17 10:33:12 -04:00
|
|
|
enum ruby_tag_type state = TAG_NONE;
|
2021-10-18 11:50:10 -04:00
|
|
|
if (RTEST(wrap)) {
|
|
|
|
if (!RB_TYPE_P(wrap, T_MODULE)) {
|
|
|
|
wrap = rb_module_new();
|
|
|
|
}
|
|
|
|
state = load_wrapping(ec, fname, wrap);
|
2019-08-17 10:33:12 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
load_iseq_eval(ec, fname);
|
|
|
|
}
|
|
|
|
raise_load_if_failed(ec, state);
|
2015-07-18 07:44:59 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
rb_load(VALUE fname, int wrap)
|
|
|
|
{
|
2019-08-08 04:53:36 -04:00
|
|
|
VALUE tmp = rb_find_file(FilePathValue(fname));
|
|
|
|
if (!tmp) load_failed(fname);
|
2021-10-18 11:50:10 -04:00
|
|
|
rb_load_internal(tmp, RBOOL(wrap));
|
2009-06-23 03:05:04 -04:00
|
|
|
}
|
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
void
|
2017-06-23 03:25:52 -04:00
|
|
|
rb_load_protect(VALUE fname, int wrap, int *pstate)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2017-06-23 03:25:52 -04:00
|
|
|
enum ruby_tag_type state;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2017-12-05 22:16:08 -05:00
|
|
|
EC_PUSH_TAG(GET_EC());
|
|
|
|
if ((state = EC_EXEC_TAG()) == TAG_NONE) {
|
2019-08-08 04:53:36 -04:00
|
|
|
rb_load(fname, wrap);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
2017-12-05 22:16:08 -05:00
|
|
|
EC_POP_TAG();
|
2017-06-23 03:25:52 -04:00
|
|
|
|
|
|
|
if (state != TAG_NONE) *pstate = state;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:31:22 -04:00
|
|
|
* load(filename, wrap=false) -> true
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2020-05-29 11:57:09 -04:00
|
|
|
* Loads and executes the Ruby program in the file _filename_.
|
|
|
|
*
|
2020-07-09 17:47:13 -04:00
|
|
|
* 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
|
2020-05-30 09:04:49 -04:00
|
|
|
* directories listed in <code>$LOAD_PATH</code> (<code>$:</code>).
|
2020-07-09 17:47:13 -04:00
|
|
|
* 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.
|
2020-05-29 11:57:09 -04:00
|
|
|
*
|
|
|
|
* If the optional _wrap_ parameter is +true+, the loaded script will
|
|
|
|
* be executed under an anonymous module, protecting the calling
|
2021-10-18 11:50:10 -04:00
|
|
|
* program's global namespace. 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.
|
2006-12-31 10:02:22 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2019-08-28 05:19:11 -04:00
|
|
|
rb_f_load(int argc, VALUE *argv, VALUE _)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2014-10-29 01:44:33 -04:00
|
|
|
VALUE fname, wrap, path, orig_fname;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
|
|
|
rb_scan_args(argc, argv, "11", &fname, &wrap);
|
* probes.d: add DTrace probe declarations. [ruby-core:27448]
* array.c (empty_ary_alloc, ary_new): added array create DTrace probe.
* compile.c (rb_insns_name): allowing DTrace probes to access
instruction sequence name.
* Makefile.in: translate probes.d file to appropriate header file.
* common.mk: declare dependencies on the DTrace header.
* configure.in: add a test for existence of DTrace.
* eval.c (setup_exception): add a probe for when an exception is
raised.
* gc.c: Add DTrace probes for mark begin and end, and sweep begin and
end.
* hash.c (empty_hash_alloc): Add a probe for hash allocation.
* insns.def: Add probes for function entry and return.
* internal.h: function declaration for compile.c change.
* load.c (rb_f_load): add probes for `load` entry and exit, require
entry and exit, and wrapping search_required for load path search.
* object.c (rb_obj_alloc): added a probe for general object creation.
* parse.y (yycompile0): added a probe around parse and compile phase.
* string.c (empty_str_alloc, str_new): DTrace probes for string
allocation.
* test/dtrace/*: tests for DTrace probes.
* vm.c (vm_invoke_proc): add probes for function return on exception
raise, hash create, and instruction sequence execution.
* vm_core.h: add probe declarations for function entry and exit.
* vm_dump.c: add probes header file.
* vm_eval.c (vm_call0_cfunc, vm_call0_cfunc_with_frame): add probe on
function entry and return.
* vm_exec.c: expose instruction number to instruction name function.
* vm_insnshelper.c: add function entry and exit probes for cfunc
methods.
* vm_insnhelper.h: vm usage information is always collected, so
uncomment the functions.
12 19:14:50 2012 Akinori MUSHA <knu@iDaemons.org>
* configure.in (isinf, isnan): isinf() and isnan() are macros on
DragonFly which cannot be found by AC_REPLACE_FUNCS(). This
workaround enforces the fact that they exist on DragonFly.
12 15:59:38 2012 Shugo Maeda <shugo@ruby-lang.org>
* vm_core.h (rb_call_info_t::refinements), compile.c (new_callinfo),
vm_insnhelper.c (vm_search_method): revert r37616 because it's too
slow. [ruby-dev:46477]
* test/ruby/test_refinement.rb (test_inline_method_cache): skip
the test until the bug is fixed efficiently.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37631 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2012-11-12 16:52:12 -05:00
|
|
|
|
2019-09-20 22:06:22 -04:00
|
|
|
orig_fname = rb_get_path_check_to_string(fname);
|
2016-04-08 23:58:01 -04:00
|
|
|
fname = rb_str_encode_ospath(orig_fname);
|
2017-06-07 10:36:18 -04:00
|
|
|
RUBY_DTRACE_HOOK(LOAD_ENTRY, RSTRING_PTR(orig_fname));
|
|
|
|
|
2014-10-29 01:44:33 -04:00
|
|
|
path = rb_find_file(fname);
|
2009-06-23 03:05:04 -04:00
|
|
|
if (!path) {
|
|
|
|
if (!rb_file_load_ok(RSTRING_PTR(fname)))
|
2014-10-29 01:44:33 -04:00
|
|
|
load_failed(orig_fname);
|
2009-06-23 03:05:04 -04:00
|
|
|
path = fname;
|
|
|
|
}
|
2021-10-18 11:50:10 -04:00
|
|
|
rb_load_internal(path, wrap);
|
* probes.d: add DTrace probe declarations. [ruby-core:27448]
* array.c (empty_ary_alloc, ary_new): added array create DTrace probe.
* compile.c (rb_insns_name): allowing DTrace probes to access
instruction sequence name.
* Makefile.in: translate probes.d file to appropriate header file.
* common.mk: declare dependencies on the DTrace header.
* configure.in: add a test for existence of DTrace.
* eval.c (setup_exception): add a probe for when an exception is
raised.
* gc.c: Add DTrace probes for mark begin and end, and sweep begin and
end.
* hash.c (empty_hash_alloc): Add a probe for hash allocation.
* insns.def: Add probes for function entry and return.
* internal.h: function declaration for compile.c change.
* load.c (rb_f_load): add probes for `load` entry and exit, require
entry and exit, and wrapping search_required for load path search.
* object.c (rb_obj_alloc): added a probe for general object creation.
* parse.y (yycompile0): added a probe around parse and compile phase.
* string.c (empty_str_alloc, str_new): DTrace probes for string
allocation.
* test/dtrace/*: tests for DTrace probes.
* vm.c (vm_invoke_proc): add probes for function return on exception
raise, hash create, and instruction sequence execution.
* vm_core.h: add probe declarations for function entry and exit.
* vm_dump.c: add probes header file.
* vm_eval.c (vm_call0_cfunc, vm_call0_cfunc_with_frame): add probe on
function entry and return.
* vm_exec.c: expose instruction number to instruction name function.
* vm_insnshelper.c: add function entry and exit probes for cfunc
methods.
* vm_insnhelper.h: vm usage information is always collected, so
uncomment the functions.
12 19:14:50 2012 Akinori MUSHA <knu@iDaemons.org>
* configure.in (isinf, isnan): isinf() and isnan() are macros on
DragonFly which cannot be found by AC_REPLACE_FUNCS(). This
workaround enforces the fact that they exist on DragonFly.
12 15:59:38 2012 Shugo Maeda <shugo@ruby-lang.org>
* vm_core.h (rb_call_info_t::refinements), compile.c (new_callinfo),
vm_insnhelper.c (vm_search_method): revert r37616 because it's too
slow. [ruby-dev:46477]
* test/ruby/test_refinement.rb (test_inline_method_cache): skip
the test until the bug is fixed efficiently.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37631 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2012-11-12 16:52:12 -05:00
|
|
|
|
2017-06-07 10:36:18 -04:00
|
|
|
RUBY_DTRACE_HOOK(LOAD_RETURN, RSTRING_PTR(orig_fname));
|
* probes.d: add DTrace probe declarations. [ruby-core:27448]
* array.c (empty_ary_alloc, ary_new): added array create DTrace probe.
* compile.c (rb_insns_name): allowing DTrace probes to access
instruction sequence name.
* Makefile.in: translate probes.d file to appropriate header file.
* common.mk: declare dependencies on the DTrace header.
* configure.in: add a test for existence of DTrace.
* eval.c (setup_exception): add a probe for when an exception is
raised.
* gc.c: Add DTrace probes for mark begin and end, and sweep begin and
end.
* hash.c (empty_hash_alloc): Add a probe for hash allocation.
* insns.def: Add probes for function entry and return.
* internal.h: function declaration for compile.c change.
* load.c (rb_f_load): add probes for `load` entry and exit, require
entry and exit, and wrapping search_required for load path search.
* object.c (rb_obj_alloc): added a probe for general object creation.
* parse.y (yycompile0): added a probe around parse and compile phase.
* string.c (empty_str_alloc, str_new): DTrace probes for string
allocation.
* test/dtrace/*: tests for DTrace probes.
* vm.c (vm_invoke_proc): add probes for function return on exception
raise, hash create, and instruction sequence execution.
* vm_core.h: add probe declarations for function entry and exit.
* vm_dump.c: add probes header file.
* vm_eval.c (vm_call0_cfunc, vm_call0_cfunc_with_frame): add probe on
function entry and return.
* vm_exec.c: expose instruction number to instruction name function.
* vm_insnshelper.c: add function entry and exit probes for cfunc
methods.
* vm_insnhelper.h: vm usage information is always collected, so
uncomment the functions.
12 19:14:50 2012 Akinori MUSHA <knu@iDaemons.org>
* configure.in (isinf, isnan): isinf() and isnan() are macros on
DragonFly which cannot be found by AC_REPLACE_FUNCS(). This
workaround enforces the fact that they exist on DragonFly.
12 15:59:38 2012 Shugo Maeda <shugo@ruby-lang.org>
* vm_core.h (rb_call_info_t::refinements), compile.c (new_callinfo),
vm_insnhelper.c (vm_search_method): revert r37616 because it's too
slow. [ruby-dev:46477]
* test/ruby/test_refinement.rb (test_inline_method_cache): skip
the test until the bug is fixed efficiently.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37631 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2012-11-12 16:52:12 -05:00
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
return Qtrue;
|
|
|
|
}
|
|
|
|
|
2007-05-03 09:19:11 -04:00
|
|
|
static char *
|
2021-09-16 12:20:10 -04:00
|
|
|
load_lock(rb_vm_t *vm, const char *ftptr, bool warn)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2007-05-03 09:19:11 -04:00
|
|
|
st_data_t data;
|
2021-09-16 12:20:10 -04:00
|
|
|
st_table *loading_tbl = get_loading_table(vm);
|
2007-05-03 09:19:11 -04:00
|
|
|
|
2015-06-03 03:21:37 -04:00
|
|
|
if (!st_lookup(loading_tbl, (st_data_t)ftptr, &data)) {
|
2007-05-03 09:19:11 -04:00
|
|
|
/* partial state */
|
|
|
|
ftptr = ruby_strdup(ftptr);
|
2012-07-05 03:00:29 -04:00
|
|
|
data = (st_data_t)rb_thread_shield_new();
|
2007-05-03 09:19:11 -04:00
|
|
|
st_insert(loading_tbl, (st_data_t)ftptr, data);
|
|
|
|
return (char *)ftptr;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
2017-04-07 02:41:32 -04:00
|
|
|
else if (imemo_type_p(data, imemo_memo)) {
|
2015-03-10 20:20:45 -04:00
|
|
|
struct MEMO *memo = MEMO_CAST(data);
|
2019-08-26 23:29:00 -04:00
|
|
|
void (*init)(void) = memo->u3.func;
|
2013-11-02 20:35:49 -04:00
|
|
|
data = (st_data_t)rb_thread_shield_new();
|
|
|
|
st_insert(loading_tbl, (st_data_t)ftptr, data);
|
|
|
|
(*init)();
|
|
|
|
return (char *)"";
|
|
|
|
}
|
2021-09-23 15:31:32 -04:00
|
|
|
if (warn) {
|
2017-04-27 08:07:43 -04:00
|
|
|
VALUE warning = rb_warning_string("loading in progress, circular require considered harmful - %s", ftptr);
|
|
|
|
rb_backtrace_each(rb_str_append, warning);
|
2018-01-20 17:07:36 -05:00
|
|
|
rb_warning("%"PRIsVALUE, warning);
|
2009-06-13 02:03:44 -04:00
|
|
|
}
|
2012-07-05 03:00:29 -04:00
|
|
|
switch (rb_thread_shield_wait((VALUE)data)) {
|
2011-12-13 20:20:11 -05:00
|
|
|
case Qfalse:
|
|
|
|
case Qnil:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return (char *)ftptr;
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2012-01-13 03:23:43 -05:00
|
|
|
static int
|
2012-07-05 03:00:29 -04:00
|
|
|
release_thread_shield(st_data_t *key, st_data_t *value, st_data_t done, int existing)
|
2012-01-13 03:23:43 -05:00
|
|
|
{
|
2012-07-05 03:00:29 -04:00
|
|
|
VALUE thread_shield = (VALUE)*value;
|
2012-03-29 03:36:12 -04:00
|
|
|
if (!existing) return ST_STOP;
|
2016-12-05 06:10:05 -05:00
|
|
|
if (done) {
|
|
|
|
rb_thread_shield_destroy(thread_shield);
|
2016-12-05 18:37:25 -05:00
|
|
|
/* Delete the entry even if there are waiting threads, because they
|
|
|
|
* won't load the file and won't delete the entry. */
|
2016-12-05 06:10:05 -05:00
|
|
|
}
|
|
|
|
else if (rb_thread_shield_release(thread_shield)) {
|
2012-01-13 03:23:43 -05:00
|
|
|
/* still in-use */
|
|
|
|
return ST_CONTINUE;
|
|
|
|
}
|
2012-03-29 10:50:20 -04:00
|
|
|
xfree((char *)*key);
|
2012-01-13 03:23:43 -05:00
|
|
|
return ST_DELETE;
|
|
|
|
}
|
|
|
|
|
2007-05-03 09:19:11 -04:00
|
|
|
static void
|
2021-09-16 12:20:10 -04:00
|
|
|
load_unlock(rb_vm_t *vm, const char *ftptr, int done)
|
2007-05-03 09:19:11 -04:00
|
|
|
{
|
|
|
|
if (ftptr) {
|
|
|
|
st_data_t key = (st_data_t)ftptr;
|
2021-09-16 12:20:10 -04:00
|
|
|
st_table *loading_tbl = get_loading_table(vm);
|
2007-05-03 09:19:11 -04:00
|
|
|
|
2012-07-05 03:00:29 -04:00
|
|
|
st_update(loading_tbl, key, release_thread_shield, done);
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
2007-05-03 09:19:11 -04:00
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2011-08-23 02:26:11 -04:00
|
|
|
* require(name) -> true or false
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2011-08-23 02:26:11 -04:00
|
|
|
* Loads the given +name+, returning +true+ if successful and +false+ if the
|
|
|
|
* feature is already loaded.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2020-05-30 09:04:49 -04:00
|
|
|
* 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>).
|
2020-05-31 10:06:07 -04:00
|
|
|
* If the filename starts with './' or '../', resolution is based on Dir.pwd.
|
2011-08-23 02:26:11 -04:00
|
|
|
*
|
|
|
|
* If the filename has the extension ".rb", it is loaded as a source file; if
|
|
|
|
* the extension is ".so", ".o", or ".dll", 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 any shared library
|
|
|
|
* extension. For example, on Linux the socket extension is "socket.so" and
|
|
|
|
* <code>require 'socket.dll'</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"
|
2012-02-22 20:58:01 -05:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2006-12-31 10:02:22 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
VALUE
|
|
|
|
rb_f_require(VALUE obj, VALUE fname)
|
|
|
|
{
|
2019-09-20 22:06:22 -04:00
|
|
|
return rb_require_string(fname);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
2010-12-24 21:07:13 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
|
|
|
* require_relative(string) -> true or false
|
|
|
|
*
|
|
|
|
* Ruby tries to load the library named _string_ relative to the requiring
|
|
|
|
* file's path. If the file's path cannot be determined a LoadError is raised.
|
|
|
|
* If a file is loaded +true+ is returned and false otherwise.
|
|
|
|
*/
|
2010-12-24 22:48:57 -05:00
|
|
|
VALUE
|
2010-03-16 13:40:00 -04:00
|
|
|
rb_f_require_relative(VALUE obj, VALUE fname)
|
|
|
|
{
|
|
|
|
VALUE base = rb_current_realfilepath();
|
|
|
|
if (NIL_P(base)) {
|
2012-03-06 18:38:33 -05:00
|
|
|
rb_loaderror("cannot infer basepath");
|
2010-03-16 13:40:00 -04:00
|
|
|
}
|
2010-03-30 05:26:09 -04:00
|
|
|
base = rb_file_dirname(base);
|
2019-09-20 22:06:22 -04:00
|
|
|
return rb_require_string(rb_file_absolute_path(fname, base));
|
2010-03-16 13:40:00 -04:00
|
|
|
}
|
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
typedef int (*feature_func)(rb_vm_t *vm, const char *feature, const char *ext, int rb, int expanded, const char **fn);
|
2018-12-30 20:14:51 -05:00
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
static int
|
2021-09-16 12:20:10 -04:00
|
|
|
search_required(rb_vm_t *vm, VALUE fname, volatile VALUE *path, feature_func rb_feature_p)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
|
|
|
VALUE tmp;
|
|
|
|
char *ext, *ftptr;
|
|
|
|
int type, ft = 0;
|
2007-12-24 03:06:16 -05:00
|
|
|
const char *loading;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
|
|
|
*path = 0;
|
|
|
|
ext = strrchr(ftptr = RSTRING_PTR(fname), '.');
|
|
|
|
if (ext && !strchr(ext, '/')) {
|
2007-11-08 22:56:38 -05:00
|
|
|
if (IS_RBEXT(ext)) {
|
2021-09-16 12:20:10 -04:00
|
|
|
if (rb_feature_p(vm, ftptr, ext, TRUE, FALSE, &loading)) {
|
2012-08-23 03:46:12 -04:00
|
|
|
if (loading) *path = rb_filesystem_str_new_cstr(loading);
|
2006-12-31 10:02:22 -05:00
|
|
|
return 'r';
|
2007-12-24 03:06:16 -05:00
|
|
|
}
|
2019-09-20 22:06:22 -04:00
|
|
|
if ((tmp = rb_find_file(fname)) != 0) {
|
2006-12-31 10:02:22 -05:00
|
|
|
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
|
2021-09-16 12:20:10 -04:00
|
|
|
if (!rb_feature_p(vm, ftptr, ext, TRUE, TRUE, &loading) || loading)
|
2006-12-31 10:02:22 -05:00
|
|
|
*path = tmp;
|
|
|
|
return 'r';
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
else if (IS_SOEXT(ext)) {
|
2021-09-16 12:20:10 -04:00
|
|
|
if (rb_feature_p(vm, ftptr, ext, FALSE, FALSE, &loading)) {
|
2012-08-23 03:46:12 -04:00
|
|
|
if (loading) *path = rb_filesystem_str_new_cstr(loading);
|
2006-12-31 10:02:22 -05:00
|
|
|
return 's';
|
2007-12-24 03:06:16 -05:00
|
|
|
}
|
2012-08-23 03:46:12 -04:00
|
|
|
tmp = rb_str_subseq(fname, 0, ext - RSTRING_PTR(fname));
|
2006-12-31 10:02:22 -05:00
|
|
|
rb_str_cat2(tmp, DLEXT);
|
|
|
|
OBJ_FREEZE(tmp);
|
2019-09-20 22:06:22 -04:00
|
|
|
if ((tmp = rb_find_file(tmp)) != 0) {
|
2006-12-31 10:02:22 -05:00
|
|
|
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
|
2021-09-16 12:20:10 -04:00
|
|
|
if (!rb_feature_p(vm, ftptr, ext, FALSE, TRUE, &loading) || loading)
|
2006-12-31 10:02:22 -05:00
|
|
|
*path = tmp;
|
|
|
|
return 's';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (IS_DLEXT(ext)) {
|
2021-09-16 12:20:10 -04:00
|
|
|
if (rb_feature_p(vm, ftptr, ext, FALSE, FALSE, &loading)) {
|
2012-08-23 03:46:12 -04:00
|
|
|
if (loading) *path = rb_filesystem_str_new_cstr(loading);
|
2006-12-31 10:02:22 -05:00
|
|
|
return 's';
|
2007-12-24 03:06:16 -05:00
|
|
|
}
|
2019-09-20 22:06:22 -04:00
|
|
|
if ((tmp = rb_find_file(fname)) != 0) {
|
2006-12-31 10:02:22 -05:00
|
|
|
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
|
2021-09-16 12:20:10 -04:00
|
|
|
if (!rb_feature_p(vm, ftptr, ext, FALSE, TRUE, &loading) || loading)
|
2006-12-31 10:02:22 -05:00
|
|
|
*path = tmp;
|
|
|
|
return 's';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-09-16 12:20:10 -04:00
|
|
|
else if ((ft = rb_feature_p(vm, ftptr, 0, FALSE, FALSE, &loading)) == 'r') {
|
2012-08-23 03:46:12 -04:00
|
|
|
if (loading) *path = rb_filesystem_str_new_cstr(loading);
|
2006-12-31 10:02:22 -05:00
|
|
|
return 'r';
|
|
|
|
}
|
|
|
|
tmp = fname;
|
2021-07-27 16:55:21 -04:00
|
|
|
type = rb_find_file_ext(&tmp, ft == 's' ? ruby_ext : loadable_ext);
|
2006-12-31 10:02:22 -05:00
|
|
|
switch (type) {
|
2007-05-03 09:19:11 -04:00
|
|
|
case 0:
|
2006-12-31 10:02:22 -05:00
|
|
|
if (ft)
|
2013-11-02 20:35:49 -04:00
|
|
|
goto statically_linked;
|
2007-12-24 03:06:16 -05:00
|
|
|
ftptr = RSTRING_PTR(tmp);
|
2021-09-16 12:20:10 -04:00
|
|
|
return rb_feature_p(vm, ftptr, 0, FALSE, TRUE, 0);
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2007-05-03 09:19:11 -04:00
|
|
|
default:
|
2013-11-02 20:35:49 -04:00
|
|
|
if (ft) {
|
2020-06-15 03:04:52 -04:00
|
|
|
goto statically_linked;
|
2013-11-02 20:35:49 -04:00
|
|
|
}
|
2019-07-14 04:32:49 -04:00
|
|
|
/* fall through */
|
2007-05-03 09:19:11 -04:00
|
|
|
case 1:
|
2006-12-31 10:02:22 -05:00
|
|
|
ext = strrchr(ftptr = RSTRING_PTR(tmp), '.');
|
2021-09-16 12:20:10 -04:00
|
|
|
if (rb_feature_p(vm, ftptr, ext, !--type, TRUE, &loading) && !loading)
|
2006-12-31 10:02:22 -05:00
|
|
|
break;
|
|
|
|
*path = tmp;
|
|
|
|
}
|
|
|
|
return type ? 's' : 'r';
|
2020-06-15 03:04:52 -04:00
|
|
|
|
|
|
|
statically_linked:
|
|
|
|
if (loading) *path = rb_filesystem_str_new_cstr(loading);
|
|
|
|
return ft;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
load_failed(VALUE fname)
|
|
|
|
{
|
2012-03-07 02:30:31 -05:00
|
|
|
rb_load_fail(fname, "cannot load such file");
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
2007-06-18 04:02:30 -04:00
|
|
|
static VALUE
|
2007-06-18 21:53:31 -04:00
|
|
|
load_ext(VALUE path)
|
2007-06-18 04:02:30 -04:00
|
|
|
{
|
2015-06-03 10:07:24 -04:00
|
|
|
rb_scope_visibility_set(METHOD_VISI_PUBLIC);
|
2010-02-23 21:52:08 -05:00
|
|
|
return (VALUE)dln_load(RSTRING_PTR(path));
|
2007-06-18 04:02:30 -04:00
|
|
|
}
|
|
|
|
|
2018-12-30 20:14:51 -05:00
|
|
|
static int
|
2021-09-16 12:20:10 -04:00
|
|
|
no_feature_p(rb_vm_t *vm, const char *feature, const char *ext, int rb, int expanded, const char **fn)
|
2018-12-30 20:14:51 -05:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-13 09:23:49 -04:00
|
|
|
// Documented in doc/globals.rdoc
|
2018-12-06 01:40:54 -05:00
|
|
|
VALUE
|
|
|
|
rb_resolve_feature_path(VALUE klass, VALUE fname)
|
|
|
|
{
|
|
|
|
VALUE path;
|
|
|
|
int found;
|
|
|
|
VALUE sym;
|
|
|
|
|
2019-09-20 22:06:22 -04:00
|
|
|
fname = rb_get_path(fname);
|
2018-12-06 01:40:54 -05:00
|
|
|
path = rb_str_encode_ospath(fname);
|
2021-09-16 12:20:10 -04:00
|
|
|
found = search_required(GET_VM(), path, &path, no_feature_p);
|
2018-12-06 01:40:54 -05:00
|
|
|
|
|
|
|
switch (found) {
|
|
|
|
case 'r':
|
|
|
|
sym = ID2SYM(rb_intern("rb"));
|
|
|
|
break;
|
|
|
|
case 's':
|
|
|
|
sym = ID2SYM(rb_intern("so"));
|
|
|
|
break;
|
|
|
|
default:
|
2019-08-04 07:09:30 -04:00
|
|
|
return Qnil;
|
2018-12-06 01:40:54 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return rb_ary_new_from_args(2, sym, path);
|
|
|
|
}
|
|
|
|
|
2020-11-30 02:18:43 -05:00
|
|
|
static void
|
|
|
|
ext_config_push(rb_thread_t *th, 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, struct rb_ext_config *prev)
|
|
|
|
{
|
|
|
|
th->ext_config = *prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
rb_ext_ractor_safe(bool flag)
|
|
|
|
{
|
|
|
|
GET_THREAD()->ext_config.ractor_safe = flag;
|
|
|
|
}
|
|
|
|
|
2014-12-03 01:13:58 -05:00
|
|
|
/*
|
|
|
|
* returns
|
|
|
|
* 0: if already loaded (false)
|
|
|
|
* 1: successfully loaded (true)
|
|
|
|
* <0: not found (LoadError)
|
|
|
|
* >1: exception
|
|
|
|
*/
|
2019-08-08 09:17:22 -04:00
|
|
|
static int
|
2021-09-23 15:31:32 -04:00
|
|
|
require_internal(rb_execution_context_t *ec, VALUE fname, int exception, bool warn)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2014-12-03 01:13:58 -05:00
|
|
|
volatile int result = -1;
|
2019-08-08 11:06:08 -04:00
|
|
|
rb_thread_t *th = rb_ec_thread_ptr(ec);
|
2021-06-14 00:52:26 -04:00
|
|
|
volatile const struct {
|
|
|
|
VALUE wrapper, self, errinfo;
|
|
|
|
} saved = {
|
|
|
|
th->top_wrapper, th->top_self, ec->errinfo,
|
|
|
|
};
|
2017-06-23 03:25:52 -04:00
|
|
|
enum ruby_tag_type state;
|
2006-12-31 10:02:22 -05:00
|
|
|
char *volatile ftptr = 0;
|
2017-06-04 03:29:52 -04:00
|
|
|
VALUE path;
|
2021-06-14 00:49:10 -04:00
|
|
|
volatile VALUE saved_path;
|
2021-10-08 02:44:47 -04:00
|
|
|
volatile VALUE realpath = 0;
|
2021-09-16 12:20:10 -04:00
|
|
|
VALUE realpaths = get_loaded_features_realpaths(th->vm);
|
2020-11-30 02:18:43 -05:00
|
|
|
volatile bool reset_ext_config = false;
|
|
|
|
struct rb_ext_config prev_ext_config;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2019-09-20 22:06:22 -04:00
|
|
|
fname = rb_get_path(fname);
|
2017-06-04 03:29:52 -04:00
|
|
|
path = rb_str_encode_ospath(fname);
|
2017-06-07 10:36:18 -04:00
|
|
|
RUBY_DTRACE_HOOK(REQUIRE_ENTRY, RSTRING_PTR(fname));
|
2021-06-14 00:49:10 -04:00
|
|
|
saved_path = path;
|
2017-06-01 09:05:54 -04:00
|
|
|
|
2017-11-07 00:45:46 -05:00
|
|
|
EC_PUSH_TAG(ec);
|
2019-08-08 09:17:22 -04:00
|
|
|
ec->errinfo = Qnil; /* ensure */
|
2019-08-08 11:06:08 -04:00
|
|
|
th->top_wrapper = 0;
|
2017-12-05 22:16:08 -05:00
|
|
|
if ((state = EC_EXEC_TAG()) == TAG_NONE) {
|
2006-12-31 10:02:22 -05:00
|
|
|
long handle;
|
|
|
|
int found;
|
|
|
|
|
2017-06-07 10:36:18 -04:00
|
|
|
RUBY_DTRACE_HOOK(FIND_REQUIRE_ENTRY, RSTRING_PTR(fname));
|
2021-09-16 12:20:10 -04:00
|
|
|
found = search_required(th->vm, path, &saved_path, rb_feature_p);
|
2017-06-07 10:36:18 -04:00
|
|
|
RUBY_DTRACE_HOOK(FIND_REQUIRE_RETURN, RSTRING_PTR(fname));
|
2021-06-14 00:49:10 -04:00
|
|
|
path = saved_path;
|
2017-06-01 09:05:54 -04:00
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
if (found) {
|
2021-09-16 12:20:10 -04:00
|
|
|
if (!path || !(ftptr = load_lock(th->vm, RSTRING_PTR(path), warn))) {
|
2014-12-03 01:13:58 -05:00
|
|
|
result = 0;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
2013-11-02 20:35:49 -04:00
|
|
|
else if (!*ftptr) {
|
2015-07-18 10:47:11 -04:00
|
|
|
result = TAG_RETURN;
|
2013-11-02 20:35:49 -04:00
|
|
|
}
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
else if (RTEST(rb_hash_aref(realpaths,
|
2021-10-04 13:51:29 -04:00
|
|
|
realpath = rb_realpath_internal(Qnil, path, 1)))) {
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
result = 0;
|
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
else {
|
|
|
|
switch (found) {
|
2007-05-03 09:19:11 -04:00
|
|
|
case 'r':
|
2019-08-08 09:17:22 -04:00
|
|
|
load_iseq_eval(ec, path);
|
2006-12-31 10:02:22 -05:00
|
|
|
break;
|
|
|
|
|
2007-05-03 09:19:11 -04:00
|
|
|
case 's':
|
2020-11-30 02:18:43 -05:00
|
|
|
reset_ext_config = true;
|
|
|
|
ext_config_push(th, &prev_ext_config);
|
* blockinlining.c: remove "yarv" prefix.
* array.c, numeric.c: ditto.
* insnhelper.ci, insns.def, vm_evalbody.ci: ditto.
* yarvcore.c: removed.
* yarvcore.h: renamed to core.h.
* cont.c, debug.c, error.c, process.c, signal.c : ditto.
* ext/probeprofiler/probeprofiler.c: ditto.
* id.c, id.h: added.
* inits.c: ditto.
* compile.c: rename internal functions.
* compile.h: fix debug flag.
* eval.c, object.c, vm.c: remove ruby_top_self.
use rb_vm_top_self() instead.
* eval_intern.h, eval_load: ditto.
* gc.c: rename yarv_machine_stack_mark() to
rb_gc_mark_machine_stack().
* insnhelper.h: remove unused macros.
* iseq.c: add iseq_compile() to create iseq object
from source string.
* proc.c: rename a internal function.
* template/insns.inc.tmpl: remove YARV prefix.
* thread.c:
* vm.c (rb_iseq_eval): added.
* vm.c: move some functions from yarvcore.c.
* vm_dump.c: fix to remove compiler warning.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@12741 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2007-07-12 00:25:46 -04:00
|
|
|
handle = (long)rb_vm_call_cfunc(rb_vm_top_self(), load_ext,
|
2016-07-28 07:02:30 -04:00
|
|
|
path, VM_BLOCK_HANDLER_NONE, path);
|
2006-12-31 10:02:22 -05:00
|
|
|
rb_ary_push(ruby_dln_librefs, LONG2NUM(handle));
|
|
|
|
break;
|
|
|
|
}
|
2019-08-08 04:53:36 -04:00
|
|
|
result = TAG_RETURN;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-10-26 07:02:13 -04:00
|
|
|
EC_POP_TAG();
|
2020-11-30 02:18:43 -05:00
|
|
|
|
2020-12-10 10:56:06 -05:00
|
|
|
rb_thread_t *th2 = rb_ec_thread_ptr(ec);
|
2021-06-14 00:52:26 -04:00
|
|
|
th2->top_self = saved.self;
|
|
|
|
th2->top_wrapper = saved.wrapper;
|
2020-12-10 10:56:06 -05:00
|
|
|
if (reset_ext_config) ext_config_pop(th2, &prev_ext_config);
|
2020-11-30 02:18:43 -05:00
|
|
|
|
2021-06-14 00:49:10 -04:00
|
|
|
path = saved_path;
|
2021-09-16 12:20:10 -04:00
|
|
|
if (ftptr) load_unlock(th2->vm, RSTRING_PTR(path), !state);
|
2006-12-31 10:02:22 -05:00
|
|
|
|
|
|
|
if (state) {
|
2019-11-19 02:56:56 -05:00
|
|
|
if (state == TAG_FATAL) {
|
|
|
|
EC_JUMP_TAG(ec, state);
|
|
|
|
}
|
|
|
|
else if (exception) {
|
2019-08-08 09:17:22 -04:00
|
|
|
/* 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;
|
|
|
|
}
|
2017-06-01 09:05:54 -04:00
|
|
|
RB_GC_GUARD(fname);
|
2014-12-03 01:13:58 -05:00
|
|
|
/* never TAG_RETURN */
|
2014-12-03 00:51:28 -05:00
|
|
|
return state;
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
2019-08-08 09:17:22 -04:00
|
|
|
if (!NIL_P(ec->errinfo)) {
|
|
|
|
if (!exception) return TAG_RAISE;
|
|
|
|
rb_exc_raise(ec->errinfo);
|
|
|
|
}
|
2006-12-31 10:02:22 -05:00
|
|
|
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
if (result == TAG_RETURN) {
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_provide_feature(th2->vm, path);
|
2021-10-08 02:44:47 -04:00
|
|
|
VALUE real = realpath;
|
|
|
|
if (real) {
|
|
|
|
rb_hash_aset(realpaths, rb_fstring(real), Qtrue);
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
}
|
|
|
|
}
|
2021-06-14 00:52:26 -04:00
|
|
|
ec->errinfo = saved.errinfo;
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2017-06-07 10:36:18 -04:00
|
|
|
RUBY_DTRACE_HOOK(REQUIRE_RETURN, RSTRING_PTR(fname));
|
* probes.d: add DTrace probe declarations. [ruby-core:27448]
* array.c (empty_ary_alloc, ary_new): added array create DTrace probe.
* compile.c (rb_insns_name): allowing DTrace probes to access
instruction sequence name.
* Makefile.in: translate probes.d file to appropriate header file.
* common.mk: declare dependencies on the DTrace header.
* configure.in: add a test for existence of DTrace.
* eval.c (setup_exception): add a probe for when an exception is
raised.
* gc.c: Add DTrace probes for mark begin and end, and sweep begin and
end.
* hash.c (empty_hash_alloc): Add a probe for hash allocation.
* insns.def: Add probes for function entry and return.
* internal.h: function declaration for compile.c change.
* load.c (rb_f_load): add probes for `load` entry and exit, require
entry and exit, and wrapping search_required for load path search.
* object.c (rb_obj_alloc): added a probe for general object creation.
* parse.y (yycompile0): added a probe around parse and compile phase.
* string.c (empty_str_alloc, str_new): DTrace probes for string
allocation.
* test/dtrace/*: tests for DTrace probes.
* vm.c (vm_invoke_proc): add probes for function return on exception
raise, hash create, and instruction sequence execution.
* vm_core.h: add probe declarations for function entry and exit.
* vm_dump.c: add probes header file.
* vm_eval.c (vm_call0_cfunc, vm_call0_cfunc_with_frame): add probe on
function entry and return.
* vm_exec.c: expose instruction number to instruction name function.
* vm_insnshelper.c: add function entry and exit probes for cfunc
methods.
* vm_insnhelper.h: vm usage information is always collected, so
uncomment the functions.
12 19:14:50 2012 Akinori MUSHA <knu@iDaemons.org>
* configure.in (isinf, isnan): isinf() and isnan() are macros on
DragonFly which cannot be found by AC_REPLACE_FUNCS(). This
workaround enforces the fact that they exist on DragonFly.
12 15:59:38 2012 Shugo Maeda <shugo@ruby-lang.org>
* vm_core.h (rb_call_info_t::refinements), compile.c (new_callinfo),
vm_insnhelper.c (vm_search_method): revert r37616 because it's too
slow. [ruby-dev:46477]
* test/ruby/test_refinement.rb (test_inline_method_cache): skip
the test until the bug is fixed efficiently.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37631 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2012-11-12 16:52:12 -05:00
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-09-23 15:31:32 -04:00
|
|
|
int
|
|
|
|
rb_require_internal_silent(VALUE fname)
|
|
|
|
{
|
|
|
|
rb_execution_context_t *ec = GET_EC();
|
|
|
|
return require_internal(ec, fname, 1, false);
|
|
|
|
}
|
|
|
|
|
2019-08-08 09:17:22 -04:00
|
|
|
int
|
2019-09-20 22:06:22 -04:00
|
|
|
rb_require_internal(VALUE fname)
|
2019-08-08 09:17:22 -04:00
|
|
|
{
|
|
|
|
rb_execution_context_t *ec = GET_EC();
|
2021-09-23 15:31:32 -04:00
|
|
|
return require_internal(ec, fname, 1, RTEST(ruby_verbose));
|
2019-08-08 09:17:22 -04:00
|
|
|
}
|
|
|
|
|
2014-12-03 00:51:28 -05:00
|
|
|
int
|
|
|
|
ruby_require_internal(const char *fname, unsigned int len)
|
|
|
|
{
|
|
|
|
struct RString fake;
|
|
|
|
VALUE str = rb_setup_fake_str(&fake, fname, len, 0);
|
2019-08-08 09:17:22 -04:00
|
|
|
rb_execution_context_t *ec = GET_EC();
|
2021-09-23 15:31:32 -04:00
|
|
|
int result = require_internal(ec, str, 0, RTEST(ruby_verbose));
|
2014-12-03 14:20:36 -05:00
|
|
|
rb_set_errinfo(Qnil);
|
2015-07-18 10:47:11 -04:00
|
|
|
return result == TAG_RETURN ? 1 : result ? -1 : 0;
|
2014-12-03 00:51:28 -05:00
|
|
|
}
|
|
|
|
|
2019-09-20 22:06:22 -04:00
|
|
|
VALUE
|
|
|
|
rb_require_string(VALUE fname)
|
2014-12-03 00:51:28 -05:00
|
|
|
{
|
2019-08-08 09:17:22 -04:00
|
|
|
rb_execution_context_t *ec = GET_EC();
|
2021-09-23 15:31:32 -04:00
|
|
|
int result = require_internal(ec, fname, 1, RTEST(ruby_verbose));
|
2014-12-03 00:51:28 -05:00
|
|
|
|
2015-07-18 10:47:11 -04:00
|
|
|
if (result > TAG_RETURN) {
|
2019-08-08 09:17:22 -04:00
|
|
|
EC_JUMP_TAG(ec, result);
|
2014-12-03 00:51:28 -05:00
|
|
|
}
|
2014-12-03 01:13:58 -05:00
|
|
|
if (result < 0) {
|
2014-12-03 00:51:28 -05:00
|
|
|
load_failed(fname);
|
|
|
|
}
|
|
|
|
|
2021-08-01 23:06:44 -04:00
|
|
|
return RBOOL(result);
|
2014-12-03 00:51:28 -05:00
|
|
|
}
|
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
VALUE
|
|
|
|
rb_require(const char *fname)
|
|
|
|
{
|
2019-09-20 22:06:22 -04:00
|
|
|
return rb_require_string(rb_str_new_cstr(fname));
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
2013-11-02 20:35:49 -04:00
|
|
|
static int
|
|
|
|
register_init_ext(st_data_t *key, st_data_t *value, st_data_t init, int existing)
|
2007-06-18 04:02:30 -04:00
|
|
|
{
|
2013-11-02 20:35:49 -04:00
|
|
|
const char *name = (char *)*key;
|
|
|
|
if (existing) {
|
|
|
|
/* already registered */
|
|
|
|
rb_warn("%s is already registered", name);
|
|
|
|
}
|
|
|
|
else {
|
2015-03-11 19:13:01 -04:00
|
|
|
*value = (st_data_t)MEMO_NEW(0, 0, init);
|
2013-11-02 20:35:49 -04:00
|
|
|
*key = (st_data_t)ruby_strdup(name);
|
|
|
|
}
|
|
|
|
return ST_CONTINUE;
|
2007-06-18 04:02:30 -04:00
|
|
|
}
|
|
|
|
|
2010-09-03 21:41:04 -04:00
|
|
|
RUBY_FUNC_EXPORTED void
|
2007-05-03 09:19:11 -04:00
|
|
|
ruby_init_ext(const char *name, void (*init)(void))
|
|
|
|
{
|
2021-09-16 12:20:10 -04:00
|
|
|
rb_vm_t *vm = GET_VM();
|
|
|
|
st_table *loading_tbl = get_loading_table(vm);
|
2013-11-02 20:35:49 -04:00
|
|
|
|
2021-09-16 12:20:10 -04:00
|
|
|
if (feature_provided(vm, name, 0))
|
2014-03-01 20:49:15 -05:00
|
|
|
return;
|
2013-11-02 20:35:49 -04:00
|
|
|
st_update(loading_tbl, (st_data_t)name, register_init_ext, (st_data_t)init);
|
2007-05-03 09:19:11 -04:00
|
|
|
}
|
|
|
|
|
2006-12-31 10:02:22 -05:00
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:31:22 -04:00
|
|
|
* mod.autoload(module, filename) -> nil
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2019-03-22 07:04:59 -04:00
|
|
|
* Registers _filename_ to be loaded (using Kernel::require)
|
|
|
|
* the first time that _module_ (which may be a String or
|
2006-12-31 10:02:22 -05:00
|
|
|
* a symbol) is accessed in the namespace of _mod_.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2006-12-31 10:02:22 -05:00
|
|
|
* module A
|
|
|
|
* end
|
|
|
|
* A.autoload(:B, "b")
|
|
|
|
* A::B.doit # autoloads "b"
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
rb_mod_autoload(VALUE mod, VALUE sym, VALUE file)
|
|
|
|
{
|
|
|
|
ID id = rb_to_id(sym);
|
|
|
|
|
2009-06-13 01:57:41 -04:00
|
|
|
FilePathValue(file);
|
introduce rb_autoload_str to replace rb_autoload
rb_autoload_str may be safer by preventing premature GC. It
can also be more efficient by passing a pre-frozen string that
can be deduped using rb_fstring. Common autoload callers (e.g.
rubygems, rdoc) already use string literals as the file
argument.
There seems to be no reason to expose rb_autoload_str to the
public C API since autoload is not performance-critical.
Applications may declare autoloads in Ruby code or via
rb_funcall; so merely deprecate rb_autoload without exposing
rb_autoload_str to new users.
Running: valgrind -v ruby -rrdoc -rubygems -e exit
shows a minor memory reduction (32-bit userspace)
before:
in use at exit: 1,600,621 bytes in 28,819 blocks
total heap usage: 55,786 allocs, 26,967 frees, 6,693,790 bytes allocated
after:
in use at exit: 1,599,778 bytes in 28,789 blocks
total heap usage: 55,739 allocs, 26,950 frees, 6,692,973 bytes allocated
* include/ruby/intern.h (rb_autoload): deprecate
* internal.h (rb_autoload_str): declare
* load.c (rb_mod_autoload): use rb_autoload_str
* variable.c (rb_autoload): become compatibility wrapper
(rb_autoload_str): hoisted out from old rb_autoload
[ruby-core:71369] [Feature #11664]
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@52909 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2015-12-06 07:28:09 -05:00
|
|
|
rb_autoload_str(mod, id, file);
|
2006-12-31 10:02:22 -05:00
|
|
|
return Qnil;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-09-23 15:45:37 -04:00
|
|
|
* call-seq:
|
2019-05-07 06:52:24 -04:00
|
|
|
* mod.autoload?(name, inherit=true) -> String or nil
|
2009-09-23 15:45:37 -04:00
|
|
|
*
|
|
|
|
* Returns _filename_ to be loaded if _name_ is registered as
|
2019-05-07 06:52:24 -04:00
|
|
|
* +autoload+ in the namespace of _mod_ or one of its ancestors.
|
2009-09-23 15:45:37 -04:00
|
|
|
*
|
|
|
|
* module A
|
|
|
|
* end
|
|
|
|
* A.autoload(:B, "b")
|
2010-05-17 17:07:33 -04:00
|
|
|
* A.autoload?(:B) #=> "b"
|
2019-05-07 06:52:24 -04:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
2006-12-31 10:02:22 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2019-05-07 06:52:24 -04:00
|
|
|
rb_mod_autoload_p(int argc, VALUE *argv, VALUE mod)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2019-06-21 04:21:34 -04:00
|
|
|
int recur = (rb_check_arity(argc, 1, 2) == 1) ? TRUE : RTEST(argv[1]);
|
2019-05-07 06:52:24 -04:00
|
|
|
VALUE sym = argv[0];
|
|
|
|
|
2014-07-09 02:14:41 -04:00
|
|
|
ID id = rb_check_id(&sym);
|
2011-07-26 12:05:35 -04:00
|
|
|
if (!id) {
|
|
|
|
return Qnil;
|
|
|
|
}
|
2019-05-07 06:52:24 -04:00
|
|
|
return rb_autoload_at_p(mod, id, recur);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* call-seq:
|
2010-05-17 17:31:22 -04:00
|
|
|
* autoload(module, filename) -> nil
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2019-03-22 07:04:59 -04:00
|
|
|
* Registers _filename_ to be loaded (using Kernel::require)
|
|
|
|
* the first time that _module_ (which may be a String or
|
2006-12-31 10:02:22 -05:00
|
|
|
* a symbol) is accessed.
|
2009-02-22 09:23:33 -05:00
|
|
|
*
|
2006-12-31 10:02:22 -05:00
|
|
|
* autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
|
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
|
|
|
rb_f_autoload(VALUE obj, VALUE sym, VALUE file)
|
|
|
|
{
|
2011-07-10 02:32:06 -04:00
|
|
|
VALUE klass = rb_class_real(rb_vm_cbase());
|
2020-10-08 12:21:10 -04:00
|
|
|
if (!klass) {
|
2006-12-31 10:02:22 -05:00
|
|
|
rb_raise(rb_eTypeError, "Can not set autoload on singleton class");
|
|
|
|
}
|
|
|
|
return rb_mod_autoload(klass, sym, file);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-09-23 15:45:37 -04:00
|
|
|
* call-seq:
|
2019-05-07 06:52:24 -04:00
|
|
|
* autoload?(name, inherit=true) -> String or nil
|
2009-09-23 15:45:37 -04:00
|
|
|
*
|
|
|
|
* Returns _filename_ to be loaded if _name_ is registered as
|
|
|
|
* +autoload+.
|
|
|
|
*
|
|
|
|
* autoload(:B, "b")
|
2010-05-17 17:07:33 -04:00
|
|
|
* autoload?(:B) #=> "b"
|
2006-12-31 10:02:22 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
static VALUE
|
2019-05-07 06:52:24 -04:00
|
|
|
rb_f_autoload_p(int argc, VALUE *argv, VALUE obj)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
* vm.c, insns.def, eval.c, vm_insnhelper.c: fix CREF handling.
VM value stack frame of block contains cref information.
(dfp[-1] points CREF)
* compile.c, eval_intern.h, eval_method.c, load.c, proc.c,
vm_dump.h, vm_core.h: ditto.
* include/ruby/ruby.h, gc.c: remove T_VALUES because of above
changes.
* bootstraptest/test_eval.rb, test_knownbug.rb: move solved test.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@16468 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-05-18 23:08:50 -04:00
|
|
|
/* use rb_vm_cbase() as same as rb_f_autoload. */
|
|
|
|
VALUE klass = rb_vm_cbase();
|
2006-12-31 10:02:22 -05:00
|
|
|
if (NIL_P(klass)) {
|
|
|
|
return Qnil;
|
|
|
|
}
|
2019-05-07 06:52:24 -04:00
|
|
|
return rb_mod_autoload_p(argc, argv, klass);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-09-30 01:25:32 -04:00
|
|
|
Init_load(void)
|
2006-12-31 10:02:22 -05:00
|
|
|
{
|
2008-04-30 05:03:03 -04:00
|
|
|
rb_vm_t *vm = GET_VM();
|
2008-08-15 20:20:31 -04:00
|
|
|
static const char var_load_path[] = "$:";
|
|
|
|
ID id_load_path = rb_intern2(var_load_path, sizeof(var_load_path)-1);
|
2008-04-30 05:03:03 -04:00
|
|
|
|
2009-06-21 09:35:41 -04:00
|
|
|
rb_define_hooked_variable(var_load_path, (VALUE*)vm, load_path_getter, rb_gvar_readonly_setter);
|
2020-09-25 13:56:30 -04:00
|
|
|
rb_alias_variable(rb_intern_const("$-I"), id_load_path);
|
|
|
|
rb_alias_variable(rb_intern_const("$LOAD_PATH"), id_load_path);
|
2008-04-30 05:03:03 -04:00
|
|
|
vm->load_path = rb_ary_new();
|
2013-03-08 19:03:40 -05:00
|
|
|
vm->expanded_load_path = rb_ary_tmp_new(0);
|
|
|
|
vm->load_path_snapshot = rb_ary_tmp_new(0);
|
2012-11-05 10:27:08 -05:00
|
|
|
vm->load_path_check_cache = 0;
|
2019-07-11 01:05:34 -04:00
|
|
|
rb_define_singleton_method(vm->load_path, "resolve_feature_path", rb_resolve_feature_path, 1);
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2019-08-27 01:21:18 -04:00
|
|
|
rb_define_virtual_variable("$\"", get_LOADED_FEATURES, 0);
|
|
|
|
rb_define_virtual_variable("$LOADED_FEATURES", get_LOADED_FEATURES, 0);
|
2008-04-30 05:03:03 -04:00
|
|
|
vm->loaded_features = rb_ary_new();
|
2013-03-08 19:03:40 -05:00
|
|
|
vm->loaded_features_snapshot = rb_ary_tmp_new(0);
|
2018-02-14 13:38:33 -05:00
|
|
|
vm->loaded_features_index = st_init_numtable();
|
Do not load file with same realpath twice when requiring
This fixes issues with paths being loaded twice in certain cases
when symlinks are used.
It took me multiple attempts to get this working. My original
attempt tried to convert paths to realpaths before adding them
to $LOADED_FEATURES. Unfortunately, this doesn't work well
with the loaded feature index, which is based off load paths
and not realpaths. While I was able to get require working, I'm
fairly sure the loaded feature index was not being used as
expected, which would have significant performance implications.
Additionally, I was never able to get that approach working with
autoload when autoloading a non-realpath file. It also broke
some specs.
This takes a more conservative approach. Directly before loading the
file, if the file with the same realpath has been required, the
loading of the file is skipped. The realpaths are stored as
fstrings in a hidden hash.
When rebuilding the loaded feature index, the hash of realpaths
is also rebuilt. I'm guessing this makes rebuilding process
slower, but I don think that is a hot path. In general, modifying
loaded features is only done when reloading, and that tends to be
in non-production environments.
Change test_require_with_loaded_features_pop test to use 30 threads
and 300 iterations, instead of 4 threads and 1000 iterations.
I saw only sporadic failures with 4/1000, but consistent failures
30/300 threads. These failures were due to the fact that the
concurrent deletions from $LOADED_FEATURES in other threads can
result in rb_ary_entry returning nil when rebuilding the loaded
features index.
To avoid concurrency issues when rebuilding the loaded features
index, the building of the index itself is left alone, and
afterwards, a separate loop is done on a copy of the loaded feature
snapshot in order to rebuild the realpaths hash.
Fixes [Bug #17885]
2021-06-30 16:50:19 -04:00
|
|
|
vm->loaded_features_realpaths = rb_hash_new();
|
|
|
|
rb_obj_hide(vm->loaded_features_realpaths);
|
2006-12-31 10:02:22 -05:00
|
|
|
|
|
|
|
rb_define_global_function("load", rb_f_load, -1);
|
|
|
|
rb_define_global_function("require", rb_f_require, 1);
|
2010-03-16 13:40:00 -04:00
|
|
|
rb_define_global_function("require_relative", rb_f_require_relative, 1);
|
2006-12-31 10:02:22 -05:00
|
|
|
rb_define_method(rb_cModule, "autoload", rb_mod_autoload, 2);
|
2019-05-07 06:52:24 -04:00
|
|
|
rb_define_method(rb_cModule, "autoload?", rb_mod_autoload_p, -1);
|
2006-12-31 10:02:22 -05:00
|
|
|
rb_define_global_function("autoload", rb_f_autoload, 2);
|
2019-05-07 06:52:24 -04:00
|
|
|
rb_define_global_function("autoload?", rb_f_autoload_p, -1);
|
2006-12-31 10:02:22 -05:00
|
|
|
|
2013-03-08 19:05:40 -05:00
|
|
|
ruby_dln_librefs = rb_ary_tmp_new(0);
|
* gc.c, include/ruby/ruby.h: rename rb_register_mark_object()
to rb_gc_register_mark_object().
* eval.c, vm.c: initialize vm->mark_object_ary at
Init_top_self().
* bignum.c, complex.c, encoding.c, ext/win32ole/win32ole.c,
io.c, load.c, marshal.c, rational.c, ruby.c, vm.c:
use rb_gc_register_mark_object() instead of
rb_global_variable() or rb_gc_register_address().
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19365 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-09-15 10:59:14 -04:00
|
|
|
rb_gc_register_mark_object(ruby_dln_librefs);
|
2006-12-31 10:02:22 -05:00
|
|
|
}
|