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"
33#define id_attached id__attached__
35#define METACLASS_OF(k) RBASIC(k)->klass
36#define SET_METACLASS_OF(k, cls) RBASIC_SET_CLASS(k, cls)
41push_subclass_entry_to_list(VALUE super, VALUE klass)
48 head = RCLASS_SUBCLASSES(super);
51 RCLASS_SUBCLASSES(super) = head;
53 entry->next = head->next;
57 head->next->prev = entry;
65rb_class_subclass_add(VALUE super, VALUE klass)
67 if (super && super !=
Qundef) {
69 RCLASS_SUBCLASS_ENTRY(klass) = entry;
74rb_module_add_to_subclasses_list(VALUE module, VALUE iclass)
77 RCLASS_MODULE_SUBCLASS_ENTRY(iclass) = entry;
81rb_class_remove_subclass_head(VALUE klass)
87 head->next->prev = NULL;
89 RCLASS_SUBCLASSES(klass) = NULL;
95rb_class_remove_from_super_subclasses(VALUE klass)
112 RCLASS_SUBCLASS_ENTRY(klass) = NULL;
116rb_class_remove_from_module_subclasses(VALUE klass)
133 RCLASS_MODULE_SUBCLASS_ENTRY(klass) = NULL;
137rb_class_foreach_subclass(VALUE klass,
void (*f)(VALUE, VALUE), VALUE arg)
151 VALUE curklass = cur->klass;
160class_detach_subclasses(VALUE klass, VALUE arg)
162 rb_class_remove_from_super_subclasses(klass);
166rb_class_detach_subclasses(VALUE klass)
168 rb_class_foreach_subclass(klass, class_detach_subclasses,
Qnil);
172class_detach_module_subclasses(VALUE klass, VALUE arg)
174 rb_class_remove_from_module_subclasses(klass);
178rb_class_detach_module_subclasses(VALUE klass)
180 rb_class_foreach_subclass(klass, class_detach_module_subclasses,
Qnil);
198 size_t alloc_size =
sizeof(
struct RClass);
207 RVARGC_NEWOBJ_OF(obj,
struct RClass, klass, flags, alloc_size);
225 RCLASS_SET_ORIGIN((VALUE)obj, (VALUE)obj);
226 RCLASS_SERIAL(obj) = rb_next_class_serial();
228 RCLASS_ALLOCATOR(obj) = 0;
234RCLASS_M_TBL_INIT(VALUE c)
236 RCLASS_M_TBL(c) = rb_id_table_create(0);
253 RCLASS_SET_SUPER(klass, super);
254 RCLASS_M_TBL_INIT(klass);
263 rb_raise(rb_eTypeError,
"superclass must be an instance of Class (given an instance of %"PRIsVALUE
")",
264 rb_obj_class(super));
267 rb_raise(rb_eTypeError,
"can't make subclass of singleton class");
269 if (super == rb_cClass) {
270 rb_raise(rb_eTypeError,
"can't make subclass of Class");
283rb_class_s_alloc(VALUE klass)
289clone_method(VALUE old_klass, VALUE new_klass, ID mid,
const rb_method_entry_t *me)
291 if (me->def->type == VM_METHOD_TYPE_ISEQ) {
293 rb_vm_rewrite_cref(me->def->body.iseq.
cref, old_klass, new_klass, &new_cref);
294 rb_add_method_iseq(new_klass, mid, me->def->body.iseq.
iseqptr, new_cref, METHOD_ENTRY_VISI(me));
297 rb_method_entry_set(new_klass, mid, me, METHOD_ENTRY_VISI(me));
306static enum rb_id_table_iterator_result
307clone_method_i(ID key, VALUE value,
void *data)
310 clone_method(arg->old_klass, arg->new_klass, key, (
const rb_method_entry_t *)value);
311 return ID_TABLE_CONTINUE;
327 rb_id_table_insert(arg->tbl, key, (VALUE)nce);
328 return ID_TABLE_CONTINUE;
331static enum rb_id_table_iterator_result
332clone_const_i(ID key, VALUE value,
void *data)
338class_init_copy_check(VALUE clone, VALUE orig)
340 if (orig == rb_cBasicObject) {
341 rb_raise(rb_eTypeError,
"can't copy the root class");
343 if (
RCLASS_SUPER(clone) != 0 || clone == rb_cBasicObject) {
344 rb_raise(rb_eTypeError,
"already initialized class");
347 rb_raise(rb_eTypeError,
"can't copy singleton class");
352copy_tables(VALUE clone, VALUE orig)
354 if (RCLASS_IV_TBL(clone)) {
355 st_free_table(RCLASS_IV_TBL(clone));
356 RCLASS_IV_TBL(clone) = 0;
358 if (RCLASS_CONST_TBL(clone)) {
359 rb_free_const_table(RCLASS_CONST_TBL(clone));
360 RCLASS_CONST_TBL(clone) = 0;
362 RCLASS_M_TBL(clone) = 0;
363 if (RCLASS_IV_TBL(orig)) {
366 rb_iv_tbl_copy(clone, orig);
368 st_delete(RCLASS_IV_TBL(clone), &
id, 0);
370 st_delete(RCLASS_IV_TBL(clone), &
id, 0);
372 st_delete(RCLASS_IV_TBL(clone), &
id, 0);
374 if (RCLASS_CONST_TBL(orig)) {
377 arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0);
379 rb_id_table_foreach(RCLASS_CONST_TBL(orig), clone_const_i, &arg);
383static bool ensure_origin(VALUE klass);
391RMODULE_UNINITIALIZED(VALUE module)
393 return FL_TEST_RAW(module, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED);
397rb_module_set_initialized(VALUE mod)
399 FL_UNSET_RAW(mod, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED);
404rb_module_check_initializable(VALUE mod)
406 if (!RMODULE_UNINITIALIZED(mod)) {
407 rb_raise(rb_eTypeError,
"already initialized module");
419 class_init_copy_check(clone, orig);
422 rb_module_check_initializable(clone);
432 FL_SET(clone, RCLASS_CLONED);
433 FL_SET(orig , RCLASS_CLONED);
439 RCLASS_ALLOCATOR(clone) = RCLASS_ALLOCATOR(orig);
440 copy_tables(clone, orig);
441 if (RCLASS_M_TBL(orig)) {
443 arg.old_klass = orig;
444 arg.new_klass = clone;
445 RCLASS_M_TBL_INIT(clone);
446 rb_id_table_foreach(RCLASS_M_TBL(orig), clone_method_i, &arg);
449 if (RCLASS_ORIGIN(orig) == orig) {
454 VALUE orig_origin = RCLASS_ORIGIN(orig);
455 VALUE prev_clone_p = clone;
463 ensure_origin(clone);
464 clone_origin = RCLASS_ORIGIN(clone);
466 while (p && p != orig_origin) {
468 rb_bug(
"non iclass between module/class and origin");
471 RCLASS_SET_SUPER(prev_clone_p, clone_p);
472 prev_clone_p = clone_p;
473 RCLASS_M_TBL(clone_p) = RCLASS_M_TBL(p);
474 RCLASS_CONST_TBL(clone_p) = RCLASS_CONST_TBL(p);
475 RCLASS_IV_TBL(clone_p) = RCLASS_IV_TBL(p);
476 RCLASS_ALLOCATOR(clone_p) = RCLASS_ALLOCATOR(p);
478 RCLASS_SET_INCLUDER(clone_p, clone);
481 if (p != RCLASS_ORIGIN(p)) {
483 origin[1] = RCLASS_ORIGIN(p);
486 else if ((origin_len =
RARRAY_LEN(origin_stack)) > 1 &&
488 RCLASS_SET_ORIGIN(
RARRAY_AREF(origin_stack, (origin_len -= 2)), clone_p);
489 RICLASS_SET_ORIGIN_SHARED_MTBL(clone_p);
491 add_subclass = FALSE;
494 rb_module_add_to_subclasses_list(
RBASIC(p)->klass, clone_p);
499 if (p == orig_origin) {
501 RCLASS_SET_SUPER(clone_p, clone_origin);
502 RCLASS_SET_SUPER(clone_origin,
RCLASS_SUPER(orig_origin));
504 copy_tables(clone_origin, orig_origin);
505 if (RCLASS_M_TBL(orig_origin)) {
507 arg.old_klass = orig;
508 arg.new_klass = clone;
509 RCLASS_M_TBL_INIT(clone_origin);
510 rb_id_table_foreach(RCLASS_M_TBL(orig_origin), clone_method_i, &arg);
514 rb_bug(
"no origin for class that has origin");
524 return rb_singleton_class_clone_and_attach(obj,
Qundef);
529rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
531 const VALUE klass =
RBASIC(obj)->klass;
543 bool klass_of_clone_is_new;
547 klass_of_clone_is_new =
true;
548 RBASIC_SET_CLASS(clone, clone);
554 klass_of_clone_is_new = (METACLASS_OF(klass) != klass_metaclass_clone);
555 RBASIC_SET_CLASS(clone, klass_metaclass_clone);
559 RCLASS_ALLOCATOR(clone) = RCLASS_ALLOCATOR(klass);
560 if (RCLASS_IV_TBL(klass)) {
561 rb_iv_tbl_copy(clone, klass);
563 if (RCLASS_CONST_TBL(klass)) {
565 arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0);
567 rb_id_table_foreach(RCLASS_CONST_TBL(klass), clone_const_i, &arg);
572 RCLASS_M_TBL_INIT(clone);
575 arg.old_klass = klass;
576 arg.new_klass = clone;
577 rb_id_table_foreach(RCLASS_M_TBL(klass), clone_method_i, &arg);
579 if (klass_of_clone_is_new) {
592 rb_class_ivar_set(klass, id_attached, obj);
601#define META_CLASS_OF_CLASS_CLASS_P(k) (METACLASS_OF(k) == (k))
604rb_singleton_class_has_metaclass_p(VALUE sklass)
606 return rb_attr_get(METACLASS_OF(sklass), id_attached) == sklass;
610rb_singleton_class_internal_p(VALUE sklass)
613 !rb_singleton_class_has_metaclass_p(sklass));
621#define HAVE_METACLASS_P(k) \
622 (FL_TEST(METACLASS_OF(k), FL_SINGLETON) && \
623 rb_singleton_class_has_metaclass_p(k))
632#define ENSURE_EIGENCLASS(klass) \
633 (HAVE_METACLASS_P(klass) ? METACLASS_OF(klass) : make_metaclass(klass))
655 SET_METACLASS_OF(klass, metaclass);
656 SET_METACLASS_OF(metaclass, metaclass);
659 VALUE tmp = METACLASS_OF(klass);
660 SET_METACLASS_OF(klass, metaclass);
680 VALUE orig_class =
RBASIC(obj)->klass;
684 RBASIC_SET_CLASS(obj, klass);
687 SET_METACLASS_OF(klass, METACLASS_OF(
rb_class_real(orig_class)));
693boot_defclass(
const char *name, VALUE super)
699 rb_vm_add_root_module(obj);
750refinement_import_methods(
int argc, VALUE *argv, VALUE refinement)
758 rb_cBasicObject = boot_defclass(
"BasicObject", 0);
759 rb_cObject = boot_defclass(
"Object", rb_cBasicObject);
765 rb_cModule = boot_defclass(
"Module", rb_cObject);
766 rb_cClass = boot_defclass(
"Class", rb_cModule);
767 rb_cRefinement = boot_defclass(
"Refinement", rb_cModule);
771 rb_define_method(rb_cRefinement,
"import_methods", refinement_import_methods, -1);
775 RBASIC_SET_CLASS(rb_cClass, rb_cClass);
776 RBASIC_SET_CLASS(rb_cModule, rb_cClass);
777 RBASIC_SET_CLASS(rb_cObject, rb_cClass);
778 RBASIC_SET_CLASS(rb_cRefinement, rb_cClass);
779 RBASIC_SET_CLASS(rb_cBasicObject, rb_cClass);
796rb_make_metaclass(VALUE obj, VALUE unused)
811 if (!super) super = rb_cObject;
813 rb_make_metaclass(klass,
RBASIC(super)->klass);
827MJIT_FUNC_EXPORTED VALUE
831 if (!super) super = rb_cObject;
833 return rb_funcall(super, inherited, 1, klass);
846 rb_raise(rb_eTypeError,
"%s is not a class (%"PRIsVALUE
")",
847 name, rb_obj_class(klass));
850 rb_raise(rb_eTypeError,
"superclass mismatch for class %s", name);
854 rb_vm_add_root_module(klass);
858 rb_raise(rb_eArgError,
"no super class for `%s'", name);
861 rb_vm_add_root_module(klass);
882 rb_raise(rb_eTypeError,
"%"PRIsVALUE
"::%"PRIsVALUE
" is not a class"
884 outer,
rb_id2str(
id), rb_obj_class(klass));
887 rb_raise(rb_eTypeError,
"superclass mismatch for class "
888 "%"PRIsVALUE
"::%"PRIsVALUE
""
889 " (%"PRIsVALUE
" is given but was %"PRIsVALUE
")",
893 rb_vm_add_root_module(klass);
898 rb_raise(rb_eArgError,
"no super class for `%"PRIsVALUE
"::%"PRIsVALUE
"'",
905 rb_vm_add_root_module(klass);
911rb_module_s_alloc(VALUE klass)
914 RCLASS_M_TBL_INIT(mod);
915 FL_SET(mod, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED);
921module_new(VALUE klass)
924 RCLASS_M_TBL_INIT(mdl);
931 return module_new(rb_cModule);
937 return module_new(rb_cRefinement);
957 rb_raise(rb_eTypeError,
"%s is not a module (%"PRIsVALUE
")",
958 name, rb_obj_class(module));
961 rb_vm_add_root_module(module);
965 rb_vm_add_root_module(module);
985 rb_raise(rb_eTypeError,
"%"PRIsVALUE
"::%"PRIsVALUE
" is not a module"
987 outer,
rb_id2str(
id), rb_obj_class(module));
1002rb_include_class_new(VALUE module, VALUE super)
1006 RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
1008 RCLASS_SET_ORIGIN(klass, klass);
1010 module =
RBASIC(module)->klass;
1013 if (!RCLASS_IV_TBL(module)) {
1014 RCLASS_IV_TBL(module) = st_init_numtable();
1016 if (!RCLASS_CONST_TBL(module)) {
1017 RCLASS_CONST_TBL(module) = rb_id_table_create(0);
1019 RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);
1020 RCLASS_CVC_TBL(klass) = RCLASS_CVC_TBL(module);
1021 RCLASS_CONST_TBL(klass) = RCLASS_CONST_TBL(module);
1023 RCLASS_SET_SUPER(klass, super);
1024 RBASIC_SET_CLASS(klass, module);
1026 return (VALUE)klass;
1029static int include_modules_at(
const VALUE klass, VALUE c, VALUE module,
int search_super);
1032ensure_includable(VALUE klass, VALUE module)
1036 rb_module_set_initialized(module);
1037 if (!
NIL_P(rb_refinement_module_get_refined_class(module))) {
1038 rb_raise(rb_eArgError,
"refinement module is not allowed");
1047 ensure_includable(klass, module);
1049 changed = include_modules_at(klass, RCLASS_ORIGIN(klass), module, TRUE);
1051 rb_raise(rb_eArgError,
"cyclic include detected");
1056 if (iclass && !iclass->klass) {
1057 iclass = iclass->next;
1062 VALUE check_class = iclass->klass;
1065 if (!rb_objspace_garbage_object_p(check_class)) {
1066 while (check_class) {
1067 RUBY_ASSERT(!rb_objspace_garbage_object_p(check_class));
1070 (
RBASIC(check_class)->klass == module)) {
1077 include_modules_at(iclass->klass, RCLASS_ORIGIN(iclass->klass), module, TRUE);
1081 iclass = iclass->next;
1086static enum rb_id_table_iterator_result
1087add_refined_method_entry_i(ID key, VALUE value,
void *data)
1089 rb_add_refined_method_entry((VALUE)data, key);
1090 return ID_TABLE_CONTINUE;
1093static enum rb_id_table_iterator_result
1094clear_module_cache_i(ID
id, VALUE val,
void *data)
1096 VALUE klass = (
VALUE)data;
1097 rb_clear_method_cache(klass,
id);
1098 return ID_TABLE_CONTINUE;
1102module_in_super_chain(
const VALUE klass, VALUE module)
1104 struct rb_id_table *
const klass_m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(klass));
1107 if (klass_m_tbl == RCLASS_M_TBL(module))
1116do_include_modules_at(
const VALUE klass, VALUE c, VALUE module,
int search_super,
bool check_cyclic)
1118 VALUE p, iclass, origin_stack = 0;
1119 int method_changed = 0, constant_changed = 0, add_subclass;
1121 VALUE klass_origin = RCLASS_ORIGIN(klass);
1122 VALUE original_klass = klass;
1124 if (check_cyclic && module_in_super_chain(klass, module))
1129 int superclass_seen = FALSE;
1135 if (klass_origin != c || search_super) {
1141 if (klass_origin == p && !search_super)
1146 if (RCLASS_M_TBL(p) == RCLASS_M_TBL(module)) {
1147 if (!superclass_seen && c_seen) {
1154 superclass_seen = TRUE;
1162 RB_DEBUG_COUNTER_INC(cvar_include_invalidate);
1163 ruby_vm_global_cvar_state++;
1164 tbl = RCLASS_M_TBL(module);
1165 if (tbl && rb_id_table_size(tbl)) {
1168 rb_id_table_foreach(tbl, clear_module_cache_i, (
void *)super_class);
1173 rb_id_table_foreach(tbl, clear_module_cache_i, (
void *)original_klass);
1180 iclass = rb_include_class_new(module, super_class);
1181 c = RCLASS_SET_SUPER(c, iclass);
1182 RCLASS_SET_INCLUDER(iclass, klass);
1183 add_subclass = TRUE;
1184 if (module != RCLASS_ORIGIN(module)) {
1186 VALUE origin[2] = {iclass, RCLASS_ORIGIN(module)};
1189 else if (origin_stack && (origin_len =
RARRAY_LEN(origin_stack)) > 1 &&
1190 RARRAY_AREF(origin_stack, origin_len - 1) == module) {
1191 RCLASS_SET_ORIGIN(
RARRAY_AREF(origin_stack, (origin_len -= 2)), iclass);
1192 RICLASS_SET_ORIGIN_SHARED_MTBL(iclass);
1194 add_subclass = FALSE;
1200 rb_module_add_to_subclasses_list(m, iclass);
1203 if (
FL_TEST(klass, RMODULE_IS_REFINEMENT)) {
1204 VALUE refined_class =
1205 rb_refinement_module_get_refined_class(klass);
1207 rb_id_table_foreach(RCLASS_M_TBL(module), add_refined_method_entry_i, (
void *)refined_class);
1208 FL_SET(c, RMODULE_INCLUDED_INTO_REFINEMENT);
1211 tbl = RCLASS_CONST_TBL(module);
1212 if (tbl && rb_id_table_size(tbl)) constant_changed = 1;
1219 return method_changed;
1223include_modules_at(
const VALUE klass, VALUE c, VALUE module,
int search_super)
1225 return do_include_modules_at(klass, c, module, search_super,
true);
1228static enum rb_id_table_iterator_result
1229move_refined_method(ID key, VALUE value,
void *data)
1233 if (me->def->type == VM_METHOD_TYPE_REFINED) {
1234 VALUE klass = (
VALUE)data;
1237 if (me->def->body.refined.orig_me) {
1239 RB_OBJ_WRITE(me, &me->def->body.refined.orig_me, NULL);
1240 new_me = rb_method_entry_clone(me);
1241 rb_method_table_insert(klass, tbl, key, new_me);
1242 rb_method_entry_copy(me, orig_me);
1243 return ID_TABLE_CONTINUE;
1246 rb_method_table_insert(klass, tbl, key, me);
1247 return ID_TABLE_DELETE;
1251 return ID_TABLE_CONTINUE;
1255static enum rb_id_table_iterator_result
1256cache_clear_refined_method(ID key, VALUE value,
void *data)
1260 if (me->def->type == VM_METHOD_TYPE_REFINED && me->def->body.refined.orig_me) {
1261 VALUE klass = (
VALUE)data;
1262 rb_clear_method_cache(klass, me->called_id);
1267 return ID_TABLE_CONTINUE;
1271ensure_origin(VALUE klass)
1273 VALUE origin = RCLASS_ORIGIN(klass);
1274 if (origin == klass) {
1277 RCLASS_SET_SUPER(klass, origin);
1278 RCLASS_SET_ORIGIN(klass, origin);
1279 RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass);
1280 RCLASS_M_TBL_INIT(klass);
1281 rb_id_table_foreach(RCLASS_M_TBL(origin), cache_clear_refined_method, (
void *)klass);
1282 rb_id_table_foreach(RCLASS_M_TBL(origin), move_refined_method, (
void *)klass);
1292 bool klass_had_no_origin;
1294 ensure_includable(klass, module);
1295 if (module_in_super_chain(klass, module))
1296 rb_raise(rb_eArgError,
"cyclic prepend detected");
1298 klass_had_no_origin = ensure_origin(klass);
1299 changed = do_include_modules_at(klass, klass, module, FALSE,
false);
1302 rb_vm_check_redefinition_by_prepend(klass);
1307 if (iclass && iclass->next) {
1309 iclass = iclass->next;
1312 VALUE klass_origin = RCLASS_ORIGIN(klass);
1313 struct rb_id_table *klass_m_tbl = RCLASS_M_TBL(klass);
1314 struct rb_id_table *klass_origin_m_tbl = RCLASS_M_TBL(klass_origin);
1318 if (!rb_objspace_garbage_object_p(iclass->klass)) {
1319 if (klass_had_no_origin && klass_origin_m_tbl == RCLASS_M_TBL(iclass->klass)) {
1321 rb_id_table_foreach(RCLASS_M_TBL(iclass->klass), clear_module_cache_i, (
void *)iclass->klass);
1322 RCLASS_M_TBL(iclass->klass) = klass_m_tbl;
1323 VALUE origin = rb_include_class_new(klass_origin,
RCLASS_SUPER(iclass->klass));
1324 RCLASS_SET_SUPER(iclass->klass, origin);
1325 RCLASS_SET_INCLUDER(origin, RCLASS_INCLUDER(iclass->klass));
1326 RCLASS_SET_ORIGIN(iclass->klass, origin);
1327 RICLASS_SET_ORIGIN_SHARED_MTBL(origin);
1329 include_modules_at(iclass->klass, iclass->klass, module, FALSE);
1332 iclass = iclass->next;
1364 VALUE origin = RCLASS_ORIGIN(mod);
1368 VALUE m =
RBASIC(p)->klass;
1431 VALUE refined_class =
Qnil;
1432 if (
FL_TEST(mod, RMODULE_IS_REFINEMENT)) {
1433 refined_class = rb_refinement_module_get_refined_class(mod);
1437 if (p == refined_class)
break;
1438 if (p != RCLASS_ORIGIN(p))
continue;
1454 bool immediate_only;
1458class_descendants_recursive(VALUE klass, VALUE v)
1463 if (data->buffer && data->count < data->maxcount && !rb_objspace_garbage_object_p(klass)) {
1468 if (!data->immediate_only) {
1469 rb_class_foreach_subclass(klass, class_descendants_recursive, v);
1473 rb_class_foreach_subclass(klass, class_descendants_recursive, v);
1478class_descendants(VALUE klass,
bool immediate_only)
1483 rb_class_foreach_subclass(klass, class_descendants_recursive, (VALUE) &data);
1487 data.maxcount = data.count;
1493 rb_class_foreach_subclass(klass, class_descendants_recursive, (VALUE) &data);
1496 rb_bug(
"GC must not occur during the subclass iteration of Class#descendants");
1523 return class_descendants(klass,
true);
1527ins_methods_push(st_data_t name, st_data_t ary)
1533ins_methods_i(st_data_t name, st_data_t
type, st_data_t ary)
1535 switch ((rb_method_visibility_t)
type) {
1536 case METHOD_VISI_UNDEF:
1537 case METHOD_VISI_PRIVATE:
1540 ins_methods_push(name, ary);
1547ins_methods_type_i(st_data_t name, st_data_t
type, st_data_t ary, rb_method_visibility_t visi)
1549 if ((rb_method_visibility_t)
type == visi) {
1550 ins_methods_push(name, ary);
1556ins_methods_prot_i(st_data_t name, st_data_t
type, st_data_t ary)
1558 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PROTECTED);
1562ins_methods_priv_i(st_data_t name, st_data_t
type, st_data_t ary)
1564 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PRIVATE);
1568ins_methods_pub_i(st_data_t name, st_data_t
type, st_data_t ary)
1570 return ins_methods_type_i(name,
type, ary, METHOD_VISI_PUBLIC);
1578static enum rb_id_table_iterator_result
1579method_entry_i(ID key, VALUE value,
void *data)
1583 rb_method_visibility_t
type;
1585 if (me->def->type == VM_METHOD_TYPE_REFINED) {
1586 VALUE owner = me->owner;
1587 me = rb_resolve_refined_method(
Qnil, me);
1588 if (!me)
return ID_TABLE_CONTINUE;
1589 if (!arg->recur && me->owner != owner)
return ID_TABLE_CONTINUE;
1591 if (!st_is_member(arg->list, key)) {
1592 if (UNDEFINED_METHOD_ENTRY_P(me)) {
1593 type = METHOD_VISI_UNDEF;
1596 type = METHOD_ENTRY_VISI(me);
1599 st_add_direct(arg->list, key, (st_data_t)
type);
1601 return ID_TABLE_CONTINUE;
1609 rb_id_table_foreach(m_tbl, method_entry_i, me_arg);
1613particular_class_p(VALUE mod)
1615 if (!mod)
return false;
1622class_instance_method_list(
int argc,
const VALUE *argv, VALUE mod,
int obj,
int (*func) (st_data_t, st_data_t, st_data_t))
1625 int recur = TRUE, prepended = 0;
1630 me_arg.list = st_init_numtable();
1631 me_arg.recur = recur;
1634 for (; particular_class_p(mod); mod =
RCLASS_SUPER(mod)) {
1635 add_instance_method_list(mod, &me_arg);
1639 if (!recur && RCLASS_ORIGIN(mod) != mod) {
1640 mod = RCLASS_ORIGIN(mod);
1645 add_instance_method_list(mod, &me_arg);
1651 st_free_table(me_arg.list);
1686 return class_instance_method_list(argc, argv, mod, 0, ins_methods_i);
1701 return class_instance_method_list(argc, argv, mod, 0, ins_methods_prot_i);
1724 return class_instance_method_list(argc, argv, mod, 0, ins_methods_priv_i);
1739 return class_instance_method_list(argc, argv, mod, 0, ins_methods_pub_i);
1773rb_obj_methods(
int argc,
const VALUE *argv, VALUE obj)
1776 if (argc > 0 && !
RTEST(argv[0])) {
1779 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_i);
1792rb_obj_protected_methods(
int argc,
const VALUE *argv, VALUE obj)
1794 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_prot_i);
1807rb_obj_private_methods(
int argc,
const VALUE *argv, VALUE obj)
1809 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_priv_i);
1822rb_obj_public_methods(
int argc,
const VALUE *argv, VALUE obj)
1824 return class_instance_method_list(argc, argv,
CLASS_OF(obj), 1, ins_methods_pub_i);
1863 VALUE ary, klass, origin;
1873 origin = RCLASS_ORIGIN(klass);
1874 me_arg.list = st_init_numtable();
1875 me_arg.recur = recur;
1877 if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
1882 if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
1888 st_free_table(me_arg.list);
1901#ifdef rb_define_method_id
1902#undef rb_define_method_id
1907 rb_add_method_cfunc(klass, mid, func, argc, METHOD_VISI_PUBLIC);
1910#ifdef rb_define_method
1911#undef rb_define_method
1916 rb_add_method_cfunc(klass,
rb_intern(name), func, argc, METHOD_VISI_PUBLIC);
1919#ifdef rb_define_protected_method
1920#undef rb_define_protected_method
1925 rb_add_method_cfunc(klass,
rb_intern(name), func, argc, METHOD_VISI_PROTECTED);
1928#ifdef rb_define_private_method
1929#undef rb_define_private_method
1934 rb_add_method_cfunc(klass,
rb_intern(name), func, argc, METHOD_VISI_PRIVATE);
1940 rb_add_method(klass,
rb_intern(name), VM_METHOD_TYPE_UNDEF, 0, METHOD_VISI_UNDEF);
1943static enum rb_id_table_iterator_result
1944undef_method_i(ID name, VALUE value,
void *data)
1946 VALUE klass = (
VALUE)data;
1947 rb_add_method(klass, name, VM_METHOD_TYPE_UNDEF, 0, METHOD_VISI_UNDEF);
1948 return ID_TABLE_CONTINUE;
1952rb_undef_methods_from(VALUE klass, VALUE super)
1956 rb_id_table_foreach(mtbl, undef_method_i, (
void *)klass);
1969special_singleton_class_of(VALUE obj)
1972 case Qnil:
return rb_cNilClass;
1973 case Qfalse:
return rb_cFalseClass;
1974 case Qtrue:
return rb_cTrueClass;
1975 default:
return Qnil;
1980rb_special_singleton_class(VALUE obj)
1982 return special_singleton_class_of(obj);
1995singleton_class_of(VALUE obj)
1999 switch (
TYPE(obj)) {
2004 rb_raise(rb_eTypeError,
"can't define singleton");
2009 klass = special_singleton_class_of(obj);
2011 rb_bug(
"unknown immediate %p", (
void *)obj);
2016 rb_raise(rb_eTypeError,
"can't define singleton");
2020 klass =
RBASIC(obj)->klass;
2023 rb_serial_t serial = RCLASS_SERIAL(klass);
2024 klass = rb_make_metaclass(obj, klass);
2025 RCLASS_SERIAL(klass) = serial;
2039 if (klass && (klass = RCLASS_ORIGIN(klass)) != 0 &&
2059 return rb_special_singleton_class(obj);
2061 klass =
RBASIC(obj)->klass;
2070 VALUE klass = singleton_class_of(obj);
2087#ifdef rb_define_singleton_method
2088#undef rb_define_singleton_method
2096#ifdef rb_define_module_function
2097#undef rb_define_module_function
2106#ifdef rb_define_global_function
2107#undef rb_define_global_function
2127MJIT_FUNC_EXPORTED VALUE
2128rb_keyword_error_new(
const char *error, VALUE keys)
2131 VALUE error_message =
rb_sprintf(
"%s keyword%.*s", error, len > 1,
"s");
2138 if (++i >= len)
break;
2143 return rb_exc_new_str(rb_eArgError, error_message);
2146NORETURN(
static void rb_keyword_error(
const char *error, VALUE keys));
2148rb_keyword_error(
const char *error, VALUE keys)
2153NORETURN(
static void unknown_keyword_error(VALUE hash,
const ID *table,
int keywords));
2155unknown_keyword_error(VALUE hash,
const ID *table,
int keywords)
2158 for (i = 0; i < keywords; i++) {
2159 st_data_t key =
ID2SYM(table[i]);
2160 rb_hash_stlike_delete(hash, &key, NULL);
2162 rb_keyword_error(
"unknown", rb_hash_keys(hash));
2167separate_symbol(st_data_t key, st_data_t value, st_data_t arg)
2169 VALUE *kwdhash = (VALUE *)arg;
2179 VALUE parthash[2] = {0, 0};
2180 VALUE hash = *orighash;
2187 *orighash = parthash[1];
2195rb_get_kwargs(VALUE keyword_hash,
const ID *table,
int required,
int optional, VALUE *values)
2199 VALUE missing =
Qnil;
2202#define extract_kwarg(keyword, val) \
2203 (key = (st_data_t)(keyword), values ? \
2204 (rb_hash_stlike_delete(keyword_hash, &key, &(val)) || ((val) = Qundef, 0)) : \
2205 rb_hash_stlike_lookup(keyword_hash, key, NULL))
2207 if (
NIL_P(keyword_hash)) keyword_hash = 0;
2211 optional = -1-optional;
2214 for (; i < required; i++) {
2215 VALUE keyword =
ID2SYM(table[i]);
2217 if (extract_kwarg(keyword, values[i])) {
2224 if (!
NIL_P(missing)) {
2225 rb_keyword_error(
"missing", missing);
2229 if (optional && keyword_hash) {
2230 for (i = 0; i < optional; i++) {
2231 if (extract_kwarg(
ID2SYM(table[required+i]), values[required+i])) {
2236 if (!rest && keyword_hash) {
2237 if (
RHASH_SIZE(keyword_hash) > (
unsigned int)(values ? 0 : j)) {
2238 unknown_keyword_error(keyword_hash, table, required+optional);
2241 if (values && !keyword_hash) {
2242 for (i = 0; i < required + optional; i++) {
2261rb_scan_args_parse(
int kw_flag,
const char *fmt,
struct rb_scan_args_t *arg)
2263 const char *p = fmt;
2265 memset(arg, 0,
sizeof(*arg));
2266 arg->kw_flag = kw_flag;
2269 arg->n_lead = *p -
'0';
2272 arg->n_opt = *p -
'0';
2281 arg->n_trail = *p -
'0';
2293 rb_fatal(
"bad scan arg format: %s", fmt);
2298rb_scan_args_assign(
const struct rb_scan_args_t *arg,
int argc,
const VALUE *
const argv, va_list vargs)
2301 VALUE *var, hash =
Qnil;
2302#define rb_scan_args_next_param() va_arg(vargs, VALUE *)
2303 const int kw_flag = arg->kw_flag;
2304 const int n_lead = arg->n_lead;
2305 const int n_opt = arg->n_opt;
2306 const int n_trail = arg->n_trail;
2307 const int n_mand = n_lead + n_trail;
2308 const bool f_var = arg->f_var;
2309 const bool f_hash = arg->f_hash;
2310 const bool f_block = arg->f_block;
2313 if (f_hash && argc > 0) {
2314 VALUE last = argv[argc - 1];
2315 if (rb_scan_args_keyword_p(kw_flag, last)) {
2321 if (argc < n_mand) {
2326 for (i = 0; i < n_lead; i++) {
2327 var = rb_scan_args_next_param();
2328 if (var) *var = argv[argi];
2332 for (i = 0; i < n_opt; i++) {
2333 var = rb_scan_args_next_param();
2334 if (argi < argc - n_trail) {
2335 if (var) *var = argv[argi];
2339 if (var) *var =
Qnil;
2344 int n_var = argc - argi - n_trail;
2346 var = rb_scan_args_next_param();
2356 for (i = 0; i < n_trail; i++) {
2357 var = rb_scan_args_next_param();
2358 if (var) *var = argv[argi];
2363 var = rb_scan_args_next_param();
2364 if (var) *var = hash;
2368 var = rb_scan_args_next_param();
2383#undef rb_scan_args_next_param
2387rb_scan_args_result(
const struct rb_scan_args_t *
const arg,
int argc)
2389 const int n_lead = arg->n_lead;
2390 const int n_opt = arg->n_opt;
2391 const int n_trail = arg->n_trail;
2392 const int n_mand = n_lead + n_trail;
2393 const bool f_var = arg->f_var;
2411 va_start(vargs,fmt);
2412 argc = rb_scan_args_assign(&arg, argc, argv, vargs);
2414 return rb_scan_args_result(&arg, argc);
2417#undef rb_scan_args_kw
2423 rb_scan_args_parse(kw_flag, fmt, &arg);
2424 va_start(vargs,fmt);
2425 argc = rb_scan_args_assign(&arg, argc, argv, vargs);
2427 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 RUBY_EXTERN
Declaration of externally visible global variables.
static VALUE RB_OBJ_FROZEN_RAW(VALUE obj)
This is an implenentation detail of RB_OBJ_FROZEN().
static void RB_FL_SET_RAW(VALUE obj, VALUE flags)
This is an implenentation detail of RB_FL_SET().
@ RUBY_FL_USER5
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.
void Init_class_hierarchy(void)
Internal header aggregating init functions.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
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)
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.
void rb_define_module_function(VALUE module, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a module function for a module.
void rb_define_protected_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Identical to rb_define_method(), except it defines a protected 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_define_private_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Identical to rb_define_method(), except it defines a private method.
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.
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a method.
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Identical to rb_define_method(), except it defines a singleton method.
int rb_block_given_p(void)
Determines if the current method is given a block.
void rb_define_method_id(VALUE klass, ID mid, VALUE(*func)(ANYARGS), int argc)
Identical to rb_define_method(), except it takes the name of the method in ID instead of C's string.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
#define TYPE(_)
Old name of rb_type.
#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 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_PROMOTED1
Old name of RUBY_FL_PROMOTED1.
#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 SYMBOL_P
Old name of RB_SYMBOL_P.
void rb_raise(VALUE exc, const char *fmt,...)
Exception entry point.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_bug(const char *fmt,...)
Interpreter panic switch.
void rb_fatal(const char *fmt,...)
Raises the unsung "fatal" exception.
VALUE rb_cHash
Hash class.
VALUE rb_class_real(VALUE klass)
Finds a "real" 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.
void rb_gc_register_mark_object(VALUE object)
Inform the garbage collector that object is a live Ruby object that should not be moved.
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_tmp_new(long capa)
Allocates a "temporary" 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.
size_t rb_gc_count(void)
Identical to rb_gc_stat(), with "count" parameter.
void rb_hash_foreach(VALUE hash, int(*func)(VALUE key, VALUE val, VALUE arg), VALUE arg)
Iterates over a hash.
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Inserts or replaces ("upsert"s) the objects into the given hash table.
VALUE rb_hash_dup(VALUE hash)
Duplicates a hash.
VALUE rb_hash_new(void)
Creates a new, empty hash object.
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.
VALUE rb_str_cat_cstr(VALUE dst, const char *src)
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.
VALUE rb_attr_get(VALUE obj, ID name)
Identical to rb_ivar_get()
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_clear_constant_cache(void)
Clears the constant cache.
void rb_attr(VALUE klass, ID name, int need_reader, int need_writer, int honour_visibility)
This function resembles now-deprecated Module#attr.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
ID rb_intern(const char *name)
Finds or creates a symbol of the given name.
VALUE rb_id2str(ID id)
Identical to rb_id2name(), except it returns a Ruby's String instead of C's.
VALUE rb_sprintf(const char *fmt,...)
Ruby's extended sprintf(3).
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
VALUE type(ANYARGS)
ANYARGS-ed function type.
int st_foreach(st_table *q, int_type *w, st_data_t e)
Iteration over the given table.
#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 RCLASS(obj)
Convenient casting macro.
#define RGENGC_WB_PROTECTED_CLASS
This is a compile-time flag to enable/disable write barrier for struct RClass.
#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.
const rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
rb_cref_t * cref
class reference, should be marked
Internal header for Class.
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.