X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=libobjc%2Finit.c;h=33a933875b0e6ac7f706ecca012cd7da8d8de4d5;hb=9d1e93a51ddb4d2347b0609601feca13cf4a29a1;hp=954fc9240ae7f0f15a47fa2162a35e194b220e8b;hpb=3dc3ad443f9b5847d5d576eea3eb97cc81c038ed;p=pf3gnuchains%2Fgcc-fork.git diff --git a/libobjc/init.c b/libobjc/init.c index 954fc9240ae..33a933875b0 100644 --- a/libobjc/init.c +++ b/libobjc/init.c @@ -1,21 +1,21 @@ /* GNU Objective C Runtime initialization - Copyright (C) 1993, 1995, 1996, 1997 Free Software Foundation, Inc. + Copyright (C) 1993, 1995, 1996, 1997, 2002 Free Software Foundation, Inc. Contributed by Kresten Krab Thorup +load support contributed by Ovidiu Predescu -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify it under the +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 2, or (at your option) any later version. -GNU CC is distributed in the hope that it will be useful, but WITHOUT ANY +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. You should have received a copy of the GNU General Public License along with -GNU CC; see the file COPYING. If not, write to the Free Software +GCC; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* As a special exception, if you link this library with files compiled with @@ -27,62 +27,62 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "runtime.h" /* The version number of this runtime. This must match the number - defined in gcc (objc-act.c) */ + defined in gcc (objc-act.c). */ #define OBJC_VERSION 8 #define PROTOCOL_VERSION 2 -/* This list contains all modules currently loaded into the runtime */ -static struct objc_list* __objc_module_list = 0; /* !T:MUTEX */ +/* This list contains all modules currently loaded into the runtime. */ +static struct objc_list *__objc_module_list = 0; /* !T:MUTEX */ -/* This list contains all proto_list's not yet assigned class links */ -static struct objc_list* unclaimed_proto_list = 0; /* !T:MUTEX */ +/* This list contains all proto_list's not yet assigned class links. */ +static struct objc_list *unclaimed_proto_list = 0; /* !T:MUTEX */ /* List of unresolved static instances. */ static struct objc_list *uninitialized_statics = 0; /* !T:MUTEX */ -/* Global runtime "write" mutex. */ +/* Global runtime "write" mutex. */ objc_mutex_t __objc_runtime_mutex = 0; -/* Number of threads that are alive. */ +/* Number of threads that are alive. */ int __objc_runtime_threads_alive = 1; /* !T:MUTEX */ -/* Check compiler vs runtime version */ +/* Check compiler vs runtime version. */ static void init_check_module_version (Module_t); -/* Assign isa links to protos */ -static void __objc_init_protocols (struct objc_protocol_list* protos); +/* Assign isa links to protos. */ +static void __objc_init_protocols (struct objc_protocol_list *protos); -/* Add protocol to class */ -static void __objc_class_add_protocols (Class, struct objc_protocol_list*); +/* Add protocol to class. */ +static void __objc_class_add_protocols (Class, struct objc_protocol_list *); -/* This is a hook which is called by __objc_exec_class every time a class - or a category is loaded into the runtime. This may e.g. help a - dynamic loader determine the classes that have been loaded when - an object file is dynamically linked in */ -void (*_objc_load_callback)(Class class, Category* category); /* !T:SAFE */ +/* This is a hook which is called by __objc_exec_class every time a + class or a category is loaded into the runtime. This may e.g. help + a dynamic loader determine the classes that have been loaded when + an object file is dynamically linked in. */ +void (*_objc_load_callback) (Class class, Category *category); /* !T:SAFE */ -/* Is all categories/classes resolved? */ +/* Is all categories/classes resolved? */ BOOL __objc_dangling_categories = NO; /* !T:UNUSED */ extern SEL __sel_register_typed_name (const char *name, const char *types, struct objc_selector *orig, BOOL is_const); -/* Sends +load to all classes and categories in certain situations. */ +/* Sends +load to all classes and categories in certain situations. */ static void objc_send_load (void); /* Inserts all the classes defined in module in a tree of classes that - resembles the class hierarchy. This tree is traversed in preorder and the - classes in its nodes receive the +load message if these methods were not - executed before. The algorithm ensures that when the +load method of a class - is executed all the superclasses have been already received the +load - message. */ + resembles the class hierarchy. This tree is traversed in preorder + and the classes in its nodes receive the +load message if these + methods were not executed before. The algorithm ensures that when + the +load method of a class is executed all the superclasses have + been already received the +load message. */ static void __objc_create_classes_tree (Module_t module); static void __objc_call_callback (Module_t module); /* A special version that works only before the classes are completely - installed in the runtime. */ + installed in the runtime. */ static BOOL class_is_subclass_of_class (Class class, Class superclass); typedef struct objc_class_tree { @@ -90,24 +90,70 @@ typedef struct objc_class_tree { struct objc_list *subclasses; /* `head' is pointer to an objc_class_tree */ } objc_class_tree; -/* This is a linked list of objc_class_tree trees. The head of these trees - are root classes (their super class is Nil). These different trees - represent different class hierarchies. */ +/* This is a linked list of objc_class_tree trees. The head of these + trees are root classes (their super class is Nil). These different + trees represent different class hierarchies. */ static struct objc_list *__objc_class_tree_list = NULL; -/* Keeps the +load methods who have been already executed. This hash should - not be destroyed during the execution of the program. */ +/* Keeps the +load methods who have been already executed. This hash + should not be destroyed during the execution of the program. */ static cache_ptr __objc_load_methods = NULL; -/* Creates a tree of classes whose topmost class is directly inherited from - `upper' and the bottom class in this tree is `bottom_class'. The classes - in this tree are super classes of `bottom_class'. `subclasses' member - of each tree node point to the next subclass tree node. */ +/* This function is used when building the class tree used to send + ordinately the +load message to all classes needing it. The tree + is really needed so that superclasses will get the message before + subclasses. + + This tree will contain classes which are being loaded (or have just + being loaded), and whose super_class pointers have not yet been + resolved. This implies that their super_class pointers point to a + string with the name of the superclass; when the first message is + sent to the class (/an object of that class) the class links will + be resolved, which will replace the super_class pointers with + pointers to the actual superclasses. + + Unfortunately, the tree might also contain classes which had been + loaded previously, and whose class links have already been + resolved. + + This function returns the superclass of a class in both cases, and + can be used to build the determine the class relationships while + building the tree. +*/ +static Class class_superclass_of_class (Class class) +{ + char *super_class_name; + + /* If the class links have been resolved, use the resolved + * links. */ + if (CLS_ISRESOLV (class)) + return class->super_class; + + /* Else, 'class' has not yet been resolved. This means that its + * super_class pointer is really the name of the super class (rather + * than a pointer to the actual superclass). */ + super_class_name = (char *)class->super_class; + + /* Return Nil for a root class. */ + if (super_class_name == NULL) + return Nil; + + /* Lookup the superclass of non-root classes. */ + return objc_lookup_class (super_class_name); +} + + +/* Creates a tree of classes whose topmost class is directly inherited + from `upper' and the bottom class in this tree is + `bottom_class'. The classes in this tree are super classes of + `bottom_class'. `subclasses' member of each tree node point to the + next subclass tree node. */ + static objc_class_tree * create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper) { Class superclass = bottom_class->super_class ? - objc_lookup_class ((char*)bottom_class->super_class) + objc_lookup_class ((char *) bottom_class->super_class) : Nil; objc_class_tree *tree, *prev; @@ -125,20 +171,20 @@ create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper) tree = objc_calloc (1, sizeof (objc_class_tree)); tree->class = superclass; tree->subclasses = list_cons (prev, tree->subclasses); - superclass = (superclass->super_class ? - objc_lookup_class ((char*)superclass->super_class) - : Nil); + superclass = class_superclass_of_class (superclass); prev = tree; } return tree; } -/* Insert the `class' into the proper place in the `tree' class hierarchy. This - function returns a new tree if the class has been successfully inserted into - the tree or NULL if the class is not part of the classes hierarchy described - by `tree'. This function is private to objc_tree_insert_class(), you should - not call it directly. */ +/* Insert the `class' into the proper place in the `tree' class + hierarchy. This function returns a new tree if the class has been + successfully inserted into the tree or NULL if the class is not + part of the classes hierarchy described by `tree'. This function is + private to objc_tree_insert_class (), you should not call it + directly. */ + static objc_class_tree * __objc_tree_insert_class (objc_class_tree *tree, Class class) { @@ -153,22 +199,19 @@ __objc_tree_insert_class (objc_class_tree *tree, Class class) DEBUG_PRINTF ("1. class %s was previously inserted\n", class->name); return tree; } - else if ((class->super_class ? - objc_lookup_class ((char*)class->super_class) - : Nil) - == tree->class) + else if (class_superclass_of_class (class) == tree->class) { /* If class is a direct subclass of tree->class then add class to the list of subclasses. First check to see if it wasn't already - inserted. */ + inserted. */ struct objc_list *list = tree->subclasses; objc_class_tree *node; while (list) { /* Class has been already inserted; do nothing just return - the tree. */ - if (((objc_class_tree*)list->head)->class == class) + the tree. */ + if (((objc_class_tree *) list->head)->class == class) { DEBUG_PRINTF ("2. class %s was previously inserted\n", class->name); @@ -186,24 +229,25 @@ __objc_tree_insert_class (objc_class_tree *tree, Class class) } else { - /* The class is not a direct subclass of tree->class. Search for class's - superclasses in the list of subclasses. */ + /* The class is not a direct subclass of tree->class. Search for + class's superclasses in the list of subclasses. */ struct objc_list *subclasses = tree->subclasses; - /* Precondition: the class must be a subclass of tree->class; otherwise - return NULL to indicate our caller that it must take the next tree. */ - if (!class_is_subclass_of_class (class, tree->class)) + /* Precondition: the class must be a subclass of tree->class; + otherwise return NULL to indicate our caller that it must + take the next tree. */ + if (! class_is_subclass_of_class (class, tree->class)) return NULL; for (; subclasses != NULL; subclasses = subclasses->tail) { - Class aClass = ((objc_class_tree*)(subclasses->head))->class; + Class aClass = ((objc_class_tree *) (subclasses->head))->class; if (class_is_subclass_of_class (class, aClass)) { - /* If we found one of class's superclasses we insert the class - into its subtree and return the original tree since nothing - has been changed. */ + /* If we found one of class's superclasses we insert the + class into its subtree and return the original tree + since nothing has been changed. */ subclasses->head = __objc_tree_insert_class (subclasses->head, class); DEBUG_PRINTF ("4. class %s inserted\n", class->name); @@ -211,12 +255,12 @@ __objc_tree_insert_class (objc_class_tree *tree, Class class) } } - /* We haven't found a subclass of `class' in the `subclasses' list. - Create a new tree of classes whose topmost class is a direct subclass - of tree->class. */ + /* We haven't found a subclass of `class' in the `subclasses' + list. Create a new tree of classes whose topmost class is a + direct subclass of tree->class. */ { objc_class_tree *new_tree - = create_tree_of_subclasses_inherited_from (class, tree->class); + = create_tree_of_subclasses_inherited_from (class, tree->class); tree->subclasses = list_cons (new_tree, tree->subclasses); DEBUG_PRINTF ("5. class %s inserted\n", class->name); return tree; @@ -224,7 +268,8 @@ __objc_tree_insert_class (objc_class_tree *tree, Class class) } } -/* This function inserts `class' in the right tree hierarchy classes. */ +/* This function inserts `class' in the right tree hierarchy classes. */ + static void objc_tree_insert_class (Class class) { @@ -244,20 +289,21 @@ objc_tree_insert_class (Class class) list_node = list_node->tail; } - /* If the list was finished but the class hasn't been inserted, insert it - here. */ - if (!list_node) + /* If the list was finished but the class hasn't been inserted, + insert it here. */ + if (! list_node) { __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list); __objc_class_tree_list->head = __objc_tree_insert_class (NULL, class); } } -/* Traverse tree in preorder. Used to send +load. */ +/* Traverse tree in preorder. Used to send +load. */ + static void objc_preorder_traverse (objc_class_tree *tree, int level, - void (*function)(objc_class_tree*, int)) + void (*function) (objc_class_tree *, int)) { struct objc_list *node; @@ -266,11 +312,12 @@ objc_preorder_traverse (objc_class_tree *tree, objc_preorder_traverse (node->head, level + 1, function); } -/* Traverse tree in postorder. Used to destroy a tree. */ +/* Traverse tree in postorder. Used to destroy a tree. */ + static void objc_postorder_traverse (objc_class_tree *tree, - int level, - void (*function)(objc_class_tree*, int)) + int level, + void (*function) (objc_class_tree *, int)) { struct objc_list *node; @@ -279,7 +326,8 @@ objc_postorder_traverse (objc_class_tree *tree, (*function) (tree, level); } -/* Used to print a tree class hierarchy. */ +/* Used to print a tree class hierarchy. */ + #ifdef DEBUG static void __objc_tree_print (objc_class_tree *tree, int level) @@ -292,63 +340,68 @@ __objc_tree_print (objc_class_tree *tree, int level) } #endif -/* Walks on a linked list of methods in the reverse order and executes all - the methods corresponding to `op' selector. Walking in the reverse order - assures the +load of class is executed first and then +load of categories - because of the way in which categories are added to the class methods. */ +/* Walks on a linked list of methods in the reverse order and executes + all the methods corresponding to `op' selector. Walking in the + reverse order assures the +load of class is executed first and then + +load of categories because of the way in which categories are + added to the class methods. */ + static void __objc_send_message_in_list (MethodList_t method_list, Class class, SEL op) { int i; - if (!method_list) + if (! method_list) return; /* First execute the `op' message in the following method lists */ __objc_send_message_in_list (method_list->method_next, class, op); - /* Search the method list. */ + /* Search the method list. */ for (i = 0; i < method_list->method_count; i++) { Method_t mth = &method_list->method_list[i]; if (mth->method_name && sel_eq (mth->method_name, op) - && !hash_is_key_in_hash (__objc_load_methods, mth->method_name)) + && ! hash_is_key_in_hash (__objc_load_methods, mth->method_imp)) { - /* The method was found and wasn't previously executed. */ - (*mth->method_imp) ((id)class, mth->method_name); - /* Add this method into the +load hash table */ hash_add (&__objc_load_methods, mth->method_imp, mth->method_imp); DEBUG_PRINTF ("sending +load in class: %s\n", class->name); + /* The method was found and wasn't previously executed. */ + (*mth->method_imp) ((id)class, mth->method_name); + break; } } } static void -__objc_send_load (objc_class_tree *tree, int level) +__objc_send_load (objc_class_tree *tree, + int level __attribute__ ((__unused__))) { static SEL load_sel = 0; Class class = tree->class; MethodList_t method_list = class->class_pointer->methods; - if (!load_sel) + if (! load_sel) load_sel = sel_register_name ("load"); __objc_send_message_in_list (method_list, class, load_sel); } static void -__objc_destroy_class_tree_node (objc_class_tree *tree, int level) +__objc_destroy_class_tree_node (objc_class_tree *tree, + int level __attribute__ ((__unused__))) { objc_free (tree); } -/* This is used to check if the relationship between two classes before the - runtime completely installs the classes. */ +/* This is used to check if the relationship between two classes + before the runtime completely installs the classes. */ + static BOOL class_is_subclass_of_class (Class class, Class superclass) { @@ -356,20 +409,18 @@ class_is_subclass_of_class (Class class, Class superclass) { if (class == superclass) return YES; - class = (class->super_class ? - objc_lookup_class ((char*)class->super_class) - : Nil); + class = class_superclass_of_class (class); } return NO; } -/* This list contains all the classes in the runtime system for whom their - superclasses are not yet know to the runtime. */ -static struct objc_list* unresolved_classes = 0; +/* This list contains all the classes in the runtime system for whom + their superclasses are not yet known to the runtime. */ +static struct objc_list *unresolved_classes = 0; -/* Extern function used to reference the Object and NXConstantString classes. - */ +/* Extern function used to reference the Object and NXConstantString + classes. */ extern void __objc_force_linking (void); @@ -380,15 +431,16 @@ __objc_force_linking (void) __objc_linking (); } -/* Run through the statics list, removing modules as soon as all its statics - have been initialized. */ +/* Run through the statics list, removing modules as soon as all its + statics have been initialized. */ + static void objc_init_statics (void) { struct objc_list **cell = &uninitialized_statics; struct objc_static_instances **statics_in_module; - objc_mutex_lock(__objc_runtime_mutex); + objc_mutex_lock (__objc_runtime_mutex); while (*cell) { @@ -400,7 +452,7 @@ objc_init_statics (void) struct objc_static_instances *statics = *statics_in_module; Class class = objc_lookup_class (statics->class_name); - if (!class) + if (! class) module_initialized = 0; /* Actually, the static's class_pointer will be NULL when we haven't been here before. However, the comparison is to be @@ -430,19 +482,19 @@ objc_init_statics (void) /* Remove this module from the uninitialized list. */ struct objc_list *this = *cell; *cell = this->tail; - objc_free(this); + objc_free (this); } else cell = &(*cell)->tail; } - objc_mutex_unlock(__objc_runtime_mutex); + objc_mutex_unlock (__objc_runtime_mutex); } /* objc_init_statics */ /* This function is called by constructor functions generated for each - module compiled. (_GLOBAL_$I$...) The purpose of this function is to - gather the module pointers so that they may be processed by the - initialization routines as soon as possible */ + module compiled. (_GLOBAL_$I$...) The purpose of this function is + to gather the module pointers so that they may be processed by the + initialization routines as soon as possible. */ void __objc_exec_class (Module_t module) @@ -451,7 +503,7 @@ __objc_exec_class (Module_t module) indicate that some global data structures need to be built. */ static BOOL previous_constructors = 0; - static struct objc_list* unclaimed_categories = 0; + static struct objc_list *unclaimed_categories = 0; /* The symbol table (defined in objc-api.h) generated by gcc */ Symtab_t symtab = module->symtab; @@ -461,7 +513,7 @@ __objc_exec_class (Module_t module) = symtab->defs[symtab->cls_def_cnt + symtab->cat_def_cnt]; /* Entry used to traverse hash lists */ - struct objc_list** cell; + struct objc_list **cell; /* The table of selector references for this module */ SEL selectors = symtab->refs; @@ -472,19 +524,19 @@ __objc_exec_class (Module_t module) DEBUG_PRINTF ("received module: %s\n", module->name); /* check gcc version */ - init_check_module_version(module); + init_check_module_version (module); /* On the first call of this routine, initialize some data structures. */ - if (!previous_constructors) + if (! previous_constructors) { /* Initialize thread-safe system */ - __objc_init_thread_system(); + __objc_init_thread_system (); __objc_runtime_threads_alive = 1; - __objc_runtime_mutex = objc_mutex_allocate(); + __objc_runtime_mutex = objc_mutex_allocate (); - __objc_init_selector_tables(); - __objc_init_class_tables(); - __objc_init_dispatch_tables(); + __objc_init_selector_tables (); + __objc_init_class_tables (); + __objc_init_dispatch_tables (); __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list); __objc_load_methods = hash_new (128, (hash_func_type)hash_ptr, compare_ptrs); @@ -492,8 +544,8 @@ __objc_exec_class (Module_t module) } /* Save the module pointer for later processing. (not currently used) */ - objc_mutex_lock(__objc_runtime_mutex); - __objc_module_list = list_cons(module, __objc_module_list); + objc_mutex_lock (__objc_runtime_mutex); + __objc_module_list = list_cons (module, __objc_module_list); /* Replace referenced selectors from names to SEL's. */ if (selectors) @@ -501,12 +553,12 @@ __objc_exec_class (Module_t module) for (i = 0; selectors[i].sel_id; ++i) { const char *name, *type; - name = (char*)selectors[i].sel_id; - type = (char*)selectors[i].sel_types; + name = (char *) selectors[i].sel_id; + type = (char *) selectors[i].sel_types; /* Constructors are constant static data so we can safely store pointers to them in the runtime structures. is_const == YES */ __sel_register_typed_name (name, type, - (struct objc_selector*)&(selectors[i]), + (struct objc_selector *) &(selectors[i]), YES); } } @@ -516,15 +568,15 @@ __objc_exec_class (Module_t module) for (i = 0; i < symtab->cls_def_cnt; ++i) { Class class = (Class) symtab->defs[i]; - const char* superclass = (char*)class->super_class; + const char *superclass = (char *) class->super_class; /* Make sure we have what we think. */ - assert (CLS_ISCLASS(class)); - assert (CLS_ISMETA(class->class_pointer)); + assert (CLS_ISCLASS (class)); + assert (CLS_ISMETA (class->class_pointer)); DEBUG_PRINTF ("phase 1, processing class: %s\n", class->name); /* Initialize the subclass list to be NULL. - In some cases it isn't and this crashes the program. */ + In some cases it isn't and this crashes the program. */ class->subclass_list = NULL; /* Store the class in the class table and assign class numbers. */ @@ -535,19 +587,19 @@ __objc_exec_class (Module_t module) __objc_register_selectors_from_class ((Class) class->class_pointer); /* Install the fake dispatch tables */ - __objc_install_premature_dtable(class); - __objc_install_premature_dtable(class->class_pointer); + __objc_install_premature_dtable (class); + __objc_install_premature_dtable (class->class_pointer); /* Register the instance methods as class methods, this is - only done for root classes. */ - __objc_register_instance_methods_to_class(class); + only done for root classes. */ + __objc_register_instance_methods_to_class (class); if (class->protocols) __objc_init_protocols (class->protocols); /* Check to see if the superclass is known in this point. If it's not - add the class to the unresolved_classes list. */ - if (superclass && !objc_lookup_class (superclass)) + add the class to the unresolved_classes list. */ + if (superclass && ! objc_lookup_class (superclass)) unresolved_classes = list_cons (class, unresolved_classes); } @@ -581,14 +633,14 @@ __objc_exec_class (Module_t module) } /* Register the instance methods as class methods, this is - only done for root classes. */ - __objc_register_instance_methods_to_class(class); + only done for root classes. */ + __objc_register_instance_methods_to_class (class); } else { /* The object to which the category methods belong can't be found. Save the information. */ - unclaimed_categories = list_cons(category, unclaimed_categories); + unclaimed_categories = list_cons (category, unclaimed_categories); } } @@ -599,9 +651,7 @@ __objc_exec_class (Module_t module) /* Scan the unclaimed category hash. Attempt to attach any unclaimed categories to objects. */ - for (cell = &unclaimed_categories; - *cell; - ({ if (*cell) cell = &(*cell)->tail; })) + for (cell = &unclaimed_categories; *cell; ) { Category_t category = (*cell)->head; Class class = objc_lookup_class (category->class_name); @@ -627,37 +677,41 @@ __objc_exec_class (Module_t module) } /* Register the instance methods as class methods, this is - only done for root classes. */ - __objc_register_instance_methods_to_class(class); + only done for root classes. */ + __objc_register_instance_methods_to_class (class); } + else + cell = &(*cell)->tail; } if (unclaimed_proto_list && objc_lookup_class ("Protocol")) { - list_mapcar (unclaimed_proto_list,(void(*)(void*))__objc_init_protocols); + list_mapcar (unclaimed_proto_list, + (void (*) (void *))__objc_init_protocols); list_free (unclaimed_proto_list); unclaimed_proto_list = 0; } objc_send_load (); - objc_mutex_unlock(__objc_runtime_mutex); + objc_mutex_unlock (__objc_runtime_mutex); } -static void objc_send_load (void) +static void +objc_send_load (void) { - if (!__objc_module_list) + if (! __objc_module_list) return; /* Try to find out if all the classes loaded so far also have their - superclasses known to the runtime. We suppose that the objects that are - allocated in the +load method are in general of a class declared in the - same module. */ + superclasses known to the runtime. We suppose that the objects + that are allocated in the +load method are in general of a class + declared in the same module. */ if (unresolved_classes) { Class class = unresolved_classes->head; - while (objc_lookup_class ((char*)class->super_class)) + while (objc_lookup_class ((char *) class->super_class)) { list_remove_head (&unresolved_classes); if (unresolved_classes) @@ -666,25 +720,25 @@ static void objc_send_load (void) break; } - /* - * If we still have classes for whom we don't have yet their super - * classes known to the runtime we don't send the +load messages. - */ + /* If we still have classes for whom we don't have yet their + super classes known to the runtime we don't send the +load + messages. */ if (unresolved_classes) return; } - /* Special check to allow creating and sending messages to constant strings - in +load methods. If these classes are not yet known, even if all the - other classes are known, delay sending of +load. */ - if (!objc_lookup_class ("NXConstantString") || - !objc_lookup_class ("Object")) + /* Special check to allow creating and sending messages to constant + strings in +load methods. If these classes are not yet known, + even if all the other classes are known, delay sending of +load. */ + if (! objc_lookup_class ("NXConstantString") || + ! objc_lookup_class ("Object")) return; - /* Iterate over all modules in the __objc_module_list and call on them the - __objc_create_classes_tree function. This function creates a tree of - classes that resembles the class hierarchy. */ - list_mapcar (__objc_module_list, (void(*)(void*))__objc_create_classes_tree); + /* Iterate over all modules in the __objc_module_list and call on + them the __objc_create_classes_tree function. This function + creates a tree of classes that resembles the class hierarchy. */ + list_mapcar (__objc_module_list, + (void (*) (void *)) __objc_create_classes_tree); while (__objc_class_tree_list) { @@ -699,7 +753,7 @@ static void objc_send_load (void) list_remove_head (&__objc_class_tree_list); } - list_mapcar (__objc_module_list, (void(*)(void*))__objc_call_callback); + list_mapcar (__objc_module_list, (void (*) (void *)) __objc_call_callback); list_free (__objc_module_list); __objc_module_list = NULL; } @@ -712,8 +766,8 @@ __objc_create_classes_tree (Module_t module) Symtab_t symtab = module->symtab; int i; - /* Iterate thru classes defined in this module and insert them in the classes - tree hierarchy. */ + /* Iterate thru classes defined in this module and insert them in + the classes tree hierarchy. */ for (i = 0; i < symtab->cls_def_cnt; i++) { Class class = (Class) symtab->defs[i]; @@ -725,72 +779,74 @@ __objc_create_classes_tree (Module_t module) static void __objc_call_callback (Module_t module) { - /* The runtime mutex is locked in this point */ + /* The runtime mutex is locked in this point. */ Symtab_t symtab = module->symtab; int i; - /* Iterate thru classes defined in this module and call the callback for - each one. */ + /* Iterate thru classes defined in this module and call the callback + for each one. */ for (i = 0; i < symtab->cls_def_cnt; i++) { Class class = (Class) symtab->defs[i]; - /* Call the _objc_load_callback for this class. */ + /* Call the _objc_load_callback for this class. */ if (_objc_load_callback) - _objc_load_callback(class, 0); + _objc_load_callback (class, 0); } - /* Call the _objc_load_callback for categories. Don't register the instance - methods as class methods for categories to root classes since they were - already added in the class. */ + /* Call the _objc_load_callback for categories. Don't register the + instance methods as class methods for categories to root classes + since they were already added in the class. */ for (i = 0; i < symtab->cat_def_cnt; i++) { Category_t category = symtab->defs[i + symtab->cls_def_cnt]; Class class = objc_lookup_class (category->class_name); if (_objc_load_callback) - _objc_load_callback(class, category); + _objc_load_callback (class, category); } } -/* Sanity check the version of gcc used to compile `module'*/ -static void init_check_module_version(Module_t module) +/* Sanity check the version of gcc used to compile `module'. */ + +static void +init_check_module_version (Module_t module) { if ((module->version != OBJC_VERSION) || (module->size != sizeof (Module))) { int code; - if(module->version > OBJC_VERSION) + if (module->version > OBJC_VERSION) code = OBJC_ERR_OBJC_VERSION; else if (module->version < OBJC_VERSION) code = OBJC_ERR_GCC_VERSION; else code = OBJC_ERR_MODULE_SIZE; - objc_error(nil, code, "Module %s version %d doesn't match runtime %d\n", - module->name, (int)module->version, OBJC_VERSION); + objc_error (nil, code, "Module %s version %d doesn't match runtime %d\n", + module->name, (int)module->version, OBJC_VERSION); } } static void -__objc_init_protocols (struct objc_protocol_list* protos) +__objc_init_protocols (struct objc_protocol_list *protos) { - int i; + size_t i; static Class proto_class = 0; if (! protos) return; - objc_mutex_lock(__objc_runtime_mutex); + objc_mutex_lock (__objc_runtime_mutex); - if (!proto_class) - proto_class = objc_lookup_class("Protocol"); + if (! proto_class) + proto_class = objc_lookup_class ("Protocol"); - if (!proto_class) + if (! proto_class) { unclaimed_proto_list = list_cons (protos, unclaimed_proto_list); - objc_mutex_unlock(__objc_runtime_mutex); + objc_mutex_unlock (__objc_runtime_mutex); return; } @@ -798,9 +854,9 @@ __objc_init_protocols (struct objc_protocol_list* protos) assert (protos->next == 0); /* only single ones allowed */ #endif - for(i = 0; i < protos->count; i++) + for (i = 0; i < protos->count; i++) { - struct objc_protocol* aProto = protos->list[i]; + struct objc_protocol *aProto = protos->list[i]; if (((size_t)aProto->class_pointer) == PROTOCOL_VERSION) { /* assign class pointer */ @@ -811,24 +867,25 @@ __objc_init_protocols (struct objc_protocol_list* protos) } else if (protos->list[i]->class_pointer != proto_class) { - objc_error(nil, OBJC_ERR_PROTOCOL_VERSION, + objc_error (nil, OBJC_ERR_PROTOCOL_VERSION, "Version %d doesn't match runtime protocol version %d\n", - (int)((char*)protos->list[i]->class_pointer-(char*)0), + (int) ((char *) protos->list[i]->class_pointer + - (char *) 0), PROTOCOL_VERSION); } } - objc_mutex_unlock(__objc_runtime_mutex); + objc_mutex_unlock (__objc_runtime_mutex); } -static void __objc_class_add_protocols (Class class, - struct objc_protocol_list* protos) +static void +__objc_class_add_protocols (Class class, struct objc_protocol_list *protos) { - /* Well... */ + /* Well... */ if (! protos) return; - /* Add it... */ + /* Add it... */ protos->next = class->protocols; class->protocols = protos; }