Finished rewriting the loader. It's now cleanly separated into logically-separate components, so there's a chance it might actually be maintainable...
theraven
16 years ago
parent
7c72069fd9
commit
bb8cafaa15
@ -0,0 +1,62 @@
|
|||||||
|
/**
|
||||||
|
* buffer.h defines a simple dynamic array that is used to store temporary
|
||||||
|
* values for later processing. Define BUFFER_TYPE before including this file.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <stdlib.h>
|
||||||
|
|
||||||
|
#define BUFFER_SIZE 128
|
||||||
|
static BUFFER_TYPE *buffered_object_buffer[BUFFER_SIZE];
|
||||||
|
static BUFFER_TYPE **buffered_object_overflow;
|
||||||
|
static int buffered_objects;
|
||||||
|
static int buffered_object_overflow_space;
|
||||||
|
|
||||||
|
static void set_buffered_object_at_index(BUFFER_TYPE *cat, unsigned int i)
|
||||||
|
{
|
||||||
|
if (i < BUFFER_SIZE)
|
||||||
|
{
|
||||||
|
buffered_object_buffer[i] = cat;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
i -= BUFFER_SIZE;
|
||||||
|
if (NULL == buffered_object_overflow)
|
||||||
|
{
|
||||||
|
buffered_object_overflow =
|
||||||
|
calloc(BUFFER_SIZE, sizeof(BUFFER_TYPE*));
|
||||||
|
buffered_object_overflow_space = BUFFER_SIZE;
|
||||||
|
}
|
||||||
|
while (i > buffered_object_overflow_space)
|
||||||
|
{
|
||||||
|
buffered_object_overflow_space <<= 1;
|
||||||
|
buffered_object_overflow = realloc(buffered_object_overflow,
|
||||||
|
buffered_object_overflow_space * sizeof(BUFFER_TYPE*));
|
||||||
|
}
|
||||||
|
buffered_object_overflow[i] = cat;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static BUFFER_TYPE *buffered_object_at_index(unsigned int i)
|
||||||
|
{
|
||||||
|
if (i<BUFFER_SIZE)
|
||||||
|
{
|
||||||
|
return buffered_object_buffer[i];
|
||||||
|
}
|
||||||
|
return buffered_object_overflow[i-BUFFER_SIZE];
|
||||||
|
}
|
||||||
|
|
||||||
|
static void compact_buffer(void)
|
||||||
|
{
|
||||||
|
// Move up all of the non-NULL pointers
|
||||||
|
unsigned size = buffered_objects;
|
||||||
|
unsigned insert = 0;
|
||||||
|
for (unsigned i=0 ; i<size ; i++)
|
||||||
|
{
|
||||||
|
BUFFER_TYPE *c = buffered_object_at_index(i);
|
||||||
|
if (c != NULL)
|
||||||
|
{
|
||||||
|
set_buffered_object_at_index(c, insert++);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
buffered_objects = insert;
|
||||||
|
}
|
||||||
@ -0,0 +1,35 @@
|
|||||||
|
|
||||||
|
/**
|
||||||
|
* The structure used to represent a category.
|
||||||
|
*
|
||||||
|
* This provides a set of new definitions that are used to replace those
|
||||||
|
* contained within a class.
|
||||||
|
*
|
||||||
|
* Note: Objective-C 2 allows properties to be added to classes. The current
|
||||||
|
* ABI does not provide a field for adding properties in categories. This is
|
||||||
|
* likely to be added with ABI version 10. Until then, the methods created by
|
||||||
|
* a declared property will work, but introspection on the property will not.
|
||||||
|
*/
|
||||||
|
struct objc_category
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* The name of this category.
|
||||||
|
*/
|
||||||
|
const char *name;
|
||||||
|
/**
|
||||||
|
* The name of the class to which this category should be applied.
|
||||||
|
*/
|
||||||
|
const char *class_name;
|
||||||
|
/**
|
||||||
|
* The list of instance methods to add to the class.
|
||||||
|
*/
|
||||||
|
struct objc_method_list *instance_methods;
|
||||||
|
/**
|
||||||
|
* The list of class methods to add to the class.
|
||||||
|
*/
|
||||||
|
struct objc_method_list *class_methods;
|
||||||
|
/**
|
||||||
|
* The list of protocols adopted by this category.
|
||||||
|
*/
|
||||||
|
struct objc_protocol_list *protocols;
|
||||||
|
};
|
||||||
@ -0,0 +1,81 @@
|
|||||||
|
#include <stdio.h>
|
||||||
|
#include "objc/runtime.h"
|
||||||
|
#include "loader.h"
|
||||||
|
|
||||||
|
#define BUFFER_TYPE struct objc_category
|
||||||
|
#include "buffer.h"
|
||||||
|
|
||||||
|
static void register_methods(struct objc_class *cls, struct objc_method_list *l)
|
||||||
|
{
|
||||||
|
if (NULL == l) { return; }
|
||||||
|
|
||||||
|
// Replace the method names with selectors.
|
||||||
|
objc_register_selectors_from_list(l);
|
||||||
|
// Add the method list at the head of the list of lists.
|
||||||
|
l->next = cls->methods;
|
||||||
|
cls->methods = l;
|
||||||
|
// Update the dtable to catch the new methods.
|
||||||
|
// FIXME: We can make this more efficient by simply passing the new method
|
||||||
|
// list to the dtable and telling it only to update those methods.
|
||||||
|
objc_update_dtable_for_class(cls);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void load_category(struct objc_category *cat, struct objc_class *class)
|
||||||
|
{
|
||||||
|
register_methods(class, cat->instance_methods);
|
||||||
|
register_methods(class->isa, cat->class_methods);
|
||||||
|
|
||||||
|
if (cat->protocols)
|
||||||
|
{
|
||||||
|
objc_init_protocols(cat->protocols);
|
||||||
|
cat->protocols->next = class->protocols;
|
||||||
|
class->protocols = cat->protocols;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static BOOL try_load_category(struct objc_category *cat)
|
||||||
|
{
|
||||||
|
Class class = (Class)objc_getClass(cat->class_name);
|
||||||
|
if (Nil != class)
|
||||||
|
{
|
||||||
|
load_category(cat, class);
|
||||||
|
return YES;
|
||||||
|
}
|
||||||
|
return NO;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Attaches a category to its class, if the class is already loaded. Buffers
|
||||||
|
* it for future resolution if not.
|
||||||
|
*/
|
||||||
|
void objc_try_load_category(struct objc_category *cat)
|
||||||
|
{
|
||||||
|
if (!try_load_category(cat))
|
||||||
|
{
|
||||||
|
set_buffered_object_at_index(cat, buffered_objects++);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void objc_load_buffered_categories(void)
|
||||||
|
{
|
||||||
|
BOOL shouldReshuffle = NO;
|
||||||
|
|
||||||
|
for (unsigned i=0 ; i<buffered_objects ; i++)
|
||||||
|
{
|
||||||
|
struct objc_category *c = buffered_object_at_index(i);
|
||||||
|
if (NULL != c)
|
||||||
|
{
|
||||||
|
if (try_load_category(c))
|
||||||
|
{
|
||||||
|
set_buffered_object_at_index(NULL, i);
|
||||||
|
shouldReshuffle = YES;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (shouldReshuffle)
|
||||||
|
{
|
||||||
|
compact_buffer();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
@ -1,388 +0,0 @@
|
|||||||
/* GNU Objective C Runtime initialization
|
|
||||||
Copyright (C) 1993, 1995, 1996, 1997, 2002, 2009
|
|
||||||
Free Software Foundation, Inc.
|
|
||||||
Contributed by Kresten Krab Thorup
|
|
||||||
+load support contributed by Ovidiu Predescu <ovidiu@net-community.com>
|
|
||||||
|
|
||||||
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/>. */
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include "objc/runtime-legacy.h"
|
|
||||||
#include "objc/encoding.h"
|
|
||||||
#include "lock.h"
|
|
||||||
#include "magic_objects.h"
|
|
||||||
|
|
||||||
/* The version number of this runtime. This must match the number
|
|
||||||
defined in gcc (objc-act.c). */
|
|
||||||
#define PROTOCOL_VERSION 2
|
|
||||||
#define OBJC2_PROTOCOL_VERSION 3
|
|
||||||
|
|
||||||
void __objc_sync_init(void);
|
|
||||||
void __objc_resolve_class_links(void);
|
|
||||||
void objc_load_class(struct objc_class *class);
|
|
||||||
|
|
||||||
/* 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. */
|
|
||||||
static mutex_t objc_runtime_mutex;
|
|
||||||
objc_mutex_t __objc_runtime_mutex = &objc_runtime_mutex;
|
|
||||||
|
|
||||||
/* Number of threads that are alive. */
|
|
||||||
int __objc_runtime_threads_alive = 1; /* !T:MUTEX */
|
|
||||||
|
|
||||||
void __objc_register_selector_array(SEL selectors, unsigned long count);
|
|
||||||
|
|
||||||
/* Check compiler vs runtime version. */
|
|
||||||
static void init_check_module_version (Module_t);
|
|
||||||
|
|
||||||
/* Assign isa links to protos. */
|
|
||||||
void __objc_init_protocols (struct objc_protocol_list *protos);
|
|
||||||
|
|
||||||
/* Add protocol to class. */
|
|
||||||
static void __objc_class_add_protocols (Class, struct objc_protocol_list *);
|
|
||||||
|
|
||||||
/* Is all categories/classes resolved? */
|
|
||||||
BOOL __objc_dangling_categories = NO; /* !T:UNUSED */
|
|
||||||
|
|
||||||
/* Extern function used to reference the Object and NXConstantString
|
|
||||||
classes. */
|
|
||||||
|
|
||||||
extern void __objc_force_linking (void);
|
|
||||||
|
|
||||||
void
|
|
||||||
__objc_force_linking (void)
|
|
||||||
{
|
|
||||||
extern void __objc_linking (void);
|
|
||||||
__objc_linking ();
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 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;
|
|
||||||
|
|
||||||
LOCK(__objc_runtime_mutex);
|
|
||||||
|
|
||||||
while (*cell)
|
|
||||||
{
|
|
||||||
int module_initialized = 1;
|
|
||||||
|
|
||||||
for (statics_in_module = (*cell)->head;
|
|
||||||
*statics_in_module; statics_in_module++)
|
|
||||||
{
|
|
||||||
struct objc_static_instances *statics = *statics_in_module;
|
|
||||||
Class class = objc_lookup_class (statics->class_name);
|
|
||||||
if (strcmp(statics->class_name, "NXConstantString") == 0)
|
|
||||||
{
|
|
||||||
Class constStr = objc_lookup_class(CONSTANT_STRING_CLASS);
|
|
||||||
if (constStr)
|
|
||||||
{
|
|
||||||
class = constStr;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
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
|
|
||||||
reminded of taking into account class posing and to think about
|
|
||||||
possible semantics... */
|
|
||||||
else if (class != statics->instances[0]->class_pointer)
|
|
||||||
{
|
|
||||||
id *inst;
|
|
||||||
|
|
||||||
for (inst = &statics->instances[0]; *inst; inst++)
|
|
||||||
{
|
|
||||||
(*inst)->class_pointer = class;
|
|
||||||
|
|
||||||
/* ??? Make sure the object will not be freed. With
|
|
||||||
refcounting, invoke `-retain'. Without refcounting, do
|
|
||||||
nothing and hope that `-free' will never be invoked. */
|
|
||||||
|
|
||||||
/* ??? Send the object an `-initStatic' or something to
|
|
||||||
that effect now or later on? What are the semantics of
|
|
||||||
statically allocated instances, besides the trivial
|
|
||||||
NXConstantString, anyway? */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (module_initialized)
|
|
||||||
{
|
|
||||||
/* Remove this module from the uninitialized list. */
|
|
||||||
struct objc_list *this = *cell;
|
|
||||||
*cell = this->tail;
|
|
||||||
objc_free (this);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
cell = &(*cell)->tail;
|
|
||||||
}
|
|
||||||
|
|
||||||
UNLOCK(__objc_runtime_mutex);
|
|
||||||
} /* objc_init_statics */
|
|
||||||
|
|
||||||
void __objc_init_protocol_table(void);
|
|
||||||
/* 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. */
|
|
||||||
|
|
||||||
BOOL objc_check_abi_version(unsigned long version, unsigned long module_size);
|
|
||||||
|
|
||||||
void
|
|
||||||
__objc_exec_class (Module_t module)
|
|
||||||
{
|
|
||||||
/* Have we processed any constructors previously? This flag is used to
|
|
||||||
indicate that some global data structures need to be built. */
|
|
||||||
static BOOL previous_constructors = 0;
|
|
||||||
|
|
||||||
static struct objc_list *unclaimed_categories = 0;
|
|
||||||
|
|
||||||
/* The symbol table (defined in objc-api.h) generated by gcc */
|
|
||||||
Symtab_t symtab = module->symtab;
|
|
||||||
|
|
||||||
/* The statics in this module */
|
|
||||||
struct objc_static_instances **statics
|
|
||||||
= symtab->defs[symtab->cls_def_cnt + symtab->cat_def_cnt];
|
|
||||||
|
|
||||||
/* Entry used to traverse hash lists */
|
|
||||||
struct objc_list **cell;
|
|
||||||
|
|
||||||
/* dummy counter */
|
|
||||||
int i;
|
|
||||||
|
|
||||||
DEBUG_PRINTF ("received module: %s\n", module->name);
|
|
||||||
|
|
||||||
/* check compiler version */
|
|
||||||
assert(objc_check_abi_version(module->version, module->size));
|
|
||||||
|
|
||||||
/* On the first call of this routine, initialize some data structures. */
|
|
||||||
// FIXME: This should really be using a pthread_once or equivalent.
|
|
||||||
if (! previous_constructors)
|
|
||||||
{
|
|
||||||
/* Initialize thread-safe system */
|
|
||||||
INIT_LOCK(objc_runtime_mutex);
|
|
||||||
__objc_init_thread_system ();
|
|
||||||
__objc_sync_init();
|
|
||||||
__objc_runtime_threads_alive = 1;
|
|
||||||
|
|
||||||
__objc_init_selector_tables ();
|
|
||||||
__objc_init_protocol_table ();
|
|
||||||
__objc_init_class_tables ();
|
|
||||||
__objc_init_dispatch_tables ();
|
|
||||||
previous_constructors = 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Save the module pointer for later processing. (not currently used) */
|
|
||||||
LOCK(__objc_runtime_mutex);
|
|
||||||
|
|
||||||
/* Replace referenced selectors from names to SEL's. */
|
|
||||||
if (symtab->refs)
|
|
||||||
{
|
|
||||||
__objc_register_selector_array(symtab->refs, symtab->sel_ref_cnt);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* 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)
|
|
||||||
{
|
|
||||||
objc_load_class((Class) symtab->defs[i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Process category information from the module. */
|
|
||||||
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 the class for the category exists then append its methods. */
|
|
||||||
if (class)
|
|
||||||
{
|
|
||||||
|
|
||||||
DEBUG_PRINTF ("processing categories from (module,object): %s, %s\n",
|
|
||||||
module->name,
|
|
||||||
class->name);
|
|
||||||
|
|
||||||
/* Do instance methods. */
|
|
||||||
if (category->instance_methods)
|
|
||||||
class_add_method_list (class, category->instance_methods);
|
|
||||||
|
|
||||||
/* Do class methods. */
|
|
||||||
if (category->class_methods)
|
|
||||||
class_add_method_list ((Class) class->class_pointer,
|
|
||||||
category->class_methods);
|
|
||||||
|
|
||||||
if (category->protocols)
|
|
||||||
{
|
|
||||||
__objc_init_protocols (category->protocols);
|
|
||||||
__objc_class_add_protocols (class, category->protocols);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* The object to which the category methods belong can't be found.
|
|
||||||
Save the information. */
|
|
||||||
unclaimed_categories = list_cons (category, unclaimed_categories);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (statics)
|
|
||||||
uninitialized_statics = list_cons (statics, uninitialized_statics);
|
|
||||||
if (uninitialized_statics)
|
|
||||||
objc_init_statics ();
|
|
||||||
|
|
||||||
/* Scan the unclaimed category hash. Attempt to attach any unclaimed
|
|
||||||
categories to objects. */
|
|
||||||
for (cell = &unclaimed_categories; *cell; )
|
|
||||||
{
|
|
||||||
Category_t category = (*cell)->head;
|
|
||||||
Class class = objc_lookup_class (category->class_name);
|
|
||||||
|
|
||||||
if (class)
|
|
||||||
{
|
|
||||||
DEBUG_PRINTF ("attaching stored categories to object: %s\n",
|
|
||||||
class->name);
|
|
||||||
|
|
||||||
list_remove_head (cell);
|
|
||||||
|
|
||||||
if (category->instance_methods)
|
|
||||||
class_add_method_list (class, category->instance_methods);
|
|
||||||
|
|
||||||
if (category->class_methods)
|
|
||||||
class_add_method_list ((Class) class->class_pointer,
|
|
||||||
category->class_methods);
|
|
||||||
|
|
||||||
if (category->protocols)
|
|
||||||
{
|
|
||||||
__objc_init_protocols (category->protocols);
|
|
||||||
__objc_class_add_protocols (class, category->protocols);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
cell = &(*cell)->tail;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (unclaimed_proto_list && objc_lookup_class ("Protocol"))
|
|
||||||
{
|
|
||||||
list_mapcar (unclaimed_proto_list,
|
|
||||||
(void (*) (void *))__objc_init_protocols);
|
|
||||||
list_free (unclaimed_proto_list);
|
|
||||||
unclaimed_proto_list = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
__objc_resolve_class_links();
|
|
||||||
|
|
||||||
UNLOCK(__objc_runtime_mutex);
|
|
||||||
}
|
|
||||||
|
|
||||||
void __objc_compute_ivar_offsets(Class class);
|
|
||||||
|
|
||||||
|
|
||||||
struct objc_protocol *__objc_unique_protocol(struct objc_protocol*);
|
|
||||||
void __objc_init_protocols (struct objc_protocol_list *protos)
|
|
||||||
{
|
|
||||||
size_t i;
|
|
||||||
static Class proto_class = 0;
|
|
||||||
static Class proto_class2 = 0;
|
|
||||||
|
|
||||||
if (! protos)
|
|
||||||
return;
|
|
||||||
|
|
||||||
LOCK(__objc_runtime_mutex);
|
|
||||||
|
|
||||||
if (! proto_class)
|
|
||||||
proto_class = objc_lookup_class ("Protocol");
|
|
||||||
if (! proto_class2)
|
|
||||||
proto_class2 = objc_lookup_class ("Protocol2");
|
|
||||||
|
|
||||||
/* Protocol2 will always exist if Protocol exists */
|
|
||||||
if (! proto_class2)
|
|
||||||
{
|
|
||||||
unclaimed_proto_list = list_cons (protos, unclaimed_proto_list);
|
|
||||||
UNLOCK(__objc_runtime_mutex);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
assert (protos->next == 0); /* only single ones allowed */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
for (i = 0; i < protos->count; i++)
|
|
||||||
{
|
|
||||||
struct objc_protocol *aProto = protos->list[i];
|
|
||||||
switch (((size_t)aProto->class_pointer))
|
|
||||||
{
|
|
||||||
case PROTOCOL_VERSION:
|
|
||||||
{
|
|
||||||
/* assign class pointer */
|
|
||||||
aProto->class_pointer = proto_class;
|
|
||||||
|
|
||||||
/* init super protocols */
|
|
||||||
__objc_init_protocols (aProto->protocol_list);
|
|
||||||
protos->list[i] = __objc_unique_protocol (aProto);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
// FIXME: Initialize empty protocol by updating fields to reflect
|
|
||||||
// those of a real protocol with the same name
|
|
||||||
case OBJC2_PROTOCOL_VERSION:
|
|
||||||
{
|
|
||||||
/* assign class pointer */
|
|
||||||
aProto->class_pointer = proto_class2;
|
|
||||||
/* init super protocols */
|
|
||||||
__objc_init_protocols (aProto->protocol_list);
|
|
||||||
protos->list[i] = __objc_unique_protocol (aProto);
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
{
|
|
||||||
if (protos->list[i]->class_pointer != proto_class
|
|
||||||
&& protos->list[i]->class_pointer != proto_class2)
|
|
||||||
{
|
|
||||||
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),
|
|
||||||
PROTOCOL_VERSION);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
UNLOCK(__objc_runtime_mutex);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
__objc_class_add_protocols (Class class, struct objc_protocol_list *protos)
|
|
||||||
{
|
|
||||||
/* Well... */
|
|
||||||
if (! protos)
|
|
||||||
return;
|
|
||||||
|
|
||||||
/* Add it... */
|
|
||||||
protos->next = class->protocols;
|
|
||||||
class->protocols = protos;
|
|
||||||
}
|
|
||||||
@ -0,0 +1,92 @@
|
|||||||
|
#include <stdlib.h>
|
||||||
|
#include <assert.h>
|
||||||
|
#include "objc/runtime.h"
|
||||||
|
#include "lock.h"
|
||||||
|
#include "loader.h"
|
||||||
|
#include "magic_objects.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Runtime lock. This is exposed in
|
||||||
|
*/
|
||||||
|
static mutex_t objc_runtime_mutex;
|
||||||
|
void *__objc_runtime_mutex = &objc_runtime_mutex;
|
||||||
|
|
||||||
|
void __objc_sync_init(void);
|
||||||
|
void __objc_init_selector_tables(void);
|
||||||
|
void __objc_init_protocol_table(void);
|
||||||
|
void __objc_init_class_tables(void);
|
||||||
|
void __objc_init_dispatch_tables(void);
|
||||||
|
|
||||||
|
/* Number of threads that are alive. */
|
||||||
|
int __objc_runtime_threads_alive = 1; /* !T:MUTEX */
|
||||||
|
|
||||||
|
void __objc_exec_class(struct objc_module_abi_8 *module)
|
||||||
|
{
|
||||||
|
static BOOL first_run = YES;
|
||||||
|
|
||||||
|
// Check that this module uses an ABI version that we recognise.
|
||||||
|
// In future, we should pass the ABI version to the class / category load
|
||||||
|
// functions so that we can change various structures more easily.
|
||||||
|
assert(objc_check_abi_version(module->version, module->size));
|
||||||
|
|
||||||
|
if (first_run)
|
||||||
|
{
|
||||||
|
// Create the main runtime lock. This is not safe in theory, but in
|
||||||
|
// practice the first time that this function is called will be in the
|
||||||
|
// loader, from the main thread. Future loaders may run concurrently,
|
||||||
|
// but that is likely to break the semantics of a lot of languages, so
|
||||||
|
// we don't have to worry about it for a long time.
|
||||||
|
//
|
||||||
|
// The only case when this can potentially go badly wrong is when a
|
||||||
|
// pure-C main() function spawns two threads which then, concurrently,
|
||||||
|
// call dlopen() or equivalent, and the platform's implementation of
|
||||||
|
// this does not perform any synchronization.
|
||||||
|
INIT_LOCK(objc_runtime_mutex);
|
||||||
|
// Create the lock used to protect the creation of hidden classes by
|
||||||
|
// @synchronize()
|
||||||
|
__objc_sync_init();
|
||||||
|
|
||||||
|
// Create the various tables that the runtime needs.
|
||||||
|
__objc_init_selector_tables();
|
||||||
|
__objc_init_protocol_table();
|
||||||
|
__objc_init_class_tables();
|
||||||
|
__objc_init_dispatch_tables();
|
||||||
|
first_run = NO;
|
||||||
|
}
|
||||||
|
|
||||||
|
// The runtime mutex is held for the entire duration of a load. It does
|
||||||
|
// not need to be acquired or released in any of the called load functions.
|
||||||
|
LOCK_UNTIL_RETURN(__objc_runtime_mutex);
|
||||||
|
|
||||||
|
struct objc_symbol_table_abi_8 *symbols = module->symbol_table;
|
||||||
|
// Register all of the selectors used in this module.
|
||||||
|
if (symbols->selectors)
|
||||||
|
{
|
||||||
|
objc_register_selector_array(symbols->selectors,
|
||||||
|
symbols->selector_count);
|
||||||
|
}
|
||||||
|
|
||||||
|
unsigned short defs = 0;
|
||||||
|
// Load the classes from this module
|
||||||
|
for (unsigned short i=0 ; i<symbols->class_count ; i++)
|
||||||
|
{
|
||||||
|
objc_load_class(symbols->definitions[defs++]);
|
||||||
|
}
|
||||||
|
// Load the categories from this module
|
||||||
|
for (unsigned short i=0 ; i<symbols->category_count; i++)
|
||||||
|
{
|
||||||
|
objc_try_load_category(symbols->definitions[defs++]);
|
||||||
|
}
|
||||||
|
// Load the static instances
|
||||||
|
struct objc_static_instance_list **statics = (void*)symbols->definitions[defs];
|
||||||
|
while (NULL != statics && NULL != *statics)
|
||||||
|
{
|
||||||
|
objc_init_statics(*(statics++));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Fix up the class links for loaded classes.
|
||||||
|
objc_resolve_class_links();
|
||||||
|
// Load categories and statics that were deferred.
|
||||||
|
objc_load_buffered_categories();
|
||||||
|
objc_init_buffered_statics();
|
||||||
|
}
|
||||||
@ -0,0 +1,67 @@
|
|||||||
|
#ifndef __OBJC_LOADER_H_INCLUDED
|
||||||
|
#define __OBJC_LOADER_H_INCLUDED
|
||||||
|
#include "category.h"
|
||||||
|
#include "method_list.h"
|
||||||
|
#include "module.h"
|
||||||
|
#include "class.h"
|
||||||
|
#include "protocol.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Checks whether it is safe to load a module with the specified version and
|
||||||
|
* module size. This depends on whether another module with an incompatible
|
||||||
|
* ABI has already been loaded.
|
||||||
|
*/
|
||||||
|
BOOL objc_check_abi_version(unsigned long version, unsigned long module_size);
|
||||||
|
/**
|
||||||
|
* Initializes a protocol list, uniquing the protocols in the list.
|
||||||
|
*/
|
||||||
|
void objc_init_protocols(struct objc_protocol_list *protocols);
|
||||||
|
/**
|
||||||
|
* Registers a set of selectors from a method list.
|
||||||
|
*/
|
||||||
|
void objc_register_selectors_from_list(struct objc_method_list *l);
|
||||||
|
/**
|
||||||
|
* Register all of the (unregistered) selectors that are used in a class.
|
||||||
|
*/
|
||||||
|
void objc_register_selectors_from_class(Class class);
|
||||||
|
/**
|
||||||
|
* Registers all of the selectors in an array.
|
||||||
|
*/
|
||||||
|
void objc_register_selector_array(SEL selectors, unsigned long count);
|
||||||
|
/**
|
||||||
|
* Loads a class into the runtime system. If possible, the class is resolved
|
||||||
|
* (inserted into the class tree) immediately. If its superclass is not yet
|
||||||
|
* resolved, it is enqueued for later resolution.
|
||||||
|
*/
|
||||||
|
void objc_load_class(struct objc_class *class);
|
||||||
|
/**
|
||||||
|
* Resolves classes that have not yet been resolved, if their superclasses have
|
||||||
|
* subsequently been loaded.
|
||||||
|
*/
|
||||||
|
void objc_resolve_class_links(void);
|
||||||
|
/**
|
||||||
|
* Attaches a category to its class, if the class is already loaded. Buffers
|
||||||
|
* it for future resolution if not.
|
||||||
|
*/
|
||||||
|
void objc_try_load_category(struct objc_category *cat);
|
||||||
|
/**
|
||||||
|
* Tries to load all of the categories that could not previously be loaded
|
||||||
|
* because their classes were not yet loaded.
|
||||||
|
*/
|
||||||
|
void objc_load_buffered_categories(void);
|
||||||
|
/**
|
||||||
|
* Updates the dispatch table for a class.
|
||||||
|
*/
|
||||||
|
void objc_update_dtable_for_class(Class cls);
|
||||||
|
/**
|
||||||
|
* Initialises a list of static object instances belonging to the same class if
|
||||||
|
* possible, or defers initialisation until the class has been loaded it not.
|
||||||
|
*/
|
||||||
|
void objc_init_statics(struct objc_static_instance_list *statics);
|
||||||
|
/**
|
||||||
|
* Tries again to initialise static instances which could not be initialised
|
||||||
|
* earlier.
|
||||||
|
*/
|
||||||
|
void objc_init_buffered_statics(void);
|
||||||
|
|
||||||
|
#endif //__OBJC_LOADER_H_INCLUDED
|
||||||
@ -0,0 +1,99 @@
|
|||||||
|
|
||||||
|
enum PropertyAttributeKind
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Property has no attributes.
|
||||||
|
*/
|
||||||
|
OBJC_PR_noattr = 0x00,
|
||||||
|
/**
|
||||||
|
* The property is declared read-only.
|
||||||
|
*/
|
||||||
|
OBJC_PR_readonly = (1<<0),
|
||||||
|
/**
|
||||||
|
* The property has a getter.
|
||||||
|
*/
|
||||||
|
OBJC_PR_getter = (1<<1),
|
||||||
|
/**
|
||||||
|
* The property has assign semantics.
|
||||||
|
*/
|
||||||
|
OBJC_PR_assign = (1<<2),
|
||||||
|
/**
|
||||||
|
* The property is declared read-write.
|
||||||
|
*/
|
||||||
|
OBJC_PR_readwrite = (1<<3),
|
||||||
|
/**
|
||||||
|
* Property has retain semantics.
|
||||||
|
*/
|
||||||
|
OBJC_PR_retain = (1<<4),
|
||||||
|
/**
|
||||||
|
* Property has copy semantics.
|
||||||
|
*/
|
||||||
|
OBJC_PR_copy = (1<<5),
|
||||||
|
/**
|
||||||
|
* Property is marked as non-atomic.
|
||||||
|
*/
|
||||||
|
OBJC_PR_nonatomic = (1<<6),
|
||||||
|
/**
|
||||||
|
* Property has setter.
|
||||||
|
*/
|
||||||
|
OBJC_PR_setter = (1<<7)
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Structure used for property enumeration. Note that property enumeration is
|
||||||
|
* currently quite broken on OS X, so achieving full compatibility there is
|
||||||
|
* impossible. Instead, we strive to achieve com
|
||||||
|
*/
|
||||||
|
struct objc_property
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Name of this property.
|
||||||
|
*/
|
||||||
|
const char *name;
|
||||||
|
/**
|
||||||
|
* Attributes for this property. Made by ORing together
|
||||||
|
* PropertyAttributeKinds.
|
||||||
|
*/
|
||||||
|
const char attributes;
|
||||||
|
/**
|
||||||
|
* Flag set if the property is synthesized.
|
||||||
|
*/
|
||||||
|
const char isSynthesized;
|
||||||
|
/**
|
||||||
|
* Name of the set method for this property.
|
||||||
|
*/
|
||||||
|
const char *setter_name;
|
||||||
|
/**
|
||||||
|
* Type encoding of the setter for this property.
|
||||||
|
*/
|
||||||
|
const char *setter_types;
|
||||||
|
/**
|
||||||
|
* Name of the getter for this property.
|
||||||
|
*/
|
||||||
|
const char *getter_name;
|
||||||
|
/**
|
||||||
|
* Type encoding for the get method for this property.
|
||||||
|
*/
|
||||||
|
const char *getter_types;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* List of property inrospection data.
|
||||||
|
*/
|
||||||
|
struct objc_property_list
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Number of properties in this array.
|
||||||
|
*/
|
||||||
|
int count;
|
||||||
|
/*
|
||||||
|
* UNUSED. In future, categories will be allowed to add properties and
|
||||||
|
* then this will be used to link the declarations together.
|
||||||
|
*/
|
||||||
|
struct objc_property_list *next;
|
||||||
|
/**
|
||||||
|
* List of properties.
|
||||||
|
*/
|
||||||
|
struct objc_property properties[1];
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,115 @@
|
|||||||
|
#include "selector.h"
|
||||||
|
|
||||||
|
struct objc_method_description_list
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Number of method descriptions in this list.
|
||||||
|
*/
|
||||||
|
int count;
|
||||||
|
/**
|
||||||
|
* Methods in this list. Note: these selectors are NOT resolved. The name
|
||||||
|
* field points to the name, not to the index of the uniqued version of the
|
||||||
|
* name. You must not use them for dispatch.
|
||||||
|
*/
|
||||||
|
struct objc_selector methods[1];
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Definition of the Protocol type. Protocols are objects, but are rarely used
|
||||||
|
* as such.
|
||||||
|
*/
|
||||||
|
#ifdef __OBJC__
|
||||||
|
@interface Protocol
|
||||||
|
#else
|
||||||
|
struct objc_protocol
|
||||||
|
#endif
|
||||||
|
{
|
||||||
|
/** Class pointer. */
|
||||||
|
id isa;
|
||||||
|
/**
|
||||||
|
* The name of this protocol. Two protocols are regarded as identical if
|
||||||
|
* they have the same name.
|
||||||
|
*/
|
||||||
|
char *name;
|
||||||
|
/**
|
||||||
|
* The list of protocols that this protocol conforms to.
|
||||||
|
*/
|
||||||
|
struct objc_protocol_list *protocol_list;
|
||||||
|
/**
|
||||||
|
* List of instance methods required by this protocol.
|
||||||
|
*/
|
||||||
|
struct objc_method_description_list *instance_methods;
|
||||||
|
/**
|
||||||
|
* List of class methods required by this protocol.
|
||||||
|
*/
|
||||||
|
struct objc_method_description_list *class_methods;
|
||||||
|
}
|
||||||
|
#ifdef __OBJC__
|
||||||
|
@end
|
||||||
|
#else
|
||||||
|
;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __OBJC__
|
||||||
|
@interface Protocol2
|
||||||
|
{
|
||||||
|
#else
|
||||||
|
typedef struct objc_protocol2
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Redefinition of the superclass ivars in the C version.
|
||||||
|
*/
|
||||||
|
id isa;
|
||||||
|
char *name;
|
||||||
|
struct objc_protocol_list *protocol_list;
|
||||||
|
struct objc_method_description_list *instance_methods;
|
||||||
|
struct objc_method_description_list *class_methods;
|
||||||
|
#endif
|
||||||
|
/**
|
||||||
|
* Instance methods that are declared as optional for this protocol.
|
||||||
|
*/
|
||||||
|
struct objc_method_description_list *optional_instance_methods;
|
||||||
|
/**
|
||||||
|
* Class methods that are declared as optional for this protocol.
|
||||||
|
*/
|
||||||
|
struct objc_method_description_list *optional_class_methods;
|
||||||
|
/**
|
||||||
|
* Properties that are required by this protocol.
|
||||||
|
*/
|
||||||
|
struct objc_property_list *properties;
|
||||||
|
/**
|
||||||
|
* Optional properties.
|
||||||
|
*/
|
||||||
|
struct objc_property_list *optional_properties;
|
||||||
|
}
|
||||||
|
#ifdef __OBJC__
|
||||||
|
@end
|
||||||
|
#else
|
||||||
|
Protocol2;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* List of protocols. Attached to a class or a category by the compiler and to
|
||||||
|
* a class by the runtime.
|
||||||
|
*/
|
||||||
|
struct objc_protocol_list
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Additional protocol lists. Loading a category that declares protocols
|
||||||
|
* will cause a new list to be prepended using this pointer to the protocol
|
||||||
|
* list for the class. Unlike methods, protocols can not be overridden,
|
||||||
|
* although it is possible for a protocol to appear twice.
|
||||||
|
*/
|
||||||
|
struct objc_protocol_list *next;
|
||||||
|
/**
|
||||||
|
* The number of protocols in this list.
|
||||||
|
*/
|
||||||
|
size_t count;
|
||||||
|
/**
|
||||||
|
* An array of protocols. Actually contains count elements, not 1.
|
||||||
|
*
|
||||||
|
* The instances in this array may be any version of protocols.
|
||||||
|
*/
|
||||||
|
Protocol2 *list[1];
|
||||||
|
};
|
||||||
|
|
||||||
@ -0,0 +1,71 @@
|
|||||||
|
#include <string.h>
|
||||||
|
#include <stdio.h>
|
||||||
|
#include "objc/runtime.h"
|
||||||
|
#include "module.h"
|
||||||
|
#include "magic_objects.h"
|
||||||
|
|
||||||
|
#define BUFFER_TYPE struct objc_static_instance_list
|
||||||
|
#include "buffer.h"
|
||||||
|
|
||||||
|
static BOOL try_init_statics(struct objc_static_instance_list *statics)
|
||||||
|
{
|
||||||
|
const char *class_name = statics->class_name;
|
||||||
|
|
||||||
|
// This is a horrible hack.
|
||||||
|
//
|
||||||
|
// Very bad things happen when you have more than one constant string class
|
||||||
|
// used in a program. Unfortunately, GCC defaults to using
|
||||||
|
// NXConstantString, and if you forget to specify
|
||||||
|
// -fconstant-string-class=NSConstantString for some compilation units then
|
||||||
|
// you will end up with some NSConstantString instances and some
|
||||||
|
// NXConstantString instances. This is a mess. We hack around this by
|
||||||
|
// silently assuming that the user meant NSConstantString when they said
|
||||||
|
// NXConstantString if NSConstantString is set as the constant string class
|
||||||
|
// in magic_objects.h
|
||||||
|
if (strcmp(class_name, "NXConstantString") == 0)
|
||||||
|
{
|
||||||
|
class_name = CONSTANT_STRING_CLASS;
|
||||||
|
}
|
||||||
|
|
||||||
|
Class class = (Class)objc_getClass(class_name);
|
||||||
|
|
||||||
|
if (Nil == class)
|
||||||
|
{
|
||||||
|
return NO;
|
||||||
|
}
|
||||||
|
for (id *instance=statics->instances ; nil!=*instance ; instance++)
|
||||||
|
{
|
||||||
|
(*instance)->isa = class;
|
||||||
|
}
|
||||||
|
return YES;
|
||||||
|
}
|
||||||
|
void objc_init_statics(struct objc_static_instance_list *statics)
|
||||||
|
{
|
||||||
|
if (!try_init_statics(statics))
|
||||||
|
{
|
||||||
|
set_buffered_object_at_index(statics, buffered_objects++);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void objc_init_buffered_statics(void)
|
||||||
|
{
|
||||||
|
BOOL shouldReshuffle = NO;
|
||||||
|
|
||||||
|
for (unsigned i=0 ; i<buffered_objects ; i++)
|
||||||
|
{
|
||||||
|
struct objc_static_instance_list *c = buffered_object_at_index(i);
|
||||||
|
if (NULL != c)
|
||||||
|
{
|
||||||
|
if (try_init_statics(c))
|
||||||
|
{
|
||||||
|
set_buffered_object_at_index(NULL, i);
|
||||||
|
shouldReshuffle = YES;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (shouldReshuffle)
|
||||||
|
{
|
||||||
|
compact_buffer();
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue