void rb_prepend_module(VALUE klass, VALUE module) { void rb_vm_check_redefinition_by_prepend(VALUE klass); VALUE origin; int changed = 0; rb_frozen_class_p(klass); Check_Type(module, T_MODULE); OBJ_INFECT(klass, module); origin = RCLASS_ORIGIN(klass); if (origin == klass) { origin = class_alloc(T_ICLASS, klass); RCLASS_SET_SUPER(origin, RCLASS_SUPER(klass)); RCLASS_SET_SUPER(klass, origin); RCLASS_ORIGIN(klass) = origin; RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass); RCLASS_M_TBL(klass) = st_init_numtable(); st_foreach(RCLASS_M_TBL(origin), move_refined_method, (st_data_t) RCLASS_M_TBL(klass)); } changed = include_modules_at(klass, klass, module); if (changed < 0) rb_raise(rb_eArgError, "cyclic prepend detected"); if (changed) { rb_clear_cache(); rb_vm_check_redefinition_by_prepend(klass); } }
void rb_prepend_module(VALUE klass, VALUE module) { void rb_vm_check_redefinition_by_prepend(VALUE klass); VALUE origin; int changed = 0; rb_frozen_class_p(klass); Check_Type(module, T_MODULE); OBJ_INFECT(klass, module); origin = RCLASS_ORIGIN(klass); if (origin == klass) { origin = class_alloc(T_ICLASS, klass); OBJ_WB_UNPROTECT(origin); /* TODO: conservertive shading. Need more survery. */ RCLASS_SET_SUPER(origin, RCLASS_SUPER(klass)); RCLASS_SET_SUPER(klass, origin); RCLASS_ORIGIN(klass) = origin; RCLASS_M_TBL_WRAPPER(origin) = RCLASS_M_TBL_WRAPPER(klass); RCLASS_M_TBL_INIT(klass); st_foreach(RCLASS_M_TBL(origin), move_refined_method, (st_data_t) RCLASS_M_TBL(klass)); } changed = include_modules_at(klass, klass, module); if (changed < 0) rb_raise(rb_eArgError, "cyclic prepend detected"); if (changed) { rb_vm_check_redefinition_by_prepend(klass); } }
/* call-seq: * set_singleton_class(klass) -> klass * * Makes the given +klass+ the singleton class of the receiver, * ignoring any existing singleton class and modules extending the receiver. * Modules already included in +klass+ become modules that extend the receiver. * If the receiver is an immediate or +klass+ is not a Class, * raises +TypeError+. */ static VALUE evilr_set_singleton_class(VALUE self, VALUE klass) { evilr__check_obj_and_class(self, klass); RCLASS_SET_SUPER(evilr__iclass_before_next_class(klass), rb_obj_class(self)); rb_clear_cache_by_class(klass); evilr__make_singleton(self, klass); return klass; }
/*! * Creates a metaclass of \a klass * \param klass a class * \return created metaclass for the class * \pre \a klass is a Class object * \pre \a klass has no singleton class. * \post the class of \a klass is the returned class. * \post the returned class is meta^(n+1)-class when \a klass is a meta^(n)-klass for n >= 0 */ static inline VALUE make_metaclass(VALUE klass) { VALUE super; VALUE metaclass = rb_class_boot(Qundef); FL_SET(metaclass, FL_SINGLETON); rb_singleton_class_attached(metaclass, klass); if (META_CLASS_OF_CLASS_CLASS_P(klass)) { SET_METACLASS_OF(klass, metaclass); SET_METACLASS_OF(metaclass, metaclass); } else { VALUE tmp = METACLASS_OF(klass); /* for a meta^(n)-class klass, tmp is meta^(n)-class of Class class */ SET_METACLASS_OF(klass, metaclass); SET_METACLASS_OF(metaclass, ENSURE_EIGENCLASS(tmp)); } super = RCLASS_SUPER(klass); while (RB_TYPE_P(super, T_ICLASS)) super = RCLASS_SUPER(super); RCLASS_SET_SUPER(metaclass, super ? ENSURE_EIGENCLASS(super) : rb_cClass); OBJ_INFECT(metaclass, RCLASS_SUPER(metaclass)); return metaclass; }
VALUE rb_include_class_new(VALUE module, VALUE super) { VALUE klass = class_alloc(T_ICLASS, rb_cClass); if (BUILTIN_TYPE(module) == T_ICLASS) { module = RBASIC(module)->klass; } if (!RCLASS_IV_TBL(module)) { RCLASS_IV_TBL(module) = st_init_numtable(); } if (!RCLASS_CONST_TBL(module)) { RCLASS_CONST_TBL(module) = st_init_numtable(); } RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module); RCLASS_CONST_TBL(klass) = RCLASS_CONST_TBL(module); RCLASS_M_TBL_WRAPPER(OBJ_WB_UNPROTECT(klass)) = RCLASS_M_TBL_WRAPPER(OBJ_WB_UNPROTECT(RCLASS_ORIGIN(module))); RCLASS_SET_SUPER(klass, super); if (RB_TYPE_P(module, T_ICLASS)) { RBASIC_SET_CLASS(klass, RBASIC(module)->klass); } else { RBASIC_SET_CLASS(klass, module); } OBJ_INFECT(klass, module); OBJ_INFECT(klass, super); return (VALUE)klass; }
static int include_modules_at(const VALUE klass, VALUE c, VALUE module) { VALUE p, iclass; int method_changed = 0, constant_changed = 0; const st_table *const klass_m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(klass)); while (module) { int superclass_seen = FALSE; if (RCLASS_ORIGIN(module) != module) goto skip; if (klass_m_tbl && klass_m_tbl == RCLASS_M_TBL(module)) return -1; /* ignore if the module included already in superclasses */ for (p = RCLASS_SUPER(klass); p; p = RCLASS_SUPER(p)) { switch (BUILTIN_TYPE(p)) { case T_ICLASS: if (RCLASS_M_TBL_WRAPPER(p) == RCLASS_M_TBL_WRAPPER(module)) { if (!superclass_seen) { c = p; /* move insertion point */ } goto skip; } break; case T_CLASS: superclass_seen = TRUE; break; } } iclass = rb_include_class_new(module, RCLASS_SUPER(c)); c = RCLASS_SET_SUPER(c, iclass); if (BUILTIN_TYPE(module) == T_ICLASS) { rb_module_add_to_subclasses_list(RBASIC(module)->klass, iclass); } else { rb_module_add_to_subclasses_list(module, iclass); } if (FL_TEST(klass, RMODULE_IS_REFINEMENT)) { VALUE refined_class = rb_refinement_module_get_refined_class(klass); st_foreach(RMODULE_M_TBL(module), add_refined_method_entry_i, (st_data_t) refined_class); FL_SET(c, RMODULE_INCLUDED_INTO_REFINEMENT); } if (RMODULE_M_TBL(module) && RMODULE_M_TBL(module)->num_entries) method_changed = 1; if (RMODULE_CONST_TBL(module) && RMODULE_CONST_TBL(module)->num_entries) constant_changed = 1; skip: module = RCLASS_SUPER(module); } if (method_changed) rb_clear_method_cache_by_class(klass); if (constant_changed) rb_clear_constant_cache(); return method_changed; }
void rb_extend_object(VALUE obj, VALUE module) { VALUE klass; if (TYPE(obj) == T_CLASS && RCLASS_RUBY(obj)) { VALUE sklass = rb_make_singleton_class(RCLASS_SUPER(obj)); RCLASS_SET_SUPER(obj, sklass); klass = *(VALUE *)sklass; } else { klass = rb_singleton_class(obj); } rb_include_module(klass, module); VALUE m = module; do { VALUE ary = rb_attr_get(m, idIncludedModules); if (ary != Qnil) { for (int i = 0, count = RARRAY_LEN(ary); i < count; i++) { VALUE mod = RARRAY_AT(ary, i); rb_extend_object(obj, mod); } } m = RCLASS_SUPER(m); } while (m == 0 || RCLASS_SINGLETON(m)); }
static VALUE rb_mod_append_features(VALUE module, SEL sel, VALUE include) { VALUE orig = include; switch (TYPE(include)) { case T_CLASS: case T_MODULE: break; default: Check_Type(include, T_CLASS); break; } if (RCLASS_RUBY(include)) { VALUE sinclude = rb_make_singleton_class(RCLASS_SUPER(include)); RCLASS_SET_SUPER(include, sinclude); include = sinclude; } rb_include_module2(include, orig, module, true, true); VALUE m = module; do { VALUE ary = rb_attr_get(m, idIncludedModules); if (ary != Qnil) { for (int i = 0, count = RARRAY_LEN(ary); i < count; i++) { VALUE mod = RARRAY_AT(ary, i); rb_mod_append_features(mod, sel, include); } } m = RCLASS_SUPER(m); } while (m == 0 || RCLASS_SINGLETON(m)); return module; }
/* call-seq: * superclass=(klass) -> klass * * Modifies the superclass of the current class to be the given * class. Any modules included in the receiver remain included. * Raises +TypeError+ if klass is not a Class or if the receiver * and class are not compatible (where their instances use * different internal types). */ static VALUE evilr_superclass_e(VALUE klass, VALUE super) { VALUE iclass; evilr__check_compatible_classes(klass, super); iclass = evilr__iclass_before_next_class(klass); RCLASS_SET_SUPER(iclass, super); rb_clear_cache_by_class(klass); return super; }
/* call-seq: * to_class(klass=Object) -> Class * * Makes a copy of the module, converts the copy to a class, and returns it. The * returned class can then have instances created from it. The +klass+ argument * sets the superclass of the returned class. If +klass+ is not a Class, * raises +TypeError+. */ static VALUE evilr_to_class(int argc, VALUE *argv, VALUE self) { VALUE klass = evilr__optional_class(argc, argv); self = rb_obj_clone(self); RBASIC_SET_KLASS(self, rb_singleton_class(klass)); RCLASS_SET_SUPER(self, klass); FL_UNSET(self, T_MASK); FL_SET(self, T_CLASS); return self; }
/* If self has a singleton class, set the superclass of the * singleton class to the given klass, keeping all modules * that are included in the singleton class. Otherwise, set the * object's klass to the given klass. */ void evilr__reparent_singleton_class(VALUE self, VALUE klass) { VALUE self_klass = RBASIC_KLASS(self); if (IS_SINGLETON_CLASS(self_klass)) { RCLASS_SET_SUPER(evilr__iclass_before_next_class(self_klass), klass); rb_clear_cache_by_class(self_klass); } else { RBASIC_SET_KLASS(self, klass); } }
VALUE rb_mod_init_copy(VALUE clone, SEL sel, VALUE orig) { rb_obj_init_copy(clone, 0, orig); VALUE super; if (!RCLASS_RUBY(orig)) { super = orig; rb_warn("cloning class `%s' is not supported, creating a " \ "subclass instead", rb_class2name(orig)); } else { super = RCLASS_SUPER(orig); } RCLASS_SET_SUPER(clone, super); // Copy flags. unsigned long version_flag = RCLASS_IS_RUBY_CLASS; if ((RCLASS_VERSION(super) & RCLASS_IS_OBJECT_SUBCLASS) == RCLASS_IS_OBJECT_SUBCLASS) { version_flag |= RCLASS_IS_OBJECT_SUBCLASS; } if (RCLASS_MODULE(orig)) { version_flag |= RCLASS_IS_MODULE; } RCLASS_SET_VERSION(clone, version_flag); if (!class_isMetaClass((Class)clone)) { // Clear type info. RCLASS_SET_VERSION(*(Class *)clone, RCLASS_VERSION(*(Class *)clone)); } // Copy methods. rb_vm_copy_methods((Class)orig, (Class)clone); if (!class_isMetaClass((Class)orig)) { rb_vm_copy_methods(*(Class *)orig, *(Class *)clone); } // Copy ivars. CFMutableDictionaryRef orig_dict = rb_class_ivar_dict(orig); CFMutableDictionaryRef clone_dict; if (orig_dict != NULL) { clone_dict = CFDictionaryCreateMutableCopy(NULL, 0, orig_dict); rb_class_ivar_set_dict(clone, clone_dict); CFMakeCollectable(clone_dict); } else { clone_dict = rb_class_ivar_dict_or_create(clone); } // Remove the classpath & classid (name) so that they are not // copied over the new module / class. CFDictionaryRemoveValue(clone_dict, (const void *)id_classpath); CFDictionaryRemoveValue(clone_dict, (const void *)id_classid); return clone; }
/*! * A utility function that wraps class_alloc. * * allocates a class and initializes safely. * \param super a class from which the new class derives. * \return a class object. * \pre \a super must be a class. * \post the metaclass of the new class is Class. */ VALUE rb_class_boot(VALUE super) { VALUE klass = class_alloc(T_CLASS, rb_cClass); RCLASS_SET_SUPER(klass, super); RCLASS_M_TBL(klass) = st_init_numtable(); OBJ_INFECT(klass, super); return (VALUE)klass; }
/*! * A utility function that wraps class_alloc. * * allocates a class and initializes safely. * \param super a class from which the new class derives. * \return a class object. * \pre \a super must be a class. * \post the metaclass of the new class is Class. */ VALUE rb_class_boot(VALUE super) { VALUE klass = class_alloc(T_CLASS, rb_cClass); RCLASS_SET_SUPER(klass, super); RCLASS_M_TBL_INIT(klass); OBJ_INFECT(klass, super); return (VALUE)klass; }
/* :nodoc: */ VALUE rb_mod_init_copy(VALUE clone, SEL sel, VALUE orig) { static ID classpath = 0; static ID classid = 0; rb_obj_init_copy(clone, 0, orig); { VALUE super; unsigned long version_flag; if (!RCLASS_RUBY(orig)) { super = orig; rb_warn("cloning class `%s' is not supported, creating a " \ "subclass instead", rb_class2name(orig)); } else { super = RCLASS_SUPER(orig); } RCLASS_SET_SUPER(clone, super); version_flag = RCLASS_IS_RUBY_CLASS; if ((RCLASS_VERSION(super) & RCLASS_IS_OBJECT_SUBCLASS) == RCLASS_IS_OBJECT_SUBCLASS) { version_flag |= RCLASS_IS_OBJECT_SUBCLASS; } RCLASS_SET_VERSION(clone, version_flag); rb_vm_copy_methods((Class)orig, (Class)clone); CFMutableDictionaryRef ivar_dict = rb_class_ivar_dict(orig); if (ivar_dict != NULL) { CFMutableDictionaryRef cloned_ivar_dict; if (classpath == 0) { classpath = rb_intern("__classpath__"); } if (classid == 0) { classid = rb_intern("__classid__"); } cloned_ivar_dict = CFDictionaryCreateMutableCopy(NULL, 0, (CFDictionaryRef)ivar_dict); // Remove the classpath & classid (name) so that they are not // copied over the new module / class CFDictionaryRemoveValue(cloned_ivar_dict, (const void *)classpath); CFDictionaryRemoveValue(cloned_ivar_dict, (const void *)classid); CFMakeCollectable(cloned_ivar_dict); rb_class_ivar_set_dict(clone, cloned_ivar_dict); } } return clone; }
/* Empty is an almost completely empty class, even more basic than * BasicObject. It has no parent class, and only implements * +allocate+, +new+, +initialize+, and +superclass+. All other * behavior must be added by the user. Note that if you want to * call a method defined in Object, Kernel, or BasicObject that * isn't defined in Empty, you can use <tt>UndefinedMethod#force_bind</tt>, * to do so: * * Object.instance_method(:puts).force_bind(Empty.new).call() */ void Init_evilr(void) { empty = rb_define_class("Empty", rb_cObject); rb_define_alloc_func(empty, evilr_empty_alloc); rb_define_singleton_method(empty, "new", evilr_empty_new, -1); rb_define_singleton_method(empty, "superclass", evilr_empty_superclass, 0); rb_define_method(empty, "initialize", evilr_empty_initialize, 0); RCLASS_SET_SUPER(empty, NULL); rb_global_variable(&empty); evilr__attached = rb_intern("__attached__"); evilr__bind = rb_intern("bind"); evilr__clone = rb_intern("clone"); rb_define_method(rb_cObject, "class=", evilr_class_e, 1); rb_define_method(rb_cObject, "evilr_debug_print", evilr_debug_print, 0); rb_define_method(rb_cObject, "extend_between", evilr_extend_between, 1); rb_define_method(rb_cObject, "flags", evilr_flags, 0); rb_define_method(rb_cObject, "detach_singleton_class", evilr_detach_singleton_class, 0); rb_define_method(rb_cObject, "dup_singleton_class", evilr_dup_singleton_class, -1); rb_define_method(rb_cObject, "pop_singleton_class", evilr_pop_singleton_class, 0); rb_define_method(rb_cObject, "push_singleton_class", evilr_push_singleton_class, 1); rb_define_method(rb_cObject, "remove_singleton_class", evilr_remove_singleton_class, 0); rb_define_method(rb_cObject, "remove_singleton_classes", evilr_remove_singleton_classes, 0); rb_define_method(rb_cObject, "set_singleton_class", evilr_set_singleton_class, 1); rb_define_method(rb_cObject, "swap", evilr_swap, 1); rb_define_method(rb_cObject, "swap_instance_variables", evilr_swap_instance_variables, 1); rb_define_method(rb_cObject, "swap_singleton_class", evilr_swap_singleton_class, 1); rb_define_method(rb_cObject, "unextend", evilr_unextend, 1); rb_define_method(rb_cObject, "unfreeze", evilr_unfreeze, 0); rb_define_method(rb_mKernel, "segfault", evilr_segfault, 0); rb_define_method(rb_mKernel, "seppuku", evilr_seppuku, 0); rb_define_method(rb_mKernel, "set_safe_level", evilr_set_safe_level, 1); rb_define_method(rb_cModule, "include_between", evilr_include_between, 1); rb_define_method(rb_cModule, "swap_method_tables", evilr_swap_method_tables, 1); rb_define_method(rb_cModule, "to_class", evilr_to_class, -1); rb_define_method(rb_cModule, "uninclude", evilr_uninclude, 1); rb_define_method(rb_cClass, "detach_singleton", evilr_detach_singleton, 0); rb_define_method(rb_cClass, "inherit", evilr_inherit, -1); rb_define_method(rb_cClass, "singleton_class_instance", evilr_singleton_class_instance, 0); rb_define_method(rb_cClass, "superclass=", evilr_superclass_e, 1); rb_define_method(rb_cClass, "to_module", evilr_to_module, 0); rb_define_method(rb_cUnboundMethod, "force_bind", evilr_force_bind, 1); rb_define_method(rb_cProc, "self", evilr_self, 0); rb_define_method(rb_cProc, "self=", evilr_self_e, 1); }
/* call-seq: * include_between(mod){|p, c| } -> mod || nil * * Walks the receiver's super chain, yielding the previous and current entries in * the super chain at every step. The first time the block returns +true+, +mod+ is * inserted into the super chain between the two values, and the method returns * immediately. Raises +TypeError+ if +mod+ is not a Module. * If the block ever returns +true+, the return value is +mod+. If * the block never returns +true+, the return value is +nil+. On the first block call, * the first block argument is the receiver, and on the last block call, the last block * argument is +nil+. */ static VALUE evilr_include_between(VALUE klass, VALUE mod) { VALUE iclass, prev, cur; evilr__check_immediate(mod); evilr__check_type(T_MODULE, mod); /* Create ICLASS for module by inserting it and removing it. * If module already in super chain, will change it's position. */ rb_include_module(klass, mod); iclass = evilr__iclass_matching(klass, mod); evilr_uninclude(klass, mod); for (prev = klass, cur = RCLASS_SUPER(klass); prev ; prev = cur, cur = cur ? RCLASS_SUPER(cur) : cur) { if (BUILTIN_TYPE(prev) == T_CLASS) { rb_clear_cache_by_class(prev); } if (rb_yield_values(2, INCLUDE_BETWEEN_VAL(prev), INCLUDE_BETWEEN_VAL(cur)) == Qtrue) { RCLASS_SET_SUPER(prev, iclass); RCLASS_SET_SUPER(iclass, cur); return mod; } } return Qnil; }
/* call-seq: * extend_between(mod){|p, c| } -> mod || nil * * Walks the receiver's singleton class's super chain until it reaches the receiver's * class, yielding the previous and current entries in the super chain at every step. * The first time the block returns +true+, +mod+ is inserted into the super chain * between the two values and the method returns immediately. Raises +TypeError+ if * +mod+ is not a Module or if the receiver is an immediate. * If the block ever returns +true+, the return value is * +mod+. If the block never returns +true+, the return value is +nil+. On the first block call, * the first block argument is the receiver's singleton class, and on the last block call, * the last block argument is the receiver's class. */ static VALUE evilr_extend_between(VALUE self, VALUE mod) { VALUE sc, iclass, klass, prev, cur; evilr__check_immediates(self, mod); evilr__check_type(T_MODULE, mod); sc = rb_singleton_class(self); klass = rb_obj_class(self); rb_extend_object(self, mod); iclass = evilr__iclass_matching_before(sc, mod, klass); if (iclass == NULL) { rb_raise(rb_eArgError, "module already included in object's class"); } evilr_unextend(self, mod); for (prev = sc, cur = RCLASS_SUPER(sc); prev && prev != klass; prev = cur, cur = cur ? RCLASS_SUPER(cur) : cur) { if (rb_yield_values(2, INCLUDE_BETWEEN_VAL(prev), INCLUDE_BETWEEN_VAL(cur)) == Qtrue) { RCLASS_SET_SUPER(prev, iclass); RCLASS_SET_SUPER(iclass, cur); return mod; } } return Qnil; }
/** * Allocates a struct RClass for a new class. * * \param flags initial value for basic.flags of the returned class. * \param klass the class of the returned class. * \return an uninitialized Class object. * \pre \p klass must refer \c Class class or an ancestor of Class. * \pre \code (flags | T_CLASS) != 0 \endcode * \post the returned class can safely be \c #initialize 'd. * * \note this function is not Class#allocate. */ static VALUE class_alloc(VALUE flags, VALUE klass) { NEWOBJ_OF(obj, struct RClass, klass, (flags & T_MASK) | (RGENGC_WB_PROTECTED_CLASS ? FL_WB_PROTECTED : 0)); obj->ptr = ALLOC(rb_classext_t); RCLASS_IV_TBL(obj) = 0; RCLASS_CONST_TBL(obj) = 0; RCLASS_M_TBL(obj) = 0; RCLASS_SET_SUPER((VALUE)obj, 0); RCLASS_ORIGIN(obj) = (VALUE)obj; RCLASS_IV_INDEX_TBL(obj) = 0; RCLASS_REFINED_CLASS(obj) = Qnil; RCLASS_EXT(obj)->allocator = 0; return (VALUE)obj; }
/* :nodoc: */ VALUE rb_mod_init_copy(VALUE clone, VALUE orig) { if (RB_TYPE_P(clone, T_CLASS)) { class_init_copy_check(clone, orig); } if (!OBJ_INIT_COPY(clone, orig)) return clone; if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) { RBASIC_SET_CLASS(clone, rb_singleton_class_clone(orig)); rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone); } RCLASS_SET_SUPER(clone, RCLASS_SUPER(orig)); RCLASS_EXT(clone)->allocator = RCLASS_EXT(orig)->allocator; if (RCLASS_IV_TBL(orig)) { st_data_t id; if (RCLASS_IV_TBL(clone)) { st_free_table(RCLASS_IV_TBL(clone)); } RCLASS_IV_TBL(clone) = rb_st_copy(clone, RCLASS_IV_TBL(orig)); CONST_ID(id, "__tmp_classpath__"); st_delete(RCLASS_IV_TBL(clone), &id, 0); CONST_ID(id, "__classpath__"); st_delete(RCLASS_IV_TBL(clone), &id, 0); CONST_ID(id, "__classid__"); st_delete(RCLASS_IV_TBL(clone), &id, 0); } if (RCLASS_CONST_TBL(orig)) { struct clone_const_arg arg; if (RCLASS_CONST_TBL(clone)) { rb_free_const_table(RCLASS_CONST_TBL(clone)); } RCLASS_CONST_TBL(clone) = st_init_numtable(); arg.klass = clone; arg.tbl = RCLASS_CONST_TBL(clone); st_foreach(RCLASS_CONST_TBL(orig), clone_const_i, (st_data_t)&arg); } if (RCLASS_M_TBL(orig)) { if (RCLASS_M_TBL_WRAPPER(clone)) { rb_free_m_tbl_wrapper(RCLASS_M_TBL_WRAPPER(clone)); } RCLASS_M_TBL_INIT(clone); st_foreach(RCLASS_M_TBL(orig), clone_method_i, (st_data_t)clone); } return clone; }
/* call-seq: * unextend(mod) -> mod || nil * * Unextends the given module +mod+ from the receiver. If the receiver's class includes the * module, does not uninclude it, so this should not affect any other objects besides the * receiver. If +mod+ already extended the object, returns +mod+, otherwise returns +nil+. * Raises +TypeError+ if +mod+ is not a Module or if the receiver is an immediate. */ static VALUE evilr_unextend(VALUE self, VALUE mod) { VALUE prev, cur; evilr__check_immediates(self, mod); evilr__check_type(T_MODULE, mod); self = rb_singleton_class(self); rb_clear_cache_by_class(self); for (prev = self, cur = RCLASS_SUPER(self); cur && BUILTIN_TYPE(cur) != T_CLASS; prev = cur, cur = RCLASS_SUPER(cur)) { if (BUILTIN_TYPE(cur) == T_ICLASS && RBASIC_KLASS(cur) == mod) { RCLASS_SET_SUPER(prev, RCLASS_SUPER(cur)); return mod; } } return Qnil; }
/* call-seq: * uninclude(mod) -> mod || nil * * Unincludes the given module +mod+ from the receiver or any of the receiver's * ancestors. Walks the super chain of the receiver, and if an iclass for +mod+ is * encountered, the super chain is modified to skip that iclass. Returns +mod+ if * an iclass for mod was present in the super chain, and +nil+ otherwise. If +mod+ is * not a Module, a +TypeError+ is raised. */ static VALUE evilr_uninclude(VALUE klass, VALUE mod) { VALUE cur, prev; evilr__check_immediate(mod); evilr__check_type(T_MODULE, mod); for (prev = klass, cur = RCLASS_SUPER(klass); cur ; prev = cur, cur = RCLASS_SUPER(cur)) { if (BUILTIN_TYPE(prev) == T_CLASS) { rb_clear_cache_by_class(prev); } if (BUILTIN_TYPE(cur) == T_ICLASS && RBASIC_KLASS(cur) == mod) { RCLASS_SET_SUPER(prev, RCLASS_SUPER(cur)); return mod; } } return Qnil; }
VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach) { VALUE klass = RBASIC(obj)->klass; if (!FL_TEST(klass, FL_SINGLETON)) return klass; else { /* copy singleton(unnamed) class */ VALUE clone = class_alloc(RBASIC(klass)->flags, 0); if (BUILTIN_TYPE(obj) == T_CLASS) { RBASIC_SET_CLASS(clone, clone); } else { RBASIC_SET_CLASS(clone, rb_singleton_class_clone(klass)); } RCLASS_SET_SUPER(clone, RCLASS_SUPER(klass)); RCLASS_EXT(clone)->allocator = RCLASS_EXT(klass)->allocator; if (RCLASS_IV_TBL(klass)) { RCLASS_IV_TBL(clone) = rb_st_copy(clone, RCLASS_IV_TBL(klass)); } if (RCLASS_CONST_TBL(klass)) { struct clone_const_arg arg; RCLASS_CONST_TBL(clone) = st_init_numtable(); arg.klass = clone; arg.tbl = RCLASS_CONST_TBL(clone); st_foreach(RCLASS_CONST_TBL(klass), clone_const_i, (st_data_t)&arg); } if (attach != Qundef) { rb_singleton_class_attached(clone, attach); } RCLASS_M_TBL_INIT(clone); st_foreach(RCLASS_M_TBL(klass), clone_method_i, (st_data_t)clone); rb_singleton_class_attached(RBASIC(clone)->klass, clone); FL_SET(clone, FL_SINGLETON); return clone; } }
/* call-seq: * to_module -> Module * * Makes a copy of the class, converts the copy to a module, and returns it. The * returned module can be included in other classes. */ static VALUE evilr_to_module(VALUE klass) { VALUE mod, iclass; if (IS_SINGLETON_CLASS(klass)) { if((mod = evilr_singleton_class_instance(klass))) { mod = rb_singleton_class_clone(mod); (void)evilr_detach_singleton(mod); } else { rb_raise(rb_eTypeError, "singleton class without attached instance"); } } else { mod = rb_obj_clone(klass); } RBASIC_SET_KLASS(mod, rb_cModule); iclass = RCLASS_SUPER(mod); RCLASS_SET_SUPER(mod, NULL); FL_UNSET(mod, T_MASK); FL_SET(mod, T_MODULE); evilr__include_iclasses(mod, iclass); return mod; }
/* Set the superclass of self to the given klass, keeping all * modules that are included in the class. */ void evilr__reparent_class(VALUE self, VALUE klass) { RCLASS_SET_SUPER(evilr__iclass_before_next_class(self), klass); rb_clear_cache_by_class(self); }