Index: src/OFApplication.h ================================================================== --- src/OFApplication.h +++ src/OFApplication.h @@ -26,16 +26,16 @@ @class OFMutableArray OF_GENERIC(ObjectType); @class OFMutableDictionary OF_GENERIC(KeyType, ObjectType); @class OFSandbox; @class OFString; -#define OF_APPLICATION_DELEGATE(cls) \ +#define OF_APPLICATION_DELEGATE(class_) \ int \ main(int argc, char *argv[]) \ { \ return of_application_main(&argc, &argv, \ - (cls *)[[cls alloc] init]); \ + (class_ *)[[class_ alloc] init]); \ } #ifdef OF_HAVE_PLEDGE # define OF_HAVE_SANDBOX #endif Index: src/OFBlock.m ================================================================== --- src/OFBlock.m +++ src/OFBlock.m @@ -101,12 +101,12 @@ 8, OBJC_CLASS_INFO_CLASS, sizeof(of_block_literal_t), NULL, NULL }; static struct { unsigned long unknown; - struct objc_abi_selector *sel_refs; - uint16_t cls_def_cnt, cat_def_cnt; + struct objc_abi_selector *selectorRefs; + uint16_t classDefsCount, categoryDefsCount; void *defs[4]; } symtab = { 0, NULL, 3, 0, { &_NSConcreteStackBlock, &_NSConcreteGlobalBlock, @@ -308,50 +308,50 @@ break; } } void -_Block_object_dispose(const void *obj_, const int flags_) +_Block_object_dispose(const void *object_, const int flags_) { const int flags = flags_ & (OF_BLOCK_FIELD_IS_BLOCK | OF_BLOCK_FIELD_IS_OBJECT | OF_BLOCK_FIELD_IS_BYREF); - if (obj_ == NULL) + if (object_ == NULL) return; switch (flags) { case OF_BLOCK_FIELD_IS_BLOCK: - _Block_release(obj_); + _Block_release(object_); break; case OF_BLOCK_FIELD_IS_OBJECT: if (!(flags_ & OF_BLOCK_BYREF_CALLER)) - [(id)obj_ release]; + [(id)object_ release]; break; case OF_BLOCK_FIELD_IS_BYREF:; - of_block_byref_t *obj = (of_block_byref_t *)obj_; + of_block_byref_t *object = (of_block_byref_t *)object_; - obj = obj->forwarding; + object = object->forwarding; #ifdef OF_HAVE_ATOMIC_OPS - if ((of_atomic_int_dec(&obj->flags) & + if ((of_atomic_int_dec(&object->flags) & OF_BLOCK_REFCOUNT_MASK) == 0) { - if (obj->flags & OF_BLOCK_HAS_COPY_DISPOSE) - obj->byref_dispose(obj); + if (object->flags & OF_BLOCK_HAS_COPY_DISPOSE) + object->byref_dispose(object); - free(obj); + free(object); } #else - unsigned hash = SPINLOCK_HASH(obj); + unsigned hash = SPINLOCK_HASH(object); OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash])); - if ((--obj->flags & OF_BLOCK_REFCOUNT_MASK) == 0) { + if ((--object->flags & OF_BLOCK_REFCOUNT_MASK) == 0) { OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash])); - if (obj->flags & OF_BLOCK_HAS_COPY_DISPOSE) - obj->byref_dispose(obj); + if (object->flags & OF_BLOCK_HAS_COPY_DISPOSE) + object->byref_dispose(object); - free(obj); + free(object); } OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash])); #endif break; } Index: src/OFObject.m ================================================================== --- src/OFObject.m +++ src/OFObject.m @@ -142,13 +142,13 @@ { @throw [OFEnumerationMutationException exceptionWithObject: object]; } void OF_NO_RETURN_FUNC -of_method_not_found(id obj, SEL sel) +of_method_not_found(id object, SEL selector) { - [obj doesNotRecognizeSelector: sel]; + [object doesNotRecognizeSelector: selector]; /* * Just in case doesNotRecognizeSelector: returned, even though it must * never return. */ @@ -156,13 +156,13 @@ OF_UNREACHABLE } void OF_NO_RETURN_FUNC -of_method_not_found_stret(void *st, id obj, SEL sel) +of_method_not_found_stret(void *stret, id object, SEL selector) { - of_method_not_found(obj, sel); + of_method_not_found(object, selector); } id of_alloc_object(Class class, size_t extraSize, size_t extraAlignment, void **extra) Index: src/foundation-compat.m ================================================================== --- src/foundation-compat.m +++ src/foundation-compat.m @@ -41,13 +41,13 @@ { return [OFAutoreleasePool alloc]; } static void -addObject(Class self, SEL _cmd, id obj) +addObject(Class self, SEL _cmd, id object) { - [OFAutoreleasePool addObject: obj]; + [OFAutoreleasePool addObject: object]; } static id autorelease(id self, SEL _cmd) { Index: src/instance.m ================================================================== --- src/instance.m +++ src/instance.m @@ -17,85 +17,85 @@ #include "config.h" #import "OFObject.h" -static SEL constructSel = NULL; -static SEL destructSel = NULL; +static SEL constructSelector = NULL; +static SEL destructSelector = NULL; static bool -callConstructors(Class cls, id obj) +callConstructors(Class class, id object) { - Class super = class_getSuperclass(cls); + Class super = class_getSuperclass(class); id (*construct)(id, SEL); id (*last)(id, SEL); if (super != nil) - if (!callConstructors(super, obj)) + if (!callConstructors(super, object)) return false; - if (constructSel == NULL) - constructSel = sel_registerName(".cxx_construct"); + if (constructSelector == NULL) + constructSelector = sel_registerName(".cxx_construct"); - if (!class_respondsToSelector(cls, constructSel)) + if (!class_respondsToSelector(class, constructSelector)) return true; construct = (id (*)(id, SEL)) - class_getMethodImplementation(cls, constructSel); + class_getMethodImplementation(class, constructSelector); last = (id (*)(id, SEL)) - class_getMethodImplementation(super, constructSel); + class_getMethodImplementation(super, constructSelector); if (construct == last) return true; - return (construct(obj, constructSel) != nil); + return (construct(object, constructSelector) != nil); } id -objc_constructInstance(Class cls, void *bytes) +objc_constructInstance(Class class, void *bytes) { - id obj = (id)bytes; + id object = (id)bytes; + + if (class == Nil || bytes == NULL) + return nil; + + object_setClass(object, class); - if (cls == Nil || bytes == NULL) + if (!callConstructors(class, object)) return nil; - object_setClass(obj, cls); - - if (!callConstructors(cls, obj)) - return nil; - - return obj; + return object; } void * -objc_destructInstance(id obj) +objc_destructInstance(id object) { - Class cls; + Class class; void (*last)(id, SEL) = NULL; - if (obj == nil) + if (object == nil) return NULL; #ifdef OF_OBJFW_RUNTIME - objc_zero_weak_references(obj); + objc_zero_weak_references(object); #endif - if (destructSel == NULL) - destructSel = sel_registerName(".cxx_destruct"); + if (destructSelector == NULL) + destructSelector = sel_registerName(".cxx_destruct"); - for (cls = object_getClass(obj); cls != Nil; - cls = class_getSuperclass(cls)) { + for (class = object_getClass(object); class != Nil; + class = class_getSuperclass(class)) { void (*destruct)(id, SEL); - if (class_respondsToSelector(cls, destructSel)) { + if (class_respondsToSelector(class, destructSelector)) { if ((destruct = (void (*)(id, SEL)) - class_getMethodImplementation(cls, - destructSel)) != last) - destruct(obj, destructSel); + class_getMethodImplementation(class, + destructSelector)) != last) + destruct(object, destructSelector); last = destruct; } else break; } - return obj; + return object; } Index: src/macros.h ================================================================== --- src/macros.h +++ src/macros.h @@ -209,13 +209,13 @@ # define nullable # define null_unspecified #endif #if __has_feature(objc_kindof) -# define OF_KINDOF(cls) __kindof cls +# define OF_KINDOF(class_) __kindof class_ #else -# define OF_KINDOF(cls) id +# define OF_KINDOF(class_) id #endif #if __has_feature(objc_class_property) # define OF_HAVE_CLASS_PROPERTIES #endif Index: src/runtime/ObjFW_RT.h ================================================================== --- src/runtime/ObjFW_RT.h +++ src/runtime/ObjFW_RT.h @@ -106,11 +106,15 @@ const char *_Nullable typeEncoding; }; struct objc_super { id __unsafe_unretained _Nullable self; - Class _Nonnull cls; +#ifdef __cplusplus + Class _Nonnull class_; +#else + Class _Nonnull class; +#endif }; struct objc_method { struct objc_selector selector; IMP _Nonnull implementation; @@ -211,36 +215,37 @@ extern SEL _Nonnull sel_registerName(const char *_Nonnull name); extern const char *_Nonnull sel_getName(SEL _Nonnull selector); extern bool sel_isEqual(SEL _Nonnull selector1, SEL _Nonnull selector2); extern Class _Nonnull objc_allocateClassPair(Class _Nullable superclass, const char *_Nonnull name, size_t extraBytes); -extern void objc_registerClassPair(Class _Nonnull cls); +extern void objc_registerClassPair(Class _Nonnull class_); extern unsigned int objc_getClassList(Class _Nonnull *_Nullable buffer, unsigned int count); extern Class _Nonnull *_Nonnull objc_copyClassList( unsigned int *_Nullable length); -extern bool class_isMetaClass(Class _Nullable cls); -extern const char *_Nullable class_getName(Class _Nullable cls); -extern Class _Nullable class_getSuperclass(Class _Nullable cls); -extern unsigned long class_getInstanceSize(Class _Nullable cls); -extern bool class_respondsToSelector(Class _Nullable cls, +extern bool class_isMetaClass(Class _Nullable class_); +extern const char *_Nullable class_getName(Class _Nullable class_); +extern Class _Nullable class_getSuperclass(Class _Nullable class_); +extern unsigned long class_getInstanceSize(Class _Nullable class_); +extern bool class_respondsToSelector(Class _Nullable class_, SEL _Nonnull selector); -extern bool class_conformsToProtocol(Class _Nullable cls, +extern bool class_conformsToProtocol(Class _Nullable class_, Protocol *_Nonnull protocol); -extern IMP _Nullable class_getMethodImplementation(Class _Nullable cls, - SEL _Nonnull selector); -extern IMP _Nullable class_getMethodImplementation_stret(Class _Nullable cls, - SEL _Nonnull selector); -extern const char *_Nullable class_getMethodTypeEncoding(Class _Nullable cls, - SEL _Nonnull selector); -extern bool class_addMethod(Class _Nonnull cls, SEL _Nonnull selector, - IMP _Nonnull implementation, const char *_Nullable typeEncoding); -extern IMP _Nullable class_replaceMethod(Class _Nonnull cls, +extern IMP _Nullable class_getMethodImplementation(Class _Nullable class_, + SEL _Nonnull selector); +extern IMP _Nullable class_getMethodImplementation_stret(Class _Nullable class_, + SEL _Nonnull selector); +extern const char *_Nullable class_getMethodTypeEncoding(Class _Nullable class_, + SEL _Nonnull selector); +extern bool class_addMethod(Class _Nonnull class_, SEL _Nonnull selector, + IMP _Nonnull implementation, const char *_Nullable typeEncoding); +extern IMP _Nullable class_replaceMethod(Class _Nonnull class_, SEL _Nonnull selector, IMP _Nonnull implementation, const char *_Nullable typeEncoding); extern Class _Nullable object_getClass(id _Nullable object); -extern Class _Nullable object_setClass(id _Nullable object, Class _Nonnull cls); +extern Class _Nullable object_setClass(id _Nullable object, + Class _Nonnull class_); extern const char *_Nullable object_getClassName(id _Nullable object); extern const char *_Nonnull protocol_getName(Protocol *_Nonnull protocol); extern bool protocol_isEqual(Protocol *_Nonnull protocol1, Protocol *_Nonnull protocol2); extern bool protocol_conformsToProtocol(Protocol *_Nonnull protocol1, Index: src/runtime/ObjFW_RT.sfd ================================================================== --- src/runtime/ObjFW_RT.sfd +++ src/runtime/ObjFW_RT.sfd @@ -22,11 +22,11 @@ int objc_sync_exit_m68k(id _Nullable object)(a0) id objc_getProperty_m68k(id _Nonnull self, SEL _Nonnull _cmd, ptrdiff_t offset, bool atomic)(a0,a1,d0,d1) void objc_setProperty_m68k(id _Nonnull self, SEL _Nonnull _cmd, ptrdiff_t offset, id value, bool atomic, signed char copy)(a0,a1,d0,a2,d1,d2) void objc_getPropertyStruct_m68k(void *_Nonnull dest, const void *_Nonnull src, ptrdiff_t size, bool atomic, bool strong)(a0,a1,d0,d1,d2) void objc_setPropertyStruct_m68k(void *_Nonnull dest, const void *_Nonnull src, ptrdiff_t size, bool atomic, bool strong)(a0,a1,d0,d1,d2) -void objc_enumerationMutation_m68k(id _Nonnull obj)(a0) +void objc_enumerationMutation_m68k(id _Nonnull object)(a0) int __gnu_objc_personality_v0_m68k(int version, int actions, uint64_t *_Nonnull exClass, void *_Nonnull ex, void *_Nonnull ctx)(d0,d1,d2,a0,a1) int __gnu_objc_personality_sj0_m68k(int version, int actions, uint64_t *_Nonnull exClass, void *_Nonnull ex, void *_Nonnull ctx)(d0,d1,d2,a0,a1) id _Nullable objc_retain_m68k(id _Nullable object)(a0) id _Nullable objc_retainBlock_m68k(id _Nullable block)(a0) id _Nullable objc_retainAutorelease_m68k(id _Nullable object)(a0) @@ -48,26 +48,26 @@ * the benefit of having all __saveds in a single place. SEL _Nonnull sel_registerName_m68k(const char *_Nonnull name)(a0) const char *_Nonnull sel_getName_m68k(SEL _Nonnull selector)(a0) bool sel_isEqual_m68k(SEL _Nonnull selector1, SEL _Nonnull selector2)(a0,a1) Class _Nonnull objc_allocateClassPair_m68k(Class _Nullable superclass, const char *_Nonnull name, size_t extraBytes)(a0,a1,d0) -void objc_registerClassPair_m68k(Class _Nonnull cls)(a0) +void objc_registerClassPair_m68k(Class _Nonnull class_)(a0) unsigned int objc_getClassList_m68k(Class _Nonnull *_Nullable buffer, unsigned int count)(a0,d0) Class _Nonnull *_Nonnull objc_copyClassList_m68k(unsigned int *_Nullable length)(a0) -bool class_isMetaClass_m68k(Class _Nullable cls)(a0) -const char *_Nullable class_getName_m68k(Class _Nullable cls)(a0) -Class _Nullable class_getSuperclass_m68k(Class _Nullable cls)(a0) -unsigned long class_getInstanceSize_m68k(Class _Nullable cls)(a0) -bool class_respondsToSelector_m68k(Class _Nullable cls, SEL _Nonnull selector)(a0,a1) -bool class_conformsToProtocol_m68k(Class _Nullable cls, Protocol *_Nonnull p)(a0,a1) -IMP _Nullable class_getMethodImplementation_m68k(Class _Nullable cls, SEL _Nonnull selector)(a0,a1) -IMP _Nullable class_getMethodImplementation_stret_m68k(Class _Nullable cls, SEL _Nonnull selector)(a0,a1) -const char *_Nullable class_getMethodTypeEncoding_m68k(Class _Nullable cls, SEL _Nonnull selector)(a0,a1) -bool class_addMethod_m68k(Class _Nonnull cls, SEL _Nonnull selector, IMP _Nonnull implementation, const char *_Nullable typeEncoding)(a0,a1,a2,a3) -IMP _Nullable class_replaceMethod_m68k(Class _Nonnull cls, SEL _Nonnull selector, IMP _Nonnull implementation, const char *_Nullable typeEncoding)(a0,a1,a2,a3) +bool class_isMetaClass_m68k(Class _Nullable class_)(a0) +const char *_Nullable class_getName_m68k(Class _Nullable class_)(a0) +Class _Nullable class_getSuperclass_m68k(Class _Nullable class_)(a0) +unsigned long class_getInstanceSize_m68k(Class _Nullable class_)(a0) +bool class_respondsToSelector_m68k(Class _Nullable class_, SEL _Nonnull selector)(a0,a1) +bool class_conformsToProtocol_m68k(Class _Nullable class_, Protocol *_Nonnull p)(a0,a1) +IMP _Nullable class_getMethodImplementation_m68k(Class _Nullable class_, SEL _Nonnull selector)(a0,a1) +IMP _Nullable class_getMethodImplementation_stret_m68k(Class _Nullable class_, SEL _Nonnull selector)(a0,a1) +const char *_Nullable class_getMethodTypeEncoding_m68k(Class _Nullable class_, SEL _Nonnull selector)(a0,a1) +bool class_addMethod_m68k(Class _Nonnull class_, SEL _Nonnull selector, IMP _Nonnull implementation, const char *_Nullable typeEncoding)(a0,a1,a2,a3) +IMP _Nullable class_replaceMethod_m68k(Class _Nonnull class_, SEL _Nonnull selector, IMP _Nonnull implementation, const char *_Nullable typeEncoding)(a0,a1,a2,a3) Class _Nullable object_getClass_m68k(id _Nullable object)(a0) -Class _Nullable object_setClass_m68k(id _Nullable object, Class _Nonnull cls)(a0,a1) +Class _Nullable object_setClass_m68k(id _Nullable object, Class _Nonnull class_)(a0,a1) const char *_Nullable object_getClassName_m68k(id _Nullable object)(a0) const char *_Nonnull protocol_getName_m68k(Protocol *_Nonnull protocol)(a0) bool protocol_isEqual_m68k(Protocol *_Nonnull protocol1, Protocol *_Nonnull protocol2)(a0,a1) bool protocol_conformsToProtocol_m68k(Protocol *_Nonnull protocol1, Protocol *_Nonnull protocol2)(a0,a1) void objc_exit_m68k(void)() Index: src/runtime/amiga-glue.m ================================================================== --- src/runtime/amiga-glue.m +++ src/runtime/amiga-glue.m @@ -392,13 +392,13 @@ } void __saveds objc_registerClassPair_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) - objc_registerClassPair(cls); + objc_registerClassPair(class); } unsigned int __saveds objc_getClassList_m68k(void) { @@ -417,104 +417,105 @@ } bool __saveds class_isMetaClass_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) - return class_isMetaClass(cls); + return class_isMetaClass(class); } const char *__saveds class_getName_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) - return class_getName(cls); + return class_getName(class); } Class __saveds class_getSuperclass_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) - return class_getSuperclass(cls); + return class_getSuperclass(class); } unsigned long __saveds class_getInstanceSize_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) - return class_getInstanceSize(cls); + return class_getInstanceSize(class); } bool __saveds class_respondsToSelector_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) OBJC_M68K_ARG(SEL, selector, a1) - return class_respondsToSelector(cls, selector); + return class_respondsToSelector(class, selector); } bool __saveds class_conformsToProtocol_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) OBJC_M68K_ARG(Protocol *, protocol, a1) - return class_conformsToProtocol(cls, protocol); + return class_conformsToProtocol(class, protocol); } IMP __saveds class_getMethodImplementation_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) OBJC_M68K_ARG(SEL, selector, a1) - return class_getMethodImplementation(cls, selector); + return class_getMethodImplementation(class, selector); } IMP __saveds class_getMethodImplementation_stret_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) OBJC_M68K_ARG(SEL, selector, a1) - return class_getMethodImplementation_stret(cls, selector); + return class_getMethodImplementation_stret(class, selector); } const char *__saveds class_getMethodTypeEncoding_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) OBJC_M68K_ARG(SEL, selector, a1) - return class_getMethodTypeEncoding(cls, selector); + return class_getMethodTypeEncoding(class, selector); } bool __saveds class_addMethod_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) OBJC_M68K_ARG(SEL, selector, a1) OBJC_M68K_ARG(IMP, implementation, a2) OBJC_M68K_ARG(const char *, typeEncoding, a3) - return class_addMethod(cls, selector, implementation, typeEncoding); + return class_addMethod(class, selector, implementation, typeEncoding); } IMP __saveds class_replaceMethod_m68k(void) { - OBJC_M68K_ARG(Class, cls, a0) + OBJC_M68K_ARG(Class, class, a0) OBJC_M68K_ARG(SEL, selector, a1) OBJC_M68K_ARG(IMP, implementation, a2) OBJC_M68K_ARG(const char *, typeEncoding, a3) - return class_replaceMethod(cls, selector, implementation, typeEncoding); + return class_replaceMethod(class, selector, implementation, + typeEncoding); } Class __saveds object_getClass_m68k(void) { @@ -525,13 +526,13 @@ Class __saveds object_setClass_m68k(void) { OBJC_M68K_ARG(id, object, a0) - OBJC_M68K_ARG(Class, cls, a1) + OBJC_M68K_ARG(Class, class, a1) - return object_setClass(object, cls); + return object_setClass(object, class); } const char *__saveds object_getClassName_m68k(void) { Index: src/runtime/arc.m ================================================================== --- src/runtime/arc.m +++ src/runtime/arc.m @@ -36,19 +36,19 @@ #ifdef OF_HAVE_THREADS static of_spinlock_t spinlock; #endif static uint32_t -hash(const void *obj) +hash(const void *object) { - return (uint32_t)(uintptr_t)obj; + return (uint32_t)(uintptr_t)object; } static bool -equal(const void *obj1, const void *obj2) +equal(const void *object1, const void *object2) { - return (obj1 == obj2); + return (object1 == object2); } OF_CONSTRUCTOR() { hashtable = objc_hashtable_new(hash, equal, 2); Index: src/runtime/category.m ================================================================== --- src/runtime/category.m +++ src/runtime/category.m @@ -45,11 +45,11 @@ static void registerCategory(struct objc_abi_category *category) { struct objc_abi_category **categories; - Class cls = objc_classname_to_class(category->className, false); + Class class = objc_classname_to_class(category->className, false); if (categoriesMap == NULL) categoriesMap = objc_hashtable_new( objc_hash_string, objc_equal_string, 2); @@ -71,13 +71,13 @@ newCategories[i] = category; newCategories[i + 1] = NULL; objc_hashtable_set(categoriesMap, category->className, newCategories); - if (cls != Nil && cls->info & OBJC_CLASS_INFO_SETUP) { - objc_update_dtable(cls); - objc_update_dtable(cls->isa); + if (class != Nil && class->info & OBJC_CLASS_INFO_SETUP) { + objc_update_dtable(class); + objc_update_dtable(class->isa); } return; } @@ -88,13 +88,13 @@ categories[0] = category; categories[1] = NULL; objc_hashtable_set(categoriesMap, category->className, categories); - if (cls != Nil && cls->info & OBJC_CLASS_INFO_SETUP) { - objc_update_dtable(cls); - objc_update_dtable(cls->isa); + if (class != Nil && class->info & OBJC_CLASS_INFO_SETUP) { + objc_update_dtable(class); + objc_update_dtable(class->isa); } } void objc_register_all_categories(struct objc_abi_symtab *symtab) @@ -107,17 +107,17 @@ registerCategory(categories[i]); } } struct objc_category ** -objc_categories_for_class(Class cls) +objc_categories_for_class(Class class) { if (categoriesMap == NULL) return NULL; return (struct objc_category **)objc_hashtable_get(categoriesMap, - cls->name); + class->name); } void objc_unregister_all_categories(void) { Index: src/runtime/class.m ================================================================== --- src/runtime/class.m +++ src/runtime/class.m @@ -32,62 +32,62 @@ static struct objc_dtable *emptyDTable = NULL; static unsigned lookupsUntilFastPath = 128; static struct objc_sparsearray *fastPath = NULL; static void -registerClass(struct objc_abi_class *cls) +registerClass(struct objc_abi_class *rawClass) { if (classes == NULL) classes = objc_hashtable_new( objc_hash_string, objc_equal_string, 2); - objc_hashtable_set(classes, cls->name, cls); + objc_hashtable_set(classes, rawClass->name, rawClass); if (emptyDTable == NULL) emptyDTable = objc_dtable_new(); - cls->DTable = emptyDTable; - cls->metaclass->DTable = emptyDTable; + rawClass->DTable = emptyDTable; + rawClass->metaclass->DTable = emptyDTable; - if (strcmp(cls->name, "Protocol") != 0) + if (strcmp(rawClass->name, "Protocol") != 0) classesCount++; } bool -class_registerAlias_np(Class cls, const char *name) +class_registerAlias_np(Class class, const char *name) { objc_global_mutex_lock(); if (classes == NULL) { objc_global_mutex_unlock(); return NO; } - objc_hashtable_set(classes, name, (Class)((uintptr_t)cls | 1)); + objc_hashtable_set(classes, name, (Class)((uintptr_t)class | 1)); objc_global_mutex_unlock(); return YES; } static void -registerSelectors(struct objc_abi_class *cls) +registerSelectors(struct objc_abi_class *rawClass) { struct objc_abi_method_list *methodList; - for (methodList = cls->methodList; methodList != NULL; + for (methodList = rawClass->methodList; methodList != NULL; methodList = methodList->next) for (unsigned int i = 0; i < methodList->count; i++) objc_register_selector((struct objc_abi_selector *) &methodList->methods[i]); } Class objc_classname_to_class(const char *name, bool cache) { - Class cls; + Class class; if (classes == NULL) return Nil; /* @@ -110,51 +110,51 @@ * that if the runtime calls into objc_classname_to_class(), it already * has the lock and thus the performance gain would be small, but it * would waste memory. */ if (cache && fastPath != NULL) { - cls = objc_sparsearray_get(fastPath, (uintptr_t)name); + class = objc_sparsearray_get(fastPath, (uintptr_t)name); - if (cls != Nil) - return cls; + if (class != Nil) + return class; } objc_global_mutex_lock(); - cls = (Class)((uintptr_t)objc_hashtable_get(classes, name) & ~1); + class = (Class)((uintptr_t)objc_hashtable_get(classes, name) & ~1); if (cache && fastPath == NULL && --lookupsUntilFastPath == 0) fastPath = objc_sparsearray_new(sizeof(uintptr_t)); if (cache && fastPath != NULL) - objc_sparsearray_set(fastPath, (uintptr_t)name, cls); + objc_sparsearray_set(fastPath, (uintptr_t)name, class); objc_global_mutex_unlock(); - return cls; + return class; } static void -callMethod(Class cls, const char *method) +callMethod(Class class, const char *method) { SEL selector = sel_registerName(method); - for (struct objc_method_list *methodList = cls->isa->methodList; + for (struct objc_method_list *methodList = class->isa->methodList; methodList != NULL; methodList = methodList->next) for (unsigned int i = 0; i < methodList->count; i++) if (sel_isEqual((SEL)&methodList->methods[i].selector, selector)) ((void (*)(id, SEL))methodList->methods[i] - .implementation)(cls, selector); + .implementation)(class, selector); } static bool -hasLoad(Class cls) +hasLoad(Class class) { SEL selector = sel_registerName("load"); - for (struct objc_method_list *methodList = cls->isa->methodList; + for (struct objc_method_list *methodList = class->isa->methodList; methodList != NULL; methodList = methodList->next) for (size_t i = 0; i < methodList->count; i++) if (sel_isEqual((SEL)&methodList->methods[i].selector, selector)) return true; @@ -161,209 +161,211 @@ return false; } static void -callLoad(Class cls) +callLoad(Class class) { - if (cls->info & OBJC_CLASS_INFO_LOADED) + if (class->info & OBJC_CLASS_INFO_LOADED) return; - if (cls->superclass != Nil) - callLoad(cls->superclass); + if (class->superclass != Nil) + callLoad(class->superclass); - callMethod(cls, "load"); + callMethod(class, "load"); - cls->info |= OBJC_CLASS_INFO_LOADED; + class->info |= OBJC_CLASS_INFO_LOADED; } void -objc_update_dtable(Class cls) +objc_update_dtable(Class class) { struct objc_category **categories; - if (!(cls->info & OBJC_CLASS_INFO_DTABLE)) + if (!(class->info & OBJC_CLASS_INFO_DTABLE)) return; - if (cls->DTable == emptyDTable) - cls->DTable = objc_dtable_new(); + if (class->DTable == emptyDTable) + class->DTable = objc_dtable_new(); - if (cls->superclass != Nil) - objc_dtable_copy(cls->DTable, cls->superclass->DTable); + if (class->superclass != Nil) + objc_dtable_copy(class->DTable, class->superclass->DTable); - for (struct objc_method_list *methodList = cls->methodList; + for (struct objc_method_list *methodList = class->methodList; methodList != NULL; methodList = methodList->next) for (unsigned int i = 0; i < methodList->count; i++) - objc_dtable_set(cls->DTable, + objc_dtable_set(class->DTable, (uint32_t)methodList->methods[i].selector.UID, methodList->methods[i].implementation); - if ((categories = objc_categories_for_class(cls)) != NULL) { + if ((categories = objc_categories_for_class(class)) != NULL) { for (unsigned int i = 0; categories[i] != NULL; i++) { struct objc_method_list *methodList = - (cls->info & OBJC_CLASS_INFO_CLASS + (class->info & OBJC_CLASS_INFO_CLASS ? categories[i]->instanceMethods : categories[i]->classMethods); for (; methodList != NULL; methodList = methodList->next) for (unsigned int j = 0; j < methodList->count; j++) - objc_dtable_set(cls->DTable, (uint32_t) - methodList->methods[j].selector.UID, + objc_dtable_set(class->DTable, + (uint32_t)methodList->methods[j] + .selector.UID, methodList->methods[j] .implementation); } } - if (cls->subclassList != NULL) - for (Class *iter = cls->subclassList; *iter != NULL; iter++) + if (class->subclassList != NULL) + for (Class *iter = class->subclassList; *iter != NULL; iter++) objc_update_dtable(*iter); } static void -addSubclass(Class cls) +addSubclass(Class class) { size_t i; - if (cls->superclass->subclassList == NULL) { - if ((cls->superclass->subclassList = + if (class->superclass->subclassList == NULL) { + if ((class->superclass->subclassList = malloc(2 * sizeof(Class))) == NULL) OBJC_ERROR("Not enough memory for subclass list of " - "class %s!", cls->superclass->name); + "class %s!", class->superclass->name); - cls->superclass->subclassList[0] = cls; - cls->superclass->subclassList[1] = Nil; + class->superclass->subclassList[0] = class; + class->superclass->subclassList[1] = Nil; return; } - for (i = 0; cls->superclass->subclassList[i] != Nil; i++); + for (i = 0; class->superclass->subclassList[i] != Nil; i++); - cls->superclass->subclassList = - realloc(cls->superclass->subclassList, (i + 2) * sizeof(Class)); + class->superclass->subclassList = + realloc(class->superclass->subclassList, (i + 2) * sizeof(Class)); - if (cls->superclass->subclassList == NULL) + if (class->superclass->subclassList == NULL) OBJC_ERROR("Not enough memory for subclass list of class %s\n", - cls->superclass->name); + class->superclass->name); - cls->superclass->subclassList[i] = cls; - cls->superclass->subclassList[i + 1] = Nil; + class->superclass->subclassList[i] = class; + class->superclass->subclassList[i + 1] = Nil; } static void -updateIVarOffsets(Class cls) -{ - if (!(cls->info & OBJC_CLASS_INFO_NEW_ABI)) - return; - - if (cls->instanceSize > 0) - return; - - cls->instanceSize = -cls->instanceSize; - - if (cls->superclass != Nil) { - cls->instanceSize += cls->superclass->instanceSize; - - if (cls->iVars != NULL) { - for (unsigned int i = 0; i < cls->iVars->count; i++) { - cls->iVars->iVars[i].offset += - cls->superclass->instanceSize; - *cls->iVarOffsets[i] = - cls->iVars->iVars[i].offset; +updateIVarOffsets(Class class) +{ + if (!(class->info & OBJC_CLASS_INFO_NEW_ABI)) + return; + + if (class->instanceSize > 0) + return; + + class->instanceSize = -class->instanceSize; + + if (class->superclass != Nil) { + class->instanceSize += class->superclass->instanceSize; + + if (class->iVars != NULL) { + for (unsigned int i = 0; i < class->iVars->count; i++) { + class->iVars->iVars[i].offset += + class->superclass->instanceSize; + *class->iVarOffsets[i] = + class->iVars->iVars[i].offset; } } } else - for (unsigned int i = 0; i < cls->iVars->count; i++) - *cls->iVarOffsets[i] = cls->iVars->iVars[i].offset; + for (unsigned int i = 0; i < class->iVars->count; i++) + *class->iVarOffsets[i] = class->iVars->iVars[i].offset; } static void -setupClass(Class cls) +setupClass(Class class) { - const char *superclass; + const char *superclassName; - if (cls->info & OBJC_CLASS_INFO_SETUP) + if (class->info & OBJC_CLASS_INFO_SETUP) return; - if ((superclass = ((struct objc_abi_class *)cls)->superclass) != NULL) { - Class super = objc_classname_to_class(superclass, false); + superclassName = ((struct objc_abi_class *)class)->superclass; + if (superclassName != NULL) { + Class super = objc_classname_to_class(superclassName, false); if (super == Nil) return; setupClass(super); if (!(super->info & OBJC_CLASS_INFO_SETUP)) return; - cls->superclass = super; - cls->isa->superclass = super->isa; + class->superclass = super; + class->isa->superclass = super->isa; - addSubclass(cls); - addSubclass(cls->isa); + addSubclass(class); + addSubclass(class->isa); } else - cls->isa->superclass = cls; + class->isa->superclass = class; - updateIVarOffsets(cls); + updateIVarOffsets(class); - cls->info |= OBJC_CLASS_INFO_SETUP; - cls->isa->info |= OBJC_CLASS_INFO_SETUP; + class->info |= OBJC_CLASS_INFO_SETUP; + class->isa->info |= OBJC_CLASS_INFO_SETUP; } static void -initializeClass(Class cls) +initializeClass(Class class) { - if (cls->info & OBJC_CLASS_INFO_INITIALIZED) + if (class->info & OBJC_CLASS_INFO_INITIALIZED) return; - if (cls->superclass) - initializeClass(cls->superclass); - - cls->info |= OBJC_CLASS_INFO_DTABLE; - cls->isa->info |= OBJC_CLASS_INFO_DTABLE; - - objc_update_dtable(cls); - objc_update_dtable(cls->isa); + if (class->superclass) + initializeClass(class->superclass); + + class->info |= OBJC_CLASS_INFO_DTABLE; + class->isa->info |= OBJC_CLASS_INFO_DTABLE; + + objc_update_dtable(class); + objc_update_dtable(class->isa); /* * Set it first to prevent calling it recursively due to message sends * in the initialize method */ - cls->info |= OBJC_CLASS_INFO_INITIALIZED; - cls->isa->info |= OBJC_CLASS_INFO_INITIALIZED; + class->info |= OBJC_CLASS_INFO_INITIALIZED; + class->isa->info |= OBJC_CLASS_INFO_INITIALIZED; - callMethod(cls, "initialize"); + callMethod(class, "initialize"); } void -objc_initialize_class(Class cls) +objc_initialize_class(Class class) { - if (cls->info & OBJC_CLASS_INFO_INITIALIZED) + if (class->info & OBJC_CLASS_INFO_INITIALIZED) return; objc_global_mutex_lock(); /* * It's possible that two threads try to initialize a class at the same * time. Make sure that the thread which held the lock did not already * initialize it. */ - if (cls->info & OBJC_CLASS_INFO_INITIALIZED) { + if (class->info & OBJC_CLASS_INFO_INITIALIZED) { objc_global_mutex_unlock(); return; } - setupClass(cls); + setupClass(class); - if (!(cls->info & OBJC_CLASS_INFO_SETUP)) { + if (!(class->info & OBJC_CLASS_INFO_SETUP)) { objc_global_mutex_unlock(); return; } - initializeClass(cls); + initializeClass(class); objc_global_mutex_unlock(); } static void @@ -396,123 +398,123 @@ void objc_register_all_classes(struct objc_abi_symtab *symtab) { for (uint16_t i = 0; i < symtab->classDefsCount; i++) { - struct objc_abi_class *cls = + struct objc_abi_class *rawClass = (struct objc_abi_class *)symtab->defs[i]; - registerClass(cls); - registerSelectors(cls); - registerSelectors(cls->metaclass); + registerClass(rawClass); + registerSelectors(rawClass); + registerSelectors(rawClass->metaclass); } for (uint16_t i = 0; i < symtab->classDefsCount; i++) { - Class cls = (Class)symtab->defs[i]; + Class class = (Class)symtab->defs[i]; - if (hasLoad(cls)) { - setupClass(cls); + if (hasLoad(class)) { + setupClass(class); - if (cls->info & OBJC_CLASS_INFO_SETUP) - callLoad(cls); + if (class->info & OBJC_CLASS_INFO_SETUP) + callLoad(class); else { loadQueue = realloc(loadQueue, sizeof(Class) * (loadQueueCount + 1)); if (loadQueue == NULL) OBJC_ERROR("Not enough memory for load " "queue!"); - loadQueue[loadQueueCount++] = cls; + loadQueue[loadQueueCount++] = class; } } else - cls->info |= OBJC_CLASS_INFO_LOADED; + class->info |= OBJC_CLASS_INFO_LOADED; } processLoadQueue(); } Class objc_allocateClassPair(Class superclass, const char *name, size_t extraBytes) { - struct objc_class *cls, *metaclass; + struct objc_class *class, *metaclass; Class iter, rootclass = Nil; if (extraBytes > LONG_MAX) OBJC_ERROR("extra_bytes out of range!") - if ((cls = calloc(1, sizeof(*cls))) == NULL || - (metaclass = calloc(1, sizeof(*cls))) == NULL) + if ((class = calloc(1, sizeof(*class))) == NULL || + (metaclass = calloc(1, sizeof(*class))) == NULL) OBJC_ERROR("Not enough memory to allocate class pair for class " "%s!", name) - cls->isa = metaclass; - cls->superclass = superclass; - cls->name = name; - cls->info = OBJC_CLASS_INFO_CLASS; - cls->instanceSize = (superclass != Nil ? + class->isa = metaclass; + class->superclass = superclass; + class->name = name; + class->info = OBJC_CLASS_INFO_CLASS; + class->instanceSize = (superclass != Nil ? superclass->instanceSize : 0) + (long)extraBytes; for (iter = superclass; iter != Nil; iter = iter->superclass) rootclass = iter; - metaclass->isa = (rootclass != Nil ? rootclass->isa : cls); + metaclass->isa = (rootclass != Nil ? rootclass->isa : class); metaclass->superclass = (superclass != Nil ? superclass->isa : Nil); metaclass->name = name; metaclass->info = OBJC_CLASS_INFO_CLASS; metaclass->instanceSize = (superclass != Nil ? superclass->isa->instanceSize : 0) + (long)extraBytes; - return cls; + return class; } void -objc_registerClassPair(Class cls) +objc_registerClassPair(Class class) { objc_global_mutex_lock(); - registerClass((struct objc_abi_class *)cls); + registerClass((struct objc_abi_class *)class); - if (cls->superclass != Nil) { - addSubclass(cls); - addSubclass(cls->isa); + if (class->superclass != Nil) { + addSubclass(class); + addSubclass(class->isa); } - cls->info |= OBJC_CLASS_INFO_SETUP; - cls->isa->info |= OBJC_CLASS_INFO_SETUP; + class->info |= OBJC_CLASS_INFO_SETUP; + class->isa->info |= OBJC_CLASS_INFO_SETUP; - if (hasLoad(cls)) - callLoad(cls); + if (hasLoad(class)) + callLoad(class); else - cls->info |= OBJC_CLASS_INFO_LOADED; + class->info |= OBJC_CLASS_INFO_LOADED; processLoadQueue(); objc_global_mutex_unlock(); } Class objc_lookUpClass(const char *name) { - Class cls; + Class class; - if ((cls = objc_classname_to_class(name, true)) == NULL) + if ((class = objc_classname_to_class(name, true)) == NULL) return Nil; - if (cls->info & OBJC_CLASS_INFO_SETUP) - return cls; + if (class->info & OBJC_CLASS_INFO_SETUP) + return class; objc_global_mutex_lock(); - setupClass(cls); + setupClass(class); objc_global_mutex_unlock(); - if (!(cls->info & OBJC_CLASS_INFO_SETUP)) + if (!(class->info & OBJC_CLASS_INFO_SETUP)) return Nil; - return cls; + return class; } Class objc_getClass(const char *name) { @@ -520,16 +522,16 @@ } Class objc_getRequiredClass(const char *name) { - Class cls; + Class class; - if ((cls = objc_getClass(name)) == Nil) + if ((class = objc_getClass(name)) == Nil) OBJC_ERROR("Class %s not found!", name); - return cls; + return class; } Class objc_lookup_class(const char *name) { @@ -554,11 +556,11 @@ if (classesCount < count) count = classesCount; j = 0; for (uint32_t i = 0; i < classes->size; i++) { - void *cls; + void *class; if (j >= count) { objc_global_mutex_unlock(); return j; } @@ -567,25 +569,25 @@ continue; if (strcmp(classes->data[i]->key, "Protocol") == 0) continue; - cls = (Class)classes->data[i]->object; + class = (Class)classes->data[i]->object; - if (cls == Nil || (uintptr_t)cls & 1) + if (class == Nil || (uintptr_t)class & 1) continue; - buffer[j++] = cls; + buffer[j++] = class; } objc_global_mutex_unlock(); return j; } Class * -objc_copyClassList(unsigned int *len) +objc_copyClassList(unsigned int *length) { Class *ret; unsigned int count; objc_global_mutex_lock(); @@ -596,56 +598,56 @@ count = objc_getClassList(ret, classesCount); OF_ENSURE(count == classesCount); ret[count] = Nil; - if (len != NULL) - *len = count; + if (length != NULL) + *length = count; objc_global_mutex_unlock(); return ret; } bool -class_isMetaClass(Class cls) +class_isMetaClass(Class class) { - if (cls == Nil) + if (class == Nil) return false; - return (cls->info & OBJC_CLASS_INFO_METACLASS); + return (class->info & OBJC_CLASS_INFO_METACLASS); } const char * -class_getName(Class cls) +class_getName(Class class) { - if (cls == Nil) + if (class == Nil) return ""; - return cls->name; + return class->name; } Class -class_getSuperclass(Class cls) +class_getSuperclass(Class class) { - if (cls == Nil) + if (class == Nil) return Nil; - return cls->superclass; + return class->superclass; } unsigned long -class_getInstanceSize(Class cls) +class_getInstanceSize(Class class) { - if (cls == Nil) + if (class == Nil) return 0; - return cls->instanceSize; + return class->instanceSize; } IMP -class_getMethodImplementation(Class cls, SEL selector) +class_getMethodImplementation(Class class, SEL selector) { /* * We use a dummy object here so that the normal lookup is used, even * though we don't have an object. Doing so is safe, as objc_msg_lookup * does not access the object, but only its class. @@ -657,44 +659,44 @@ */ struct { Class isa; } dummy; - if (cls == Nil) + if (class == Nil) return NULL; - dummy.isa = cls; + dummy.isa = class; return objc_msg_lookup((id)&dummy, selector); } IMP -class_getMethodImplementation_stret(Class cls, SEL selector) +class_getMethodImplementation_stret(Class class, SEL selector) { /* * Same as above, but use objc_msg_lookup_stret instead, so that the * correct forwarding handler is returned. */ struct { Class isa; } dummy; - if (cls == Nil) + if (class == Nil) return NULL; - dummy.isa = cls; + dummy.isa = class; return objc_msg_lookup_stret((id)&dummy, selector); } static struct objc_method * -getMethod(Class cls, SEL selector) +getMethod(Class class, SEL selector) { struct objc_category **categories; - if ((categories = objc_categories_for_class(cls)) != NULL) { + if ((categories = objc_categories_for_class(class)) != NULL) { for (; *categories != NULL; categories++) { struct objc_method_list *methodList = - (cls->info & OBJC_CLASS_INFO_METACLASS + (class->info & OBJC_CLASS_INFO_METACLASS ? (*categories)->classMethods : (*categories)->instanceMethods); for (; methodList != NULL; methodList = methodList->next) @@ -705,11 +707,11 @@ selector)) return &methodList->methods[i]; } } - for (struct objc_method_list *methodList = cls->methodList; + for (struct objc_method_list *methodList = class->methodList; methodList != NULL; methodList = methodList->next) for (unsigned int i = 0; i < methodList->count; i++) if (sel_isEqual((SEL)&methodList->methods[i].selector, selector)) return &methodList->methods[i]; @@ -716,63 +718,64 @@ return NULL; } static void -addMethod(Class cls, SEL selector, IMP implementation, const char *typeEncoding) +addMethod(Class class, SEL selector, IMP implementation, + const char *typeEncoding) { struct objc_method_list *methodList; /* FIXME: We need a way to free this at objc_exit() */ if ((methodList = malloc(sizeof(struct objc_method_list))) == NULL) OBJC_ERROR("Not enough memory to replace method!"); - methodList->next = cls->methodList; + methodList->next = class->methodList; methodList->count = 1; methodList->methods[0].selector.UID = selector->UID; methodList->methods[0].selector.typeEncoding = typeEncoding; methodList->methods[0].implementation = implementation; - cls->methodList = methodList; + class->methodList = methodList; - objc_update_dtable(cls); + objc_update_dtable(class); } const char * -class_getMethodTypeEncoding(Class cls, SEL selector) +class_getMethodTypeEncoding(Class class, SEL selector) { struct objc_method *method; - if (cls == Nil) + if (class == Nil) return NULL; objc_global_mutex_lock(); - if ((method = getMethod(cls, selector)) != NULL) { + if ((method = getMethod(class, selector)) != NULL) { const char *ret = method->selector.typeEncoding; objc_global_mutex_unlock(); return ret; } objc_global_mutex_unlock(); - if (cls->superclass != Nil) - return class_getMethodTypeEncoding(cls->superclass, selector); + if (class->superclass != Nil) + return class_getMethodTypeEncoding(class->superclass, selector); return NULL; } bool -class_addMethod(Class cls, SEL selector, IMP implementation, +class_addMethod(Class class, SEL selector, IMP implementation, const char *typeEncoding) { bool ret; objc_global_mutex_lock(); - if (getMethod(cls, selector) == NULL) { - addMethod(cls, selector, implementation, typeEncoding); + if (getMethod(class, selector) == NULL) { + addMethod(class, selector, implementation, typeEncoding); ret = true; } else ret = false; objc_global_mutex_unlock(); @@ -779,25 +782,25 @@ return ret; } IMP -class_replaceMethod(Class cls, SEL selector, IMP implementation, +class_replaceMethod(Class class, SEL selector, IMP implementation, const char *typeEncoding) { struct objc_method *method; IMP oldImplementation; objc_global_mutex_lock(); - if ((method = getMethod(cls, selector)) != NULL) { + if ((method = getMethod(class, selector)) != NULL) { oldImplementation = method->implementation; method->implementation = implementation; - objc_update_dtable(cls); + objc_update_dtable(class); } else { oldImplementation = NULL; - addMethod(cls, selector, implementation, typeEncoding); + addMethod(class, selector, implementation, typeEncoding); } objc_global_mutex_unlock(); return oldImplementation; @@ -815,11 +818,11 @@ return object->isa; } Class -object_setClass(id object_, Class cls) +object_setClass(id object_, Class class) { struct objc_object *object; Class old; if (object_ == nil) @@ -826,82 +829,82 @@ return Nil; object = (struct objc_object *)object_; old = object->isa; - object->isa = cls; + object->isa = class; return old; } const char * -object_getClassName(id obj) +object_getClassName(id object) { - return class_getName(object_getClass(obj)); + return class_getName(object_getClass(object)); } static void -unregisterClass(Class rcls) +unregisterClass(Class class) { - struct objc_abi_class *cls = (struct objc_abi_class *)rcls; + struct objc_abi_class *rawClass = (struct objc_abi_class *)class; - if ((rcls->info & OBJC_CLASS_INFO_SETUP) && rcls->superclass != Nil && - rcls->superclass->subclassList != NULL) { + if ((class->info & OBJC_CLASS_INFO_SETUP) && class->superclass != Nil && + class->superclass->subclassList != NULL) { size_t i = SIZE_MAX, count = 0; Class *tmp; - for (tmp = rcls->superclass->subclassList; + for (tmp = class->superclass->subclassList; *tmp != Nil; tmp++) { - if (*tmp == rcls) + if (*tmp == class) i = count; count++; } if (count > 0 && i < SIZE_MAX) { - tmp = rcls->superclass->subclassList; - tmp[i] = tmp[count - 1]; - tmp[count - 1] = NULL; - - if ((tmp = realloc(rcls->superclass->subclassList, - count * sizeof(Class))) != NULL) - rcls->superclass->subclassList = tmp; - } - } - - if (rcls->subclassList != NULL) { - free(rcls->subclassList); - rcls->subclassList = NULL; - } - - if (rcls->DTable != NULL && rcls->DTable != emptyDTable) - objc_dtable_free(rcls->DTable); - - rcls->DTable = NULL; - - if ((rcls->info & OBJC_CLASS_INFO_SETUP) && rcls->superclass != Nil) - cls->superclass = rcls->superclass->name; - - rcls->info &= ~OBJC_CLASS_INFO_SETUP; + tmp = class->superclass->subclassList; + tmp[i] = tmp[count - 1]; + tmp[count - 1] = NULL; + + if ((tmp = realloc(class->superclass->subclassList, + count * sizeof(Class))) != NULL) + class->superclass->subclassList = tmp; + } + } + + if (class->subclassList != NULL) { + free(class->subclassList); + class->subclassList = NULL; + } + + if (class->DTable != NULL && class->DTable != emptyDTable) + objc_dtable_free(class->DTable); + + class->DTable = NULL; + + if ((class->info & OBJC_CLASS_INFO_SETUP) && class->superclass != Nil) + rawClass->superclass = class->superclass->name; + + class->info &= ~OBJC_CLASS_INFO_SETUP; } void -objc_unregister_class(Class cls) -{ - while (cls->subclassList != NULL && cls->subclassList[0] != Nil) - objc_unregister_class(cls->subclassList[0]); - - if (cls->info & OBJC_CLASS_INFO_LOADED) - callMethod(cls, "unload"); - - objc_hashtable_delete(classes, cls->name); - - if (strcmp(class_getName(cls), "Protocol") != 0) +objc_unregister_class(Class class) +{ + while (class->subclassList != NULL && class->subclassList[0] != Nil) + objc_unregister_class(class->subclassList[0]); + + if (class->info & OBJC_CLASS_INFO_LOADED) + callMethod(class, "unload"); + + objc_hashtable_delete(classes, class->name); + + if (strcmp(class_getName(class), "Protocol") != 0) classesCount--; - unregisterClass(cls); - unregisterClass(cls->isa); + unregisterClass(class); + unregisterClass(class->isa); } void objc_unregister_all_classes(void) { @@ -909,16 +912,16 @@ return; for (uint32_t i = 0; i < classes->size; i++) { if (classes->data[i] != NULL && classes->data[i] != &objc_deleted_bucket) { - void *cls = (Class)classes->data[i]->object; + void *class = (Class)classes->data[i]->object; - if (cls == Nil || (uintptr_t)cls & 1) + if (class == Nil || (uintptr_t)class & 1) continue; - objc_unregister_class(cls); + objc_unregister_class(class); /* * The table might have been resized, so go back to the * start again. * Index: src/runtime/dtable.m ================================================================== --- src/runtime/dtable.m +++ src/runtime/dtable.m @@ -71,11 +71,11 @@ return DTable; } void -objc_dtable_copy(struct objc_dtable *dst, struct objc_dtable *src) +objc_dtable_copy(struct objc_dtable *dest, struct objc_dtable *src) { for (uint_fast16_t i = 0; i < 256; i++) { if (src->buckets[i] == emptyLevel2) continue; @@ -83,40 +83,41 @@ for (uint_fast16_t j = 0; j < 256; j++) { if (src->buckets[i]->buckets[j] == emptyLevel3) continue; for (uint_fast16_t k = 0; k < 256; k++) { - IMP obj; + IMP implementation; uint32_t idx; - obj = src->buckets[i]->buckets[j]->buckets[k]; + implementation = + src->buckets[i]->buckets[j]->buckets[k]; - if (obj == (IMP)0) + if (implementation == (IMP)0) continue; idx = (uint32_t) (((uint32_t)i << 16) | (j << 8) | k); - objc_dtable_set(dst, idx, obj); + objc_dtable_set(dest, idx, implementation); } } #else for (uint_fast16_t j = 0; j < 256; j++) { - IMP obj = src->buckets[i]->buckets[j]; + IMP implementation = src->buckets[i]->buckets[j]; uint32_t idx; - if (obj == (IMP)0) + if (implementation == (IMP)0) continue; idx = (uint32_t)((i << 8) | j); - objc_dtable_set(dst, idx, obj); + objc_dtable_set(dest, idx, implementation); } #endif } } void -objc_dtable_set(struct objc_dtable *dtable, uint32_t idx, IMP obj) +objc_dtable_set(struct objc_dtable *DTable, uint32_t idx, IMP implementation) { #ifdef OF_SELUID24 uint8_t i = idx >> 16; uint8_t j = idx >> 8; uint8_t k = idx; @@ -123,11 +124,11 @@ #else uint8_t i = idx >> 8; uint8_t j = idx; #endif - if (dtable->buckets[i] == emptyLevel2) { + if (DTable->buckets[i] == emptyLevel2) { struct objc_dtable_level2 *level2 = malloc(sizeof(struct objc_dtable_level2)); if (level2 == NULL) OBJC_ERROR("Not enough memory to insert into dtable!"); @@ -137,50 +138,50 @@ level2->buckets[l] = emptyLevel3; #else level2->buckets[l] = (IMP)0; #endif - dtable->buckets[i] = level2; + DTable->buckets[i] = level2; } #ifdef OF_SELUID24 - if (dtable->buckets[i]->buckets[j] == emptyLevel3) { + if (DTable->buckets[i]->buckets[j] == emptyLevel3) { struct objc_dtable_level3 *level3 = malloc(sizeof(struct objc_dtable_level3)); if (level3 == NULL) OBJC_ERROR("Not enough memory to insert into dtable!"); for (uint_fast16_t l = 0; l < 256; l++) level3->buckets[l] = (IMP)0; - dtable->buckets[i]->buckets[j] = level3; + DTable->buckets[i]->buckets[j] = level3; } - dtable->buckets[i]->buckets[j]->buckets[k] = obj; + DTable->buckets[i]->buckets[j]->buckets[k] = implementation; #else - dtable->buckets[i]->buckets[j] = obj; + DTable->buckets[i]->buckets[j] = implementation; #endif } void -objc_dtable_free(struct objc_dtable *dtable) +objc_dtable_free(struct objc_dtable *DTable) { for (uint_fast16_t i = 0; i < 256; i++) { - if (dtable->buckets[i] == emptyLevel2) + if (DTable->buckets[i] == emptyLevel2) continue; #ifdef OF_SELUID24 for (uint_fast16_t j = 0; j < 256; j++) - if (dtable->buckets[i]->buckets[j] != emptyLevel3) - free(dtable->buckets[i]->buckets[j]); + if (DTable->buckets[i]->buckets[j] != emptyLevel3) + free(DTable->buckets[i]->buckets[j]); #endif - free(dtable->buckets[i]); + free(DTable->buckets[i]); } - free(dtable); + free(DTable); } void objc_dtable_cleanup(void) { Index: src/runtime/exception.m ================================================================== --- src/runtime/exception.m +++ src/runtime/exception.m @@ -462,17 +462,17 @@ return false; #else uintptr_t callsiteLandingpad, callsiteAction; - if ((intptr_t)ip < 1) + if ((intptr_t)IP < 1) return false; do { callsiteLandingpad = (uintptr_t)readULEB128(&ptr); callsiteAction = (uintptr_t)readULEB128(&ptr); - } while (--ip > 1); + } while (--IP > 1); *landingpad = callsiteLandingpad + 1; if (callsiteAction != 0) *actionRecords = LSDA->actionTable + callsiteAction - 1; Index: src/runtime/hashtable.m ================================================================== --- src/runtime/hashtable.m +++ src/runtime/hashtable.m @@ -47,13 +47,13 @@ return hash; } bool -objc_equal_string(const void *obj1, const void *obj2) +objc_equal_string(const void *ptr1, const void *ptr2) { - return (strcmp(obj1, obj2) == 0); + return (strcmp(ptr1, ptr2) == 0); } struct objc_hashtable * objc_hashtable_new(uint32_t (*hash)(const void *), bool (*equal)(const void *, const void *), uint32_t size) Index: src/runtime/linklib/linklib.m ================================================================== --- src/runtime/linklib/linklib.m +++ src/runtime/linklib/linklib.m @@ -324,13 +324,13 @@ { return objc_allocateClassPair_m68k(superclass, name, extraBytes); } void -objc_registerClassPair(Class cls) +objc_registerClassPair(Class class) { - objc_registerClassPair_m68k(cls); + objc_registerClassPair_m68k(class); } unsigned int objc_getClassList(Class *buffer, unsigned int count) { @@ -342,76 +342,76 @@ { return objc_copyClassList_m68k(length); } bool -class_isMetaClass(Class cls) -{ - return class_isMetaClass_m68k(cls); -} - -const char * -class_getName(Class cls) -{ - return class_getName_m68k(cls); -} - -Class -class_getSuperclass(Class cls) -{ - return class_getSuperclass_m68k(cls); -} - -unsigned long -class_getInstanceSize(Class cls) -{ - return class_getInstanceSize_m68k(cls); -} - -bool -class_respondsToSelector(Class cls, SEL selector) -{ - return class_respondsToSelector_m68k(cls, selector); -} - -bool -class_conformsToProtocol(Class cls, Protocol *protocol) -{ - return class_conformsToProtocol_m68k(cls, protocol); -} - -IMP -class_getMethodImplementation(Class cls, SEL selector) -{ - return class_getMethodImplementation_m68k(cls, selector); -} - -IMP -class_getMethodImplementation_stret(Class cls, SEL selector) -{ - return class_getMethodImplementation_stret_m68k(cls, selector); -} - -const char * -class_getMethodTypeEncoding(Class cls, SEL selector) -{ - return class_getMethodTypeEncoding_m68k(cls, selector); -} - -bool -class_addMethod(Class cls, SEL selector, IMP implementation, - const char *typeEncoding) -{ - return class_addMethod_m68k(cls, selector, implementation, +class_isMetaClass(Class class) +{ + return class_isMetaClass_m68k(class); +} + +const char * +class_getName(Class class) +{ + return class_getName_m68k(class); +} + +Class +class_getSuperclass(Class class) +{ + return class_getSuperclass_m68k(class); +} + +unsigned long +class_getInstanceSize(Class class) +{ + return class_getInstanceSize_m68k(class); +} + +bool +class_respondsToSelector(Class class, SEL selector) +{ + return class_respondsToSelector_m68k(class, selector); +} + +bool +class_conformsToProtocol(Class class, Protocol *protocol) +{ + return class_conformsToProtocol_m68k(class, protocol); +} + +IMP +class_getMethodImplementation(Class class, SEL selector) +{ + return class_getMethodImplementation_m68k(class, selector); +} + +IMP +class_getMethodImplementation_stret(Class class, SEL selector) +{ + return class_getMethodImplementation_stret_m68k(class, selector); +} + +const char * +class_getMethodTypeEncoding(Class class, SEL selector) +{ + return class_getMethodTypeEncoding_m68k(class, selector); +} + +bool +class_addMethod(Class class, SEL selector, IMP implementation, + const char *typeEncoding) +{ + return class_addMethod_m68k(class, selector, implementation, typeEncoding); } IMP -class_replaceMethod(Class cls, SEL selector, IMP implementation, +class_replaceMethod(Class class, SEL selector, IMP implementation, const char *typeEncoding) { - return class_replaceMethod_m68k(cls, selector, implementation, + return class_replaceMethod_m68k(class, selector, implementation, typeEncoding); } Class object_getClass(id object) @@ -418,13 +418,13 @@ { return object_getClass_m68k(object); } Class -object_setClass(id object, Class cls) +object_setClass(id object, Class class) { - return object_setClass_m68k(object, cls); + return object_setClass_m68k(object, class); } const char * object_getClassName(id object) { Index: src/runtime/lookup.m ================================================================== --- src/runtime/lookup.m +++ src/runtime/lookup.m @@ -47,18 +47,18 @@ bool isClass = object_getClass(object)->info & OBJC_CLASS_INFO_METACLASS; if (!(object_getClass(object)->info & OBJC_CLASS_INFO_INITIALIZED)) { - Class cls = (isClass + Class class = (isClass ? (Class)object : object_getClass(object)); - objc_initialize_class(cls); + objc_initialize_class(class); - if (!(cls->info & OBJC_CLASS_INFO_SETUP)) + if (!(class->info & OBJC_CLASS_INFO_SETUP)) OBJC_ERROR("Could not dispatch message for incomplete " - "class %s!", cls->name); + "class %s!", class_getName(class)); /* * We don't need to handle the case that super was called. * The reason for this is that a call to super is not possible * before a message to the class has been sent and it thus has @@ -67,32 +67,32 @@ return lookup(object, selector); } /* Try resolveClassMethod: / resolveInstanceMethod: */ if (class_isMetaClass(object_getClass(object))) { - Class cls = object_getClass(object); + Class class = object_getClass(object); - if (class_respondsToSelector(cls, + if (class_respondsToSelector(class, @selector(resolveClassMethod:)) && [object resolveClassMethod: selector]) { - if (!class_respondsToSelector(cls, selector)) - OBJC_ERROR("[%s resolveClassMethod: %s] " + if (!class_respondsToSelector(class, selector)) + OBJC_ERROR("+[%s resolveClassMethod: %s] " "returned true without adding the method!", class_getName(object), sel_getName(selector)); return lookup(object, selector); } } else { - Class cls = object_getClass(object); - Class metaclass = object_getClass(cls); + Class class = object_getClass(object); + Class metaclass = object_getClass(class); if (class_respondsToSelector(metaclass, @selector(resolveInstanceMethod:)) && - [cls resolveInstanceMethod: selector]) { - if (!class_respondsToSelector(cls, selector)) - OBJC_ERROR("[%s resolveInstanceMethod: %s] " + [class resolveInstanceMethod: selector]) { + if (!class_respondsToSelector(class, selector)) + OBJC_ERROR("+[%s resolveInstanceMethod: %s] " "returned true without adding the method!", class_getName(object_getClass(object)), sel_getName(selector)); return lookup(object, selector); @@ -127,16 +127,16 @@ forwardHandler = forward; stretForwardHandler = stretForward; } bool -class_respondsToSelector(Class cls, SEL selector) +class_respondsToSelector(Class class, SEL selector) { - if (cls == Nil) + if (class == Nil) return false; - return (objc_dtable_get(cls->DTable, + return (objc_dtable_get(class->DTable, (uint32_t)selector->UID) != (IMP)0); } #ifndef OF_ASM_LOOKUP static id @@ -181,11 +181,11 @@ IMP imp; if (super->self == nil) return (IMP)nilMethod; - imp = objc_dtable_get(super->cls->DTable, (uint32_t)selector->UID); + imp = objc_dtable_get(super->class->DTable, (uint32_t)selector->UID); if (imp == (IMP)0) return notFound(super->self, selector); return imp; Index: src/runtime/protocol.m ================================================================== --- src/runtime/protocol.m +++ src/runtime/protocol.m @@ -53,27 +53,27 @@ return false; } bool -class_conformsToProtocol(Class cls, Protocol *protocol) +class_conformsToProtocol(Class class, Protocol *protocol) { struct objc_category **categories; - if (cls == Nil) + if (class == Nil) return false; - for (struct objc_protocol_list *protocolList = cls->protocols; + for (struct objc_protocol_list *protocolList = class->protocols; protocolList != NULL; protocolList = protocolList->next) for (long i = 0; i < protocolList->count; i++) if (protocol_conformsToProtocol(protocolList->list[i], protocol)) return true; objc_global_mutex_lock(); - if ((categories = objc_categories_for_class(cls)) == NULL) { + if ((categories = objc_categories_for_class(class)) == NULL) { objc_global_mutex_unlock(); return false; } for (long i = 0; categories[i] != NULL; i++) { Index: src/runtime/selector.m ================================================================== --- src/runtime/selector.m +++ src/runtime/selector.m @@ -39,82 +39,84 @@ static struct objc_sparsearray *selectorNames = NULL; static void **freeList = NULL; static size_t freeListCount = 0; void -objc_register_selector(struct objc_abi_selector *sel) +objc_register_selector(struct objc_abi_selector *rawSelector) { - struct objc_selector *rsel; + struct objc_selector *selector; const char *name; if (selectorsCount > SEL_MAX) OBJC_ERROR("Out of selector slots!"); if (selectors == NULL) selectors = objc_hashtable_new( objc_hash_string, objc_equal_string, 2); - else if ((rsel = objc_hashtable_get(selectors, sel->name)) != NULL) { - ((struct objc_selector *)sel)->UID = rsel->UID; + else if ((selector = objc_hashtable_get(selectors, + rawSelector->name)) != NULL) { + ((struct objc_selector *)rawSelector)->UID = selector->UID; return; } if (selectorNames == NULL) selectorNames = objc_sparsearray_new(SEL_SIZE); - name = sel->name; - rsel = (struct objc_selector *)sel; - rsel->UID = selectorsCount++; + name = rawSelector->name; + selector = (struct objc_selector *)rawSelector; + selector->UID = selectorsCount++; - objc_hashtable_set(selectors, name, rsel); - objc_sparsearray_set(selectorNames, (uint32_t)rsel->UID, (void *)name); + objc_hashtable_set(selectors, name, selector); + objc_sparsearray_set(selectorNames, (uint32_t)selector->UID, + (void *)name); } SEL sel_registerName(const char *name) { - const struct objc_abi_selector *rsel; - struct objc_abi_selector *sel; + struct objc_abi_selector *rawSelector; objc_global_mutex_lock(); if (selectors != NULL && - (rsel = objc_hashtable_get(selectors, name)) != NULL) { + (rawSelector= objc_hashtable_get(selectors, name)) != NULL) { objc_global_mutex_unlock(); - return (SEL)rsel; + return (SEL)rawSelector; } - if ((sel = malloc(sizeof(struct objc_abi_selector))) == NULL) + if ((rawSelector = malloc(sizeof(*rawSelector))) == NULL) OBJC_ERROR("Not enough memory to allocate selector!"); - if ((sel->name = of_strdup(name)) == NULL) + if ((rawSelector->name = of_strdup(name)) == NULL) OBJC_ERROR("Not enough memory to allocate selector!"); - sel->typeEncoding = NULL; + rawSelector->typeEncoding = NULL; if ((freeList = realloc(freeList, sizeof(void *) * (freeListCount + 2))) == NULL) OBJC_ERROR("Not enough memory to allocate selector!"); - freeList[freeListCount++] = sel; - freeList[freeListCount++] = (char *)sel->name; + freeList[freeListCount++] = rawSelector; + freeList[freeListCount++] = (char *)rawSelector->name; - objc_register_selector(sel); + objc_register_selector(rawSelector); objc_global_mutex_unlock(); - return (SEL)sel; + return (SEL)rawSelector; } void objc_register_all_selectors(struct objc_abi_symtab *symtab) { - struct objc_abi_selector *sel; + struct objc_abi_selector *rawSelector; if (symtab->selectorRefs == NULL) return; - for (sel = symtab->selectorRefs; sel->name != NULL; sel++) - objc_register_selector(sel); + for (rawSelector = symtab->selectorRefs; rawSelector->name != NULL; + rawSelector++) + objc_register_selector(rawSelector); } const char * sel_getName(SEL selector) { Index: src/runtime/static-instances.m ================================================================== --- src/runtime/static-instances.m +++ src/runtime/static-instances.m @@ -31,17 +31,17 @@ { struct objc_abi_static_instances **staticInstances; /* Check if the class for a static instance became available */ for (size_t i = 0; i < staticInstancesCount; i++) { - Class cls = objc_lookUpClass( + Class class = objc_lookUpClass( staticInstancesList[i]->className); - if (cls != Nil) { + if (class != Nil) { for (id *instances = staticInstancesList[i]->instances; *instances != nil; instances++) - object_setClass(*instances, cls); + object_setClass(*instances, class); staticInstancesCount--; if (staticInstancesCount == 0) { free(staticInstancesList); @@ -73,16 +73,16 @@ if (staticInstances == NULL) return; for (; *staticInstances != NULL; staticInstances++) { - Class cls = objc_lookUpClass((*staticInstances)->className); + Class class = objc_lookUpClass((*staticInstances)->className); - if (cls != Nil) { + if (class != Nil) { for (id *instances = (*staticInstances)->instances; *instances != nil; instances++) - object_setClass(*instances, cls); + object_setClass(*instances, class); } else { staticInstancesList = realloc(staticInstancesList, sizeof(struct objc_abi_static_instances *) * (staticInstancesCount + 1));