17#include "ruby/internal/config.h"
21#include "debug_counter.h"
24#include "internal/class.h"
25#include "internal/eval.h"
26#include "internal/hash.h"
27#include "internal/object.h"
28#include "internal/string.h"
29#include "internal/variable.h"
69#define METACLASS_OF(k) RBASIC(k)->klass
70#define SET_METACLASS_OF(k, cls) RBASIC_SET_CLASS(k, cls)
75push_subclass_entry_to_list(
VALUE super,
VALUE klass)
82 head = RCLASS_SUBCLASSES(super);
85 RCLASS_SUBCLASSES(super) = head;
87 entry->next = head->next;
91 head->next->prev = entry;
101 if (super && !UNDEF_P(super)) {
103 RCLASS_SUBCLASS_ENTRY(klass) = entry;
108rb_module_add_to_subclasses_list(
VALUE module,
VALUE iclass)
111 RCLASS_MODULE_SUBCLASS_ENTRY(iclass) = entry;
115rb_class_remove_subclass_head(
VALUE klass)
121 head->next->prev = NULL;
123 RCLASS_SUBCLASSES(klass) = NULL;
129rb_class_remove_from_super_subclasses(
VALUE klass)
146 RCLASS_SUBCLASS_ENTRY(klass) = NULL;
150rb_class_remove_from_module_subclasses(
VALUE klass)
167 RCLASS_MODULE_SUBCLASS_ENTRY(klass) = NULL;
185 VALUE curklass = cur->klass;
194class_detach_subclasses(
VALUE klass,
VALUE arg)
196 rb_class_remove_from_super_subclasses(klass);
200rb_class_detach_subclasses(
VALUE klass)
202 rb_class_foreach_subclass(klass, class_detach_subclasses,
Qnil);
206class_detach_module_subclasses(
VALUE klass,
VALUE arg)
208 rb_class_remove_from_module_subclasses(klass);
212rb_class_detach_module_subclasses(
VALUE klass)
214 rb_class_foreach_subclass(klass, class_detach_module_subclasses,
Qnil);
251 RCLASS_SET_ALLOCATOR((
VALUE)obj, 0);
257RCLASS_M_TBL_INIT(
VALUE c)
259 RCLASS_M_TBL(c) = rb_id_table_create(0);
276 RCLASS_SET_SUPER(klass, super);
277 RCLASS_M_TBL_INIT(klass);
283class_superclasses_including_self(
VALUE klass)
285 if (
FL_TEST_RAW(klass, RCLASS_SUPERCLASSES_INCLUDE_SELF))
286 return RCLASS_SUPERCLASSES(klass);
288 size_t depth = RCLASS_SUPERCLASS_DEPTH(klass);
291 memcpy(superclasses, RCLASS_SUPERCLASSES(klass),
sizeof(
VALUE) * depth);
292 superclasses[depth] = klass;
294 RCLASS_SUPERCLASSES(klass) = superclasses;
295 FL_SET_RAW(klass, RCLASS_SUPERCLASSES_INCLUDE_SELF);
300rb_class_update_superclasses(
VALUE klass)
304 if (!RB_TYPE_P(klass,
T_CLASS))
return;
305 if (UNDEF_P(super))
return;
308 if (RCLASS_SUPERCLASSES(klass))
323 rb_class_update_superclasses(super);
326 if (!RCLASS_SUPERCLASS_DEPTH(super))
330 RCLASS_SUPERCLASSES(klass) = class_superclasses_including_self(super);
331 RCLASS_SUPERCLASS_DEPTH(klass) = RCLASS_SUPERCLASS_DEPTH(super) + 1;
337 if (!RB_TYPE_P(super,
T_CLASS)) {
338 rb_raise(
rb_eTypeError,
"superclass must be an instance of Class (given an instance of %"PRIsVALUE
")",
342 rb_raise(
rb_eTypeError,
"can't make subclass of singleton class");
357 RCLASS_EXT(klass)->max_iv_count = RCLASS_EXT(super)->max_iv_count;
364rb_class_s_alloc(
VALUE klass)
372 if (me->def->type == VM_METHOD_TYPE_ISEQ) {
374 rb_vm_rewrite_cref(me->def->body.iseq.
cref, old_klass, new_klass, &new_cref);
375 rb_add_method_iseq(new_klass, mid, me->def->body.iseq.
iseqptr, new_cref, METHOD_ENTRY_VISI(me));
378 rb_method_entry_set(new_klass, mid, me, METHOD_ENTRY_VISI(me));
387static enum rb_id_table_iterator_result
388clone_method_i(
ID key,
VALUE value,
void *data)
391 clone_method(arg->old_klass, arg->new_klass, key, (
const rb_method_entry_t *)value);
392 return ID_TABLE_CONTINUE;
408 rb_id_table_insert(arg->tbl, key, (
VALUE)nce);
409 return ID_TABLE_CONTINUE;
412static enum rb_id_table_iterator_result
413clone_const_i(
ID key,
VALUE value,
void *data)
437static enum rb_id_table_iterator_result
438cvc_table_copy(
ID id,
VALUE val,
void *data)
447 ent->class_value = ctx->clone;
448 ent->cref = orig_entry->cref;
449 ent->global_cvar_state = orig_entry->global_cvar_state;
450 rb_id_table_insert(ctx->new_table,
id, (
VALUE)ent);
454 return ID_TABLE_CONTINUE;
460 if (RCLASS_CONST_TBL(clone)) {
461 rb_free_const_table(RCLASS_CONST_TBL(clone));
462 RCLASS_CONST_TBL(clone) = 0;
464 if (RCLASS_CVC_TBL(orig)) {
465 struct rb_id_table *rb_cvc_tbl = RCLASS_CVC_TBL(orig);
466 struct rb_id_table *rb_cvc_tbl_dup = rb_id_table_create(rb_id_table_size(rb_cvc_tbl));
470 ctx.new_table = rb_cvc_tbl_dup;
471 rb_id_table_foreach(rb_cvc_tbl, cvc_table_copy, &ctx);
472 RCLASS_CVC_TBL(clone) = rb_cvc_tbl_dup;
474 rb_id_table_free(RCLASS_M_TBL(clone));
475 RCLASS_M_TBL(clone) = 0;
479 rb_iv_tbl_copy(clone, orig);
481 rb_attr_delete(clone,
id);
483 rb_attr_delete(clone,
id);
485 if (RCLASS_CONST_TBL(orig)) {
488 arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0);
490 rb_id_table_foreach(RCLASS_CONST_TBL(orig), clone_const_i, &arg);
494static bool ensure_origin(
VALUE klass);
502RMODULE_UNINITIALIZED(
VALUE module)
504 return FL_TEST_RAW(module, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED);
508rb_module_set_initialized(
VALUE mod)
510 FL_UNSET_RAW(mod, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED);
515rb_module_check_initializable(
VALUE mod)
517 if (!RMODULE_UNINITIALIZED(mod)) {
529 class_init_copy_check(clone, orig);
532 rb_module_check_initializable(clone);
542 RCLASS_EXT(clone)->cloned =
true;
543 RCLASS_EXT(orig)->cloned =
true;
549 RCLASS_SET_ALLOCATOR(clone, RCLASS_ALLOCATOR(orig));
550 copy_tables(clone, orig);
551 if (RCLASS_M_TBL(orig)) {
553 arg.old_klass = orig;
554 arg.new_klass = clone;
555 RCLASS_M_TBL_INIT(clone);
556 rb_id_table_foreach(RCLASS_M_TBL(orig), clone_method_i, &arg);
559 if (RCLASS_ORIGIN(orig) == orig) {
564 VALUE orig_origin = RCLASS_ORIGIN(orig);
565 VALUE prev_clone_p = clone;
566 VALUE origin_stack = rb_ary_hidden_new(2);
573 ensure_origin(clone);
574 clone_origin = RCLASS_ORIGIN(clone);
576 while (p && p != orig_origin) {
578 rb_bug(
"non iclass between module/class and origin");
584 RCLASS_SET_M_TBL(clone_p, RCLASS_M_TBL(p));
585 RCLASS_SET_SUPER(prev_clone_p, clone_p);
586 prev_clone_p = clone_p;
587 RCLASS_CONST_TBL(clone_p) = RCLASS_CONST_TBL(p);
588 RCLASS_SET_ALLOCATOR(clone_p, RCLASS_ALLOCATOR(p));
589 if (RB_TYPE_P(clone,
T_CLASS)) {
590 RCLASS_SET_INCLUDER(clone_p, clone);
593 if (p != RCLASS_ORIGIN(p)) {
595 origin[1] = RCLASS_ORIGIN(p);
596 rb_ary_cat(origin_stack, origin, 2);
598 else if ((origin_len =
RARRAY_LEN(origin_stack)) > 1 &&
600 RCLASS_SET_ORIGIN(
RARRAY_AREF(origin_stack, (origin_len -= 2)), clone_p);
601 RICLASS_SET_ORIGIN_SHARED_MTBL(clone_p);
602 rb_ary_resize(origin_stack, origin_len);
603 add_subclass = FALSE;
606 rb_module_add_to_subclasses_list(METACLASS_OF(p), clone_p);
611 if (p == orig_origin) {
613 RCLASS_SET_SUPER(clone_p, clone_origin);
614 RCLASS_SET_SUPER(clone_origin,
RCLASS_SUPER(orig_origin));
616 copy_tables(clone_origin, orig_origin);
617 if (RCLASS_M_TBL(orig_origin)) {
619 arg.old_klass = orig;
620 arg.new_klass = clone;
621 RCLASS_M_TBL_INIT(clone_origin);
622 rb_id_table_foreach(RCLASS_M_TBL(orig_origin), clone_method_i, &arg);
626 rb_bug(
"no origin for class that has origin");
629 rb_class_update_superclasses(clone);
638 return rb_singleton_class_clone_and_attach(obj,
Qundef);
643rb_singleton_class_clone_and_attach(
VALUE obj,
VALUE attach)
645 const VALUE klass = METACLASS_OF(obj);
657 bool klass_of_clone_is_new;
661 klass_of_clone_is_new =
true;
662 RBASIC_SET_CLASS(clone, clone);
668 klass_of_clone_is_new = (METACLASS_OF(klass) != klass_metaclass_clone);
669 RBASIC_SET_CLASS(clone, klass_metaclass_clone);
673 rb_iv_tbl_copy(clone, klass);
674 if (RCLASS_CONST_TBL(klass)) {
676 arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0);
678 rb_id_table_foreach(RCLASS_CONST_TBL(klass), clone_const_i, &arg);
680 if (!UNDEF_P(attach)) {
683 RCLASS_M_TBL_INIT(clone);
686 arg.old_klass = klass;
687 arg.new_klass = clone;
688 rb_id_table_foreach(RCLASS_M_TBL(klass), clone_method_i, &arg);
690 if (klass_of_clone_is_new) {
703 RCLASS_SET_ATTACHED_OBJECT(klass, obj);
712#define META_CLASS_OF_CLASS_CLASS_P(k) (METACLASS_OF(k) == (k))
715rb_singleton_class_has_metaclass_p(
VALUE sklass)
717 return RCLASS_ATTACHED_OBJECT(METACLASS_OF(sklass)) == sklass;
721rb_singleton_class_internal_p(
VALUE sklass)
723 return (RB_TYPE_P(RCLASS_ATTACHED_OBJECT(sklass),
T_CLASS) &&
724 !rb_singleton_class_has_metaclass_p(sklass));
732#define HAVE_METACLASS_P(k) \
733 (FL_TEST(METACLASS_OF(k), FL_SINGLETON) && \
734 rb_singleton_class_has_metaclass_p(k))
743#define ENSURE_EIGENCLASS(klass) \
744 (HAVE_METACLASS_P(klass) ? METACLASS_OF(klass) : make_metaclass(klass))
766 SET_METACLASS_OF(klass, metaclass);
767 SET_METACLASS_OF(metaclass, metaclass);
770 VALUE tmp = METACLASS_OF(klass);
771 SET_METACLASS_OF(klass, metaclass);
780 rb_class_update_superclasses(METACLASS_OF(metaclass));
794 VALUE orig_class = METACLASS_OF(obj);
798 RBASIC_SET_CLASS(obj, klass);
801 SET_METACLASS_OF(klass, METACLASS_OF(
rb_class_real(orig_class)));
807boot_defclass(
const char *name,
VALUE super)
810 ID id = rb_intern(name);
813 rb_vm_add_root_module(obj);
864refinement_import_methods(
int argc,
VALUE *argv,
VALUE refinement)
889Init_class_hierarchy(
void)
893 rb_gc_register_mark_object(rb_cObject);
898 rb_cModule = boot_defclass(
"Module", rb_cObject);
944 if (!super) super = rb_cObject;
946 rb_make_metaclass(klass, METACLASS_OF(super));
964 if (!super) super = rb_cObject;
966 return rb_funcall(super, inherited, 1, klass);
975 id = rb_intern(name);
978 if (!RB_TYPE_P(klass,
T_CLASS)) {
983 rb_raise(
rb_eTypeError,
"superclass mismatch for class %s", name);
987 rb_vm_add_root_module(klass);
991 rb_raise(rb_eArgError,
"no super class for `%s'", name);
994 rb_vm_add_root_module(klass);
1008rb_define_class_id_under_no_pin(
VALUE outer,
ID id,
VALUE super)
1014 if (!RB_TYPE_P(klass,
T_CLASS)) {
1015 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
"::%"PRIsVALUE
" is not a class"
1021 "%"PRIsVALUE
"::%"PRIsVALUE
""
1022 " (%"PRIsVALUE
" is given but was %"PRIsVALUE
")",
1029 rb_raise(rb_eArgError,
"no super class for `%"PRIsVALUE
"::%"PRIsVALUE
"'",
1043 VALUE klass = rb_define_class_id_under_no_pin(outer,
id, super);
1044 rb_vm_add_root_module(klass);
1049rb_module_s_alloc(
VALUE klass)
1052 RCLASS_M_TBL_INIT(mod);
1053 FL_SET(mod, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED);
1058module_new(
VALUE klass)
1061 RCLASS_M_TBL_INIT(mdl);
1090 id = rb_intern(name);
1092 module = rb_const_get(rb_cObject, id);
1093 if (!RB_TYPE_P(module,
T_MODULE)) {
1094 rb_raise(
rb_eTypeError,
"%s is not a module (%"PRIsVALUE
")",
1098 rb_vm_add_root_module(module);
1101 module = rb_module_new();
1102 rb_vm_add_root_module(module);
1120 module = rb_const_get_at(outer, id);
1121 if (!RB_TYPE_P(module,
T_MODULE)) {
1122 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
"::%"PRIsVALUE
" is not a module"
1127 rb_gc_register_mark_object(module);
1130 module = rb_module_new();
1133 rb_gc_register_mark_object(module);
1139rb_include_class_new(
VALUE module,
VALUE super)
1143 RCLASS_SET_M_TBL(klass, RCLASS_M_TBL(module));
1145 RCLASS_SET_ORIGIN(klass, klass);
1147 module = METACLASS_OF(module);
1150 if (!RCLASS_CONST_TBL(module)) {
1151 RCLASS_CONST_TBL(module) = rb_id_table_create(0);
1154 RCLASS_CVC_TBL(klass) = RCLASS_CVC_TBL(module);
1155 RCLASS_CONST_TBL(klass) = RCLASS_CONST_TBL(module);
1157 RCLASS_SET_SUPER(klass, super);
1158 RBASIC_SET_CLASS(klass, module);
1160 return (
VALUE)klass;
1163static int include_modules_at(
const VALUE klass,
VALUE c,
VALUE module,
int search_super);
1170 rb_module_set_initialized(module);
1171 if (!
NIL_P(rb_refinement_module_get_refined_class(module))) {
1172 rb_raise(rb_eArgError,
"refinement module is not allowed");
1181 ensure_includable(klass, module);
1183 changed = include_modules_at(klass, RCLASS_ORIGIN(klass), module, TRUE);
1185 rb_raise(rb_eArgError,
"cyclic include detected");
1192 iclass = iclass->next;
1197 VALUE check_class = iclass->klass;
1200 if (!rb_objspace_garbage_object_p(check_class)) {
1201 while (check_class) {
1202 RUBY_ASSERT(!rb_objspace_garbage_object_p(check_class));
1204 if (RB_TYPE_P(check_class,
T_ICLASS) &&
1205 (METACLASS_OF(check_class) == module)) {
1212 include_modules_at(iclass->klass, RCLASS_ORIGIN(iclass->klass), module, TRUE);
1216 iclass = iclass->next;
1221static enum rb_id_table_iterator_result
1222add_refined_method_entry_i(
ID key,
VALUE value,
void *data)
1224 rb_add_refined_method_entry((
VALUE)data, key);
1225 return ID_TABLE_CONTINUE;
1228static enum rb_id_table_iterator_result
1229clear_module_cache_i(
ID id,
VALUE val,
void *data)
1232 rb_clear_method_cache(klass,
id);
1233 return ID_TABLE_CONTINUE;
1237module_in_super_chain(
const VALUE klass,
VALUE module)
1239 struct rb_id_table *
const klass_m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(klass));
1242 if (klass_m_tbl == RCLASS_M_TBL(module))
1244 module = RCLASS_SUPER(module);
1252static enum rb_id_table_iterator_result
1253clear_constant_cache_i(
ID id,
VALUE value,
void *data)
1256 return ID_TABLE_CONTINUE;
1260do_include_modules_at(
const VALUE klass,
VALUE c,
VALUE module,
int search_super,
bool check_cyclic)
1262 VALUE p, iclass, origin_stack = 0;
1263 int method_changed = 0, add_subclass;
1265 VALUE klass_origin = RCLASS_ORIGIN(klass);
1266 VALUE original_klass = klass;
1268 if (check_cyclic && module_in_super_chain(klass, module))
1273 int superclass_seen = FALSE;
1279 if (klass_origin != c || search_super) {
1285 if (klass_origin == p && !search_super)
1290 if (RCLASS_M_TBL(p) == RCLASS_M_TBL(module)) {
1291 if (!superclass_seen && c_seen) {
1298 superclass_seen = TRUE;
1306 RB_DEBUG_COUNTER_INC(cvar_include_invalidate);
1307 ruby_vm_global_cvar_state++;
1308 tbl = RCLASS_M_TBL(module);
1309 if (tbl && rb_id_table_size(tbl)) {
1311 if (super_class && !RB_TYPE_P(super_class,
T_MODULE)) {
1312 rb_id_table_foreach(tbl, clear_module_cache_i, (
void *)super_class);
1316 if (!RB_TYPE_P(original_klass,
T_MODULE)) {
1317 rb_id_table_foreach(tbl, clear_module_cache_i, (
void *)original_klass);
1324 iclass = rb_include_class_new(module, super_class);
1325 c = RCLASS_SET_SUPER(c, iclass);
1326 RCLASS_SET_INCLUDER(iclass, klass);
1327 add_subclass = TRUE;
1328 if (module != RCLASS_ORIGIN(module)) {
1329 if (!origin_stack) origin_stack = rb_ary_hidden_new(2);
1330 VALUE origin[2] = {iclass, RCLASS_ORIGIN(module)};
1331 rb_ary_cat(origin_stack, origin, 2);
1333 else if (origin_stack && (origin_len =
RARRAY_LEN(origin_stack)) > 1 &&
1334 RARRAY_AREF(origin_stack, origin_len - 1) == module) {
1335 RCLASS_SET_ORIGIN(
RARRAY_AREF(origin_stack, (origin_len -= 2)), iclass);
1336 RICLASS_SET_ORIGIN_SHARED_MTBL(iclass);
1337 rb_ary_resize(origin_stack, origin_len);
1338 add_subclass = FALSE;
1344 rb_module_add_to_subclasses_list(m, iclass);
1348 VALUE refined_class =
1349 rb_refinement_module_get_refined_class(klass);
1351 rb_id_table_foreach(RCLASS_M_TBL(module), add_refined_method_entry_i, (
void *)refined_class);
1355 tbl = RCLASS_CONST_TBL(module);
1356 if (tbl && rb_id_table_size(tbl))
1357 rb_id_table_foreach(tbl, clear_constant_cache_i, NULL);
1359 module = RCLASS_SUPER(module);
1362 return method_changed;
1366include_modules_at(
const VALUE klass,
VALUE c,
VALUE module,
int search_super)
1368 return do_include_modules_at(klass, c, module, search_super,
true);
1371static enum rb_id_table_iterator_result
1372move_refined_method(
ID key,
VALUE value,
void *data)
1376 if (me->def->type == VM_METHOD_TYPE_REFINED) {
1380 if (me->def->body.refined.orig_me) {
1382 RB_OBJ_WRITE(me, &me->def->body.refined.orig_me, NULL);
1383 new_me = rb_method_entry_clone(me);
1384 rb_method_table_insert(klass, tbl, key, new_me);
1385 rb_method_entry_copy(me, orig_me);
1386 return ID_TABLE_CONTINUE;
1389 rb_method_table_insert(klass, tbl, key, me);
1390 return ID_TABLE_DELETE;
1394 return ID_TABLE_CONTINUE;
1398static enum rb_id_table_iterator_result
1399cache_clear_refined_method(
ID key,
VALUE value,
void *data)
1403 if (me->def->type == VM_METHOD_TYPE_REFINED && me->def->body.refined.orig_me) {
1405 rb_clear_method_cache(klass, me->called_id);
1410 return ID_TABLE_CONTINUE;
1414ensure_origin(
VALUE klass)
1416 VALUE origin = RCLASS_ORIGIN(klass);
1417 if (origin == klass) {
1419 RCLASS_SET_M_TBL(origin, RCLASS_M_TBL(klass));
1421 RCLASS_SET_SUPER(klass, origin);
1422 RCLASS_SET_ORIGIN(klass, origin);
1423 RCLASS_M_TBL_INIT(klass);
1424 rb_id_table_foreach(RCLASS_M_TBL(origin), cache_clear_refined_method, (
void *)klass);
1425 rb_id_table_foreach(RCLASS_M_TBL(origin), move_refined_method, (
void *)klass);
1435 bool klass_had_no_origin;
1437 ensure_includable(klass, module);
1438 if (module_in_super_chain(klass, module))
1439 rb_raise(rb_eArgError,
"cyclic prepend detected");
1441 klass_had_no_origin = ensure_origin(klass);
1442 changed = do_include_modules_at(klass, klass, module, FALSE,
false);
1445 rb_vm_check_redefinition_by_prepend(klass);
1452 iclass = iclass->next;
1455 VALUE klass_origin = RCLASS_ORIGIN(klass);
1456 struct rb_id_table *klass_m_tbl = RCLASS_M_TBL(klass);
1457 struct rb_id_table *klass_origin_m_tbl = RCLASS_M_TBL(klass_origin);
1461 if (!rb_objspace_garbage_object_p(iclass->klass)) {
1462 const VALUE subclass = iclass->klass;
1463 if (klass_had_no_origin && klass_origin_m_tbl == RCLASS_M_TBL(subclass)) {
1465 rb_id_table_foreach(RCLASS_M_TBL(subclass), clear_module_cache_i, (
void *)subclass);
1466 RCLASS_M_TBL(subclass) = klass_m_tbl;
1468 RCLASS_SET_SUPER(subclass, origin);
1469 RCLASS_SET_INCLUDER(origin, RCLASS_INCLUDER(subclass));
1470 RCLASS_SET_ORIGIN(subclass, origin);
1471 RICLASS_SET_ORIGIN_SHARED_MTBL(origin);
1473 include_modules_at(subclass, subclass, module, FALSE);
1476 iclass = iclass->next;
1506 VALUE ary = rb_ary_new();
1508 VALUE origin = RCLASS_ORIGIN(mod);
1512 VALUE m = METACLASS_OF(p);
1514 rb_ary_push(ary, m);
1547 if (METACLASS_OF(p) == mod2)
return Qtrue;
1574 VALUE p, ary = rb_ary_new();
1577 refined_class = rb_refinement_module_get_refined_class(mod);
1581 if (p == refined_class)
break;
1582 if (p != RCLASS_ORIGIN(p))
continue;
1584 rb_ary_push(ary, METACLASS_OF(p));
1587 rb_ary_push(ary, p);
1598 bool immediate_only;
1602class_descendants_recursive(
VALUE klass,
VALUE v)
1607 if (data->buffer && data->count < data->maxcount && !rb_objspace_garbage_object_p(klass)) {
1609 rb_ary_push(data->buffer, klass);
1612 if (!data->immediate_only) {
1613 rb_class_foreach_subclass(klass, class_descendants_recursive, v);
1617 rb_class_foreach_subclass(klass, class_descendants_recursive, v);
1622class_descendants(
VALUE klass,
bool immediate_only)
1627 rb_class_foreach_subclass(klass, class_descendants_recursive, (
VALUE) &data);
1630 data.buffer = rb_ary_new_capa(data.count);
1631 data.maxcount = data.count;
1634 size_t gc_count = rb_gc_count();
1637 rb_class_foreach_subclass(klass, class_descendants_recursive, (
VALUE) &data);
1639 if (gc_count != rb_gc_count()) {
1640 rb_bug(
"GC must not occur during the subclass iteration of Class#descendants");
1688 return class_descendants(klass,
true);
1712 rb_raise(
rb_eTypeError,
"`%"PRIsVALUE
"' is not a singleton class", klass);
1715 return RCLASS_ATTACHED_OBJECT(klass);
1719ins_methods_push(st_data_t name, st_data_t ary)
1725ins_methods_i(st_data_t name, st_data_t
type, st_data_t ary)
1727 switch ((rb_method_visibility_t)
type) {
1728 case METHOD_VISI_UNDEF:
1729 case METHOD_VISI_PRIVATE:
1732 ins_methods_push(name, ary);
1739ins_methods_type_i(st_data_t name, st_data_t
type, st_data_t ary, rb_method_visibility_t visi)
1741 if ((rb_method_visibility_t)
type == visi) {
1742 ins_methods_push(name, ary);
1748ins_methods_prot_i(st_data_t name, st_data_t
type, st_data_t ary)
1750 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PROTECTED);
1754ins_methods_priv_i(st_data_t name, st_data_t
type, st_data_t ary)
1756 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PRIVATE);
1760ins_methods_pub_i(st_data_t name, st_data_t
type, st_data_t ary)
1762 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PUBLIC);
1766ins_methods_undef_i(st_data_t name, st_data_t
type, st_data_t ary)
1768 return ins_methods_type_i(name,
type, ary, METHOD_VISI_UNDEF);
1776static enum rb_id_table_iterator_result
1777method_entry_i(
ID key,
VALUE value,
void *data)
1781 rb_method_visibility_t
type;
1783 if (me->def->type == VM_METHOD_TYPE_REFINED) {
1784 VALUE owner = me->owner;
1785 me = rb_resolve_refined_method(
Qnil, me);
1786 if (!me)
return ID_TABLE_CONTINUE;
1787 if (!arg->recur && me->owner != owner)
return ID_TABLE_CONTINUE;
1789 if (!st_is_member(arg->list, key)) {
1790 if (UNDEFINED_METHOD_ENTRY_P(me)) {
1791 type = METHOD_VISI_UNDEF;
1794 type = METHOD_ENTRY_VISI(me);
1797 st_add_direct(arg->list, key, (st_data_t)
type);
1799 return ID_TABLE_CONTINUE;
1807 rb_id_table_foreach(m_tbl, method_entry_i, me_arg);
1811particular_class_p(
VALUE mod)
1813 if (!mod)
return false;
1820class_instance_method_list(
int argc,
const VALUE *argv,
VALUE mod,
int obj,
int (*func) (st_data_t, st_data_t, st_data_t))
1823 int recur = TRUE, prepended = 0;
1828 me_arg.list = st_init_numtable();
1829 me_arg.recur = recur;
1832 for (; particular_class_p(mod); mod =
RCLASS_SUPER(mod)) {
1833 add_instance_method_list(mod, &me_arg);
1837 if (!recur && RCLASS_ORIGIN(mod) != mod) {
1838 mod = RCLASS_ORIGIN(mod);
1843 add_instance_method_list(mod, &me_arg);
1848 st_foreach(me_arg.list, func, ary);
1849 st_free_table(me_arg.list);
1893 return class_instance_method_list(argc, argv, mod, 0, ins_methods_i);
1908 return class_instance_method_list(argc, argv, mod, 0, ins_methods_prot_i);
1931 return class_instance_method_list(argc, argv, mod, 0, ins_methods_priv_i);
1946 return class_instance_method_list(argc, argv, mod, 0, ins_methods_pub_i);
1958rb_class_undefined_instance_methods(
VALUE mod)
1961 return class_instance_method_list(1, &include_super, mod, 0, ins_methods_undef_i);
1995rb_obj_methods(
int argc,
const VALUE *argv,
VALUE obj)
1998 if (argc > 0 && !
RTEST(argv[0])) {
2001 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_i);
2014rb_obj_protected_methods(
int argc,
const VALUE *argv,
VALUE obj)
2016 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_prot_i);
2029rb_obj_private_methods(
int argc,
const VALUE *argv,
VALUE obj)
2031 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_priv_i);
2044rb_obj_public_methods(
int argc,
const VALUE *argv,
VALUE obj)
2046 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_pub_i);
2085 VALUE ary, klass, origin;
2095 origin = RCLASS_ORIGIN(klass);
2096 me_arg.list = st_init_numtable();
2097 me_arg.recur = recur;
2099 if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
2104 if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
2109 st_foreach(me_arg.list, ins_methods_i, ary);
2110 st_free_table(me_arg.list);
2123#ifdef rb_define_method_id
2124#undef rb_define_method_id
2129 rb_add_method_cfunc(klass, mid, func, argc, METHOD_VISI_PUBLIC);
2132#ifdef rb_define_method
2133#undef rb_define_method
2138 rb_add_method_cfunc(klass, rb_intern(name), func, argc, METHOD_VISI_PUBLIC);
2141#ifdef rb_define_protected_method
2142#undef rb_define_protected_method
2147 rb_add_method_cfunc(klass, rb_intern(name), func, argc, METHOD_VISI_PROTECTED);
2150#ifdef rb_define_private_method
2151#undef rb_define_private_method
2156 rb_add_method_cfunc(klass, rb_intern(name), func, argc, METHOD_VISI_PRIVATE);
2162 rb_add_method(klass, rb_intern(name), VM_METHOD_TYPE_UNDEF, 0, METHOD_VISI_UNDEF);
2165static enum rb_id_table_iterator_result
2166undef_method_i(
ID name,
VALUE value,
void *data)
2169 rb_add_method(klass, name, VM_METHOD_TYPE_UNDEF, 0, METHOD_VISI_UNDEF);
2170 return ID_TABLE_CONTINUE;
2174rb_undef_methods_from(
VALUE klass,
VALUE super)
2178 rb_id_table_foreach(mtbl, undef_method_i, (
void *)klass);
2191special_singleton_class_of(
VALUE obj)
2197 default:
return Qnil;
2202rb_special_singleton_class(
VALUE obj)
2204 return special_singleton_class_of(obj);
2217singleton_class_of(
VALUE obj)
2221 switch (
TYPE(obj)) {
2231 klass = special_singleton_class_of(obj);
2233 rb_bug(
"unknown immediate %p", (
void *)obj);
2242 klass = METACLASS_OF(obj);
2244 RCLASS_ATTACHED_OBJECT(klass) == obj)) {
2245 klass = rb_make_metaclass(obj, klass);
2279 return rb_special_singleton_class(obj);
2281 klass = METACLASS_OF(obj);
2283 if (RCLASS_ATTACHED_OBJECT(klass) != obj)
return Qnil;
2290 VALUE klass = singleton_class_of(obj);
2307#ifdef rb_define_singleton_method
2308#undef rb_define_singleton_method
2316#ifdef rb_define_module_function
2317#undef rb_define_module_function
2326#ifdef rb_define_global_function
2327#undef rb_define_global_function
2338 rb_alias(klass, rb_intern(name1), rb_intern(name2));
2344 rb_attr(klass, rb_intern(name), read, write, FALSE);
2348rb_keyword_error_new(
const char *error,
VALUE keys)
2351 VALUE error_message = rb_sprintf(
"%s keyword%.*s", error,
len > 1,
"s");
2358 if (++i >=
len)
break;
2366NORETURN(
static void rb_keyword_error(
const char *error,
VALUE keys));
2368rb_keyword_error(
const char *error,
VALUE keys)
2370 rb_exc_raise(rb_keyword_error_new(error, keys));
2373NORETURN(
static void unknown_keyword_error(
VALUE hash,
const ID *table,
int keywords));
2375unknown_keyword_error(
VALUE hash,
const ID *table,
int keywords)
2378 for (i = 0; i < keywords; i++) {
2379 st_data_t key =
ID2SYM(table[i]);
2380 rb_hash_stlike_delete(hash, &key, NULL);
2382 rb_keyword_error(
"unknown", rb_hash_keys(hash));
2387separate_symbol(st_data_t key, st_data_t value, st_data_t arg)
2391 if (!*kwdhash) *kwdhash = rb_hash_new();
2392 rb_hash_aset(*kwdhash, (
VALUE)key, (
VALUE)value);
2399 VALUE parthash[2] = {0, 0};
2400 VALUE hash = *orighash;
2407 *orighash = parthash[1];
2422#define extract_kwarg(keyword, val) \
2423 (key = (st_data_t)(keyword), values ? \
2424 (rb_hash_stlike_delete(keyword_hash, &key, &(val)) || ((val) = Qundef, 0)) : \
2425 rb_hash_stlike_lookup(keyword_hash, key, NULL))
2427 if (
NIL_P(keyword_hash)) keyword_hash = 0;
2431 optional = -1-optional;
2434 for (; i < required; i++) {
2437 if (extract_kwarg(keyword, values[i])) {
2441 if (
NIL_P(missing)) missing = rb_ary_hidden_new(1);
2442 rb_ary_push(missing, keyword);
2444 if (!
NIL_P(missing)) {
2445 rb_keyword_error(
"missing", missing);
2449 if (optional && keyword_hash) {
2450 for (i = 0; i < optional; i++) {
2451 if (extract_kwarg(
ID2SYM(table[required+i]), values[required+i])) {
2456 if (!rest && keyword_hash) {
2457 if (
RHASH_SIZE(keyword_hash) > (
unsigned int)(values ? 0 : j)) {
2458 unknown_keyword_error(keyword_hash, table, required+optional);
2461 if (values && !keyword_hash) {
2462 for (i = 0; i < required + optional; i++) {
2481rb_scan_args_parse(
int kw_flag,
const char *fmt,
struct rb_scan_args_t *arg)
2483 const char *p = fmt;
2485 memset(arg, 0,
sizeof(*arg));
2486 arg->kw_flag = kw_flag;
2489 arg->n_lead = *p -
'0';
2492 arg->n_opt = *p -
'0';
2501 arg->n_trail = *p -
'0';
2513 rb_fatal(
"bad scan arg format: %s", fmt);
2518rb_scan_args_assign(
const struct rb_scan_args_t *arg,
int argc,
const VALUE *
const argv, va_list vargs)
2522#define rb_scan_args_next_param() va_arg(vargs, VALUE *)
2523 const int kw_flag = arg->kw_flag;
2524 const int n_lead = arg->n_lead;
2525 const int n_opt = arg->n_opt;
2526 const int n_trail = arg->n_trail;
2527 const int n_mand = n_lead + n_trail;
2528 const bool f_var = arg->f_var;
2529 const bool f_hash = arg->f_hash;
2530 const bool f_block = arg->f_block;
2533 if (f_hash && argc > 0) {
2534 VALUE last = argv[argc - 1];
2535 if (rb_scan_args_keyword_p(kw_flag, last)) {
2536 hash = rb_hash_dup(last);
2541 if (argc < n_mand) {
2546 for (i = 0; i < n_lead; i++) {
2547 var = rb_scan_args_next_param();
2548 if (var) *var = argv[argi];
2552 for (i = 0; i < n_opt; i++) {
2553 var = rb_scan_args_next_param();
2554 if (argi < argc - n_trail) {
2555 if (var) *var = argv[argi];
2559 if (var) *var =
Qnil;
2564 int n_var = argc - argi - n_trail;
2566 var = rb_scan_args_next_param();
2568 if (var) *var = rb_ary_new_from_values(n_var, &argv[argi]);
2572 if (var) *var = rb_ary_new();
2576 for (i = 0; i < n_trail; i++) {
2577 var = rb_scan_args_next_param();
2578 if (var) *var = argv[argi];
2583 var = rb_scan_args_next_param();
2584 if (var) *var = hash;
2588 var = rb_scan_args_next_param();
2603#undef rb_scan_args_next_param
2607rb_scan_args_result(
const struct rb_scan_args_t *
const arg,
int argc)
2609 const int n_lead = arg->n_lead;
2610 const int n_opt = arg->n_opt;
2611 const int n_trail = arg->n_trail;
2612 const int n_mand = n_lead + n_trail;
2613 const bool f_var = arg->f_var;
2631 va_start(vargs,fmt);
2632 argc = rb_scan_args_assign(&arg, argc, argv, vargs);
2634 return rb_scan_args_result(&arg, argc);
2637#undef rb_scan_args_kw
2643 rb_scan_args_parse(kw_flag, fmt, &arg);
2644 va_start(vargs,fmt);
2645 argc = rb_scan_args_assign(&arg, argc, argv, vargs);
2647 return rb_scan_args_result(&arg, argc);
#define RUBY_ASSERT(expr)
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().
@ RUBY_FL_USER1
User-defined flag.
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.
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_define_class(const char *name, VALUE super)
Defines a top-level class.
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_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
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_boot(VALUE super)
A utility function that wraps class_alloc.
VALUE rb_define_module(const char *name)
Defines a top-level module.
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.
void rb_freeze_singleton_class(VALUE x)
This is an implementation detail of RB_OBJ_FREEZE().
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.
static VALUE class_alloc(VALUE flags, VALUE klass)
Allocates a struct RClass for a new class.
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.
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_define_module_under(VALUE outer, const char *name)
Defines a module under the namespace of outer.
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 NEWOBJ_OF
Old name of RB_NEWOBJ_OF.
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
#define FL_UNSET_RAW
Old name of RB_FL_UNSET_RAW.
#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 xfree
Old name of ruby_xfree.
#define T_MASK
Old name of RUBY_T_MASK.
#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_RAW
Old name of RB_OBJ_FREEZE_RAW.
#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 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 FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#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 FL_FREEZE
Old name of RUBY_FL_FREEZE.
#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.
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_mKernel
Kernel module.
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_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
#define RGENGC_WB_PROTECTED_CLASS
This is a compile-time flag to enable/disable write barrier for struct RClass.
#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.
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.
VALUE rb_const_get(VALUE space, ID name)
Identical to rb_const_defined(), except it returns the actual defined value.
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.
int rb_const_defined(VALUE space, ID name)
Queries if the constant is defined at the namespace.
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.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
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 RBASIC(obj)
Convenient casting macro.
#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.
rb_cref_t * cref
class reference, should be marked
const rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
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.