17#include "ruby/internal/config.h"
21#include "debug_counter.h"
24#include "internal/box.h"
25#include "internal/class.h"
26#include "internal/error.h"
27#include "internal/eval.h"
28#include "internal/gc.h"
29#include "internal/hash.h"
30#include "internal/object.h"
31#include "internal/string.h"
32#include "internal/variable.h"
33#include "internal/vm.h"
37#include "ractor_core.h"
84#define METACLASS_OF(k) RBASIC(k)->klass
85#define SET_METACLASS_OF(k, cls) RBASIC_SET_CLASS(k, cls)
91 st_data_t key = (st_data_t)box->box_object;
92 st_delete(box->classext_cow_classes, &klass, 0);
93 st_delete(RCLASS_CLASSEXT_TBL(klass), &key, &ext);
102 rb_id_table_free(RCLASSEXT_M_TBL(ext));
104 if (!RCLASSEXT_SHARED_CONST_TBL(ext) && (tbl = RCLASSEXT_CONST_TBL(ext)) != NULL) {
105 rb_free_const_table(tbl);
108 if (RCLASSEXT_SUPERCLASSES_WITH_SELF(ext)) {
110 size_t depth = RCLASSEXT_SUPERCLASS_DEPTH(ext);
111 if (depth != RCLASS_MAX_SUPERCLASS_DEPTH) {
114 SIZED_FREE_N(RCLASSEXT_SUPERCLASSES(ext), depth);
125 if (RCLASSEXT_ICLASS_IS_ORIGIN(ext) && !RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext)) {
127 rb_id_table_free(RCLASSEXT_M_TBL(ext));
130 if (RCLASSEXT_CALLABLE_M_TBL(ext) != NULL) {
131 rb_id_table_free(RCLASSEXT_CALLABLE_M_TBL(ext));
142 if (RCLASSEXT_ICLASS_IS_ORIGIN(ext) && !RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext)) {
144 rb_id_table_free(RCLASSEXT_M_TBL(ext));
147 if (RCLASSEXT_CALLABLE_M_TBL(ext) != NULL) {
148 rb_id_table_free(RCLASSEXT_CALLABLE_M_TBL(ext));
160set_box_classext_update(st_data_t *key_ptr, st_data_t *val_ptr, st_data_t a,
int existing)
166 iclass_free_orphan_classext(args->obj, (
rb_classext_t *)*val_ptr);
169 rb_bug(
"Updating existing classext for non-iclass never happen");
173 *val_ptr = (st_data_t)args->ext;
186 VM_ASSERT(BOX_MUTABLE_P(box));
188 st_update(RCLASS_CLASSEXT_TBL(obj), (st_data_t)box->box_object, set_box_classext_update, (st_data_t)&args);
193 rb_gc_writebarrier_remember(obj);
195 st_insert(box->classext_cow_classes, (st_data_t)obj, 0);
205static enum rb_id_table_iterator_result
206duplicate_classext_m_tbl_i(
ID key,
VALUE value,
void *data)
210 rb_method_table_insert0(arg->klass, arg->tbl, key, me,
false);
211 return ID_TABLE_CONTINUE;
215duplicate_classext_m_tbl(
struct rb_id_table *orig,
VALUE klass,
bool init_missing)
220 return rb_id_table_create(0);
224 tbl = rb_id_table_create(rb_id_table_size(orig));
229 rb_id_table_foreach(orig, duplicate_classext_m_tbl_i, &data);
239 dst->flag = src->flag;
240 dst->line = src->line;
247static enum rb_id_table_iterator_result
248duplicate_classext_const_tbl_i(
ID key,
VALUE value,
void *data)
253 rb_id_table_insert(arg->tbl, key, (
VALUE)entry);
255 return ID_TABLE_CONTINUE;
266 dst = rb_id_table_create(rb_id_table_size(src));
272 rb_id_table_foreach(src, duplicate_classext_const_tbl_i, (
void *)&data);
283 rb_classext_t *ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(iclass, box);
288 rb_invalidate_method_caches(RCLASSEXT_CALLABLE_M_TBL(ext), RCLASSEXT_CC_TBL(ext));
293 RCLASSEXT_BOX(ext) = box;
295 RCLASSEXT_SUPER(ext) = RCLASSEXT_SUPER(src);
298 if (RCLASSEXT_ICLASS_IS_ORIGIN(src) && !RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(src)) {
299 RCLASSEXT_M_TBL(ext) = duplicate_classext_m_tbl(RCLASSEXT_M_TBL(src), iclass,
true);
302 RCLASSEXT_M_TBL(ext) = RCLASSEXT_M_TBL(mod_ext);
305 RCLASSEXT_CONST_TBL(ext) = RCLASSEXT_CONST_TBL(mod_ext);
306 RCLASSEXT_CVC_TBL(ext) = RCLASSEXT_CVC_TBL(mod_ext);
314 RCLASSEXT_SET_ORIGIN(ext, iclass, RCLASSEXT_ORIGIN(src));
315 RCLASSEXT_ICLASS_IS_ORIGIN(ext) = RCLASSEXT_ICLASS_IS_ORIGIN(src);
316 RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext) = RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(src);
318 RCLASSEXT_SET_INCLUDER(ext, iclass, RCLASSEXT_INCLUDER(src));
322 first_set = RCLASS_SET_BOX_CLASSEXT(iclass, box, ext);
324 RCLASS_SET_PRIME_CLASSEXT_WRITABLE(iclass,
false);
336 RCLASSEXT_BOX(ext) = box;
338 RCLASSEXT_SUPER(ext) = RCLASSEXT_SUPER(orig);
340 RCLASSEXT_M_TBL(ext) = duplicate_classext_m_tbl(RCLASSEXT_M_TBL(orig), klass, dup_iclass);
341 RCLASSEXT_ICLASS_IS_ORIGIN(ext) =
true;
342 RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext) =
false;
344 if (orig->fields_obj) {
345 RB_OBJ_WRITE(klass, &ext->fields_obj, rb_imemo_fields_clone(orig->fields_obj));
348 if (RCLASSEXT_SHARED_CONST_TBL(orig)) {
349 RCLASSEXT_CONST_TBL(ext) = RCLASSEXT_CONST_TBL(orig);
350 RCLASSEXT_SHARED_CONST_TBL(ext) =
true;
353 RCLASSEXT_CONST_TBL(ext) = duplicate_classext_const_tbl(RCLASSEXT_CONST_TBL(orig), klass);
354 RCLASSEXT_SHARED_CONST_TBL(ext) =
false;
366 VALUE cvc_table = RCLASSEXT_CVC_TBL(orig);
368 cvc_table = rb_marked_id_table_dup(cvc_table);
370 else if (dup_iclass) {
371 cvc_table = rb_marked_id_table_new(2);
373 RB_OBJ_WRITE(klass, &RCLASSEXT_CVC_TBL(ext), cvc_table);
377 RCLASSEXT_SET_ORIGIN(ext, klass, RCLASSEXT_ORIGIN(orig));
386 RCLASSEXT_PERMANENT_CLASSPATH(ext) = RCLASSEXT_PERMANENT_CLASSPATH(orig);
387 RCLASSEXT_CLASSPATH(ext) = RCLASSEXT_CLASSPATH(orig);
399 VALUE subs_v = RCLASSEXT_SUBCLASSES(orig);
402 VALUE *entries = rb_imemo_subclasses_entries(subs_v);
403 for (uint32_t i = 0; i < subs->count; i++) {
404 VALUE iclass = entries[i];
405 if (!iclass)
continue;
415 class_duplicate_iclass_classext(iclass, ext, box);
425rb_class_ensure_writable(
VALUE klass)
428 RCLASS_EXT_WRITABLE(klass);
432 rb_class_classext_foreach_callback_func *func;
437class_classext_foreach_i(st_data_t key, st_data_t value, st_data_t arg)
440 rb_class_classext_foreach_callback_func *func =
foreach_arg->func;
446rb_class_classext_foreach(
VALUE klass, rb_class_classext_foreach_callback_func *func,
void *arg)
448 st_table *tbl = RCLASS_CLASSEXT_TBL(klass);
453 rb_st_foreach(tbl, class_classext_foreach_i, (st_data_t)&
foreach_arg);
455 func(RCLASS_EXT_PRIME(klass),
true, (
VALUE)NULL, arg);
465rb_class_singleton_p(
VALUE klass)
467 return RCLASS_SINGLETON_P(klass);
471rb_class_variation_count(
VALUE klass)
473 return RCLASS_VARIATION_COUNT(klass);
477push_subclass_entry_to_list(
VALUE super,
VALUE klass)
486 VALUE subs_v = RCLASS_SUBCLASSES(super);
489 if (!subs || subs->count == subs->capacity) {
490 VALUE *old_entries = subs ? rb_imemo_subclasses_entries(subs_v) : NULL;
492 for (uint32_t i = 0; subs && i < subs->count; i++) {
493 if (old_entries[i]) live++;
496 uint32_t cap = subs ? subs->capacity : 2;
497 if (live * 2 >= cap) cap *= 2;
499 VALUE new_v = rb_imemo_subclasses_new(cap);
501 VALUE *new_entries = rb_imemo_subclasses_entries(new_v);
502 for (uint32_t i = 0; subs && i < subs->count; i++) {
503 VALUE entry = old_entries[i];
505 new_entries[new_subs->count++] = entry;
509 RCLASS_SET_SUBCLASSES(super, new_v);
514 rb_imemo_subclasses_entries(subs_v)[subs->count++] = klass;
520rb_class_subclass_add(
VALUE super,
VALUE klass)
522 if (super && !UNDEF_P(super)) {
525 push_subclass_entry_to_list(super, klass);
530rb_module_add_to_subclasses_list(
VALUE module,
VALUE iclass)
532 if (module && !UNDEF_P(module)) {
535 push_subclass_entry_to_list(module, iclass);
542 VALUE subs_v = RCLASS_SUBCLASSES(klass);
546 VALUE *entries = rb_imemo_subclasses_entries(subs_v);
547 for (uint32_t i = 0; i < subs->count; i++) {
548 VALUE curklass = entries[i];
556class_switch_superclass(
VALUE super,
VALUE klass)
560 rb_class_subclass_add(super, klass);
576 const rb_box_t *box = rb_current_box();
578 if (!ruby_box_init_done) {
590 if (boxable) flags |= RCLASS_BOXABLE;
592 shape_id_t shape_id = ROOT_SHAPE_ID;
594 shape_id |= SHAPE_ID_LAYOUT_OTHER;
597 shape_id |= SHAPE_ID_LAYOUT_RCLASS;
600 struct RClass *obj = (
struct RClass *)rb_newobj(GET_EC(), klass, flags, shape_id,
true, alloc_size);
608 if (
type !=
T_ICLASS && UNLIKELY(!rb_ractor_main_p())) {
609 RCLASS_SET_OWNER_RACTOR_ID((
VALUE)obj, rb_ractor_id(GET_RACTOR()));
623 RCLASS_PRIME_BOX((
VALUE)obj) = box;
626 RCLASS_SET_PRIME_CLASSEXT_WRITABLE((
VALUE)obj, !boxable || BOX_USER_P(box));
629 RCLASS_SET_REFINED_CLASS((
VALUE)obj,
Qnil);
637 bool boxable = rb_box_available() && BOX_MASTER_P(rb_current_box());
642rb_class_owned_by_ractor_p(rb_serial_t owner_id)
644 return owner_id == rb_ractor_id(GET_RACTOR());
651class_owner_name(
VALUE klass)
655 VALUE obj = RCLASS_ATTACHED_OBJECT(klass);
661class_own_metaclass(
VALUE klass)
663 VALUE meta = METACLASS_OF(klass);
664 return (RCLASS_SINGLETON_P(meta) && RCLASS_ATTACHED_OBJECT(meta) == klass) ? meta : 0;
670rb_class_take_ownership(
VALUE klass)
673 rb_serial_t
id = rb_ractor_main_p() ? 0 : rb_ractor_id(GET_RACTOR());
677 RCLASS_SET_OWNER_RACTOR_ID(klass,
id);
678 }
while ((klass = class_own_metaclass(klass)) != 0);
682rb_class_owner_check(
VALUE klass)
684 if (UNLIKELY(!rb_class_owned_p(klass))) {
685 rb_raise(rb_eRactorIsolationError,
686 "can not modify %"PRIsVALUE
" because it is created by another Ractor",
687 class_owner_name(klass));
692class_associate_super(
VALUE klass,
VALUE super,
bool init)
694 if (super && !UNDEF_P(super)) {
699 if (RCLASS_SINGLETON_P(klass)) {
706 class_switch_superclass(super, klass);
711 RCLASS_SET_SUPER(klass, super);
714 RCLASS_WRITE_SUPER(klass, super);
716 rb_class_update_superclasses(klass);
723 return class_associate_super(klass, super,
false);
727class_initialize_method_table(
VALUE c)
730 RCLASS_SET_M_TBL(c, rb_id_table_create(0));
734class_clear_method_table(
VALUE c)
736 RCLASS_WRITE_M_TBL(c, rb_id_table_create(0));
740class_boot_boxable(
VALUE super,
bool boxable)
746 class_initialize_method_table(klass);
748 class_associate_super(klass, super,
true);
749 if (super && !UNDEF_P(super)) {
750 RCLASS_SET_ALLOCATOR(klass, RCLASS_ALLOCATOR(super));
751 rb_class_set_initialized(klass);
769 return class_boot_boxable(super,
false);
773class_superclasses_including_self(
VALUE klass)
775 if (RCLASS_SUPERCLASSES_WITH_SELF_P(klass))
776 return RCLASS_SUPERCLASSES(klass);
778 size_t depth = RCLASS_SUPERCLASS_DEPTH(klass);
781 memcpy(superclasses, RCLASS_SUPERCLASSES(klass),
sizeof(
VALUE) * depth);
782 superclasses[depth] = klass;
788rb_class_update_superclasses(
VALUE klass)
795 if (UNDEF_P(super))
return;
798 if (RCLASS_SUPERCLASSES(klass))
813 rb_class_update_superclasses(super);
816 if (!RCLASS_SUPERCLASS_DEPTH(super))
820 super_depth = RCLASS_SUPERCLASS_DEPTH(super);
821 if (RCLASS_SUPERCLASSES_WITH_SELF_P(super)) {
822 superclasses = RCLASS_SUPERCLASSES(super);
825 superclasses = class_superclasses_including_self(super);
826 RCLASS_WRITE_SUPERCLASSES(super, super_depth, superclasses,
true);
829 size_t depth = super_depth == RCLASS_MAX_SUPERCLASS_DEPTH ? super_depth : super_depth + 1;
830 RCLASS_WRITE_SUPERCLASSES(klass, depth, superclasses,
false);
837 rb_raise(
rb_eTypeError,
"superclass must be an instance of Class (given an instance of %"PRIsVALUE
")",
840 if (RCLASS_SINGLETON_P(super)) {
841 rb_raise(
rb_eTypeError,
"can't make subclass of singleton class");
855 RCLASS_SET_MAX_IV_COUNT(klass, RCLASS_MAX_IV_COUNT(super));
856 RUBY_ASSERT(getenv(
"RUBY_BOX") || RCLASS_PRIME_CLASSEXT_WRITABLE_P(klass));
862rb_class_s_alloc(
VALUE klass)
870 rb_method_entry_set(new_klass, mid, me, METHOD_ENTRY_VISI(me));
877static enum rb_id_table_iterator_result
878clone_method_i(
ID key,
VALUE value,
void *data)
882 return ID_TABLE_CONTINUE;
898 rb_id_table_insert(arg->tbl, key, (
VALUE)nce);
899 return ID_TABLE_CONTINUE;
902static enum rb_id_table_iterator_result
903clone_const_i(
ID key,
VALUE value,
void *data)
914 if (RCLASS_INITIALIZED_P(clone)) {
917 if (RCLASS_SINGLETON_P(orig)) {
928cvc_table_entry_alloc(
void)
933static enum rb_id_table_iterator_result
934cvc_table_copy(
ID id,
VALUE val,
void *data)
942 ent = cvc_table_entry_alloc();
945 ent->global_cvar_state = orig_entry->global_cvar_state;
946 rb_marked_id_table_insert(ctx->new_table,
id, (
VALUE)ent);
948 return ID_TABLE_CONTINUE;
954 if (RCLASS_CONST_TBL(clone)) {
955 rb_free_const_table(RCLASS_CONST_TBL(clone));
956 RCLASS_WRITE_CONST_TBL(clone, 0,
false);
958 if (RCLASS_CVC_TBL(orig)) {
959 VALUE rb_cvc_tbl = RCLASS_CVC_TBL(orig);
960 VALUE rb_cvc_tbl_dup = rb_marked_id_table_new(rb_marked_id_table_size(rb_cvc_tbl));
964 ctx.new_table = rb_cvc_tbl_dup;
965 rb_marked_id_table_foreach(rb_cvc_tbl, cvc_table_copy, &ctx);
966 RCLASS_WRITE_CVC_TBL(clone, rb_cvc_tbl_dup);
968 rb_id_table_free(RCLASS_M_TBL(clone));
969 RCLASS_WRITE_M_TBL(clone, 0);
971 rb_fields_tbl_copy(clone, orig);
973 if (RCLASS_CONST_TBL(orig)) {
976 struct rb_id_table *orig_tbl = RCLASS_CONST_TBL(orig);
977 arg.tbl = const_tbl = rb_id_table_create(rb_id_table_size(orig_tbl));
979 rb_id_table_foreach(orig_tbl, clone_const_i, &arg);
980 RCLASS_WRITE_CONST_TBL(clone, const_tbl,
false);
981 rb_gc_writebarrier_remember(clone);
985static bool ensure_origin(
VALUE klass);
988rb_class_set_initialized(
VALUE klass)
996rb_module_check_initializable(
VALUE mod)
998 if (RCLASS_INITIALIZED_P(mod)) {
1003static enum rb_id_table_iterator_result
1004init_copy_check_const_i(
ID id,
VALUE v,
void *data)
1008 rb_raise(rb_eRactorIsolationError,
1009 "can not copy a class/module created by another Ractor because "
1010 "constant %"PRIsVALUE
" refers to an unshareable object", rb_id2str(
id));
1012 return ID_TABLE_CONTINUE;
1016init_copy_check_field_i(
ID id,
VALUE val, st_data_t arg)
1019 rb_raise(rb_eRactorIsolationError,
1020 "can not copy a class/module created by another Ractor because "
1021 "variable %"PRIsVALUE
" refers to an unshareable object", rb_id2str(
id));
1028static enum rb_id_table_iterator_result
1029move_check_const_i(
ID id,
VALUE v,
void *data)
1033 rb_raise(rb_eRactorIsolationError,
1034 "can not move an object whose singleton class has constant %"PRIsVALUE
1035 " referring to an unshareable object", rb_id2str(
id));
1037 return ID_TABLE_CONTINUE;
1041move_check_field_i(
ID id,
VALUE val, st_data_t arg)
1044 rb_raise(rb_eRactorIsolationError,
1045 "can not move an object whose singleton class has variable %"PRIsVALUE
1046 " referring to an unshareable object", rb_id2str(
id));
1054rb_class_check_singleton_movable(
VALUE klass)
1057 if (RCLASS_CONST_TBL(klass)) {
1058 rb_id_table_foreach(RCLASS_CONST_TBL(klass), move_check_const_i, NULL);
1060 rb_ivar_foreach_buffered(klass, move_check_field_i, 0);
1061 }
while ((klass = class_own_metaclass(klass)) != 0);
1065init_copy_check_tables(
VALUE klass)
1067 if (RCLASS_CONST_TBL(klass)) {
1068 rb_id_table_foreach(RCLASS_CONST_TBL(klass), init_copy_check_const_i, NULL);
1070 rb_ivar_foreach_buffered(klass, init_copy_check_field_i, 0);
1074init_copy_owner_check(
VALUE orig)
1076 if (!rb_class_owned_p(orig)) {
1077 init_copy_check_tables(orig);
1080 VALUE meta = METACLASS_OF(orig);
1081 if (RCLASS_SINGLETON_P(meta)) {
1082 init_copy_check_tables(meta);
1096 class_init_copy_check(clone, orig);
1099 rb_module_check_initializable(clone);
1109 init_copy_owner_check(orig);
1111 rb_class_set_initialized(clone);
1113 if (!RCLASS_SINGLETON_P(
CLASS_OF(clone))) {
1118 RCLASS_SET_ALLOCATOR(clone, RCLASS_ALLOCATOR(orig));
1120 copy_tables(clone, orig);
1121 if (RCLASS_M_TBL(orig)) {
1123 arg.new_klass = clone;
1124 class_initialize_method_table(clone);
1125 rb_id_table_foreach(RCLASS_M_TBL(orig), clone_method_i, &arg);
1128 if (RCLASS_ORIGIN(orig) == orig) {
1133 VALUE orig_origin = RCLASS_ORIGIN(orig);
1134 VALUE prev_clone_p = clone;
1142 ensure_origin(clone);
1143 clone_origin = RCLASS_ORIGIN(clone);
1145 while (p && p != orig_origin) {
1147 rb_bug(
"non iclass between module/class and origin");
1149 clone_p = class_alloc(
T_ICLASS, METACLASS_OF(p));
1150 RCLASS_SET_M_TBL(clone_p, RCLASS_M_TBL(p));
1151 rb_class_set_super(prev_clone_p, clone_p);
1152 prev_clone_p = clone_p;
1153 RCLASS_SET_CONST_TBL(clone_p, RCLASS_CONST_TBL(p),
false);
1154 RCLASS_SET_INCLUDER(clone_p, clone);
1155 add_subclass = TRUE;
1156 if (p != RCLASS_ORIGIN(p)) {
1157 origin[0] = clone_p;
1158 origin[1] = RCLASS_ORIGIN(p);
1161 else if ((origin_len =
RARRAY_LEN(origin_stack)) > 1 &&
1163 RCLASS_WRITE_ORIGIN(
RARRAY_AREF(origin_stack, (origin_len -= 2)), clone_p);
1164 RICLASS_WRITE_ORIGIN_SHARED_MTBL(clone_p);
1166 add_subclass = FALSE;
1169 rb_module_add_to_subclasses_list(METACLASS_OF(p), clone_p);
1174 if (p == orig_origin) {
1176 rb_class_set_super(clone_p, clone_origin);
1177 rb_class_set_super(clone_origin,
RCLASS_SUPER(orig_origin));
1179 copy_tables(clone_origin, orig_origin);
1180 if (RCLASS_M_TBL(orig_origin)) {
1182 arg.new_klass = clone;
1183 class_initialize_method_table(clone_origin);
1184 rb_id_table_foreach(RCLASS_M_TBL(orig_origin), clone_method_i, &arg);
1188 rb_bug(
"no origin for class that has origin");
1191 rb_class_update_superclasses(clone);
1207 return rb_singleton_class_clone_and_attach(obj,
Qundef);
1212rb_singleton_class_clone_and_attach(
VALUE obj,
VALUE attach)
1214 const VALUE klass = METACLASS_OF(obj);
1220 if (!(RCLASS_SINGLETON_P(klass) && RCLASS_ATTACHED_OBJECT(klass) == obj)) {
1226 bool klass_of_clone_is_new;
1231 klass_of_clone_is_new =
true;
1232 RBASIC_SET_CLASS(clone, clone);
1238 klass_of_clone_is_new = (METACLASS_OF(klass) != klass_metaclass_clone);
1239 RBASIC_SET_CLASS(clone, klass_metaclass_clone);
1243 class_initialize_method_table(clone);
1246 rb_fields_tbl_copy(clone, klass);
1247 if (RCLASS_CONST_TBL(klass)) {
1250 arg.tbl = table = rb_id_table_create(rb_id_table_size(RCLASS_CONST_TBL(klass)));
1252 rb_id_table_foreach(RCLASS_CONST_TBL(klass), clone_const_i, &arg);
1253 RCLASS_SET_CONST_TBL(clone, table,
false);
1255 if (!UNDEF_P(attach)) {
1260 arg.new_klass = clone;
1261 rb_id_table_foreach(RCLASS_M_TBL(klass), clone_method_i, &arg);
1263 if (klass_of_clone_is_new) {
1275 if (RCLASS_SINGLETON_P(klass)) {
1276 RCLASS_SET_ATTACHED_OBJECT(klass, obj);
1285#define META_CLASS_OF_CLASS_CLASS_P(k) (METACLASS_OF(k) == (k))
1288rb_singleton_class_has_metaclass_p(
VALUE sklass)
1290 return RCLASS_ATTACHED_OBJECT(METACLASS_OF(sklass)) == sklass;
1294rb_singleton_class_internal_p(
VALUE sklass)
1297 !rb_singleton_class_has_metaclass_p(sklass));
1305#define HAVE_METACLASS_P(k) \
1306 (FL_TEST(METACLASS_OF(k), FL_SINGLETON) && \
1307 rb_singleton_class_has_metaclass_p(k))
1316#define ENSURE_EIGENCLASS(klass) \
1317 (HAVE_METACLASS_P(klass) ? METACLASS_OF(klass) : make_metaclass(klass))
1337 RCLASS_SET_OWNER_RACTOR_ID(metaclass, RCLASS_OWNER_RACTOR_ID(klass));
1341 SET_METACLASS_OF(klass, metaclass);
1342 SET_METACLASS_OF(metaclass, metaclass);
1345 VALUE tmp = METACLASS_OF(klass);
1346 SET_METACLASS_OF(klass, metaclass);
1353 rb_class_set_initialized(klass);
1356 rb_class_update_superclasses(METACLASS_OF(metaclass));
1370 VALUE orig_class = METACLASS_OF(obj);
1375 RCLASS_SET_OWNER_RACTOR_ID(klass, RCLASS_OWNER_RACTOR_ID(obj));
1380 RCLASS_SET_OWNER_RACTOR_ID(klass, 0);
1382 class_initialize_method_table(klass);
1383 class_associate_super(klass, orig_class,
true);
1384 if (orig_class && !UNDEF_P(orig_class)) {
1385 rb_class_set_initialized(klass);
1388 RBASIC_SET_CLASS(obj, klass);
1390 rb_yjit_invalidate_no_singleton_class(orig_class);
1391 rb_zjit_invalidate_no_singleton_class(orig_class);
1393 SET_METACLASS_OF(klass, METACLASS_OF(
rb_class_real(orig_class)));
1399boot_defclass(
const char *name,
VALUE super)
1402 ID id = rb_intern(name);
1405 rb_vm_register_global_object(obj);
1456refinement_import_methods(
int argc,
VALUE *argv,
VALUE refinement)
1481Init_class_hierarchy(
void)
1542 rb_make_metaclass(klass, METACLASS_OF(super));
1562 return rb_funcallv_uncached(super, inherited, 1, &klass);
1565#ifdef rb_define_class
1566#undef rb_define_class
1569rb_define_class(
const char *name,
VALUE super)
1571 return rb_define_class_under(
rb_cObject, name, super);
1574#ifdef rb_define_class_under
1575#undef rb_define_class_under
1584rb_define_class_id_under_no_pin(
VALUE outer,
ID id,
VALUE super)
1596 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
"::%"PRIsVALUE
" is not a class"
1603 rb_raise(
rb_eTypeError,
"superclass mismatch for class %s", rb_id2name(
id));
1607 "%"PRIsVALUE
"::%"PRIsVALUE
""
1608 " (%"PRIsVALUE
" is given but was %"PRIsVALUE
")",
1617 rb_raise(rb_eArgError,
"no super class for '%"PRIsVALUE
"'", rb_id2str(
id));
1620 rb_raise(rb_eArgError,
"no super class for '%"PRIsVALUE
"::%"PRIsVALUE
"'",
1635 VALUE klass = rb_define_class_id_under_no_pin(outer,
id, super);
1636 rb_vm_register_global_object(klass);
1641rb_module_s_alloc(
VALUE klass)
1644 class_initialize_method_table(mod);
1649module_new(
VALUE klass)
1652 class_initialize_method_table(mdl);
1675#ifdef rb_define_module
1676#undef rb_define_module
1679rb_define_module(
const char *name)
1684#ifdef rb_define_module_under
1685#undef rb_define_module_under
1688rb_define_module_under(
VALUE outer,
const char *name)
1699 module = rb_const_get_at(outer, id);
1702 rb_raise(
rb_eTypeError,
"%s is not a module (%"PRIsVALUE
")",
1706 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
"::%"PRIsVALUE
" is not a module"
1712 rb_vm_register_global_object(module);
1715 module = rb_module_new();
1718 rb_vm_register_global_object(module);
1724rb_include_class_new(
VALUE module,
VALUE super)
1728 RCLASS_SET_M_TBL(klass, RCLASS_WRITABLE_M_TBL(module));
1730 RCLASS_SET_ORIGIN(klass, klass);
1732 module = METACLASS_OF(module);
1735 if (RCLASS_WRITABLE_CONST_TBL(module)) {
1736 RCLASS_SET_CONST_TBL(klass, RCLASS_WRITABLE_CONST_TBL(module),
true);
1739 RCLASS_WRITE_CONST_TBL(module, rb_id_table_create(0),
false);
1740 RCLASS_SET_CONST_TBL(klass, RCLASS_WRITABLE_CONST_TBL(module),
true);
1743 RCLASS_SET_CVC_TBL(klass, RCLASS_WRITABLE_CVC_TBL(module));
1745 class_associate_super(klass, super,
true);
1746 RBASIC_SET_CLASS(klass, module);
1748 return (
VALUE)klass;
1751static int include_modules_at(
const VALUE klass,
VALUE c,
VALUE module,
int search_super);
1758 rb_class_set_initialized(module);
1759 if (!
NIL_P(rb_refinement_module_get_refined_class(module))) {
1760 rb_raise(rb_eArgError,
"refinement module is not allowed");
1769 ensure_includable(klass, module);
1771 changed = include_modules_at(klass, RCLASS_ORIGIN(klass), module, TRUE);
1773 rb_raise(rb_eArgError,
"cyclic include detected");
1776 VALUE subs_v = RCLASS_SUBCLASSES(klass);
1779 VALUE *entries = rb_imemo_subclasses_entries(subs_v);
1780 for (uint32_t i = 0; i < subs->count; i++) {
1781 VALUE check_class = entries[i];
1782 if (!check_class)
continue;
1787 if (!rb_objspace_garbage_object_p(check_class)) {
1788 VALUE walk = check_class;
1793 (METACLASS_OF(walk) == module)) {
1800 include_modules_at(check_class, RCLASS_ORIGIN(check_class), module, TRUE);
1808static enum rb_id_table_iterator_result
1809add_refined_method_entry_i(
ID key,
VALUE value,
void *data)
1811 rb_add_refined_method_entry((
VALUE)data, key);
1812 return ID_TABLE_CONTINUE;
1815static enum rb_id_table_iterator_result
1816clear_module_cache_i(
ID id,
VALUE val,
void *data)
1819 rb_clear_method_cache(klass,
id);
1820 return ID_TABLE_CONTINUE;
1824module_in_super_chain(
const VALUE klass,
VALUE module)
1826 struct rb_id_table *
const klass_m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(klass));
1829 if (klass_m_tbl == RCLASS_M_TBL(module))
1831 module = RCLASS_SUPER(module);
1839static enum rb_id_table_iterator_result
1840clear_constant_cache_i(
ID id,
VALUE value,
void *data)
1843 return ID_TABLE_CONTINUE;
1847do_include_modules_at(
const VALUE klass,
VALUE c,
VALUE module,
int search_super,
bool check_cyclic)
1849 VALUE p, iclass, origin_stack = 0;
1850 int method_changed = 0;
1852 VALUE klass_origin = RCLASS_ORIGIN(klass);
1853 VALUE original_klass = klass;
1855 if (check_cyclic && module_in_super_chain(klass, module))
1860 int superclass_seen = FALSE;
1866 if (klass_origin != c || search_super) {
1872 if (klass_origin == p && !search_super)
1877 if (RCLASS_M_TBL(p) == RCLASS_M_TBL(module)) {
1878 if (!superclass_seen && c_seen) {
1885 superclass_seen = TRUE;
1893 RB_DEBUG_COUNTER_INC(cvar_include_invalidate);
1894 ruby_vm_global_cvar_state++;
1895 tbl = RCLASS_M_TBL(module);
1896 if (tbl && rb_id_table_size(tbl)) {
1899 rb_id_table_foreach(tbl, clear_module_cache_i, (
void *)super_class);
1904 rb_id_table_foreach(tbl, clear_module_cache_i, (
void *)original_klass);
1911 iclass = rb_include_class_new(module, super_class);
1912 c = rb_class_set_super(c, iclass);
1913 RCLASS_SET_INCLUDER(iclass, klass);
1914 if (module != RCLASS_ORIGIN(module)) {
1916 VALUE origin[2] = {iclass, RCLASS_ORIGIN(module)};
1919 else if (origin_stack && (origin_len =
RARRAY_LEN(origin_stack)) > 1 &&
1920 RARRAY_AREF(origin_stack, origin_len - 1) == module) {
1921 RCLASS_WRITE_ORIGIN(
RARRAY_AREF(origin_stack, (origin_len -= 2)), iclass);
1922 RICLASS_WRITE_ORIGIN_SHARED_MTBL(iclass);
1928 rb_module_add_to_subclasses_list(m, iclass);
1931 VALUE refined_class =
1932 rb_refinement_module_get_refined_class(klass);
1934 rb_id_table_foreach(RCLASS_M_TBL(module), add_refined_method_entry_i, (
void *)refined_class);
1938 tbl = RCLASS_CONST_TBL(module);
1939 if (tbl && rb_id_table_size(tbl))
1940 rb_id_table_foreach(tbl, clear_constant_cache_i, NULL);
1942 module = RCLASS_SUPER(module);
1945 return method_changed;
1949include_modules_at(
const VALUE klass,
VALUE c,
VALUE module,
int search_super)
1951 return do_include_modules_at(klass, c, module, search_super,
true);
1954static enum rb_id_table_iterator_result
1955move_refined_method(
ID key,
VALUE value,
void *data)
1959 if (me->def->type == VM_METHOD_TYPE_REFINED) {
1961 struct rb_id_table *tbl = RCLASS_WRITABLE_M_TBL(klass);
1963 if (me->def->body.refined.orig_me) {
1965 RB_OBJ_WRITE(me, &me->def->body.refined.orig_me, NULL);
1966 new_me = rb_method_entry_clone(me);
1967 rb_method_table_insert(klass, tbl, key, new_me);
1968 rb_method_entry_copy(me, orig_me);
1969 return ID_TABLE_CONTINUE;
1972 rb_method_table_insert(klass, tbl, key, me);
1973 return ID_TABLE_DELETE;
1977 return ID_TABLE_CONTINUE;
1981static enum rb_id_table_iterator_result
1982cache_clear_refined_method(
ID key,
VALUE value,
void *data)
1986 if (me->def->type == VM_METHOD_TYPE_REFINED && me->def->body.refined.orig_me) {
1988 rb_clear_method_cache(klass, me->called_id);
1993 return ID_TABLE_CONTINUE;
1997ensure_origin(
VALUE klass)
1999 VALUE origin = RCLASS_ORIGIN(klass);
2000 if (origin == klass) {
2004 rb_class_ensure_writable(klass);
2005 origin = class_alloc(
T_ICLASS, klass);
2006 RCLASS_SET_M_TBL(origin, RCLASS_M_TBL(klass));
2008 rb_class_set_super(klass, origin);
2009 RCLASS_WRITE_ORIGIN(klass, origin);
2013 rb_gc_writebarrier_remember(origin);
2015 class_clear_method_table(klass);
2016 rb_id_table_foreach(RCLASS_M_TBL(origin), cache_clear_refined_method, (
void *)klass);
2017 rb_id_table_foreach(RCLASS_M_TBL(origin), move_refined_method, (
void *)klass);
2027 bool klass_had_no_origin;
2029 ensure_includable(klass, module);
2030 if (module_in_super_chain(klass, module))
2031 rb_raise(rb_eArgError,
"cyclic prepend detected");
2033 klass_had_no_origin = ensure_origin(klass);
2034 changed = do_include_modules_at(klass, klass, module, FALSE,
false);
2037 rb_vm_check_redefinition_by_prepend(klass);
2040 VALUE subs_v = RCLASS_SUBCLASSES(klass);
2041 VALUE klass_origin = RCLASS_ORIGIN(klass);
2042 struct rb_id_table *klass_m_tbl = RCLASS_M_TBL(klass);
2043 struct rb_id_table *klass_origin_m_tbl = RCLASS_M_TBL(klass_origin);
2046 VALUE *entries = rb_imemo_subclasses_entries(subs_v);
2047 VALUE new_origins = 0;
2048 for (uint32_t i = 0; i < subs->count; i++) {
2049 const VALUE subclass = entries[i];
2050 if (!subclass)
continue;
2053 if (!rb_objspace_garbage_object_p(subclass)) {
2054 if (klass_had_no_origin && klass_origin_m_tbl == RCLASS_M_TBL(subclass)) {
2056 rb_id_table_foreach(RCLASS_M_TBL(subclass), clear_module_cache_i, (
void *)subclass);
2057 RCLASS_WRITE_M_TBL(subclass, klass_m_tbl);
2059 rb_class_set_super(subclass, origin);
2060 RCLASS_SET_INCLUDER(origin, RCLASS_INCLUDER(subclass));
2061 RCLASS_WRITE_ORIGIN(subclass, origin);
2062 RICLASS_SET_ORIGIN_SHARED_MTBL(origin);
2066 include_modules_at(subclass, subclass, module, FALSE);
2072 for (
long i = 0; i <
RARRAY_LEN(new_origins); i++) {
2073 rb_module_add_to_subclasses_list(klass,
RARRAY_AREF(new_origins, i));
2108 VALUE origin = RCLASS_ORIGIN(mod);
2112 VALUE m = METACLASS_OF(p);
2147 if (METACLASS_OF(p) == mod2)
return Qtrue;
2177 refined_class = rb_refinement_module_get_refined_class(mod);
2181 if (p == refined_class)
break;
2182 if (p != RCLASS_ORIGIN(p))
continue;
2198 bool immediate_only;
2202class_descendants_recursive(
VALUE klass,
VALUE v)
2208 if (!RCLASS_SINGLETON_P(klass)) {
2209 if (data->buffer && data->count < data->maxcount && !rb_objspace_garbage_object_p(klass)) {
2214 if (data->immediate_only)
return;
2216 rb_class_foreach_subclass(klass, class_descendants_recursive, v);
2220class_descendants(
VALUE klass,
bool immediate_only)
2225 rb_class_foreach_subclass(klass, class_descendants_recursive, (
VALUE) &data);
2229 data.maxcount = data.count;
2232 size_t gc_count = rb_gc_count();
2235 rb_class_foreach_subclass(klass, class_descendants_recursive, (
VALUE) &data);
2237 if (gc_count != rb_gc_count()) {
2238 rb_bug(
"GC must not occur during the subclass iteration of Class#descendants");
2286 return class_descendants(klass,
true);
2297static void module_descendants_recursive(
VALUE entry,
VALUE v);
2303 if (data->buffer && data->count >= data->maxcount)
return;
2305 if (st_insert(data->visited, (st_data_t)klass, 1))
return;
2312 rb_class_foreach_subclass(klass, module_descendants_recursive, (
VALUE)data);
2318iclass_in_ancestors_p(
VALUE iclass,
VALUE includer)
2321 if (p == iclass)
return true;
2327module_descendants_recursive(
VALUE entry,
VALUE v)
2331 if (rb_objspace_garbage_object_p(entry))
return;
2336 VALUE includer = RCLASS_INCLUDER(entry);
2338 includer = RCLASS_INCLUDER(includer);
2340 if (!includer || UNDEF_P(includer))
return;
2341 if (rb_objspace_garbage_object_p(includer))
return;
2342 if (RCLASS_SINGLETON_P(includer))
return;
2343 if (!iclass_in_ancestors_p(entry, includer))
return;
2344 module_descendants_add(includer, data);
2347 if (RCLASS_SINGLETON_P(entry))
return;
2348 module_descendants_add(entry, data);
2385 data.visited = st_init_numtable();
2386 st_insert(data.visited, (st_data_t)mod, 1);
2387 rb_class_foreach_subclass(mod, module_descendants_recursive, (
VALUE)&data);
2388 st_free_table(data.visited);
2392 data.maxcount = data.count;
2395 data.visited = st_init_numtable_with_size(data.maxcount + 1);
2396 st_insert(data.visited, (st_data_t)mod, 1);
2398 size_t gc_count = rb_gc_count();
2400 rb_class_foreach_subclass(mod, module_descendants_recursive, (
VALUE)&data);
2402 if (gc_count != rb_gc_count()) {
2403 rb_bug(
"GC must not occur during the subclass iteration of Module#descendants");
2405 st_free_table(data.visited);
2433 if (!RCLASS_SINGLETON_P(klass)) {
2434 rb_raise(
rb_eTypeError,
"'%"PRIsVALUE
"' is not a singleton class", klass);
2437 const VALUE obj = RCLASS_ATTACHED_OBJECT(klass);
2444 rb_raise(rb_eRactorIsolationError,
2445 "can not get an unshareable attached object from another Ractor");
2452ins_methods_push(st_data_t name, st_data_t ary)
2458ins_methods_i(st_data_t name, st_data_t
type, st_data_t ary)
2460 switch ((rb_method_visibility_t)
type) {
2461 case METHOD_VISI_UNDEF:
2462 case METHOD_VISI_PRIVATE:
2465 ins_methods_push(name, ary);
2472ins_methods_type_i(st_data_t name, st_data_t
type, st_data_t ary, rb_method_visibility_t visi)
2474 if ((rb_method_visibility_t)
type == visi) {
2475 ins_methods_push(name, ary);
2481ins_methods_prot_i(st_data_t name, st_data_t
type, st_data_t ary)
2483 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PROTECTED);
2487ins_methods_priv_i(st_data_t name, st_data_t
type, st_data_t ary)
2489 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PRIVATE);
2493ins_methods_pub_i(st_data_t name, st_data_t
type, st_data_t ary)
2495 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PUBLIC);
2499ins_methods_undef_i(st_data_t name, st_data_t
type, st_data_t ary)
2501 return ins_methods_type_i(name,
type, ary, METHOD_VISI_UNDEF);
2509static enum rb_id_table_iterator_result
2510method_entry_i(
ID key,
VALUE value,
void *data)
2514 rb_method_visibility_t
type;
2516 if (me->def->type == VM_METHOD_TYPE_REFINED) {
2517 VALUE owner = me->owner;
2518 me = rb_resolve_refined_method(
Qnil, me);
2519 if (!me)
return ID_TABLE_CONTINUE;
2520 if (!arg->recur && me->owner != owner)
return ID_TABLE_CONTINUE;
2522 if (!st_is_member(arg->list, key)) {
2523 if (UNDEFINED_METHOD_ENTRY_P(me)) {
2524 type = METHOD_VISI_UNDEF;
2527 type = METHOD_ENTRY_VISI(me);
2530 st_add_direct(arg->list, key, (st_data_t)
type);
2532 return ID_TABLE_CONTINUE;
2540 rb_id_table_foreach(m_tbl, method_entry_i, me_arg);
2544particular_class_p(
VALUE mod)
2546 if (!mod)
return false;
2547 if (RCLASS_SINGLETON_P(mod))
return true;
2553class_instance_method_list(
int argc,
const VALUE *argv,
VALUE mod,
int obj,
int (*func) (st_data_t, st_data_t, st_data_t))
2556 int recur = TRUE, prepended = 0;
2561 me_arg.list = st_init_numtable();
2562 me_arg.recur = recur;
2565 for (; particular_class_p(mod); mod =
RCLASS_SUPER(mod)) {
2566 add_instance_method_list(mod, &me_arg);
2570 if (!recur && RCLASS_ORIGIN(mod) != mod) {
2571 mod = RCLASS_ORIGIN(mod);
2576 add_instance_method_list(mod, &me_arg);
2581 st_foreach(me_arg.list, func, ary);
2582 st_free_table(me_arg.list);
2626 return class_instance_method_list(argc, argv, mod, 0, ins_methods_i);
2641 return class_instance_method_list(argc, argv, mod, 0, ins_methods_prot_i);
2664 return class_instance_method_list(argc, argv, mod, 0, ins_methods_priv_i);
2679 return class_instance_method_list(argc, argv, mod, 0, ins_methods_pub_i);
2691rb_class_undefined_instance_methods(
VALUE mod)
2694 return class_instance_method_list(1, &include_super, mod, 0, ins_methods_undef_i);
2728rb_obj_methods(
int argc,
const VALUE *argv,
VALUE obj)
2731 if (argc > 0 && !
RTEST(argv[0])) {
2734 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_i);
2747rb_obj_protected_methods(
int argc,
const VALUE *argv,
VALUE obj)
2749 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_prot_i);
2762rb_obj_private_methods(
int argc,
const VALUE *argv,
VALUE obj)
2764 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_priv_i);
2777rb_obj_public_methods(
int argc,
const VALUE *argv,
VALUE obj)
2779 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_pub_i);
2818 VALUE ary, klass, origin;
2828 origin = RCLASS_ORIGIN(klass);
2829 me_arg.list = st_init_numtable();
2830 me_arg.recur = recur;
2831 if (klass && RCLASS_SINGLETON_P(klass)) {
2832 if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
2837 if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
2842 st_foreach(me_arg.list, ins_methods_i, ary);
2843 st_free_table(me_arg.list);
2856#ifdef rb_define_method_id
2857#undef rb_define_method_id
2862 rb_add_method_cfunc(klass, mid, func, argc, METHOD_VISI_PUBLIC);
2865#ifdef rb_define_method
2866#undef rb_define_method
2871 rb_add_method_cfunc(klass, rb_intern(name), func, argc, METHOD_VISI_PUBLIC);
2874#ifdef rb_define_protected_method
2875#undef rb_define_protected_method
2880 rb_add_method_cfunc(klass, rb_intern(name), func, argc, METHOD_VISI_PROTECTED);
2883#ifdef rb_define_private_method
2884#undef rb_define_private_method
2889 rb_add_method_cfunc(klass, rb_intern(name), func, argc, METHOD_VISI_PRIVATE);
2895 rb_add_method(klass, rb_intern(name), VM_METHOD_TYPE_UNDEF, 0, METHOD_VISI_UNDEF);
2898static enum rb_id_table_iterator_result
2899undef_method_i(
ID name,
VALUE value,
void *data)
2902 rb_add_method(klass, name, VM_METHOD_TYPE_UNDEF, 0, METHOD_VISI_UNDEF);
2903 return ID_TABLE_CONTINUE;
2907rb_undef_methods_from(
VALUE klass,
VALUE super)
2911 rb_id_table_foreach(mtbl, undef_method_i, (
void *)klass);
2924special_singleton_class_of(
VALUE obj)
2930 default:
return Qnil;
2935rb_special_singleton_class(
VALUE obj)
2937 return special_singleton_class_of(obj);
2950singleton_class_of(
VALUE obj,
bool ensure_eigenclass)
2954 switch (
TYPE(obj)) {
2964 klass = special_singleton_class_of(obj);
2966 rb_bug(
"unknown immediate %p", (
void *)obj);
2970 if (CHILLED_STRING_P(obj)) {
2971 CHILLED_STRING_MUTATED(obj);
2981 RB_VM_LOCK_ENTER_LEV(&lev);
2984 klass = METACLASS_OF(obj);
2985 if (!(RCLASS_SINGLETON_P(klass) &&
2986 RCLASS_ATTACHED_OBJECT(klass) == obj)) {
2987 klass = rb_make_metaclass(obj, klass);
2996 RB_VM_LOCK_LEAVE_LEV(&lev);
3002#if RUBY_VERSION_SINCE(4, 2)
3003RBIMPL_TODO(
"make rb_freeze_singleton_class internal; remove from fl_type.h")
3015 (RCLASS_ATTACHED_OBJECT(klass) == attached_object)) {
3016 attached_object = klass;
3034 return rb_special_singleton_class(obj);
3036 klass = METACLASS_OF(obj);
3037 if (!RCLASS_SINGLETON_P(klass))
return Qnil;
3038 if (RCLASS_ATTACHED_OBJECT(klass) != obj)
return Qnil;
3045 return singleton_class_of(obj,
true);
3057#ifdef rb_define_singleton_method
3058#undef rb_define_singleton_method
3066#ifdef rb_define_module_function
3067#undef rb_define_module_function
3076#ifdef rb_define_global_function
3077#undef rb_define_global_function
3088 rb_alias(klass, rb_intern(name1), rb_intern(name2));
3094 rb_attr(klass, rb_intern(name), read, write, FALSE);
3098rb_keyword_error_new(
const char *error,
VALUE keys)
3101 VALUE error_message = rb_sprintf(
"%s keyword%.*s", error,
len > 1,
"s");
3108 if (++i >=
len)
break;
3116NORETURN(
static void rb_keyword_error(
const char *error,
VALUE keys));
3118rb_keyword_error(
const char *error,
VALUE keys)
3123NORETURN(
static void unknown_keyword_error(
VALUE hash,
const ID *table,
int keywords));
3125unknown_keyword_error(
VALUE hash,
const ID *table,
int keywords)
3128 for (i = 0; i < keywords; i++) {
3129 st_data_t key =
ID2SYM(table[i]);
3130 rb_hash_stlike_delete(hash, &key, NULL);
3132 rb_keyword_error(
"unknown", rb_hash_keys(hash));
3137separate_symbol(st_data_t key, st_data_t value, st_data_t arg)
3141 if (!*kwdhash) *kwdhash = rb_hash_new();
3142 rb_hash_aset(*kwdhash, (
VALUE)key, (
VALUE)value);
3149 VALUE parthash[2] = {0, 0};
3150 VALUE hash = *orighash;
3157 *orighash = parthash[1];
3172#define extract_kwarg(keyword, val) \
3173 (key = (st_data_t)(keyword), values ? \
3174 (rb_hash_stlike_delete(keyword_hash, &key, &(val)) || ((val) = Qundef, 0)) : \
3175 rb_hash_stlike_lookup(keyword_hash, key, NULL))
3177 if (
NIL_P(keyword_hash)) keyword_hash = 0;
3181 optional = -1-optional;
3184 for (; i < required; i++) {
3187 if (extract_kwarg(keyword, values[i])) {
3194 if (!
NIL_P(missing)) {
3195 rb_keyword_error(
"missing", missing);
3199 if (optional && keyword_hash) {
3200 for (i = 0; i < optional; i++) {
3201 if (extract_kwarg(
ID2SYM(table[required+i]), values[required+i])) {
3206 if (!rest && keyword_hash) {
3207 if (
RHASH_SIZE(keyword_hash) > (
unsigned int)(values ? 0 : j)) {
3208 unknown_keyword_error(keyword_hash, table, required+optional);
3211 if (values && !keyword_hash) {
3212 for (i = 0; i < required + optional; i++) {
3231rb_scan_args_parse(
int kw_flag,
const char *fmt,
struct rb_scan_args_t *arg)
3233 const char *p = fmt;
3235 memset(arg, 0,
sizeof(*arg));
3236 arg->kw_flag = kw_flag;
3239 arg->n_lead = *p -
'0';
3242 arg->n_opt = *p -
'0';
3251 arg->n_trail = *p -
'0';
3263 rb_fatal(
"bad scan arg format: %s", fmt);
3268rb_scan_args_assign(
const struct rb_scan_args_t *arg,
int argc,
const VALUE *
const argv, va_list vargs)
3272#define rb_scan_args_next_param() va_arg(vargs, VALUE *)
3273 const int kw_flag = arg->kw_flag;
3274 const int n_lead = arg->n_lead;
3275 const int n_opt = arg->n_opt;
3276 const int n_trail = arg->n_trail;
3277 const int n_mand = n_lead + n_trail;
3278 const bool f_var = arg->f_var;
3279 const bool f_hash = arg->f_hash;
3280 const bool f_block = arg->f_block;
3283 if (f_hash && argc > 0) {
3284 VALUE last = argv[argc - 1];
3285 if (rb_scan_args_keyword_p(kw_flag, last)) {
3286 hash = rb_hash_dup(last);
3291 if (argc < n_mand) {
3296 for (i = 0; i < n_lead; i++) {
3297 var = rb_scan_args_next_param();
3298 if (var) *var = argv[argi];
3302 for (i = 0; i < n_opt; i++) {
3303 var = rb_scan_args_next_param();
3304 if (argi < argc - n_trail) {
3305 if (var) *var = argv[argi];
3309 if (var) *var =
Qnil;
3314 int n_var = argc - argi - n_trail;
3316 var = rb_scan_args_next_param();
3326 for (i = 0; i < n_trail; i++) {
3327 var = rb_scan_args_next_param();
3328 if (var) *var = argv[argi];
3333 var = rb_scan_args_next_param();
3334 if (var) *var = hash;
3338 var = rb_scan_args_next_param();
3353#undef rb_scan_args_next_param
3357rb_scan_args_result(
const struct rb_scan_args_t *
const arg,
int argc)
3359 const int n_lead = arg->n_lead;
3360 const int n_opt = arg->n_opt;
3361 const int n_trail = arg->n_trail;
3362 const int n_mand = n_lead + n_trail;
3363 const bool f_var = arg->f_var;
3381 va_start(vargs,fmt);
3382 argc = rb_scan_args_assign(&arg, argc, argv, vargs);
3384 return rb_scan_args_result(&arg, argc);
3387#undef rb_scan_args_kw
3393 rb_scan_args_parse(kw_flag, fmt, &arg);
3394 va_start(vargs,fmt);
3395 argc = rb_scan_args_assign(&arg, argc, argv, vargs);
3397 return rb_scan_args_result(&arg, argc);
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_method_id(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define rb_define_protected_method(klass, mid, func, arity)
Defines klass#mid and makes it protected.
#define rb_define_module_function(klass, mid, func, arity)
Defines klass#mid and makes it a module function.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
#define RUBY_EXTERN
Declaration of externally visible global variables.
static VALUE RB_OBJ_FROZEN_RAW(VALUE obj)
This is an implementation detail of RB_OBJ_FROZEN().
static void RB_FL_SET_RAW(VALUE obj, VALUE flags)
This is an implementation detail of RB_FL_SET().
VALUE rb_class_protected_instance_methods(int argc, const VALUE *argv, VALUE mod)
Identical to rb_class_instance_methods(), except it returns names of methods that are protected only.
static VALUE class_alloc0(enum ruby_value_type type, VALUE klass, bool boxable)
Allocates a struct RClass for a new class, iclass, or module.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_refinement_new(void)
Creates a new, anonymous refinement.
VALUE rb_class_new(VALUE super)
Creates a new, anonymous class.
static VALUE make_singleton_class(VALUE obj)
Creates a singleton class for obj.
VALUE rb_singleton_class_clone(VALUE obj)
Clones a singleton class.
void rb_prepend_module(VALUE klass, VALUE module)
Identical to rb_include_module(), except it "prepends" the passed module to the klass,...
VALUE rb_class_subclasses(VALUE klass)
Queries the class's direct descendants.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
VALUE rb_class_attached_object(VALUE klass)
Returns the attached object for a singleton class.
VALUE rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj)
Identical to rb_class_instance_methods(), except it returns names of singleton methods instead of ins...
VALUE rb_module_new(void)
Creates a new, anonymous module.
#define META_CLASS_OF_CLASS_CLASS_P(k)
whether k is a meta^(n)-class of Class class
VALUE rb_class_instance_methods(int argc, const VALUE *argv, VALUE mod)
Generates an array of symbols, which are the list of method names defined in the passed class.
void rb_check_inheritable(VALUE super)
Asserts that the given class can derive a child class.
VALUE rb_class_public_instance_methods(int argc, const VALUE *argv, VALUE mod)
Identical to rb_class_instance_methods(), except it returns names of methods that are public only.
VALUE rb_class_super_of(VALUE klass)
Internal header for Objspace.
VALUE rb_class_boot(VALUE super)
A utility function that wraps class_alloc.
void rb_class_modify_check(VALUE klass)
Asserts that klass is not a frozen class.
VALUE rb_define_module_id_under(VALUE outer, ID id)
Identical to rb_define_module_under(), except it takes the name in ID instead of C's string.
void rb_singleton_class_attached(VALUE klass, VALUE obj)
Attaches a singleton class to its corresponding object.
VALUE rb_mod_included_modules(VALUE mod)
Queries the list of included modules.
VALUE rb_define_class_id_under(VALUE outer, ID id, VALUE super)
Identical to rb_define_class_under(), except it takes the name in ID instead of C's string.
VALUE rb_mod_ancestors(VALUE mod)
Queries the module's ancestors.
static VALUE make_metaclass(VALUE klass)
Creates a metaclass of klass
VALUE rb_class_inherited(VALUE super, VALUE klass)
Calls Class::inherited.
VALUE rb_mod_include_p(VALUE mod, VALUE mod2)
Queries if the passed module is included by the module.
void rb_freeze_singleton_class(VALUE attached_object)
This is an implementation detail of RB_OBJ_FREEZE().
VALUE rb_class_private_instance_methods(int argc, const VALUE *argv, VALUE mod)
Identical to rb_class_instance_methods(), except it returns names of methods that are private only.
#define ENSURE_EIGENCLASS(klass)
ensures klass belongs to its own eigenclass.
VALUE rb_mod_init_copy(VALUE clone, VALUE orig)
The comment that comes with this function says :nodoc:.
VALUE rb_mod_descendants(VALUE mod)
Queries the module's descendants.
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
VALUE rb_define_module_id(ID id)
This is a very badly designed API that creates an anonymous module.
VALUE rb_define_class_id(ID id, VALUE super)
This is a very badly designed API that creates an anonymous class.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
VALUE rb_extract_keywords(VALUE *orighash)
Splits a hash into two.
void rb_define_attr(VALUE klass, const char *name, int read, int write)
Defines public accessor method(s) for an attribute.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
int rb_scan_args_kw(int kw_flag, int argc, const VALUE *argv, const char *fmt,...)
Identical to rb_scan_args(), except it also accepts kw_splat.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define TYPE(_)
Old name of rb_type.
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define ALLOC
Old name of RB_ALLOC.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define T_NIL
Old name of RUBY_T_NIL.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define ZALLOC
Old name of RB_ZALLOC.
#define FL_SHAREABLE
Old name of RUBY_FL_SHAREABLE.
#define CLASS_OF
Old name of rb_class_of.
#define xmalloc
Old name of ruby_xmalloc.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define ISDIGIT
Old name of rb_isdigit.
#define T_TRUE
Old name of RUBY_T_TRUE.
#define T_ICLASS
Old name of RUBY_T_ICLASS.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define FL_SET
Old name of RB_FL_SET.
#define T_FALSE
Old name of RUBY_T_FALSE.
#define Qtrue
Old name of RUBY_Qtrue.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define NIL_P
Old name of RB_NIL_P.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define T_CLASS
Old name of RUBY_T_CLASS.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define FL_TEST
Old name of RB_FL_TEST.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define OBJ_FROZEN_RAW
Old name of RB_OBJ_FROZEN_RAW.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_cClass
Class class.
VALUE rb_class_superclass(VALUE klass)
Queries the parent of the given class.
VALUE rb_mKernel
Kernel module.
VALUE rb_cObject
Object class.
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_cRefinement
Refinement class.
VALUE rb_cNilClass
NilClass class.
VALUE rb_cHash
Hash class.
VALUE rb_cFalseClass
FalseClass class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_cModule
Module class.
VALUE rb_class_real(VALUE klass)
Finds a "real" class.
VALUE rb_cTrueClass
TrueClass class.
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
VALUE rb_ary_new_from_values(long n, const VALUE *elts)
Identical to rb_ary_new_from_args(), except how objects are passed.
VALUE rb_ary_cat(VALUE ary, const VALUE *train, long len)
Destructively appends multiple elements at the end of the array.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_new_capa(long capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
VALUE rb_ary_resize(VALUE ary, long len)
Expands or shrinks the passed array to the passed length.
VALUE rb_ary_hidden_new(long capa)
Allocates a hidden (no class) empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
int rb_is_instance_id(ID id)
Classifies the given ID, then sees if it is an instance variable.
int rb_is_class_id(ID id)
Classifies the given ID, then sees if it is a class variable.
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
void rb_const_set(VALUE space, ID name, VALUE val)
Names a constant.
VALUE rb_const_get_at(VALUE space, ID name)
Identical to rb_const_defined_at(), except it returns the actual defined value.
void rb_set_class_path_string(VALUE klass, VALUE space, VALUE name)
Identical to rb_set_class_path(), except it accepts the name as Ruby's string instead of C's.
int rb_const_defined_at(VALUE space, ID name)
Identical to rb_const_defined(), except it doesn't look for parent classes.
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
void rb_alias(VALUE klass, ID dst, ID src)
Resembles alias.
void rb_attr(VALUE klass, ID name, int need_reader, int need_writer, int honour_visibility)
This function resembles now-deprecated Module#attr.
void rb_clear_constant_cache_for_id(ID id)
Clears the inline constant caches associated with a particular ID.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
int len
Length of the buffer.
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE type(ANYARGS)
ANYARGS-ed function type.
void rb_hash_foreach(VALUE q, int_type *w, VALUE e)
Iteration over the given hash.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#define RCLASS_SUPER
Just another name of rb_class_get_superclass.
#define RHASH_SIZE(h)
Queries the size of the hash.
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
#define RB_SCAN_ARGS_PASS_CALLED_KEYWORDS
Same behaviour as rb_scan_args().
#define RTEST
This is an old name of RB_TEST.
#define ANYARGS
Functions declared using this macro take arbitrary arguments, including void.
Internal header for Ruby Box.
Internal header for Class.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
ruby_value_type
C-level type of an object.