Ruby 3.5.0dev (2025-10-10 revision 1399134f6a504cf647c02a00c67b6a04ad7c76a4)
class.h
1#ifndef INTERNAL_CLASS_H /*-*-C-*-vi:se ft=c:*/
2#define INTERNAL_CLASS_H
11#include "id.h"
12#include "id_table.h" /* for struct rb_id_table */
13#include "internal/namespace.h" /* for rb_current_namespace */
14#include "internal/serial.h" /* for rb_serial_t */
15#include "internal/static_assert.h"
16#include "internal/variable.h" /* for rb_class_ivar_set */
17#include "ruby/internal/stdbool.h" /* for bool */
18#include "ruby/intern.h" /* for rb_alloc_func_t */
19#include "ruby/ruby.h" /* for struct RBasic */
20#include "shape.h"
21#include "ruby_assert.h"
22#include "vm_core.h"
23#include "vm_sync.h"
24#include "method.h" /* for rb_cref_t */
25
26#ifdef RCLASS_SUPER
27# undef RCLASS_SUPER
28#endif
29
31 long refcount;
32 struct st_table *tbl;
33};
35
36static inline long
37rb_ns_subclasses_ref_count(rb_ns_subclasses_t *ns_sub)
38{
39 return ns_sub->refcount;
40}
41
42static inline rb_ns_subclasses_t *
43rb_ns_subclasses_ref_inc(rb_ns_subclasses_t *ns_sub)
44{
45 ns_sub->refcount++;
46 return ns_sub;
47}
48
49static inline void
50rb_ns_subclasses_ref_dec(rb_ns_subclasses_t *ns_sub)
51{
52 ns_sub->refcount--;
53 if (ns_sub->refcount == 0) {
54 st_free_table(ns_sub->tbl);
55 xfree(ns_sub);
56 }
57}
58
60 rb_ns_subclasses_t *ns_subclasses;
61 struct rb_subclass_entry *head;
62};
64
66 VALUE klass;
67 struct rb_subclass_entry *next;
68 struct rb_subclass_entry *prev;
69};
71
73 uint32_t index;
74 rb_serial_t global_cvar_state;
75 const rb_cref_t * cref;
76 VALUE class_value;
77};
78
80 const rb_namespace_t *ns;
81 VALUE super;
82 VALUE fields_obj; // Fields are either ivar or other internal properties stored inline
83 struct rb_id_table *m_tbl;
84 struct rb_id_table *const_tbl;
85 struct rb_id_table *callable_m_tbl;
86 VALUE cc_tbl; /* { ID => { cme, [cc1, cc2, ...] }, ... } */
87 struct rb_id_table *cvc_tbl;
88 VALUE *superclasses;
108
109 const VALUE origin_;
110 const VALUE refined_class;
111 union {
112 struct {
113 rb_alloc_func_t allocator;
114 } class;
115 struct {
116 VALUE attached_object;
117 } singleton_class;
118 struct {
119 const VALUE includer;
120 } iclass;
121 } as;
122 attr_index_t max_iv_count;
123 uint16_t superclass_depth;
124 unsigned char variation_count;
125 bool permanent_classpath : 1;
126 bool cloned : 1;
127 bool shared_const_tbl : 1;
128 bool iclass_is_origin : 1;
129 bool iclass_origin_shared_mtbl : 1;
130 bool superclasses_with_self : 1;
131 VALUE classpath;
132};
133typedef struct rb_classext_struct rb_classext_t;
134
135STATIC_ASSERT(shape_max_variations, SHAPE_MAX_VARIATIONS < (1 << (sizeof(((rb_classext_t *)0)->variation_count) * CHAR_BIT)));
136
137struct RClass {
138 struct RBasic basic;
139 VALUE object_id;
140 /*
141 * If ns_classext_tbl is NULL, then the prime classext is readable (because no other classext exists).
142 * For the check whether writable or not, check flag RCLASS_PRIME_CLASSEXT_WRITABLE
143 */
144};
145
147 struct RClass rclass;
148 rb_classext_t classext;
149};
150
151#if SIZEOF_VALUE >= SIZEOF_LONG_LONG
152// Assert that classes can be embedded in heaps[2] (which has 160B slot size)
153// On 32bit platforms there is no variable width allocation so it doesn't matter.
154STATIC_ASSERT(sizeof_rb_classext_t, sizeof(struct RClass_and_rb_classext_t) <= 4 * RVALUE_SIZE);
155#endif
156
158 struct RClass_and_rb_classext_t base;
159 st_table *ns_classext_tbl; // ns_object -> (rb_classext_t *)
160};
161
162static const uint16_t RCLASS_MAX_SUPERCLASS_DEPTH = ((uint16_t)-1);
163
164static inline bool RCLASS_SINGLETON_P(VALUE klass);
165
166static inline bool RCLASS_PRIME_CLASSEXT_READABLE_P(VALUE obj);
167static inline bool RCLASS_PRIME_CLASSEXT_WRITABLE_P(VALUE obj);
168static inline void RCLASS_SET_PRIME_CLASSEXT_WRITABLE(VALUE obj, bool writable);
169
170#define RCLASS_EXT_PRIME(c) (&((struct RClass_and_rb_classext_t*)(c))->classext)
171#define RCLASS_EXT_PRIME_P(ext, c) (&((struct RClass_and_rb_classext_t*)(c))->classext == ext)
172
173static inline rb_classext_t * RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns);
174static inline rb_classext_t * RCLASS_EXT_READABLE(VALUE obj);
175static inline rb_classext_t * RCLASS_EXT_WRITABLE_IN_NS(VALUE obj, const rb_namespace_t *ns);
176static inline rb_classext_t * RCLASS_EXT_WRITABLE(VALUE obj);
177
178// Raw accessor
179#define RCLASSEXT_NS(ext) (ext->ns)
180#define RCLASSEXT_SUPER(ext) (ext->super)
181#define RCLASSEXT_FIELDS(ext) (ext->fields_obj ? ROBJECT_FIELDS(ext->fields_obj) : NULL)
182#define RCLASSEXT_FIELDS_OBJ(ext) (ext->fields_obj)
183#define RCLASSEXT_M_TBL(ext) (ext->m_tbl)
184#define RCLASSEXT_CONST_TBL(ext) (ext->const_tbl)
185#define RCLASSEXT_CALLABLE_M_TBL(ext) (ext->callable_m_tbl)
186#define RCLASSEXT_CC_TBL(ext) (ext->cc_tbl)
187#define RCLASSEXT_CVC_TBL(ext) (ext->cvc_tbl)
188#define RCLASSEXT_SUPERCLASS_DEPTH(ext) (ext->superclass_depth)
189#define RCLASSEXT_SUPERCLASSES(ext) (ext->superclasses)
190#define RCLASSEXT_SUBCLASSES(ext) (ext->subclasses)
191#define RCLASSEXT_NS_SUPER_SUBCLASSES(ext) (ext->ns_super_subclasses)
192#define RCLASSEXT_NS_MODULE_SUBCLASSES(ext) (ext->ns_module_subclasses)
193#define RCLASSEXT_ORIGIN(ext) (ext->origin_)
194#define RCLASSEXT_REFINED_CLASS(ext) (ext->refined_class)
195// class.allocator/singleton_class.attached_object are not accessed directly via RCLASSEXT_*
196#define RCLASSEXT_INCLUDER(ext) (ext->as.iclass.includer)
197#define RCLASSEXT_PERMANENT_CLASSPATH(ext) (ext->permanent_classpath)
198#define RCLASSEXT_CLONED(ext) (ext->cloned)
199#define RCLASSEXT_SHARED_CONST_TBL(ext) (ext->shared_const_tbl)
200#define RCLASSEXT_ICLASS_IS_ORIGIN(ext) (ext->iclass_is_origin)
201#define RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext) (ext->iclass_origin_shared_mtbl)
202#define RCLASSEXT_SUPERCLASSES_WITH_SELF(ext) (ext->superclasses_with_self)
203#define RCLASSEXT_CLASSPATH(ext) (ext->classpath)
204
205static inline void RCLASSEXT_SET_ORIGIN(rb_classext_t *ext, VALUE klass, VALUE origin);
206static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE includer);
207
208/* Prime classext entry accessor for very specific reason */
209#define RCLASS_PRIME_NS(c) (RCLASS_EXT_PRIME(c)->ns)
210// To invalidate CC by inserting&invalidating method entry into tables containing the target cme
211// See clear_method_cache_by_id_in_class()
212#define RCLASS_PRIME_FIELDS_OBJ(c) (RCLASS_EXT_PRIME(c)->fields_obj)
213#define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT_PRIME(c)->m_tbl)
214#define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT_PRIME(c)->const_tbl)
215#define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT_PRIME(c)->callable_m_tbl)
216#define RCLASS_PRIME_CC_TBL(c) (RCLASS_EXT_PRIME(c)->cc_tbl)
217#define RCLASS_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->m_tbl != tbl)
218#define RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->callable_m_tbl != tbl)
219#define RCLASS_CC_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->cc_tbl != tbl)
220
221// Read accessor, regarding namespaces
222#define RCLASS_SUPER(c) (RCLASS_EXT_READABLE(c)->super)
223#define RCLASS_M_TBL(c) (RCLASS_EXT_READABLE(c)->m_tbl)
224#define RCLASS_CONST_TBL(c) (RCLASS_EXT_READABLE(c)->const_tbl)
225/*
226 * Both cc_tbl/callable_m_tbl are cache-like and always be changed when referreed,
227 * so always those should be writable.
228 */
229#define RCLASS_CVC_TBL(c) (RCLASS_EXT_READABLE(c)->cvc_tbl)
230#define RCLASS_SUBCLASSES_X(c) (RCLASS_EXT_READABLE(c)->subclasses)
231#define RCLASS_SUBCLASSES_FIRST(c) (RCLASS_EXT_READABLE(c)->subclasses->head->next)
232#define RCLASS_ORIGIN(c) (RCLASS_EXT_READABLE(c)->origin_)
233#define RICLASS_IS_ORIGIN_P(c) (RCLASS_EXT_READABLE(c)->iclass_is_origin)
234#define RCLASS_PERMANENT_CLASSPATH_P(c) (RCLASS_EXT_READABLE(c)->permanent_classpath)
235#define RCLASS_CLONED_P(c) (RCLASS_EXT_READABLE(c)->cloned)
236#define RCLASS_CLASSPATH(c) (RCLASS_EXT_READABLE(c)->classpath)
237
238// Superclasses can't be changed after initialization
239#define RCLASS_SUPERCLASS_DEPTH(c) (RCLASS_EXT_PRIME(c)->superclass_depth)
240#define RCLASS_SUPERCLASSES(c) (RCLASS_EXT_PRIME(c)->superclasses)
241#define RCLASS_SUPERCLASSES_WITH_SELF_P(c) (RCLASS_EXT_PRIME(c)->superclasses_with_self)
242
243// namespaces don't make changes on these refined_class/attached_object/includer
244#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT_PRIME(c)->refined_class)
245#define RCLASS_ATTACHED_OBJECT(c) (RCLASS_EXT_PRIME(c)->as.singleton_class.attached_object)
246#define RCLASS_INCLUDER(c) (RCLASS_EXT_PRIME(c)->as.iclass.includer)
247
248// max IV count and variation count are just hints, so they don't need to be per-namespace
249#define RCLASS_MAX_IV_COUNT(ext) (RCLASS_EXT_PRIME(ext)->max_iv_count)
250#define RCLASS_VARIATION_COUNT(ext) (RCLASS_EXT_PRIME(ext)->variation_count)
251
252// Writable classext entries (instead of RCLASS_SET_*) because member data will be operated directly
253#define RCLASS_WRITABLE_M_TBL(c) (RCLASS_EXT_WRITABLE(c)->m_tbl)
254#define RCLASS_WRITABLE_CONST_TBL(c) (RCLASS_EXT_WRITABLE(c)->const_tbl)
255#define RCLASS_WRITABLE_CALLABLE_M_TBL(c) (RCLASS_EXT_WRITABLE(c)->callable_m_tbl)
256#define RCLASS_WRITABLE_CC_TBL(c) (RCLASS_EXT_WRITABLE(c)->cc_tbl)
257#define RCLASS_WRITABLE_CVC_TBL(c) (RCLASS_EXT_WRITABLE(c)->cvc_tbl)
258#define RCLASS_WRITABLE_SUBCLASSES(c) (RCLASS_EXT_WRITABLE(c)->subclasses)
259
260static inline void RCLASS_SET_SUPER(VALUE klass, VALUE super);
261static inline void RCLASS_WRITE_SUPER(VALUE klass, VALUE super);
262static inline void RCLASS_SET_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared);
263static inline void RCLASS_WRITE_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared);
264static inline void RCLASS_WRITE_CALLABLE_M_TBL(VALUE klass, struct rb_id_table *table);
265static inline void RCLASS_WRITE_CC_TBL(VALUE klass, VALUE table);
266static inline void RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table);
267static inline void RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table);
268
269static inline void RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool with_self);
270static inline void RCLASS_SET_SUBCLASSES(VALUE klass, rb_subclass_anchor_t *anchor);
271static inline void RCLASS_WRITE_NS_SUPER_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses);
272static inline void RCLASS_WRITE_NS_MODULE_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses);
273
274static inline void RCLASS_SET_ORIGIN(VALUE klass, VALUE origin);
275static inline void RCLASS_WRITE_ORIGIN(VALUE klass, VALUE origin);
276static inline void RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass);
277static inline void RICLASS_WRITE_ORIGIN_SHARED_MTBL(VALUE iclass);
278static inline bool RICLASS_OWNS_M_TBL_P(VALUE iclass);
279
280static inline void RCLASS_SET_REFINED_CLASS(VALUE klass, VALUE refined);
281static inline rb_alloc_func_t RCLASS_ALLOCATOR(VALUE klass);
282static inline void RCLASS_SET_ALLOCATOR(VALUE klass, rb_alloc_func_t allocator);
283static inline VALUE RCLASS_SET_ATTACHED_OBJECT(VALUE klass, VALUE attached_object);
284
285static inline void RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass);
286static inline void RCLASS_SET_MAX_IV_COUNT(VALUE klass, attr_index_t count);
287static inline void RCLASS_SET_CLONED(VALUE klass, bool cloned);
288static inline void RCLASS_SET_CLASSPATH(VALUE klass, VALUE classpath, bool permanent);
289static inline void RCLASS_WRITE_CLASSPATH(VALUE klass, VALUE classpath, bool permanent);
290
291#define RCLASS_IS_ROOT FL_USER0
292// 1 is for RUBY_FL_SINGLETON or RMODULE_IS_REFINEMENT
293#define RCLASS_PRIME_CLASSEXT_WRITABLE FL_USER2
294#define RCLASS_IS_INITIALIZED FL_USER3
295// 3 is RMODULE_IS_REFINEMENT for RMODULE
296#define RCLASS_NAMESPACEABLE FL_USER4
297
298static inline st_table *
299RCLASS_CLASSEXT_TBL(VALUE klass)
300{
301 if (FL_TEST_RAW(klass, RCLASS_NAMESPACEABLE)) {
302 struct RClass_namespaceable *ns_klass = (struct RClass_namespaceable *)klass;
303 return ns_klass->ns_classext_tbl;
304 }
305 return NULL;
306}
307
308static inline void
309RCLASS_SET_CLASSEXT_TBL(VALUE klass, st_table *tbl)
310{
311 RUBY_ASSERT(FL_TEST_RAW(klass, RCLASS_NAMESPACEABLE));
312 struct RClass_namespaceable *ns_klass = (struct RClass_namespaceable *)klass;
313 ns_klass->ns_classext_tbl = tbl;
314}
315
316/* class.c */
317rb_classext_t * rb_class_duplicate_classext(rb_classext_t *orig, VALUE obj, const rb_namespace_t *ns);
318void rb_class_ensure_writable(VALUE obj);
319
320static inline int
321RCLASS_SET_NAMESPACE_CLASSEXT(VALUE obj, const rb_namespace_t *ns, rb_classext_t *ext)
322{
323 int first_set = 0;
324 st_table *tbl = RCLASS_CLASSEXT_TBL(obj);
325 VM_ASSERT(NAMESPACE_USER_P(ns)); // non-prime classext is only for user namespace, with ns_object
326 VM_ASSERT(ns->ns_object);
327 VM_ASSERT(RCLASSEXT_NS(ext) == ns);
328 if (!tbl) {
329 tbl = st_init_numtable_with_size(1);
330 RCLASS_SET_CLASSEXT_TBL(obj, tbl);
331 }
332 if (rb_st_table_size(tbl) == 0) {
333 first_set = 1;
334 }
335 rb_st_insert(tbl, (st_data_t)ns->ns_object, (st_data_t)ext);
336 return first_set;
337}
338
339#define VM_ASSERT_NAMESPACEABLE_TYPE(klass) \
340 VM_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_MODULE) || RB_TYPE_P(klass, T_ICLASS), "%s is not namespaceable type", rb_type_str(BUILTIN_TYPE(klass)))
341
342static inline bool
343RCLASS_PRIME_CLASSEXT_READABLE_P(VALUE klass)
344{
345 VM_ASSERT(klass != 0, "klass should be a valid object");
346 VM_ASSERT_NAMESPACEABLE_TYPE(klass);
347 // if the lookup table exists, then it means the prime classext is NOT directly readable.
348 return !FL_TEST_RAW(klass, RCLASS_NAMESPACEABLE) || RCLASS_CLASSEXT_TBL(klass) == NULL;
349}
350
351static inline bool
352RCLASS_PRIME_CLASSEXT_WRITABLE_P(VALUE klass)
353{
354 VM_ASSERT(klass != 0, "klass should be a valid object");
355 VM_ASSERT_NAMESPACEABLE_TYPE(klass);
356 return FL_TEST(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
357}
358
359static inline void
360RCLASS_SET_PRIME_CLASSEXT_WRITABLE(VALUE klass, bool writable)
361{
362 VM_ASSERT(klass != 0, "klass should be a valid object");
363 VM_ASSERT_NAMESPACEABLE_TYPE(klass);
364 if (writable) {
365 FL_SET(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
366 }
367 else {
368 FL_UNSET(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
369 }
370}
371
372static inline rb_classext_t *
373RCLASS_EXT_TABLE_LOOKUP_INTERNAL(VALUE obj, const rb_namespace_t *ns)
374{
375 st_data_t classext_ptr;
376 st_table *classext_tbl = RCLASS_CLASSEXT_TBL(obj);
377 if (classext_tbl) {
378 if (rb_st_lookup(classext_tbl, (st_data_t)ns->ns_object, &classext_ptr)) {
379 return (rb_classext_t *)classext_ptr;
380 }
381 }
382 return NULL;
383}
384
385static inline rb_classext_t *
386RCLASS_EXT_READABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
387{
388 rb_classext_t *ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);
389 if (ext)
390 return ext;
391 // Classext for the ns not found. Refer the prime one instead.
392 return RCLASS_EXT_PRIME(obj);
393}
394
395static inline rb_classext_t *
396RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
397{
398 if (NAMESPACE_ROOT_P(ns)
399 || RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
400 return RCLASS_EXT_PRIME(obj);
401 }
402 return RCLASS_EXT_READABLE_LOOKUP(obj, ns);
403}
404
405static inline rb_classext_t *
406RCLASS_EXT_READABLE(VALUE obj)
407{
408 const rb_namespace_t *ns;
409 if (RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
410 return RCLASS_EXT_PRIME(obj);
411 }
412 // delay determining the current namespace to optimize for unmodified classes
413 ns = rb_current_namespace();
414 if (NAMESPACE_ROOT_P(ns)) {
415 return RCLASS_EXT_PRIME(obj);
416 }
417 return RCLASS_EXT_READABLE_LOOKUP(obj, ns);
418}
419
420static inline rb_classext_t *
421RCLASS_EXT_WRITABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
422{
423 rb_classext_t *ext;
424 int first_set = 0;
425
426 ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);
427 if (ext)
428 return ext;
429
430 RB_VM_LOCKING() {
431 // re-check the classext is not created to avoid the multi-thread race
432 ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);
433 if (!ext) {
434 ext = rb_class_duplicate_classext(RCLASS_EXT_PRIME(obj), obj, ns);
435 first_set = RCLASS_SET_NAMESPACE_CLASSEXT(obj, ns, ext);
436 if (first_set) {
437 // TODO: are there any case that a class/module become non-writable after its birthtime?
438 RCLASS_SET_PRIME_CLASSEXT_WRITABLE(obj, false);
439 }
440 }
441 }
442 return ext;
443}
444
445static inline rb_classext_t *
446RCLASS_EXT_WRITABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
447{
448 if (NAMESPACE_ROOT_P(ns)
449 || RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {
450 return RCLASS_EXT_PRIME(obj);
451 }
452 return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);
453}
454
455static inline rb_classext_t *
456RCLASS_EXT_WRITABLE(VALUE obj)
457{
458 const rb_namespace_t *ns;
459 if (LIKELY(RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj))) {
460 return RCLASS_EXT_PRIME(obj);
461 }
462 // delay determining the current namespace to optimize for unmodified classes
463 ns = rb_current_namespace();
464 if (NAMESPACE_ROOT_P(ns)) {
465 return RCLASS_EXT_PRIME(obj);
466 }
467 return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);
468}
469
470static inline void
471RCLASSEXT_SET_ORIGIN(rb_classext_t *ext, VALUE klass, VALUE origin)
472{
473 RB_OBJ_WRITE(klass, &(RCLASSEXT_ORIGIN(ext)), origin);
474}
475
476static inline void
477RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE includer)
478{
480 RB_OBJ_WRITE(klass, &(RCLASSEXT_INCLUDER(ext)), includer);
481}
482
483/* class.c */
484typedef void rb_class_classext_foreach_callback_func(rb_classext_t *classext, bool is_prime, VALUE namespace, void *arg);
485void rb_class_classext_foreach(VALUE klass, rb_class_classext_foreach_callback_func *func, void *arg);
486void rb_class_subclass_add(VALUE super, VALUE klass);
487void rb_class_remove_from_super_subclasses(VALUE);
488void rb_class_remove_from_module_subclasses(VALUE);
489void rb_class_classext_free_subclasses(rb_classext_t *, VALUE);
490void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE);
491void rb_class_detach_subclasses(VALUE);
492void rb_class_detach_module_subclasses(VALUE);
493void rb_class_update_superclasses(VALUE);
494size_t rb_class_superclasses_memsize(VALUE);
495void rb_class_remove_subclass_head(VALUE);
496int rb_singleton_class_internal_p(VALUE sklass);
497VALUE rb_class_set_super(VALUE klass, VALUE super);
499VALUE rb_class_s_alloc(VALUE klass);
500VALUE rb_module_s_alloc(VALUE klass);
501void rb_class_set_initialized(VALUE klass);
502void rb_module_check_initializable(VALUE module);
503VALUE rb_make_metaclass(VALUE, VALUE);
504VALUE rb_include_class_new(VALUE, VALUE);
505VALUE rb_define_class_id_under_no_pin(VALUE outer, ID id, VALUE super);
506VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj);
507VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj);
508VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj);
509VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj);
510VALUE rb_class_undefined_instance_methods(VALUE mod);
511VALUE rb_special_singleton_class(VALUE);
512VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach);
514void rb_undef_methods_from(VALUE klass, VALUE super);
516VALUE rb_keyword_error_new(const char *, VALUE);
517
518RUBY_SYMBOL_EXPORT_BEGIN
519
520/* for objspace */
521VALUE rb_class_super_of(VALUE klass);
522VALUE rb_class_singleton_p(VALUE klass);
523unsigned char rb_class_variation_count(VALUE klass);
524
525RUBY_SYMBOL_EXPORT_END
526
527static inline bool
528RCLASS_SINGLETON_P(VALUE klass)
529{
530 return RB_TYPE_P(klass, T_CLASS) && FL_TEST_RAW(klass, FL_SINGLETON);
531}
532
533static inline void
534RCLASS_SET_SUPER(VALUE klass, VALUE super)
535{
536 RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_PRIME(klass)), super);
537}
538
539static inline void
540RCLASS_WRITE_SUPER(VALUE klass, VALUE super)
541{
542 RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_WRITABLE(klass)), super);
543}
544
545static inline VALUE
546RCLASS_WRITABLE_ENSURE_FIELDS_OBJ(VALUE obj)
547{
549 rb_classext_t *ext = RCLASS_EXT_WRITABLE(obj);
550 if (!ext->fields_obj) {
551 RB_OBJ_WRITE(obj, &ext->fields_obj, rb_imemo_fields_new(obj, 1));
552 }
553 return ext->fields_obj;
554}
555
556static inline VALUE
557RCLASS_WRITABLE_FIELDS_OBJ(VALUE obj)
558{
560 return RCLASSEXT_FIELDS_OBJ(RCLASS_EXT_WRITABLE(obj));
561}
562
563static inline void
564RCLASSEXT_SET_FIELDS_OBJ(VALUE obj, rb_classext_t *ext, VALUE fields_obj)
565{
567
568 RB_OBJ_ATOMIC_WRITE(obj, &ext->fields_obj, fields_obj);
569}
570
571static inline void
572RCLASS_WRITABLE_SET_FIELDS_OBJ(VALUE obj, VALUE fields_obj)
573{
575
576 RCLASSEXT_SET_FIELDS_OBJ(obj, RCLASS_EXT_WRITABLE(obj), fields_obj);
577}
578
579static inline uint32_t
580RCLASS_FIELDS_COUNT(VALUE obj)
581{
583
584 VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
585 if (fields_obj) {
586 if (rb_shape_obj_too_complex_p(fields_obj)) {
587 return (uint32_t)rb_st_table_size(rb_imemo_fields_complex_tbl(fields_obj));
588 }
589 else {
590 return RSHAPE_LEN(RBASIC_SHAPE_ID(fields_obj));
591 }
592 }
593 return 0;
594}
595
596static inline void
597RCLASS_SET_M_TBL(VALUE klass, struct rb_id_table *table)
598{
599 RCLASSEXT_M_TBL(RCLASS_EXT_PRIME(klass)) = table;
600}
601
602static inline void
603RCLASS_WRITE_M_TBL(VALUE klass, struct rb_id_table *table)
604{
605 RCLASSEXT_M_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
606}
607
608static inline void
609RCLASS_SET_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared)
610{
611 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
612 RCLASSEXT_CONST_TBL(ext) = table;
613 if (shared)
614 RCLASSEXT_SHARED_CONST_TBL(ext) = true;
615}
616
617static inline void
618RCLASS_WRITE_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared)
619{
620 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
621 RCLASSEXT_CONST_TBL(ext) = table;
622 if (shared)
623 RCLASSEXT_SHARED_CONST_TBL(ext) = true;
624}
625
626static inline void
627RCLASS_WRITE_CALLABLE_M_TBL(VALUE klass, struct rb_id_table *table)
628{
629 RCLASSEXT_CALLABLE_M_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
630}
631
632static inline void
633RCLASS_WRITE_CC_TBL(VALUE klass, VALUE table)
634{
635 RB_OBJ_ATOMIC_WRITE(klass, &RCLASSEXT_CC_TBL(RCLASS_EXT_WRITABLE(klass)), table);
636}
637
638static inline void
639RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table)
640{
641 RCLASSEXT_CVC_TBL(RCLASS_EXT_PRIME(klass)) = table;
642}
643
644static inline void
645RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table)
646{
647 RCLASSEXT_CVC_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
648}
649
650static inline void
651RCLASS_SET_REFINED_CLASS(VALUE klass, VALUE refined)
652{
653 RB_OBJ_WRITE(klass, &RCLASSEXT_REFINED_CLASS(RCLASS_EXT_PRIME(klass)), refined);
654}
655
656static inline rb_alloc_func_t
657RCLASS_ALLOCATOR(VALUE klass)
658{
659 RUBY_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_ICLASS));
660 if (RCLASS_SINGLETON_P(klass) || RB_TYPE_P(klass, T_ICLASS)) {
661 return 0;
662 }
663 return RCLASS_EXT_PRIME(klass)->as.class.allocator;
664}
665
666static inline void
667RCLASS_SET_ALLOCATOR(VALUE klass, rb_alloc_func_t allocator)
668{
670 RUBY_ASSERT(!RCLASS_SINGLETON_P(klass));
671 RCLASS_EXT_PRIME(klass)->as.class.allocator = allocator; // Allocator is set only on the initial definition
672}
673
674static inline void
675RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
676{
677 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
678 RB_OBJ_WRITE(klass, &RCLASSEXT_ORIGIN(ext), origin);
679 if (klass != origin) RCLASSEXT_ICLASS_IS_ORIGIN(RCLASS_EXT_WRITABLE(origin)) = true;
680}
681
682static inline void
683RCLASS_WRITE_ORIGIN(VALUE klass, VALUE origin)
684{
685 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
686 RB_OBJ_WRITE(klass, &RCLASSEXT_ORIGIN(ext), origin);
687 if (klass != origin) RCLASSEXT_ICLASS_IS_ORIGIN(RCLASS_EXT_WRITABLE(origin)) = true;
688}
689
690static inline void
691RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass)
692{
693 RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT_PRIME(iclass)) = true;
694}
695
696static inline void
697RICLASS_WRITE_ORIGIN_SHARED_MTBL(VALUE iclass)
698{
699 RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT_WRITABLE(iclass)) = true;
700}
701
702static inline bool
703RICLASS_OWNS_M_TBL_P(VALUE iclass)
704{
705 rb_classext_t *ext = RCLASS_EXT_READABLE(iclass);
706 return RCLASSEXT_ICLASS_IS_ORIGIN(ext) && !RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext);
707}
708
709static inline void
710RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass)
711{
713 RB_OBJ_WRITE(iclass, &RCLASS_INCLUDER(iclass), klass);
714}
715
716static inline void
717RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool with_self)
718{
719 RUBY_ASSERT(depth <= RCLASS_MAX_SUPERCLASS_DEPTH);
720
721 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
722 RCLASSEXT_SUPERCLASS_DEPTH(ext) = depth;
723 RCLASSEXT_SUPERCLASSES(ext) = superclasses;
724 RCLASSEXT_SUPERCLASSES_WITH_SELF(ext) = with_self;
725}
726
727static inline void
728RCLASS_SET_SUBCLASSES(VALUE klass, struct rb_subclass_anchor *anchor)
729{
730 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
731 RCLASSEXT_SUBCLASSES(ext) = anchor;
732}
733
734static inline void
735RCLASS_WRITE_NS_SUPER_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses)
736{
737 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
738 if (RCLASSEXT_NS_SUPER_SUBCLASSES(ext))
739 rb_ns_subclasses_ref_dec(RCLASSEXT_NS_SUPER_SUBCLASSES(ext));
740 RCLASSEXT_NS_SUPER_SUBCLASSES(ext) = rb_ns_subclasses_ref_inc(ns_subclasses);
741}
742
743static inline void
744RCLASS_WRITE_NS_MODULE_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses)
745{
746 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
747 if (RCLASSEXT_NS_MODULE_SUBCLASSES(ext))
748 rb_ns_subclasses_ref_dec(RCLASSEXT_NS_MODULE_SUBCLASSES(ext));
749 RCLASSEXT_NS_MODULE_SUBCLASSES(ext) = rb_ns_subclasses_ref_inc(ns_subclasses);
750}
751
752static inline void
753RCLASS_SET_CLASSPATH(VALUE klass, VALUE classpath, bool permanent)
754{
755 rb_classext_t *ext = RCLASS_EXT_READABLE(klass);
756 assert(BUILTIN_TYPE(klass) == T_CLASS || BUILTIN_TYPE(klass) == T_MODULE);
757 assert(classpath == 0 || BUILTIN_TYPE(classpath) == T_STRING);
758
759 RB_OBJ_WRITE(klass, &(RCLASSEXT_CLASSPATH(ext)), classpath);
760 RCLASSEXT_PERMANENT_CLASSPATH(ext) = permanent;
761}
762
763static inline void
764RCLASS_WRITE_CLASSPATH(VALUE klass, VALUE classpath, bool permanent)
765{
766 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
767 assert(BUILTIN_TYPE(klass) == T_CLASS || BUILTIN_TYPE(klass) == T_MODULE);
768 assert(classpath == 0 || BUILTIN_TYPE(classpath) == T_STRING);
769
770 RB_OBJ_WRITE(klass, &(RCLASSEXT_CLASSPATH(ext)), classpath);
771 RCLASSEXT_PERMANENT_CLASSPATH(ext) = permanent;
772}
773
774static inline VALUE
775RCLASS_SET_ATTACHED_OBJECT(VALUE klass, VALUE attached_object)
776{
777 assert(RCLASS_SINGLETON_P(klass));
778
779 RB_OBJ_WRITE(klass, &RCLASS_EXT_PRIME(klass)->as.singleton_class.attached_object, attached_object);
780 return attached_object;
781}
782
783static inline void
784RCLASS_SET_MAX_IV_COUNT(VALUE klass, attr_index_t count)
785{
786 RCLASS_MAX_IV_COUNT(klass) = count;
787}
788
789static inline void
790RCLASS_SET_CLONED(VALUE klass, bool cloned)
791{
792 RCLASSEXT_CLONED(RCLASS_EXT_PRIME(klass)) = cloned;
793}
794
795static inline bool
796RCLASS_INITIALIZED_P(VALUE klass)
797{
798 VM_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_MODULE));
799 return FL_TEST_RAW(klass, RCLASS_IS_INITIALIZED);
800}
801
802#endif /* INTERNAL_CLASS_H */
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
VALUE rb_class_boot(VALUE)
A utility function that wraps class_alloc.
Definition class.c:782
VALUE rb_class_inherited(VALUE, VALUE)
Calls Class::inherited.
Definition class.c:1475
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
Definition class.c:2791
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
Definition fl_type.h:58
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
#define T_MODULE
Old name of RUBY_T_MODULE.
Definition value_type.h:70
#define T_ICLASS
Old name of RUBY_T_ICLASS.
Definition value_type.h:66
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
Definition fl_type.h:131
#define FL_SET
Old name of RB_FL_SET.
Definition fl_type.h:128
#define T_CLASS
Old name of RUBY_T_CLASS.
Definition value_type.h:58
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
Definition value_type.h:85
#define FL_TEST
Old name of RB_FL_TEST.
Definition fl_type.h:130
#define FL_UNSET
Old name of RB_FL_UNSET.
Definition fl_type.h:132
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Definition gc.h:603
VALUE(* rb_alloc_func_t)(VALUE klass)
This is the type of functions that ruby calls when trying to allocate an object.
Definition vm.h:216
C99 shim for <stdbool.h>
Ruby object's base components.
Definition rbasic.h:69
struct rb_subclass_anchor * subclasses
The head of subclasses is a blank (w/o klass) entry to be referred from anchor (and be never deleted)...
Definition class.h:93
rb_ns_subclasses_t * ns_module_subclasses
In the case that this is an ICLASS, ns_module_subclasses points to the link in the module's subclasse...
Definition class.h:107
rb_ns_subclasses_t * ns_super_subclasses
The ns_super_subclasses points the ns_subclasses struct to retreive the subclasses of the super class...
Definition class.h:101
CREF (Class REFerence)
Definition method.h:45
Definition class.h:72
Internal header for Namespace.
Definition namespace.h:14
Internal header for Class.
Definition class.h:30
Definition class.h:65
Definition st.h:79
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376
@ RUBY_T_MODULE
Definition value_type.h:118
@ RUBY_T_CLASS
Definition value_type.h:117