37 #define id_attached id__attached__
44 if (super && super !=
Qundef) {
45 entry =
xmalloc(
sizeof(*entry));
65 entry =
xmalloc(
sizeof(*entry));
66 entry->
klass = iclass;
103 entry = *
RCLASS_EXT(klass)->module_subclasses;
416 #define METACLASS_OF(k) RBASIC(k)->klass
417 #define SET_METACLASS_OF(k, cls) RBASIC_SET_CLASS(k, cls)
424 #define META_CLASS_OF_CLASS_CLASS_P(k) (METACLASS_OF(k) == (k))
431 #define HAVE_METACLASS_P(k) \
432 (FL_TEST(METACLASS_OF(k), FL_SINGLETON) && \
433 rb_ivar_get(METACLASS_OF(k), id_attached) == (k))
442 #define ENSURE_EIGENCLASS(klass) \
443 (HAVE_METACLASS_P(klass) ? METACLASS_OF(klass) : make_metaclass(klass))
590 return rb_funcall(super, inherited, 1, klass);
628 rb_warn(
"no super class for `%s', Object assumed", name);
695 rb_warn(
"no super class for `%s::%s', Object assumed",
778 module =
RBASIC(module)->klass;
836 int method_changed = 0, constant_changed = 0;
840 int superclass_seen =
FALSE;
851 if (!superclass_seen) {
858 superclass_seen =
TRUE;
872 VALUE refined_class =
882 constant_changed = 1;
890 return method_changed;
934 if (origin == klass) {
1052 #define VISI(x) ((x)&NOEX_MASK)
1053 #define VISI_CHECK(x,f) (VISI(x) == (f))
1064 visi = (type == visi);
1134 int recur, prepended = 0;
1403 if (klass != origin && (mtbl =
RCLASS_M_TBL(klass)) != 0)
1510 #define SPECIAL_SINGLETON(x,c) do {\
1551 rb_bug(
"unknown immediate %p", (
void *)obj);
1563 klass =
RBASIC(obj)->klass;
1595 klass =
RBASIC(obj)->klass;
1722 const char *
p =
fmt;
1725 int f_var = 0, f_hash = 0, f_block = 0;
1726 int n_lead = 0, n_opt = 0, n_trail = 0, n_mand;
1761 rb_fatal(
"bad scan arg format: %s", fmt);
1763 n_mand = n_lead + n_trail;
1768 va_start(vargs, fmt);
1771 if (f_hash && n_mand < argc) {
1778 if (!f_var && n_mand + n_opt < argc)
1786 hash = opts ? opts :
Qnil;
1791 for (i = n_lead; i-- > 0; ) {
1792 var = va_arg(vargs,
VALUE *);
1793 if (var) *var = argv[argi];
1797 for (i = n_opt; i-- > 0; ) {
1798 var = va_arg(vargs,
VALUE *);
1799 if (argi < argc - n_trail) {
1800 if (var) *var = argv[argi];
1804 if (var) *var =
Qnil;
1809 int n_var = argc - argi - n_trail;
1811 var = va_arg(vargs,
VALUE *);
1821 for (i = n_trail; i-- > 0; ) {
1822 var = va_arg(vargs,
VALUE *);
1823 if (var) *var = argv[argi];
1828 var = va_arg(vargs,
VALUE *);
1829 if (var) *var =
hash;
1833 var = va_arg(vargs,
VALUE *);
1855 const char *
msg =
"";
1873 for (i = 0; i < keywords; i++) {
1896 VALUE parthash[2] = {0, 0};
1904 *orighash = parthash[1];
1916 #define extract_kwarg(keyword, val) \
1917 (key = (st_data_t)(keyword), values ? \
1918 st_delete(rb_hash_tbl_raw(keyword_hash), &key, (val)) : \
1919 st_lookup(rb_hash_tbl_raw(keyword_hash), key, (val)))
1923 optional = -1-optional;
1926 for (
j = 0;
j < required + optional;
j++) {
1931 for (; i < required; i++) {
1936 if (values) values[
i] = (
VALUE)val;
1943 if (!
NIL_P(missing)) {
1948 if (optional && keyword_hash) {
1949 for (i = 0; i < optional; i++) {
1952 if (values) values[required+
i] = (
VALUE)val;
1957 if (!rest && keyword_hash) {
1963 #undef extract_kwarg
static VALUE make_metaclass(VALUE klass)
Creates a metaclass of klass.
#define RB_TYPE_P(obj, type)
static void rb_module_add_to_subclasses_list(VALUE module, VALUE iclass)
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
void rb_class_remove_from_super_subclasses(VALUE klass)
VALUE rb_const_get_at(VALUE, ID)
#define UNDEFINED_METHOD_ENTRY_P(me)
#define RCLASS_M_TBL_WRAPPER(c)
void rb_class_detach_subclasses(VALUE klass)
VALUE rb_define_module_id_under(VALUE outer, ID id)
RUBY_EXTERN VALUE rb_cBasicObject
void rb_vm_check_redefinition_by_prepend(VALUE klass)
VALUE rb_mod_include_p(VALUE mod, VALUE mod2)
#define RB_OBJ_WRITTEN(a, oldv, b)
void rb_bug(const char *fmt,...)
int rb_vm_add_root_module(ID id, VALUE module)
#define RB_OBJ_WRITE(a, slot, b)
void rb_check_inheritable(VALUE super)
Ensures a class can be derived from super.
RUBY_EXTERN VALUE rb_cNilClass
RUBY_EXTERN VALUE rb_cModule
static int ins_methods_push(ID name, long type, VALUE ary, long visi)
const char * rb_obj_classname(VALUE)
VALUE rb_obj_private_methods(int argc, VALUE *argv, VALUE obj)
#define UNLIMITED_ARGUMENTS
int st_lookup(st_table *, st_data_t, st_data_t *)
void st_add_direct(st_table *, st_data_t, st_data_t)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE))
st_table * st_init_numtable(void)
VALUE rb_class_private_instance_methods(int argc, VALUE *argv, VALUE mod)
VALUE rb_define_class_id_under(VALUE outer, ID id, VALUE super)
Defines a class under the namespace of outer.
void rb_class_remove_from_module_subclasses(VALUE klass)
rb_funcall(memo->yielder, id_lshift, 1, rb_assoc_new(memo->prev_value, memo->prev_elts))
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
SSL_METHOD *(* func)(void)
#define rb_usascii_str_new2
VALUE rb_const_get(VALUE, ID)
static VALUE class_alloc(VALUE flags, VALUE klass)
Allocates a struct RClass for a new class.
union rb_method_definition_struct::@149 body
struct rb_method_entry_struct * orig_me
VALUE rb_mod_ancestors(VALUE mod)
VALUE rb_refinement_module_get_refined_class(VALUE module)
static void RCLASS_M_TBL_INIT(VALUE c)
int rb_st_insert_id_and_value(VALUE obj, st_table *tbl, ID key, VALUE value)
void rb_define_private_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE rb_singleton_class_clone(VALUE obj)
RUBY_EXTERN VALUE rb_cTrueClass
VALUE rb_mod_init_copy(VALUE clone, VALUE orig)
VALUE rb_ary_tmp_new(long capa)
void Init_class_hierarchy(void)
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
static int ins_methods_priv_i(st_data_t name, st_data_t type, st_data_t ary)
void rb_raise(VALUE exc, const char *fmt,...)
#define SET_METACLASS_OF(k, cls)
static int clone_const_i(st_data_t key, st_data_t value, st_data_t data)
#define OBJ_WB_UNPROTECT(x)
void rb_include_module(VALUE klass, VALUE module)
void rb_define_protected_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
struct st_table * rb_hash_tbl_raw(VALUE hash)
void rb_undef_method(VALUE klass, const char *name)
VALUE rb_ivar_get(VALUE, ID)
void rb_name_error(ID id, const char *fmt,...)
void rb_free_m_tbl_wrapper(struct method_table_wrapper *wrapper)
void rb_prepend_module(VALUE klass, VALUE module)
int st_delete(st_table *, st_data_t *, st_data_t *)
VALUE rb_singleton_class(VALUE obj)
Returns the singleton class of obj.
VALUE rb_extract_keywords(VALUE *orighash)
VALUE rb_block_proc(void)
VALUE rb_class_inherited(VALUE super, VALUE klass)
Calls Class::inherited.
int rb_block_given_p(void)
VALUE rb_special_singleton_class(VALUE obj)
#define RGENGC_WB_PROTECTED_CLASS
RUBY_EXTERN VALUE rb_mKernel
static VALUE boot_defclass(const char *name, VALUE super)
#define RARRAY_AREF(a, i)
static void clone_method(VALUE klass, ID mid, const rb_method_entry_t *me)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
static VALUE special_singleton_class_of(VALUE obj)
void rb_class_subclass_add(VALUE super, VALUE klass)
VALUE rb_define_module_id(ID id)
#define META_CLASS_OF_CLASS_CLASS_P(k)
whether k is a meta^(n)-class of Class class
#define OBJ_INIT_COPY(obj, orig)
VALUE rb_check_hash_type(VALUE)
VALUE rb_obj_protected_methods(int argc, VALUE *argv, VALUE obj)
rb_method_entry_t * rb_resolve_refined_method(VALUE refinements, const rb_method_entry_t *me, VALUE *defined_class_ptr)
rb_method_entry_t * rb_method_entry(VALUE klass, ID id, VALUE *define_class_ptr)
int rb_obj_basic_to_s_p(VALUE obj)
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 module.
int st_foreach(st_table *, int(*)(ANYARGS), st_data_t)
static int add_refined_method_entry_i(st_data_t key, st_data_t value, st_data_t data)
static VALUE class_instance_method_list(int argc, VALUE *argv, VALUE mod, int obj, int(*func)(st_data_t, st_data_t, st_data_t))
st_table * rb_st_copy(VALUE obj, struct st_table *orig_tbl)
int rb_const_defined(VALUE, ID)
VALUE rb_include_class_new(VALUE module, VALUE super)
void rb_fatal(const char *fmt,...)
rb_method_entry_t * rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_flag_t noex)
#define CONST_ID(var, str)
void rb_gc_register_mark_object(VALUE)
rb_serial_t rb_next_class_serial(void)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
void rb_attr(VALUE, ID, int, int, int)
static int separate_symbol(st_data_t key, st_data_t value, st_data_t arg)
static int ins_methods_i(st_data_t name, st_data_t type, st_data_t ary)
void rb_const_set(VALUE, ID, VALUE)
#define extract_kwarg(keyword, val)
static int include_modules_at(const VALUE klass, VALUE c, VALUE module)
VALUE rb_obj_public_methods(int argc, VALUE *argv, VALUE obj)
static int ins_methods_pub_i(st_data_t name, st_data_t type, st_data_t ary)
void rb_clear_method_cache_by_class(VALUE)
void rb_alias(VALUE, ID, ID)
int rb_const_defined_at(VALUE, ID)
rb_hash_aset(hash, RARRAY_AREF(key_value_pair, 0), RARRAY_AREF(key_value_pair, 1))
VALUE rb_make_metaclass(VALUE obj, VALUE unused)
static int clone_const(ID key, const rb_const_entry_t *ce, struct clone_const_arg *arg)
void rb_class_detach_module_subclasses(VALUE klass)
rb_subclass_entry_t * next
VALUE rb_class_instance_methods(int argc, VALUE *argv, VALUE mod)
void rb_free_const_table(st_table *tbl)
#define RCLASS_CONST_TBL(c)
#define MEMCPY(p1, p2, type, n)
VALUE rb_define_module_under(VALUE outer, const char *name)
const char * rb_class2name(VALUE)
VALUE rb_class_protected_instance_methods(int argc, VALUE *argv, VALUE mod)
#define NEWOBJ_OF(obj, type, klass, flags)
void rb_define_method_id(VALUE klass, ID mid, VALUE(*func)(ANYARGS), int argc)
VALUE rb_class_public_instance_methods(int argc, VALUE *argv, VALUE mod)
void rb_singleton_class_attached(VALUE klass, VALUE obj)
Attach a object to a singleton class.
static void unknown_keyword_error(VALUE hash, const ID *table, int keywords)
VALUE rb_module_new(void)
#define ENSURE_EIGENCLASS(klass)
ensures klass belongs to its own eigenclass.
VALUE rb_obj_singleton_methods(int argc, VALUE *argv, VALUE obj)
rb_method_definition_t * def
void rb_define_attr(VALUE klass, const char *name, int read, int write)
Defines (a) public accessor method(s) for an attribute.
static VALUE RCLASS_SET_SUPER(VALUE klass, VALUE super)
void rb_error_arity(int argc, int min, int max)
RUBY_EXTERN VALUE rb_cClass
RUBY_EXTERN VALUE rb_cObject
static VALUE make_singleton_class(VALUE obj)
Creates a singleton class for obj.
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
void rb_clear_constant_cache(void)
static int method_entry_i(st_data_t key, st_data_t value, st_data_t data)
VALUE rb_obj_methods(int argc, VALUE *argv, VALUE obj)
#define RBASIC_SET_CLASS(obj, cls)
void rb_add_refined_method_entry(VALUE refined_class, ID mid)
int st_insert(st_table *, st_data_t, st_data_t)
static int ins_methods_prot_i(st_data_t name, st_data_t type, st_data_t ary)
VALUE rb_ary_join(VALUE ary, VALUE sep)
void rb_set_class_path_string(VALUE, VALUE, VALUE)
static int move_refined_method(st_data_t key, st_data_t value, st_data_t data)
void rb_frozen_class_p(VALUE klass)
#define RCLASS_IV_INDEX_TBL(c)
static void class_init_copy_check(VALUE clone, VALUE orig)
#define GetISeqPtr(obj, ptr)
const char * rb_id2name(ID id)
VALUE rb_mod_included_modules(VALUE mod)
VALUE rb_class_real(VALUE)
VALUE rb_define_class_id(ID id, VALUE super)
Defines a new class.
#define SPECIAL_SINGLETON(x, c)
rb_method_entry_t * rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_flag_t noex)
#define RMODULE_IS_REFINEMENT
#define SPECIAL_CONST_P(x)
VALUE rb_define_module(const char *name)
RUBY_EXTERN VALUE rb_cFalseClass
void rb_name_class(VALUE, ID)
static void keyword_error(const char *error, VALUE keys)
static VALUE singleton_class_of(VALUE obj)
static int clone_method_i(st_data_t key, st_data_t value, st_data_t data)
#define RCLASS_REFINED_CLASS(c)
void rb_add_method_cfunc(VALUE klass, ID mid, VALUE(*func)(ANYARGS), int argc, rb_method_flag_t noex)
VALUE rb_iseq_clone(VALUE iseqval, VALUE newcbase)
VALUE rb_class_new(VALUE super)
Creates a new class.
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
void rb_warn(const char *fmt,...)
VALUE rb_class_boot(VALUE super)
A utility function that wraps class_alloc.
void rb_vm_rewrite_cref_stack(NODE *node, VALUE old_klass, VALUE new_klass, NODE **new_cref_ptr)
void st_free_table(st_table *)
#define RMODULE_CONST_TBL(m)
VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
#define RMODULE_INCLUDED_INTO_REFINEMENT