see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
+/* Uncommented the following line to enable debug logging. Use this
+ only while debugging the runtime. */
+/* #define DEBUG 1 */
+
#include "objc-private/common.h"
#include "objc-private/error.h"
#include "objc/runtime.h"
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
+ 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
+ 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 (struct objc_module *module);
installed in the runtime. */
static BOOL class_is_subclass_of_class (Class class, Class superclass);
+/* This is a node in the class tree hierarchy used to send +load
+ messages. */
typedef struct objc_class_tree
{
+ /* The class corresponding to the node. */
Class class;
- struct objc_list *subclasses; /* `head' is a pointer to an
- objc_class_tree. */
+
+ /* This is a linked list of all the direct subclasses of this class.
+ 'head' points to a subclass node; 'tail' points to the next
+ objc_list node (whose 'head' points to another subclass node,
+ etc). */
+ struct objc_list *subclasses;
} 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
+/* 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;
is really needed so that superclasses will get the message before
subclasses.
- This tree will contain classes which are being loaded (or have just
+ This tree may 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
/* 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. */
+ from `upper' and the bottom class in this tree is `bottom_class'.
+ If `upper' is Nil, creates a class hierarchy up to a root class.
+ The classes in this tree are super classes of `bottom_class'. The
+ `subclasses' member of each tree node point to the list of
+ subclasses for the node. */
static objc_class_tree *
create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper)
{
Class superclass;
objc_class_tree *tree, *prev;
- if (bottom_class->super_class)
- superclass = objc_getClass ((char *) bottom_class->super_class);
- else
- superclass = Nil;
-
DEBUG_PRINTF ("create_tree_of_subclasses_inherited_from:");
- DEBUG_PRINTF ("bottom_class = %s, upper = %s\n",
+ DEBUG_PRINTF (" bottom_class = %s, upper = %s\n",
(bottom_class ? bottom_class->name : NULL),
(upper ? upper->name : NULL));
- tree = prev = objc_calloc (1, sizeof (objc_class_tree));
+ superclass = class_superclass_of_class (bottom_class);
+
+ prev = objc_calloc (1, sizeof (objc_class_tree));
prev->class = bottom_class;
+ if (superclass == upper)
+ return prev;
+
while (superclass != upper)
{
tree = objc_calloc (1, sizeof (objc_class_tree));
}
/* Insert the `class' into the proper place in the `tree' class
- hierarchy. This function returns a new tree if the class has been
+ 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
+ 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 ("__objc_tree_insert_class: tree = %p, class = %s\n",
- tree, class->name);
+ DEBUG_PRINTF ("__objc_tree_insert_class: tree = %p (root: %s), class = %s\n",
+ tree, ((tree && tree->class) ? tree->class->name : "Nil"), class->name);
if (tree == NULL)
return create_tree_of_subclasses_inherited_from (class, NULL);
else if (class == tree->class)
{
/* `class' has been already inserted. */
- DEBUG_PRINTF ("1. class %s was previously inserted\n", class->name);
+ DEBUG_PRINTF (" 1. class %s was previously inserted\n", class->name);
return tree;
}
else if (class_superclass_of_class (class) == tree->class)
the tree. */
if (((objc_class_tree *) list->head)->class == class)
{
- DEBUG_PRINTF ("2. class %s was previously inserted\n",
+ DEBUG_PRINTF (" 2. class %s was previously inserted\n",
class->name);
return tree;
}
node = objc_calloc (1, sizeof (objc_class_tree));
node->class = class;
tree->subclasses = list_cons (node, tree->subclasses);
- DEBUG_PRINTF ("3. class %s inserted\n", class->name);
+ DEBUG_PRINTF (" 3. class %s inserted\n", class->name);
return tree;
}
else
since nothing has been changed. */
subclasses->head
= __objc_tree_insert_class (subclasses->head, class);
- DEBUG_PRINTF ("4. class %s inserted\n", class->name);
+ DEBUG_PRINTF (" 4. class %s inserted\n", class->name);
return tree;
}
}
objc_class_tree *new_tree
= 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);
+ DEBUG_PRINTF (" 5. class %s inserted\n", class->name);
return tree;
}
}
{
struct objc_list *list_node;
objc_class_tree *tree;
-
+
list_node = __objc_class_tree_list;
while (list_node)
{
+ /* Try to insert the class in this class hierarchy. */
tree = __objc_tree_insert_class (list_node->head, class);
if (tree)
{
list_node->head = tree;
- break;
+ return;
}
else
list_node = list_node->tail;
}
-
- /* 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);
- }
+
+ /* If the list was finished but the class hasn't been inserted, we
+ don't have an existing class hierarchy that can accomodate it.
+ Create a new one. */
+ __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. */
mth->method_imp,
mth->method_imp);
- DEBUG_PRINTF ("sending +load in class: %s\n", class->name);
-
/* Call +load. */
+ DEBUG_PRINTF (" begin of [%s +load]\n", class->name);
(*mth->method_imp) ((id)class, mth->method_name);
+ DEBUG_PRINTF (" end of [%s +load]\n", class->name);
break;
}
Class class = tree->class;
struct objc_method_list *method_list = class->class_pointer->methods;
+ DEBUG_PRINTF ("+load: need to send load to class '%s'\n", class->name);
__objc_send_load_using_method_list (method_list, class);
}
int i;
- DEBUG_PRINTF ("received module: %s\n", module->name);
+ DEBUG_PRINTF ("\n__objc_exec_class (%p) - start processing module...\n", module);
/* Check gcc version. */
init_check_module_version (module);
duplicate_classes = objc_hash_new (8,
(hash_func_type)objc_hash_ptr,
objc_compare_ptrs);
- __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
__objc_load_methods = objc_hash_new (128,
(hash_func_type)objc_hash_ptr,
objc_compare_ptrs);
/* Replace referenced selectors from names to SELs. */
if (selectors)
- __objc_register_selectors_from_module (selectors);
+ {
+ DEBUG_PRINTF (" registering selectors\n");
+ __objc_register_selectors_from_module (selectors);
+ }
/* Parse the classes in the load module and gather selector
information. */
- DEBUG_PRINTF ("gathering selectors from module: %s\n", module->name);
for (i = 0; i < symtab->cls_def_cnt; ++i)
{
Class class = (Class) symtab->defs[i];
/* Make sure we have what we think. */
assert (CLS_ISCLASS (class));
assert (CLS_ISMETA (class->class_pointer));
- DEBUG_PRINTF ("phase 1, processing class: %s\n", class->name);
+ DEBUG_PRINTF (" installing class '%s'\n", class->name);
/* Initialize the subclass list to be NULL. In some cases it
isn't and this crashes the program. */
methods. */
if (class)
{
- DEBUG_PRINTF ("processing categories from (module,object): %s, %s\n",
- module->name,
- class->name);
-
+ DEBUG_PRINTF (" installing category '%s (%s)'\n", category->class_name, category->category_name);
/* Do instance methods. */
if (category->instance_methods)
class_add_method_list (class, category->instance_methods);
}
else
{
+ DEBUG_PRINTF (" delaying installation of category '%s (%s)'\n", category->class_name, category->category_name);
/* The object to which the category methods belong can't be
found. Save the information. */
unclaimed_categories = list_cons (category, unclaimed_categories);
if (class)
{
- DEBUG_PRINTF ("attaching stored categories to object: %s\n",
- class->name);
-
+ DEBUG_PRINTF (" installing (delayed) category '%s (%s)'\n", category->class_name, category->category_name);
list_remove_head (cell);
if (category->instance_methods)
"resolving the class links" at this point, which will setup all
the class/superclass pointers. */
if (!unresolved_classes && objc_getClass ("Object"))
- __objc_resolve_class_links ();
+ {
+ DEBUG_PRINTF (" resolving class links\n");
+ __objc_resolve_class_links ();
+ }
objc_mutex_unlock (__objc_runtime_mutex);
+
+ DEBUG_PRINTF ("__objc_exec_class (%p) - finished processing module...\n\n", module);
}
/* This function needs to be called with the objc_runtime_mutex
if (!objc_hash_is_key_in_hash (duplicate_classes, class))
{
/* Call the _objc_load_callback for this class. */
+ DEBUG_PRINTF (" calling the load callback for class '%s'\n", class->name);
_objc_load_callback (class, 0);
}
}
struct objc_category *category = symtab->defs[i + symtab->cls_def_cnt];
Class class = objc_getClass (category->class_name);
+ DEBUG_PRINTF (" calling the load callback for category '%s (%s)'\n",
+ category->class_name, category->category_name);
_objc_load_callback (class, category);
}
}
{
/* The module contains a duplicate class. Remember it so that
we will ignore it later. */
+ DEBUG_PRINTF (" duplicate class '%s' - will be ignored\n", class->name);
objc_hash_add (&duplicate_classes, class, class);
return NO;
}
OSDN Git Service
