diff options
Diffstat (limited to 'gcc-4.7/libobjc/class.c')
| -rw-r--r-- | gcc-4.7/libobjc/class.c | 1006 |
1 files changed, 0 insertions, 1006 deletions
diff --git a/gcc-4.7/libobjc/class.c b/gcc-4.7/libobjc/class.c deleted file mode 100644 index 3b750829f..000000000 --- a/gcc-4.7/libobjc/class.c +++ /dev/null @@ -1,1006 +0,0 @@ -/* GNU Objective C Runtime class related functions - Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002, 2009, 2010 - Free Software Foundation, Inc. - Contributed by Kresten Krab Thorup and Dennis Glatting. - - Lock-free class table code designed and written from scratch by - Nicola Pero, 2001. - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify it under the -terms of the GNU General Public License as published by the Free Software -Foundation; either version 3, or (at your option) any later version. - -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS -FOR A PARTICULAR PURPOSE. See the GNU General Public License for more -details. - -Under Section 7 of GPL version 3, you are granted additional -permissions described in the GCC Runtime Library Exception, version -3.1, as published by the Free Software Foundation. - -You should have received a copy of the GNU General Public License and -a copy of the GCC Runtime Library Exception along with this program; -see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -<http://www.gnu.org/licenses/>. */ - -/* The code in this file critically affects class method invocation - speed. This long preamble comment explains why, and the issues - involved. - - One of the traditional weaknesses of the GNU Objective-C runtime is - that class method invocations are slow. The reason is that when you - write - - array = [NSArray new]; - - this gets basically compiled into the equivalent of - - array = [(objc_get_class ("NSArray")) new]; - - objc_get_class returns the class pointer corresponding to the string - `NSArray'; and because of the lookup, the operation is more - complicated and slow than a simple instance method invocation. - - Most high performance Objective-C code (using the GNU Objc runtime) - I had the opportunity to read (or write) work around this problem by - caching the class pointer: - - Class arrayClass = [NSArray class]; - - ... later on ... - - array = [arrayClass new]; - array = [arrayClass new]; - array = [arrayClass new]; - - In this case, you always perform a class lookup (the first one), but - then all the [arrayClass new] methods run exactly as fast as an - instance method invocation. It helps if you have many class method - invocations to the same class. - - The long-term solution to this problem would be to modify the - compiler to output tables of class pointers corresponding to all the - class method invocations, and to add code to the runtime to update - these tables - that should in the end allow class method invocations - to perform precisely as fast as instance method invocations, because - no class lookup would be involved. I think the Apple Objective-C - runtime uses this technique. Doing this involves synchronized - modifications in the runtime and in the compiler. - - As a first medicine to the problem, I [NP] have redesigned and - rewritten the way the runtime is performing class lookup. This - doesn't give as much speed as the other (definitive) approach, but - at least a class method invocation now takes approximately 4.5 times - an instance method invocation on my machine (it would take approx 12 - times before the rewriting), which is a lot better. - - One of the main reason the new class lookup is so faster is because - I implemented it in a way that can safely run multithreaded without - using locks - a so-called `lock-free' data structure. The atomic - operation is pointer assignment. The reason why in this problem - lock-free data structures work so well is that you never remove - classes from the table - and the difficult thing with lock-free data - structures is freeing data when is removed from the structures. */ - -#include "objc-private/common.h" -#include "objc-private/error.h" -#include "objc/runtime.h" -#include "objc/thr.h" -#include "objc-private/module-abi-8.h" /* For CLS_ISCLASS and similar. */ -#include "objc-private/runtime.h" /* the kitchen sink */ -#include "objc-private/sarray.h" /* For sarray_put_at_safe. */ -#include "objc-private/selector.h" /* For sarray_put_at_safe. */ -#include <string.h> /* For memset */ - -/* We use a table which maps a class name to the corresponding class - pointer. The first part of this file defines this table, and - functions to do basic operations on the table. The second part of - the file implements some higher level Objective-C functionality for - classes by using the functions provided in the first part to manage - the table. */ - -/** - ** Class Table Internals - **/ - -/* A node holding a class */ -typedef struct class_node -{ - struct class_node *next; /* Pointer to next entry on the list. - NULL indicates end of list. */ - - const char *name; /* The class name string */ - int length; /* The class name string length */ - Class pointer; /* The Class pointer */ - -} *class_node_ptr; - -/* A table containing classes is a class_node_ptr (pointing to the - first entry in the table - if it is NULL, then the table is - empty). */ - -/* We have 1024 tables. Each table contains all class names which - have the same hash (which is a number between 0 and 1023). To look - up a class_name, we compute its hash, and get the corresponding - table. Once we have the table, we simply compare strings directly - till we find the one which we want (using the length first). The - number of tables is quite big on purpose (a normal big application - has less than 1000 classes), so that you shouldn't normally get any - collisions, and get away with a single comparison (which we can't - avoid since we need to know that you have got the right thing). */ -#define CLASS_TABLE_SIZE 1024 -#define CLASS_TABLE_MASK 1023 - -static class_node_ptr class_table_array[CLASS_TABLE_SIZE]; - -/* The table writing mutex - we lock on writing to avoid conflicts - between different writers, but we read without locks. That is - possible because we assume pointer assignment to be an atomic - operation. TODO: This is only true under certain circumstances, - which should be clarified. */ -static objc_mutex_t __class_table_lock = NULL; - -/* CLASS_TABLE_HASH is how we compute the hash of a class name. It is - a macro - *not* a function - arguments *are* modified directly. - - INDEX should be a variable holding an int; - HASH should be a variable holding an int; - CLASS_NAME should be a variable holding a (char *) to the class_name. - - After the macro is executed, INDEX contains the length of the - string, and HASH the computed hash of the string; CLASS_NAME is - untouched. */ - -#define CLASS_TABLE_HASH(INDEX, HASH, CLASS_NAME) \ - HASH = 0; \ - for (INDEX = 0; CLASS_NAME[INDEX] != '\0'; INDEX++) \ - { \ - HASH = (HASH << 4) ^ (HASH >> 28) ^ CLASS_NAME[INDEX]; \ - } \ - \ - HASH = (HASH ^ (HASH >> 10) ^ (HASH >> 20)) & CLASS_TABLE_MASK; - -/* Setup the table. */ -static void -class_table_setup (void) -{ - /* Start - nothing in the table. */ - memset (class_table_array, 0, sizeof (class_node_ptr) * CLASS_TABLE_SIZE); - - /* The table writing mutex. */ - __class_table_lock = objc_mutex_allocate (); -} - - -/* Insert a class in the table (used when a new class is - registered). */ -static void -class_table_insert (const char *class_name, Class class_pointer) -{ - int hash, length; - class_node_ptr new_node; - - /* Find out the class name's hash and length. */ - CLASS_TABLE_HASH (length, hash, class_name); - - /* Prepare the new node holding the class. */ - new_node = objc_malloc (sizeof (struct class_node)); - new_node->name = class_name; - new_node->length = length; - new_node->pointer = class_pointer; - - /* Lock the table for modifications. */ - objc_mutex_lock (__class_table_lock); - - /* Insert the new node in the table at the beginning of the table at - class_table_array[hash]. */ - new_node->next = class_table_array[hash]; - class_table_array[hash] = new_node; - - objc_mutex_unlock (__class_table_lock); -} - -/* Get a class from the table. This does not need mutex protection. - Currently, this function is called each time you call a static - method, this is why it must be very fast. */ -static inline Class -class_table_get_safe (const char *class_name) -{ - class_node_ptr node; - int length, hash; - - /* Compute length and hash. */ - CLASS_TABLE_HASH (length, hash, class_name); - - node = class_table_array[hash]; - - if (node != NULL) - { - do - { - if (node->length == length) - { - /* Compare the class names. */ - int i; - - for (i = 0; i < length; i++) - { - if ((node->name)[i] != class_name[i]) - break; - } - - if (i == length) - { - /* They are equal! */ - return node->pointer; - } - } - } - while ((node = node->next) != NULL); - } - - return Nil; -} - -/* Enumerate over the class table. */ -struct class_table_enumerator -{ - int hash; - class_node_ptr node; -}; - - -static Class -class_table_next (struct class_table_enumerator **e) -{ - struct class_table_enumerator *enumerator = *e; - class_node_ptr next; - - if (enumerator == NULL) - { - *e = objc_malloc (sizeof (struct class_table_enumerator)); - enumerator = *e; - enumerator->hash = 0; - enumerator->node = NULL; - - next = class_table_array[enumerator->hash]; - } - else - next = enumerator->node->next; - - if (next != NULL) - { - enumerator->node = next; - return enumerator->node->pointer; - } - else - { - enumerator->hash++; - - while (enumerator->hash < CLASS_TABLE_SIZE) - { - next = class_table_array[enumerator->hash]; - if (next != NULL) - { - enumerator->node = next; - return enumerator->node->pointer; - } - enumerator->hash++; - } - - /* Ok - table finished - done. */ - objc_free (enumerator); - return Nil; - } -} - -#if 0 /* DEBUGGING FUNCTIONS */ -/* Debugging function - print the class table. */ -void -class_table_print (void) -{ - int i; - - for (i = 0; i < CLASS_TABLE_SIZE; i++) - { - class_node_ptr node; - - printf ("%d:\n", i); - node = class_table_array[i]; - - while (node != NULL) - { - printf ("\t%s\n", node->name); - node = node->next; - } - } -} - -/* Debugging function - print an histogram of number of classes in - function of hash key values. Useful to evaluate the hash function - in real cases. */ -void -class_table_print_histogram (void) -{ - int i, j; - int counter = 0; - - for (i = 0; i < CLASS_TABLE_SIZE; i++) - { - class_node_ptr node; - - node = class_table_array[i]; - - while (node != NULL) - { - counter++; - node = node->next; - } - if (((i + 1) % 50) == 0) - { - printf ("%4d:", i + 1); - for (j = 0; j < counter; j++) - printf ("X"); - - printf ("\n"); - counter = 0; - } - } - printf ("%4d:", i + 1); - for (j = 0; j < counter; j++) - printf ("X"); - - printf ("\n"); -} -#endif /* DEBUGGING FUNCTIONS */ - -/** - ** Objective-C runtime functions - **/ - -/* From now on, the only access to the class table data structure - should be via the class_table_* functions. */ - -/* This is a hook which is called by objc_get_class and - objc_lookup_class if the runtime is not able to find the class. - This may e.g. try to load in the class using dynamic loading. - - This hook was a public, global variable in the Traditional GNU - Objective-C Runtime API (objc/objc-api.h). The modern GNU - Objective-C Runtime API (objc/runtime.h) provides the - objc_setGetUnknownClassHandler() function instead. -*/ -Class (*_objc_lookup_class) (const char *name) = 0; /* !T:SAFE */ - -/* The handler currently in use. PS: if both - __obj_get_unknown_class_handler and _objc_lookup_class are defined, - __objc_get_unknown_class_handler is called first. */ -static objc_get_unknown_class_handler -__objc_get_unknown_class_handler = NULL; - -objc_get_unknown_class_handler -objc_setGetUnknownClassHandler (objc_get_unknown_class_handler - new_handler) -{ - objc_get_unknown_class_handler old_handler - = __objc_get_unknown_class_handler; - __objc_get_unknown_class_handler = new_handler; - return old_handler; -} - - -/* True when class links has been resolved. */ -BOOL __objc_class_links_resolved = NO; /* !T:UNUSED */ - - -void -__objc_init_class_tables (void) -{ - /* Allocate the class hash table. */ - - if (__class_table_lock) - return; - - objc_mutex_lock (__objc_runtime_mutex); - - class_table_setup (); - - objc_mutex_unlock (__objc_runtime_mutex); -} - -/* This function adds a class to the class hash table, and assigns the - class a number, unless it's already known. Return 'YES' if the - class was added. Return 'NO' if the class was already known. */ -BOOL -__objc_add_class_to_hash (Class class) -{ - Class existing_class; - - objc_mutex_lock (__objc_runtime_mutex); - - /* Make sure the table is there. */ - assert (__class_table_lock); - - /* Make sure it's not a meta class. */ - assert (CLS_ISCLASS (class)); - - /* Check to see if the class is already in the hash table. */ - existing_class = class_table_get_safe (class->name); - - if (existing_class) - { - objc_mutex_unlock (__objc_runtime_mutex); - return NO; - } - else - { - /* The class isn't in the hash table. Add the class and assign - a class number. */ - static unsigned int class_number = 1; - - CLS_SETNUMBER (class, class_number); - CLS_SETNUMBER (class->class_pointer, class_number); - - ++class_number; - class_table_insert (class->name, class); - - objc_mutex_unlock (__objc_runtime_mutex); - return YES; - } -} - -Class -objc_getClass (const char *name) -{ - Class class; - - if (name == NULL) - return Nil; - - class = class_table_get_safe (name); - - if (class) - return class; - - if (__objc_get_unknown_class_handler) - return (*__objc_get_unknown_class_handler) (name); - - if (_objc_lookup_class) - return (*_objc_lookup_class) (name); - - return Nil; -} - -Class -objc_lookUpClass (const char *name) -{ - if (name == NULL) - return Nil; - else - return class_table_get_safe (name); -} - -Class -objc_getMetaClass (const char *name) -{ - Class class = objc_getClass (name); - - if (class) - return class->class_pointer; - else - return Nil; -} - -Class -objc_getRequiredClass (const char *name) -{ - Class class = objc_getClass (name); - - if (class) - return class; - else - _objc_abort ("objc_getRequiredClass ('%s') failed: class not found\n", name); -} - -int -objc_getClassList (Class *returnValue, int maxNumberOfClassesToReturn) -{ - /* Iterate over all entries in the table. */ - int hash, count = 0; - - for (hash = 0; hash < CLASS_TABLE_SIZE; hash++) - { - class_node_ptr node = class_table_array[hash]; - - while (node != NULL) - { - if (returnValue) - { - if (count < maxNumberOfClassesToReturn) - returnValue[count] = node->pointer; - else - return count; - } - count++; - node = node->next; - } - } - - return count; -} - -Class -objc_allocateClassPair (Class super_class, const char *class_name, size_t extraBytes) -{ - Class new_class; - Class new_meta_class; - - if (class_name == NULL) - return Nil; - - if (objc_getClass (class_name)) - return Nil; - - if (super_class) - { - /* If you want to build a hierarchy of classes, you need to - build and register them one at a time. The risk is that you - are able to cause confusion by registering a subclass before - the superclass or similar. */ - if (CLS_IS_IN_CONSTRUCTION (super_class)) - return Nil; - } - - /* Technically, we should create the metaclass first, then use - class_createInstance() to create the class. That complication - would be relevant if we had class variables, but we don't, so we - just ignore it and create everything directly and assume all - classes have the same size. */ - new_class = objc_calloc (1, sizeof (struct objc_class) + extraBytes); - new_meta_class = objc_calloc (1, sizeof (struct objc_class) + extraBytes); - - /* We create an unresolved class, similar to one generated by the - compiler. It will be resolved later when we register it. - - Note how the metaclass details are not that important; when the - class is resolved, the ones that matter will be fixed up. */ - new_class->class_pointer = new_meta_class; - new_meta_class->class_pointer = 0; - - if (super_class) - { - /* Force the name of the superclass in place of the link to the - actual superclass, which will be put there when the class is - resolved. */ - const char *super_class_name = class_getName (super_class); - new_class->super_class = (void *)super_class_name; - new_meta_class->super_class = (void *)super_class_name; - } - else - { - new_class->super_class = (void *)0; - new_meta_class->super_class = (void *)0; - } - - new_class->name = objc_malloc (strlen (class_name) + 1); - strcpy ((char*)new_class->name, class_name); - new_meta_class->name = new_class->name; - - new_class->version = 0; - new_meta_class->version = 0; - - new_class->info = _CLS_CLASS | _CLS_IN_CONSTRUCTION; - new_meta_class->info = _CLS_META | _CLS_IN_CONSTRUCTION; - - if (super_class) - new_class->instance_size = super_class->instance_size; - else - new_class->instance_size = 0; - new_meta_class->instance_size = sizeof (struct objc_class); - - return new_class; -} - -void -objc_registerClassPair (Class class_) -{ - if (class_ == Nil) - return; - - if ((! CLS_ISCLASS (class_)) || (! CLS_IS_IN_CONSTRUCTION (class_))) - return; - - if ((! CLS_ISMETA (class_->class_pointer)) || (! CLS_IS_IN_CONSTRUCTION (class_->class_pointer))) - return; - - objc_mutex_lock (__objc_runtime_mutex); - - if (objc_getClass (class_->name)) - { - objc_mutex_unlock (__objc_runtime_mutex); - return; - } - - CLS_SET_NOT_IN_CONSTRUCTION (class_); - CLS_SET_NOT_IN_CONSTRUCTION (class_->class_pointer); - - __objc_init_class (class_); - - /* Resolve class links immediately. No point in waiting. */ - __objc_resolve_class_links (); - - objc_mutex_unlock (__objc_runtime_mutex); -} - -void -objc_disposeClassPair (Class class_) -{ - if (class_ == Nil) - return; - - if ((! CLS_ISCLASS (class_)) || (! CLS_IS_IN_CONSTRUCTION (class_))) - return; - - if ((! CLS_ISMETA (class_->class_pointer)) || (! CLS_IS_IN_CONSTRUCTION (class_->class_pointer))) - return; - - /* Undo any class_addIvar(). */ - if (class_->ivars) - { - int i; - for (i = 0; i < class_->ivars->ivar_count; i++) - { - struct objc_ivar *ivar = &(class_->ivars->ivar_list[i]); - - objc_free ((char *)ivar->ivar_name); - objc_free ((char *)ivar->ivar_type); - } - - objc_free (class_->ivars); - } - - /* Undo any class_addMethod(). */ - if (class_->methods) - { - struct objc_method_list *list = class_->methods; - while (list) - { - int i; - struct objc_method_list *next = list->method_next; - - for (i = 0; i < list->method_count; i++) - { - struct objc_method *method = &(list->method_list[i]); - - objc_free ((char *)method->method_name); - objc_free ((char *)method->method_types); - } - - objc_free (list); - list = next; - } - } - - /* Undo any class_addProtocol(). */ - if (class_->protocols) - { - struct objc_protocol_list *list = class_->protocols; - while (list) - { - struct objc_protocol_list *next = list->next; - - objc_free (list); - list = next; - } - } - - /* Undo any class_addMethod() on the meta-class. */ - if (class_->class_pointer->methods) - { - struct objc_method_list *list = class_->class_pointer->methods; - while (list) - { - int i; - struct objc_method_list *next = list->method_next; - - for (i = 0; i < list->method_count; i++) - { - struct objc_method *method = &(list->method_list[i]); - - objc_free ((char *)method->method_name); - objc_free ((char *)method->method_types); - } - - objc_free (list); - list = next; - } - } - - /* Undo objc_allocateClassPair(). */ - objc_free ((char *)(class_->name)); - objc_free (class_->class_pointer); - objc_free (class_); -} - -/* Traditional GNU Objective-C Runtime API. Important: this method is - called automatically by the compiler while messaging (if using the - traditional ABI), so it is worth keeping it fast; don't make it - just a wrapper around objc_getClass(). */ -/* Note that this is roughly equivalent to objc_getRequiredClass(). */ -/* Get the class object for the class named NAME. If NAME does not - identify a known class, the hook _objc_lookup_class is called. If - this fails, an error message is issued and the system aborts. */ -Class -objc_get_class (const char *name) -{ - Class class; - - class = class_table_get_safe (name); - - if (class) - return class; - - if (__objc_get_unknown_class_handler) - class = (*__objc_get_unknown_class_handler) (name); - - if ((!class) && _objc_lookup_class) - class = (*_objc_lookup_class) (name); - - if (class) - return class; - - _objc_abort ("objc runtime: cannot find class %s\n", name); - - return 0; -} - -/* This is used by the compiler too. */ -Class -objc_get_meta_class (const char *name) -{ - return objc_get_class (name)->class_pointer; -} - -/* This is not used by GCC, but the clang compiler seems to use it - when targetting the GNU runtime. That's wrong, but we have it to - be compatible. */ -Class -objc_lookup_class (const char *name) -{ - return objc_getClass (name); -} - -/* This is used when the implementation of a method changes. It goes - through all classes, looking for the ones that have these methods - (either method_a or method_b; method_b can be NULL), and reloads - the implementation for these. You should call this with the - runtime mutex already locked. */ -void -__objc_update_classes_with_methods (struct objc_method *method_a, struct objc_method *method_b) -{ - int hash; - - /* Iterate over all classes. */ - for (hash = 0; hash < CLASS_TABLE_SIZE; hash++) - { - class_node_ptr node = class_table_array[hash]; - - while (node != NULL) - { - /* We execute this loop twice: the first time, we iterate - over all methods in the class (instance methods), while - the second time we iterate over all methods in the meta - class (class methods). */ - Class class = Nil; - BOOL done = NO; - - while (done == NO) - { - struct objc_method_list * method_list; - - if (class == Nil) - { - /* The first time, we work on the class. */ - class = node->pointer; - } - else - { - /* The second time, we work on the meta class. */ - class = class->class_pointer; - done = YES; - } - - method_list = class->methods; - - while (method_list) - { - int i; - - for (i = 0; i < method_list->method_count; ++i) - { - struct objc_method *method = &method_list->method_list[i]; - - /* If the method is one of the ones we are - looking for, update the implementation. */ - if (method == method_a) - sarray_at_put_safe (class->dtable, - (sidx) method_a->method_name->sel_id, - method_a->method_imp); - - if (method == method_b) - { - if (method_b != NULL) - sarray_at_put_safe (class->dtable, - (sidx) method_b->method_name->sel_id, - method_b->method_imp); - } - } - - method_list = method_list->method_next; - } - } - node = node->next; - } - } -} - -/* Resolve super/subclass links for all classes. The only thing we - can be sure of is that the class_pointer for class objects point to - the right meta class objects. */ -void -__objc_resolve_class_links (void) -{ - struct class_table_enumerator *es = NULL; - Class object_class = objc_get_class ("Object"); - Class class1; - - assert (object_class); - - objc_mutex_lock (__objc_runtime_mutex); - - /* Assign subclass links. */ - while ((class1 = class_table_next (&es))) - { - /* Make sure we have what we think we have. */ - assert (CLS_ISCLASS (class1)); - assert (CLS_ISMETA (class1->class_pointer)); - - /* The class_pointer of all meta classes point to Object's meta - class. */ - class1->class_pointer->class_pointer = object_class->class_pointer; - - if (! CLS_ISRESOLV (class1)) - { - CLS_SETRESOLV (class1); - CLS_SETRESOLV (class1->class_pointer); - - if (class1->super_class) - { - Class a_super_class - = objc_get_class ((char *) class1->super_class); - - assert (a_super_class); - - DEBUG_PRINTF ("making class connections for: %s\n", - class1->name); - - /* Assign subclass links for superclass. */ - class1->sibling_class = a_super_class->subclass_list; - a_super_class->subclass_list = class1; - - /* Assign subclass links for meta class of superclass. */ - if (a_super_class->class_pointer) - { - class1->class_pointer->sibling_class - = a_super_class->class_pointer->subclass_list; - a_super_class->class_pointer->subclass_list - = class1->class_pointer; - } - } - else /* A root class, make its meta object be a subclass of - Object. */ - { - class1->class_pointer->sibling_class - = object_class->subclass_list; - object_class->subclass_list = class1->class_pointer; - } - } - } - - /* Assign superclass links. */ - es = NULL; - while ((class1 = class_table_next (&es))) - { - Class sub_class; - for (sub_class = class1->subclass_list; sub_class; - sub_class = sub_class->sibling_class) - { - sub_class->super_class = class1; - if (CLS_ISCLASS (sub_class)) - sub_class->class_pointer->super_class = class1->class_pointer; - } - } - - objc_mutex_unlock (__objc_runtime_mutex); -} - -const char * -class_getName (Class class_) -{ - if (class_ == Nil) - return "nil"; - - return class_->name; -} - -BOOL -class_isMetaClass (Class class_) -{ - /* CLS_ISMETA includes the check for Nil class_. */ - return CLS_ISMETA (class_); -} - -/* Even inside libobjc it may be worth using class_getSuperclass - instead of accessing class_->super_class directly because it - resolves the class links if needed. If you access - class_->super_class directly, make sure to deal with the situation - where the class is not resolved yet! */ -Class -class_getSuperclass (Class class_) -{ - if (class_ == Nil) - return Nil; - - /* Classes that are in construction are not resolved, and still have - the class name (instead of a class pointer) in the - class_->super_class field. In that case we need to lookup the - superclass name to return the superclass. We can not resolve the - class until it is registered. */ - if (CLS_IS_IN_CONSTRUCTION (class_)) - { - if (CLS_ISMETA (class_)) - return object_getClass ((id)objc_lookUpClass ((const char *)(class_->super_class))); - else - return objc_lookUpClass ((const char *)(class_->super_class)); - } - - /* If the class is not resolved yet, super_class would point to a - string (the name of the super class) as opposed to the actual - super class. In that case, we need to resolve the class links - before we can return super_class. */ - if (! CLS_ISRESOLV (class_)) - __objc_resolve_class_links (); - - return class_->super_class; -} - -int -class_getVersion (Class class_) -{ - if (class_ == Nil) - return 0; - - return (int)(class_->version); -} - -void -class_setVersion (Class class_, int version) -{ - if (class_ == Nil) - return; - - class_->version = version; -} - -size_t -class_getInstanceSize (Class class_) -{ - if (class_ == Nil) - return 0; - - return class_->instance_size; -} - |