/* 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 <ovidiu@net-community.com>
-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
-Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+GCC; see the file COPYING. If not, write to the Free Software
+Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* As a special exception, if you link this library with files compiled with
GCC to produce an executable, this does not cause the resulting executable
however invalidate any other reasons why the executable file might be
covered by the GNU General Public License. */
-#include "runtime.h"
+#include "objc/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 {
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;
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)
{
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);
}
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);
}
}
- /* 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;
}
}
-/* 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)
{
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;
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;
(*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)
}
#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))
+ && ! objc_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_name, mth->method_imp);
+ objc_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)
{
{
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);
__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)
{
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
/* 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)
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;
= 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;
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);
+ __objc_load_methods = objc_hash_new (128,
+ (hash_func_type)objc_hash_ptr,
+ objc_compare_ptrs);
previous_constructors = 1;
}
/* 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)
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);
}
}
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. */
__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);
}
}
/* 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);
}
}
/* 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);
}
/* 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)
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)
{
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;
}
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];
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;
}
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 */
}
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;
}