107 res->
path = arg.path;
191 rb_bug(
"class path is not set properly");
232 const char *
s =
"Class";
246 path =
rb_sprintf(
"#<%s:%p>", s, (
void*)klass);
249 cache_path(klass, tmp_classpath, path);
286 if (!ivtbl)
return Qnil;
350 if (path[0] ==
'#') {
355 while (*p && *p !=
':') p++;
358 if (p[1] !=
':')
goto undefined_class;
365 (
int)(p-path), pathname);
411 #define global_variable rb_global_variable
412 #define global_entry rb_global_entry
414 #define gvar_getter_t rb_gvar_getter_t
415 #define gvar_setter_t rb_gvar_setter_t
416 #define gvar_marker_t rb_gvar_marker_t
435 #define undef_getter rb_gvar_undef_getter
436 #define undef_setter rb_gvar_undef_setter
437 #define undef_marker rb_gvar_undef_marker
439 #define val_getter rb_gvar_val_getter
440 #define val_setter rb_gvar_val_setter
441 #define val_marker rb_gvar_val_marker
443 #define var_getter rb_gvar_var_getter
444 #define var_setter rb_gvar_var_setter
445 #define var_marker rb_gvar_var_marker
447 #define readonly_setter rb_gvar_readonly_setter
492 var->
data = (
void*)val;
509 var->
data = (
void*)val;
523 if (!var)
return Qnil;
530 *(
VALUE *)data = val;
573 if (name[0] ==
'$')
id =
rb_intern(name);
595 gvar->
data = (
void*)var;
673 trace->
next = entry->var->trace;
677 entry->var->trace = trace;
691 while (trace->
next) {
732 trace = (entry = (
struct global_entry *)data)->var->trace;
748 if (trace->
data == cmd) {
798 (*var->
setter)(val, entry->id, var->
data, var);
861 for (i = 1; i <= 9; ++
i) {
862 buf[1] = (char)(i +
'0');
880 else if ((entry1 = (
struct global_entry *)data1)->var != entry2->var) {
899 entry2->var->counter++;
900 entry1->var = entry2->var;
912 if (!generic_iv_tbl)
return 0;
922 if (generic_iv_tbl) {
940 special_generic_ivar = 1;
942 if (!generic_iv_tbl) {
963 if (!generic_iv_tbl)
return Qfalse;
979 if (!generic_iv_tbl)
return 0;
996 if (!generic_iv_tbl)
return;
1024 if (!generic_iv_tbl)
return;
1025 if (special_generic_ivar == 0)
return;
1034 if (!generic_iv_tbl)
return;
1053 if (!generic_iv_tbl)
return;
1093 if (!iv_index_tbl)
break;
1095 if (len <= (
long)index)
break;
1145 if (!iv_index_tbl) {
1148 if (!iv_index_tbl) {
1159 if (len <= (
long)index) {
1170 long newsize = (index+1) + (index+1)/4;
1171 if (!ivar_extended &&
1179 ROBJECT(obj)->as.heap.ivptr = newptr;
1183 newptr =
ROBJECT(obj)->as.heap.ivptr;
1185 for (; len < newsize; len++)
1187 ROBJECT(obj)->as.heap.numiv = newsize;
1188 ROBJECT(obj)->as.heap.iv_index_tbl = iv_index_tbl;
1216 if (!iv_index_tbl)
break;
1250 return (data->
func)((
ID)key, val, data->
arg);
1289 if (!generic_iv_tbl)
break;
1311 for (i = count = 0; i < num; ++
i) {
1312 if (ivptr[i] !=
Qundef) {
1327 if (!generic_iv_tbl)
break;
1431 if (!iv_index_tbl)
break;
1552 #define check_autoload_table(av) \
1553 (struct st_table *)rb_check_typeddata((av), &autoload_data_type)
1603 #define check_autoload_data(av) \
1604 (struct autoload_data_i *)rb_check_typeddata((av), &autoload_data_i_type)
1618 if (!file || !*file) {
1674 const char **
p = (
const char **)arg;
1690 const char *loading;
1707 if (loadingpath && loading) {
1708 *loadingpath = loading;
1726 *value = ele->
value;
1772 const char *loading = 0, *
src;
1778 if (!load)
return Qfalse;
1780 if (
src && loading && strcmp(
src, loading) == 0)
return Qfalse;
1796 if (
RTEST(result)) {
1798 if (ele->value !=
Qundef) {
1803 args.
value = ele->value;
1821 if (!mod)
return Qnil;
1824 if (!load)
return Qnil;
1836 while (
RTEST(tmp)) {
1847 if (am == tmp)
break;
1859 if (!recurse)
break;
2082 if (
RTEST(inherit)) {
2109 if (!recurse)
break;
2199 visibility = ce->
flag;
2207 "previous definition of %"PRIsVALUE
" was here", name);
2220 ce->
flag = visibility;
2233 rb_warn(
"rb_define_const: invalid name `%s' for constant", name);
2257 for (i = 0; i <
argc; i++) {
2338 #define CVAR_FOREACH_ANCESTORS(klass, v, r) \
2339 for (klass = cvar_front_klass(klass); klass; klass = RCLASS_SUPER(klass)) { \
2340 if (cvar_lookup_at(klass, id, (v))) { \
2345 #define CVAR_LOOKUP(v,r) do {\
2346 if (cvar_lookup_at(klass, id, (v))) {r;}\
2347 CVAR_FOREACH_ANCESTORS(klass, v, r);\
2358 if (front &&
target != front) {
2395 if (front &&
target != front) {
2413 if (!klass)
return Qfalse;
2542 if (
RTEST(inherit)) {
#define RB_TYPE_P(obj, type)
static VALUE classname(VALUE klass, int *permanent)
Returns +classpath+ of klass, if it is named, or +nil+ for anonymous +class+/+module+.
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
static int givar_mark_i(st_data_t k, st_data_t v, st_data_t a)
VALUE rb_const_list(void *)
VALUE rb_const_get_at(VALUE, ID)
VALUE rb_class_path_no_cache(VALUE _klass)
static VALUE rb_const_get_0(VALUE klass, ID id, int exclude, int recurse, int visibility)
VALUE rb_f_trace_var(int, VALUE *)
static VALUE cvar_list(void *data)
static int rb_special_const_p(VALUE obj)
#define RB_OBJ_WRITTEN(a, oldv, b)
void rb_set_class_path(VALUE, VALUE, const char *)
void rb_bug(const char *fmt,...)
VALUE rb_require_safe(VALUE, int)
#define RB_OBJ_WRITE(a, slot, b)
void rb_mark_tbl(struct st_table *)
int rb_is_class_name(VALUE name)
RUBY_EXTERN VALUE rb_cModule
size_t strlen(const char *)
const char * rb_obj_classname(VALUE)
void * rb_mod_const_at(VALUE, void *)
VALUE rb_iv_set(VALUE, const char *, VALUE)
static void uninitialized_constant(VALUE klass, ID id)
VALUE rb_eval_cmd(VALUE, VALUE, int)
static VALUE generic_ivar_defined(VALUE obj, ID id)
int st_lookup(st_table *, st_data_t, st_data_t *)
void st_add_direct(st_table *, st_data_t, st_data_t)
static int autoload_defined_p(VALUE mod, ID id)
VALUE rb_gv_set(const char *, VALUE)
static st_table * generic_iv_tbl
void rb_mark_generic_ivar(VALUE)
static int cv_i(st_data_t k, st_data_t v, st_data_t a)
st_table * st_init_numtable(void)
rb_funcall(memo->yielder, id_lshift, 1, rb_assoc_new(memo->prev_value, memo->prev_elts))
SSL_METHOD *(* func)(void)
VALUE rb_const_get(VALUE, ID)
VALUE rb_obj_remove_instance_variable(VALUE, VALUE)
void rb_define_global_const(const char *, VALUE)
static VALUE autoload_require(VALUE arg)
static void remove_trace(struct global_variable *var)
void rb_error_frozen(const char *what)
VALUE rb_gvar_set(struct rb_global_entry *, VALUE)
static VALUE rb_tmp_class_path(VALUE klass, int *permanent, path_cache_func cache_path)
#define rb_check_frozen(obj)
VALUE rb_gv_get(const char *)
VALUE(* path_cache_func)(VALUE obj, ID id, VALUE val)
#define ROBJECT_EMBED_LEN_MAX
VALUE rb_str_new_cstr(const char *)
int rb_st_insert_id_and_value(VALUE obj, st_table *tbl, ID key, VALUE value)
void rb_gc_mark_global_tbl(void)
VALUE rb_iv_get(VALUE, const char *)
static VALUE find_class_path(VALUE klass, ID preferred)
Traverse constant namespace and find +classpath+ for klass.
int rb_public_const_defined(VALUE klass, ID id)
void rb_define_hooked_variable(const char *, VALUE *, VALUE(*)(ANYARGS), void(*)(ANYARGS))
void rb_vm_inc_const_missing_count(void)
VALUE rb_mod_remove_cvar(VALUE, VALUE)
VALUE rb_ary_push(VALUE ary, VALUE item)
static int cvar_lookup_at(VALUE klass, ID id, st_data_t *v)
static VALUE trace_en(struct global_variable *var)
#define check_autoload_table(av)
void rb_vm_pop_cfunc_frame(void)
static int obj_ivar_i(st_data_t key, st_data_t index, st_data_t arg)
static VALUE cvar_front_klass(VALUE klass)
void rb_mark_generic_ivar_tbl(void)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *state)
static int givar_i(st_data_t k, st_data_t v, st_data_t a)
VALUE rb_autoload_p(VALUE, ID)
void rb_raise(VALUE exc, const char *fmt,...)
static int rb_local_constants_i(st_data_t const_name, st_data_t const_value, st_data_t ary)
VALUE rb_obj_class(VALUE)
static VALUE autoload_const_set(VALUE arg)
void rb_compile_warn(const char *file, int line, const char *fmt,...)
VALUE rb_class_name(VALUE)
size_t st_memsize(const st_table *)
VALUE rb_cvar_defined(VALUE, ID)
static VALUE autoload_provided(VALUE arg)
int rb_public_const_defined_at(VALUE klass, ID id)
static void set_const_visibility(VALUE mod, int argc, VALUE *argv, rb_const_flag_t flag)
static int special_generic_ivar
#define check_autoload_data(av)
ID rb_check_id(volatile VALUE *namep)
Returns ID for the given name if it is interned already, or 0.
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
VALUE rb_path2class(const char *)
VALUE rb_path_to_class(VALUE)
VALUE rb_class_path(VALUE)
int(* func)(ID key, VALUE val, st_data_t arg)
VALUE rb_str_new_frozen(VALUE)
VALUE rb_ivar_get(VALUE, ID)
static void rb_trace_eval(VALUE cmd, VALUE val)
void rb_name_error_str(VALUE str, const char *fmt,...)
void rb_copy_generic_ivar(VALUE, VALUE)
VALUE rb_autoload_load(VALUE, ID)
VALUE rb_cvar_get(VALUE, ID)
void rb_name_error(ID id, const char *fmt,...)
#define CVAR_LOOKUP(v, r)
int rb_feature_provided(const char *, const char **)
#define MEMZERO(p, type, n)
static int list_i(st_data_t key, st_data_t value, VALUE ary)
void st_foreach_safe(struct st_table *, int(*)(ANYARGS), st_data_t)
int st_delete(st_table *, st_data_t *, st_data_t *)
int rb_is_const_id(ID id)
int rb_is_instance_id(ID id)
void rb_define_readonly_variable(const char *, VALUE *)
VALUE rb_f_untrace_var(int, VALUE *)
static void autoload_free(void *ptr)
VALUE rb_block_proc(void)
static void autoload_delete(VALUE mod, ID id)
struct rb_global_entry * rb_global_entry(ID)
static int cv_list_i(st_data_t key, st_data_t value, VALUE ary)
#define rb_intern_str(string)
VALUE rb_mod_private_constant(int argc, VALUE *argv, VALUE obj)
void rb_define_class_variable(VALUE, const char *, VALUE)
void rb_define_const(VALUE, const char *, VALUE)
void(* func)(VALUE arg, VALUE val)
VALUE rb_str_cat2(VALUE, const char *)
VALUE rb_mod_class_variables(int, VALUE *, VALUE)
int rb_public_const_defined_from(VALUE klass, ID id)
#define TypedData_Wrap_Struct(klass, data_type, sval)
#define RUBY_FUNC_EXPORTED
unsigned char buf[MIME_BUF_SIZE]
STATIC void C_block perm[64/CHUNKBITS][1<< CHUNKBITS]
static ID global_id(const char *name)
#define ALLOCA_N(type, n)
static VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
static VALUE generic_ivar_get(VALUE obj, ID id, VALUE undef)
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
static void * mod_cvar_at(VALUE mod, void *data)
VALUE rb_thread_current(void)
void * rb_mod_const_of(VALUE, void *)
st_table * rb_st_copy(VALUE obj, struct st_table *orig_tbl)
VALUE rb_sprintf(const char *format,...)
static void * mod_cvar_of(VALUE mod, void *data)
int rb_const_defined(VALUE, ID)
#define RUBY_TYPED_FREE_IMMEDIATELY
#define CONST_ID(var, str)
void Init_var_tables(void)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
VALUE rb_f_global_variables(void)
static int ivar_i(st_data_t k, st_data_t v, st_data_t a)
void rb_const_set(VALUE, ID, VALUE)
VALUE rb_mod_public_constant(int argc, VALUE *argv, VALUE obj)
static VALUE const_missing(VALUE klass, ID id)
int rb_autoloading_value(VALUE mod, ID id, VALUE *value)
int rb_const_defined_at(VALUE, ID)
VALUE rb_obj_frozen_p(VALUE)
void rb_set_safe_level_force(int)
int rb_const_defined_from(VALUE, ID)
VALUE rb_attr_get(VALUE, ID)
static int generic_ivar_remove(VALUE obj, ID id, st_data_t *valp)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
static const rb_data_type_t autoload_data_i_type
static int sv_i(st_data_t k, st_data_t v, st_data_t a)
void rb_jump_tag(int tag)
VALUE rb_mod_constants(int, VALUE *, VALUE)
static void generic_ivar_set(VALUE obj, ID id, VALUE val)
void rb_gc_mark_maybe(VALUE)
VALUE rb_ivar_defined(VALUE, ID)
#define RCLASS_CONST_TBL(c)
#define MEMCPY(p1, p2, type, n)
struct rb_global_variable * var
struct st_table * rb_generic_ivar_table(VALUE)
static VALUE autoload_data(VALUE mod, ID id)
int rb_is_const_name(VALUE name)
const char * rb_class2name(VALUE)
rb_encoding * rb_enc_get(VALUE obj)
VALUE rb_public_const_get(VALUE klass, ID id)
static VALUE trace_ev(struct trace_data *data)
VALUE rb_cv_get(VALUE, const char *)
void rb_cvar_set(VALUE, ID, VALUE)
VALUE rb_gvar_get(struct rb_global_entry *)
VALUE rb_mod_remove_const(VALUE, VALUE)
static const rb_data_type_t autoload_data_type
static void autoload_i_free(void *ptr)
VALUE rb_mod_const_missing(VALUE, VALUE)
RUBY_EXTERN VALUE rb_cObject
void rb_clear_constant_cache(void)
VALUE rb_const_remove(VALUE, ID)
static VALUE fc_path(struct fc_result *fc, ID name)
void rb_cv_set(VALUE, const char *, VALUE)
struct rb_encoding_entry * list
void rb_define_variable(const char *, VALUE *)
static int fc_i(st_data_t k, st_data_t v, st_data_t a)
static VALUE null_cache(VALUE obj, ID id, VALUE val)
VALUE rb_class_path_cached(VALUE)
int st_insert(st_table *, st_data_t, st_data_t)
void rb_define_virtual_variable(const char *, VALUE(*)(ANYARGS), void(*)(ANYARGS))
VALUE rb_public_const_get_at(VALUE klass, ID id)
static int rb_const_defined_0(VALUE klass, ID id, int exclude, int recurse, int visibility)
rb_ivar_set(yielder, id_memo, LONG2NUM(++count))
static int mark_global_entry(st_data_t k, st_data_t v, st_data_t a)
void rb_set_class_path_string(VALUE, VALUE, VALUE)
int rb_is_class_id(ID id)
#define RCLASS_IV_INDEX_TBL(c)
static VALUE reset_safe(VALUE safe)
static size_t autoload_memsize(const void *ptr)
#define rb_enc_asciicompat(enc)
static VALUE check_autoload_required(VALUE mod, ID id, const char **loadingpath)
int rb_is_instance_name(VALUE name)
VALUE rb_const_get_from(VALUE, ID)
static void autoload_i_mark(void *ptr)
VALUE rb_class_real(VALUE)
static int gvar_i(st_data_t k, st_data_t v, st_data_t a)
st_index_t rb_ivar_count(VALUE)
static size_t autoload_i_memsize(const void *ptr)
void rb_warning(const char *fmt,...)
#define ROBJECT_IV_INDEX_TBL(o)
static int tbl_copy_i(st_data_t key, st_data_t value, st_data_t data)
size_t rb_generic_ivar_memsize(VALUE)
st_table * st_copy(st_table *)
static void obj_ivar_each(VALUE obj, int(*func)(ANYARGS), st_data_t arg)
VALUE rb_public_const_get_from(VALUE klass, ID id)
#define SPECIAL_CONST_P(x)
void rb_name_class(VALUE, ID)
VALUE rb_gvar_defined(struct rb_global_entry *)
void rb_ivar_foreach(VALUE, int(*)(ANYARGS), st_data_t)
ID rb_intern2(const char *name, long len)
static VALUE original_module(VALUE c)
#define REALLOC_N(var, type, n)
void rb_free_generic_ivar(VALUE)
static VALUE rb_local_constants(VALUE mod)
void rb_warn(const char *fmt,...)
#define rb_obj_instance_variables(object)
static void autoload_mark(void *ptr)
static void check_before_mod_set(VALUE klass, ID id, VALUE val, const char *dest)
void st_free_table(st_table *)
void rb_alias_variable(ID, ID)
VALUE rb_sourcefilename(void)
void rb_autoload(VALUE, ID, const char *)