Finished rewrite of message sending. Deleted lots of legacy stuff.
theraven
16 years ago
parent
9dcfe43e69
commit
b1b9baf382
@ -0,0 +1,75 @@
|
|||||||
|
#include "lock.h"
|
||||||
|
#include "class.h"
|
||||||
|
#include "sarray2.h"
|
||||||
|
/**
|
||||||
|
* Pointer to the sparse array representing the pretend (uninstalled) dtable.
|
||||||
|
*/
|
||||||
|
extern SparseArray *__objc_uninstalled_dtable;
|
||||||
|
/**
|
||||||
|
* Structure for maintaining a linked list of temporary dtables. When sending
|
||||||
|
* an +initialize message to a class, we create a temporary dtables and store
|
||||||
|
* it in a linked list. This is then used when sending other messages to
|
||||||
|
* instances of classes in the middle of initialisation.
|
||||||
|
*/
|
||||||
|
typedef struct _InitializingDtable
|
||||||
|
{
|
||||||
|
/** The class that owns the dtable. */
|
||||||
|
Class class;
|
||||||
|
/** The dtable for this class. */
|
||||||
|
void *dtable;
|
||||||
|
/** The next uninstalled dtable in the list. */
|
||||||
|
struct _InitializingDtable *next;
|
||||||
|
} InitializingDtable;
|
||||||
|
|
||||||
|
/** Head of the list of temporary dtables. Protected by initialize_lock. */
|
||||||
|
extern InitializingDtable *temporary_dtables;
|
||||||
|
mutex_t initialize_lock;
|
||||||
|
|
||||||
|
static inline int classHasInstalledDtable(struct objc_class *cls)
|
||||||
|
{
|
||||||
|
return ((void*)cls->dtable != __objc_uninstalled_dtable);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the dtable for a given class. If we are currently in an +initialize
|
||||||
|
* method then this will block if called from a thread other than the one
|
||||||
|
* running the +initialize method.
|
||||||
|
*/
|
||||||
|
static inline SparseArray *dtable_for_class(Class cls)
|
||||||
|
{
|
||||||
|
if (classHasInstalledDtable(cls))
|
||||||
|
{
|
||||||
|
return (SparseArray*)cls->dtable;
|
||||||
|
}
|
||||||
|
LOCK_UNTIL_RETURN(&initialize_lock);
|
||||||
|
if (classHasInstalledDtable(cls))
|
||||||
|
{
|
||||||
|
return (SparseArray*)cls->dtable;
|
||||||
|
}
|
||||||
|
/* This is a linear search, and so, in theory, could be very slow. It is
|
||||||
|
* O(n) where n is the number of +initialize methods on the stack. In
|
||||||
|
* practice, this is a very small number. Profiling with GNUstep showed that
|
||||||
|
* this peaks at 8. */
|
||||||
|
SparseArray *dtable = __objc_uninstalled_dtable;
|
||||||
|
InitializingDtable *buffer = temporary_dtables;
|
||||||
|
while (NULL != buffer)
|
||||||
|
{
|
||||||
|
if (buffer->class == cls)
|
||||||
|
{
|
||||||
|
dtable = (SparseArray*)buffer->dtable;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
buffer = buffer->next;
|
||||||
|
}
|
||||||
|
UNLOCK(&initialize_lock);
|
||||||
|
if (dtable == 0)
|
||||||
|
{
|
||||||
|
dtable = __objc_uninstalled_dtable;
|
||||||
|
}
|
||||||
|
return dtable;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline int classHasDtable(struct objc_class *cls)
|
||||||
|
{
|
||||||
|
return (dtable_for_class(cls) != __objc_uninstalled_dtable);
|
||||||
|
}
|
||||||
@ -1,451 +0,0 @@
|
|||||||
/* Basic data types for Objective C.
|
|
||||||
Copyright (C) 1998, 2002, 2004, 2005, 2006, 2009 Free Software Foundation, Inc.
|
|
||||||
Contributed by Ovidiu Predescu.
|
|
||||||
|
|
||||||
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 "objc/objc.h"
|
|
||||||
#include "objc/encoding.h"
|
|
||||||
|
|
||||||
#include <assert.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
#if OBJC_WITH_GC
|
|
||||||
|
|
||||||
#include <gc.h>
|
|
||||||
#include <limits.h>
|
|
||||||
|
|
||||||
/* gc_typed.h uses the following but doesn't declare them */
|
|
||||||
typedef GC_word word;
|
|
||||||
typedef GC_signed_word signed_word;
|
|
||||||
#define BITS_PER_WORD (CHAR_BIT * sizeof (word))
|
|
||||||
|
|
||||||
#include <gc_typed.h>
|
|
||||||
|
|
||||||
/* The following functions set up in `mask` the corresponding pointers.
|
|
||||||
The offset is incremented with the size of the type. */
|
|
||||||
|
|
||||||
#define ROUND(V, A) \
|
|
||||||
({ typeof (V) __v = (V); typeof (A) __a = (A); \
|
|
||||||
__a * ((__v+__a - 1)/__a); })
|
|
||||||
|
|
||||||
#define SET_BIT_FOR_OFFSET(mask, offset) \
|
|
||||||
GC_set_bit (mask, offset / sizeof (void *))
|
|
||||||
|
|
||||||
/* Some prototypes */
|
|
||||||
static void
|
|
||||||
__objc_gc_setup_struct (GC_bitmap mask, const char *type, int offset);
|
|
||||||
static void
|
|
||||||
__objc_gc_setup_union (GC_bitmap mask, const char *type, int offset);
|
|
||||||
|
|
||||||
|
|
||||||
static void
|
|
||||||
__objc_gc_setup_array (GC_bitmap mask, const char *type, int offset)
|
|
||||||
{
|
|
||||||
int i, len = atoi (type + 1);
|
|
||||||
|
|
||||||
while (isdigit (*++type))
|
|
||||||
/* do nothing */; /* skip the size of the array */
|
|
||||||
|
|
||||||
switch (*type) {
|
|
||||||
case _C_ARY_B:
|
|
||||||
for (i = 0; i < len; i++)
|
|
||||||
__objc_gc_setup_array (mask, type, offset);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_STRUCT_B:
|
|
||||||
for (i = 0; i < len; i++)
|
|
||||||
__objc_gc_setup_struct (mask, type, offset);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_UNION_B:
|
|
||||||
for (i = 0; i < len; i++)
|
|
||||||
__objc_gc_setup_union (mask, type, offset);
|
|
||||||
break;
|
|
||||||
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
__objc_gc_setup_struct (GC_bitmap mask, const char *type, int offset)
|
|
||||||
{
|
|
||||||
struct objc_struct_layout layout;
|
|
||||||
unsigned int position;
|
|
||||||
const char *mtype;
|
|
||||||
|
|
||||||
objc_layout_structure (type, &layout);
|
|
||||||
|
|
||||||
while (objc_layout_structure_next_member (&layout))
|
|
||||||
{
|
|
||||||
BOOL gc_invisible = NO;
|
|
||||||
|
|
||||||
objc_layout_structure_get_info (&layout, &position, NULL, &mtype);
|
|
||||||
|
|
||||||
/* Skip the variable name */
|
|
||||||
if (*mtype == '"')
|
|
||||||
{
|
|
||||||
for (mtype++; *mtype++ != '"';)
|
|
||||||
/* do nothing */;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (*mtype == _C_GCINVISIBLE)
|
|
||||||
{
|
|
||||||
gc_invisible = YES;
|
|
||||||
mtype++;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Add to position the offset of this structure */
|
|
||||||
position += offset;
|
|
||||||
|
|
||||||
switch (*mtype) {
|
|
||||||
case _C_ID:
|
|
||||||
case _C_CLASS:
|
|
||||||
case _C_SEL:
|
|
||||||
case _C_PTR:
|
|
||||||
case _C_CHARPTR:
|
|
||||||
case _C_ATOM:
|
|
||||||
if (! gc_invisible)
|
|
||||||
SET_BIT_FOR_OFFSET (mask, position);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_ARY_B:
|
|
||||||
__objc_gc_setup_array (mask, mtype, position);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_STRUCT_B:
|
|
||||||
__objc_gc_setup_struct (mask, mtype, position);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_UNION_B:
|
|
||||||
__objc_gc_setup_union (mask, mtype, position);
|
|
||||||
break;
|
|
||||||
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static void
|
|
||||||
__objc_gc_setup_union (GC_bitmap mask, const char *type, int offset)
|
|
||||||
{
|
|
||||||
/* Sub-optimal, quick implementation: assume the union is made of
|
|
||||||
pointers, set up the mask accordingly. */
|
|
||||||
|
|
||||||
int i, size, align;
|
|
||||||
|
|
||||||
/* Skip the variable name */
|
|
||||||
if (*type == '"')
|
|
||||||
{
|
|
||||||
for (type++; *type++ != '"';)
|
|
||||||
/* do nothing */;
|
|
||||||
}
|
|
||||||
|
|
||||||
size = objc_sizeof_type (type);
|
|
||||||
align = objc_alignof_type (type);
|
|
||||||
|
|
||||||
offset = ROUND (offset, align);
|
|
||||||
for (i = 0; i < size; i += sizeof (void *))
|
|
||||||
{
|
|
||||||
SET_BIT_FOR_OFFSET (mask, offset);
|
|
||||||
offset += sizeof (void *);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Iterates over the types in the structure that represents the class
|
|
||||||
encoding and sets the bits in mask according to each ivar type. */
|
|
||||||
static void
|
|
||||||
__objc_gc_type_description_from_type (GC_bitmap mask, const char *type)
|
|
||||||
{
|
|
||||||
struct objc_struct_layout layout;
|
|
||||||
unsigned int offset, align;
|
|
||||||
const char *ivar_type;
|
|
||||||
|
|
||||||
objc_layout_structure (type, &layout);
|
|
||||||
|
|
||||||
while (objc_layout_structure_next_member (&layout))
|
|
||||||
{
|
|
||||||
BOOL gc_invisible = NO;
|
|
||||||
|
|
||||||
objc_layout_structure_get_info (&layout, &offset, &align, &ivar_type);
|
|
||||||
|
|
||||||
/* Skip the variable name */
|
|
||||||
if (*ivar_type == '"')
|
|
||||||
{
|
|
||||||
for (ivar_type++; *ivar_type++ != '"';)
|
|
||||||
/* do nothing */;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (*ivar_type == _C_GCINVISIBLE)
|
|
||||||
{
|
|
||||||
gc_invisible = YES;
|
|
||||||
ivar_type++;
|
|
||||||
}
|
|
||||||
|
|
||||||
switch (*ivar_type) {
|
|
||||||
case _C_ID:
|
|
||||||
case _C_CLASS:
|
|
||||||
case _C_SEL:
|
|
||||||
case _C_PTR:
|
|
||||||
case _C_CHARPTR:
|
|
||||||
if (! gc_invisible)
|
|
||||||
SET_BIT_FOR_OFFSET (mask, offset);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_ARY_B:
|
|
||||||
__objc_gc_setup_array (mask, ivar_type, offset);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_STRUCT_B:
|
|
||||||
__objc_gc_setup_struct (mask, ivar_type, offset);
|
|
||||||
break;
|
|
||||||
|
|
||||||
case _C_UNION_B:
|
|
||||||
__objc_gc_setup_union (mask, ivar_type, offset);
|
|
||||||
break;
|
|
||||||
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Computes in *type the full type encoding of this class including
|
|
||||||
its super classes. '*size' gives the total number of bytes allocated
|
|
||||||
into *type, '*current' the number of bytes used so far by the
|
|
||||||
encoding. */
|
|
||||||
static void
|
|
||||||
__objc_class_structure_encoding (Class class, char **type, int *size,
|
|
||||||
int *current)
|
|
||||||
{
|
|
||||||
int i, ivar_count;
|
|
||||||
struct objc_ivar_list *ivars;
|
|
||||||
|
|
||||||
if (! class)
|
|
||||||
{
|
|
||||||
strcat (*type, "{");
|
|
||||||
(*current)++;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Add the type encodings of the super classes */
|
|
||||||
__objc_class_structure_encoding (class->super_class, type, size, current);
|
|
||||||
|
|
||||||
ivars = class->ivars;
|
|
||||||
if (! ivars)
|
|
||||||
return;
|
|
||||||
|
|
||||||
ivar_count = ivars->ivar_count;
|
|
||||||
|
|
||||||
for (i = 0; i < ivar_count; i++)
|
|
||||||
{
|
|
||||||
struct objc_ivar *ivar = &(ivars->ivar_list[i]);
|
|
||||||
const char *ivar_type = ivar->ivar_type;
|
|
||||||
int len = strlen (ivar_type);
|
|
||||||
|
|
||||||
if (*current + len + 1 >= *size)
|
|
||||||
{
|
|
||||||
/* Increase the size of the encoding string so that it
|
|
||||||
contains this ivar's type. */
|
|
||||||
*size = ROUND (*current + len + 1, 10);
|
|
||||||
*type = objc_realloc (*type, *size);
|
|
||||||
}
|
|
||||||
strcat (*type + *current, ivar_type);
|
|
||||||
*current += len;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Allocates the memory that will hold the type description for class
|
|
||||||
and calls the __objc_class_structure_encoding that generates this
|
|
||||||
value. */
|
|
||||||
void
|
|
||||||
__objc_generate_gc_type_description (Class class)
|
|
||||||
{
|
|
||||||
GC_bitmap mask;
|
|
||||||
int bits_no, size;
|
|
||||||
int type_size = 10, current;
|
|
||||||
char *class_structure_type;
|
|
||||||
|
|
||||||
if (! CLS_ISCLASS (class))
|
|
||||||
return;
|
|
||||||
|
|
||||||
/* We have to create a mask in which each bit counts for a pointer member.
|
|
||||||
We take into consideration all the non-pointer instance variables and we
|
|
||||||
round them up to the alignment. */
|
|
||||||
|
|
||||||
/* The number of bits in the mask is the size of an instance in bytes divided
|
|
||||||
by the size of a pointer. */
|
|
||||||
bits_no = (ROUND (class_get_instance_size (class), sizeof (void *))
|
|
||||||
/ sizeof (void *));
|
|
||||||
size = ROUND (bits_no, BITS_PER_WORD) / BITS_PER_WORD;
|
|
||||||
mask = objc_atomic_malloc (size * sizeof (int));
|
|
||||||
memset (mask, 0, size * sizeof (int));
|
|
||||||
|
|
||||||
class_structure_type = objc_atomic_malloc (type_size);
|
|
||||||
*class_structure_type = current = 0;
|
|
||||||
__objc_class_structure_encoding (class, &class_structure_type,
|
|
||||||
&type_size, ¤t);
|
|
||||||
if (current + 1 == type_size)
|
|
||||||
class_structure_type = objc_realloc (class_structure_type, ++type_size);
|
|
||||||
strcat (class_structure_type + current, "}");
|
|
||||||
#ifdef DEBUG
|
|
||||||
printf ("type description for '%s' is %s\n", class->name, class_structure_type);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
__objc_gc_type_description_from_type (mask, class_structure_type);
|
|
||||||
objc_free (class_structure_type);
|
|
||||||
|
|
||||||
#ifdef DEBUG
|
|
||||||
printf (" mask for '%s', type '%s' (bits %d, mask size %d) is:",
|
|
||||||
class_structure_type, class->name, bits_no, size);
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
for (i = 0; i < size; i++)
|
|
||||||
printf (" %lx", mask[i]);
|
|
||||||
}
|
|
||||||
puts ("");
|
|
||||||
#endif
|
|
||||||
|
|
||||||
class->gc_object_type = (void *) GC_make_descriptor (mask, bits_no);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Returns YES if type denotes a pointer type, NO otherwise */
|
|
||||||
static inline BOOL
|
|
||||||
__objc_ivar_pointer (const char *type)
|
|
||||||
{
|
|
||||||
type = objc_skip_type_qualifiers (type);
|
|
||||||
|
|
||||||
return (*type == _C_ID
|
|
||||||
|| *type == _C_CLASS
|
|
||||||
|| *type == _C_SEL
|
|
||||||
|| *type == _C_PTR
|
|
||||||
|| *type == _C_CHARPTR
|
|
||||||
|| *type == _C_ATOM);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Mark the instance variable whose name is given by ivarname as a
|
|
||||||
weak pointer (a pointer hidden to the garbage collector) if
|
|
||||||
gc_invisible is true. If gc_invisible is false it unmarks the
|
|
||||||
instance variable and makes it a normal pointer, visible to the
|
|
||||||
garbage collector.
|
|
||||||
|
|
||||||
This operation only makes sense on instance variables that are
|
|
||||||
pointers. */
|
|
||||||
void
|
|
||||||
class_ivar_set_gcinvisible (Class class, const char *ivarname,
|
|
||||||
BOOL gc_invisible)
|
|
||||||
{
|
|
||||||
int i, ivar_count;
|
|
||||||
struct objc_ivar_list *ivars;
|
|
||||||
|
|
||||||
if (! class || ! ivarname)
|
|
||||||
return;
|
|
||||||
|
|
||||||
ivars = class->ivars;
|
|
||||||
if (! ivars)
|
|
||||||
return;
|
|
||||||
|
|
||||||
ivar_count = ivars->ivar_count;
|
|
||||||
|
|
||||||
for (i = 0; i < ivar_count; i++)
|
|
||||||
{
|
|
||||||
struct objc_ivar *ivar = &(ivars->ivar_list[i]);
|
|
||||||
const char *type;
|
|
||||||
|
|
||||||
if (! ivar->ivar_name || strcmp (ivar->ivar_name, ivarname))
|
|
||||||
continue;
|
|
||||||
|
|
||||||
assert (ivar->ivar_type);
|
|
||||||
type = ivar->ivar_type;
|
|
||||||
|
|
||||||
/* Skip the variable name */
|
|
||||||
if (*type == '"')
|
|
||||||
{
|
|
||||||
for (type++; *type++ != '"';)
|
|
||||||
/* do nothing */;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (*type == _C_GCINVISIBLE)
|
|
||||||
{
|
|
||||||
char *new_type;
|
|
||||||
size_t len;
|
|
||||||
|
|
||||||
if (gc_invisible || ! __objc_ivar_pointer (type))
|
|
||||||
return; /* The type of the variable already matches the
|
|
||||||
requested gc_invisible type */
|
|
||||||
|
|
||||||
/* The variable is gc_invisible so we make it gc visible. */
|
|
||||||
new_type = objc_atomic_malloc (strlen(ivar->ivar_type));
|
|
||||||
len = (type - ivar->ivar_type);
|
|
||||||
memcpy (new_type, ivar->ivar_type, len);
|
|
||||||
new_type[len] = 0;
|
|
||||||
strcat (new_type, type + 1);
|
|
||||||
ivar->ivar_type = new_type;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
char *new_type;
|
|
||||||
size_t len;
|
|
||||||
|
|
||||||
if (! gc_invisible || ! __objc_ivar_pointer (type))
|
|
||||||
return; /* The type of the variable already matches the
|
|
||||||
requested gc_invisible type */
|
|
||||||
|
|
||||||
/* The variable is gc visible so we make it gc_invisible. */
|
|
||||||
new_type = objc_malloc (strlen(ivar->ivar_type) + 2);
|
|
||||||
len = (type - ivar->ivar_type);
|
|
||||||
memcpy (new_type, ivar->ivar_type, len);
|
|
||||||
new_type[len] = 0;
|
|
||||||
strcat (new_type, "!");
|
|
||||||
strcat (new_type, type);
|
|
||||||
ivar->ivar_type = new_type;
|
|
||||||
}
|
|
||||||
|
|
||||||
__objc_generate_gc_type_description (class);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Search the instance variable in the superclasses */
|
|
||||||
class_ivar_set_gcinvisible (class->super_class, ivarname, gc_invisible);
|
|
||||||
}
|
|
||||||
|
|
||||||
#else /* !OBJC_WITH_GC */
|
|
||||||
|
|
||||||
void
|
|
||||||
__objc_generate_gc_type_description (Class class __attribute__ ((__unused__)))
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
void class_ivar_set_gcinvisible (Class class __attribute__ ((__unused__)),
|
|
||||||
const char *ivarname __attribute__ ((__unused__)),
|
|
||||||
BOOL gc_invisible __attribute__ ((__unused__)))
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif /* OBJC_WITH_GC */
|
|
||||||
@ -1,39 +0,0 @@
|
|||||||
/* Force linking of classes required by Objective C runtime.
|
|
||||||
Copyright (C) 1997, 2009 Free Software Foundation, Inc.
|
|
||||||
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 <objc/Object.h>
|
|
||||||
#include <objc/NXConstStr.h>
|
|
||||||
|
|
||||||
/* Generate references to Object and NXConstanstString classes since they are
|
|
||||||
needed by the runtime system to run correctly. */
|
|
||||||
|
|
||||||
|
|
||||||
void __objc_linking (void)
|
|
||||||
{
|
|
||||||
[Object name];
|
|
||||||
[NXConstantString name];
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,54 +0,0 @@
|
|||||||
/* GNU Objective C Runtime nil receiver function
|
|
||||||
Copyright (C) 1993, 1995, 1996, 2002, 2009 Free Software Foundation, Inc.
|
|
||||||
Contributed by Kresten Krab Thorup
|
|
||||||
|
|
||||||
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/>. */
|
|
||||||
|
|
||||||
|
|
||||||
/* This is the nil method, the function that is called when the receiver
|
|
||||||
of a method is nil */
|
|
||||||
|
|
||||||
#include "objc/runtime-legacy.h"
|
|
||||||
|
|
||||||
/* When the receiver of a method invocation is nil, the runtime
|
|
||||||
returns nil_method() as the method implementation. This function
|
|
||||||
will be casted to whatever function was supposed to be executed to
|
|
||||||
execute that method (that function will take an id, followed by a
|
|
||||||
SEL, followed by who knows what arguments, depends on the method),
|
|
||||||
and executed.
|
|
||||||
|
|
||||||
For this reason, nil_method() should be a function which can be
|
|
||||||
called in place of any function taking an 'id' argument followed by
|
|
||||||
a 'SEL' argument, followed by zero, or one, or any number of
|
|
||||||
arguments (both a fixed number, or a variable number !).
|
|
||||||
|
|
||||||
There is no "proper" implementation of such a nil_method function
|
|
||||||
in C, however in all existing implementations it does not matter
|
|
||||||
when extra arguments are present, so we can simply create a function
|
|
||||||
taking a receiver and a selector, and all other arguments will be
|
|
||||||
ignored. :-)
|
|
||||||
*/
|
|
||||||
|
|
||||||
id
|
|
||||||
nil_method (id receiver, SEL op __attribute__ ((__unused__)))
|
|
||||||
{
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@ -1,499 +0,0 @@
|
|||||||
/* GNU Objective C Runtime message lookup
|
|
||||||
Copyright (C) 1993, 1995, 1996, 1997, 1998,
|
|
||||||
2001, 2002, 2004, 2009 Free Software Foundation, Inc.
|
|
||||||
Contributed by Kresten Krab Thorup
|
|
||||||
|
|
||||||
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/slot.h"
|
|
||||||
#include "objc/encoding.h"
|
|
||||||
#include "lock.h"
|
|
||||||
#include "slot_pool.h"
|
|
||||||
|
|
||||||
/* Mutex protecting the pre-initialize dtable */
|
|
||||||
static mutex_t initialize_lock;
|
|
||||||
|
|
||||||
void objc_resolve_class(Class);
|
|
||||||
|
|
||||||
/* Two hooks for method forwarding. If either is set, it is invoked
|
|
||||||
* to return a function that performs the real forwarding. If both
|
|
||||||
* are set, the result of __objc_msg_forward2 will be preferred over
|
|
||||||
* that of __objc_msg_forward. If both return NULL or are unset,
|
|
||||||
* the libgcc based functions (__builtin_apply and friends) are
|
|
||||||
* used.
|
|
||||||
*/
|
|
||||||
IMP (*__objc_msg_forward) (SEL) = NULL;
|
|
||||||
IMP (*__objc_msg_forward2) (id, SEL) = NULL;
|
|
||||||
|
|
||||||
/* Send +initialize to class */
|
|
||||||
static void __objc_send_initialize (Class);
|
|
||||||
|
|
||||||
static void __objc_install_dispatch_table_for_class (Class);
|
|
||||||
|
|
||||||
|
|
||||||
#include "dtable.c"
|
|
||||||
|
|
||||||
/* Forward declare some functions */
|
|
||||||
static void __objc_init_install_dtable (id, SEL);
|
|
||||||
|
|
||||||
static Method_t search_for_method_in_hierarchy (Class class, SEL sel);
|
|
||||||
Method_t search_for_method_in_list (MethodList_t list, SEL op);
|
|
||||||
id nil_method (id, SEL);
|
|
||||||
|
|
||||||
/* Given a selector, return the proper forwarding implementation. */
|
|
||||||
inline static
|
|
||||||
IMP
|
|
||||||
__objc_get_forward_imp (id rcv, SEL sel)
|
|
||||||
{
|
|
||||||
/* If a custom forwarding hook was registered, try getting a forwarding
|
|
||||||
function from it. There are two forward routine hooks, one that
|
|
||||||
takes the receiver as an argument and one that does not. */
|
|
||||||
if (__objc_msg_forward2)
|
|
||||||
{
|
|
||||||
IMP result;
|
|
||||||
if ((result = __objc_msg_forward2 (rcv, sel)) != NULL)
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
if (__objc_msg_forward)
|
|
||||||
{
|
|
||||||
IMP result;
|
|
||||||
if ((result = __objc_msg_forward (sel)) != NULL)
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
fprintf(stderr, "Object forwarding not available");
|
|
||||||
abort();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static inline IMP sarray_get_imp (void *dtable, size_t key)
|
|
||||||
{
|
|
||||||
struct objc_slot *slot = sarray_get_safe (dtable, key);
|
|
||||||
return (NULL != slot) ? slot->method : (IMP)0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Given a class and selector, return the selector's implementation. */
|
|
||||||
inline
|
|
||||||
IMP
|
|
||||||
get_imp (Class class, SEL sel)
|
|
||||||
{
|
|
||||||
/* In a vanilla implementation we would first check if the dispatch
|
|
||||||
table is installed. Here instead, to get more speed in the
|
|
||||||
standard case (that the dispatch table is installed) we first try
|
|
||||||
to get the imp using brute force. Only if that fails, we do what
|
|
||||||
we should have been doing from the very beginning, that is, check
|
|
||||||
if the dispatch table needs to be installed, install it if it's
|
|
||||||
not installed, and retrieve the imp from the table if it's
|
|
||||||
installed. */
|
|
||||||
IMP res = sarray_get_imp (class->dtable, (size_t) sel->sel_id);
|
|
||||||
if (res == 0)
|
|
||||||
{
|
|
||||||
/* This will block if calling +initialize from another thread. */
|
|
||||||
void *dtable = dtable_for_class(class);
|
|
||||||
/* Not a valid method */
|
|
||||||
if (dtable == __objc_uninstalled_dtable)
|
|
||||||
{
|
|
||||||
/* The dispatch table needs to be installed. */
|
|
||||||
objc_mutex_lock (__objc_runtime_mutex);
|
|
||||||
|
|
||||||
/* Double-checked locking pattern: Check
|
|
||||||
__objc_uninstalled_dtable again in case another thread
|
|
||||||
installed the dtable while we were waiting for the lock
|
|
||||||
to be released. */
|
|
||||||
if (dtable_for_class(class) == __objc_uninstalled_dtable)
|
|
||||||
{
|
|
||||||
__objc_install_dispatch_table_for_class (class);
|
|
||||||
}
|
|
||||||
|
|
||||||
objc_mutex_unlock (__objc_runtime_mutex);
|
|
||||||
/* Call ourselves with the installed dispatch table
|
|
||||||
and get the real method */
|
|
||||||
res = get_imp (class, sel);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* The dispatch table has been installed. */
|
|
||||||
|
|
||||||
/* Get the method from the dispatch table (we try to get it
|
|
||||||
again in case another thread has installed the dtable just
|
|
||||||
after we invoked sarray_get_safe, but before we checked
|
|
||||||
class->dtable == __objc_uninstalled_dtable).
|
|
||||||
*/
|
|
||||||
res = sarray_get_imp (dtable, (size_t) sel->sel_id);
|
|
||||||
if (res == 0)
|
|
||||||
{
|
|
||||||
/* The dispatch table has been installed, and the method
|
|
||||||
is not in the dispatch table. So the method just
|
|
||||||
doesn't exist for the class. Return the forwarding
|
|
||||||
implementation. */
|
|
||||||
res = __objc_get_forward_imp ((id)class, sel);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Query if an object can respond to a selector, returns YES if the
|
|
||||||
object implements the selector otherwise NO. Does not check if the
|
|
||||||
method can be forwarded. */
|
|
||||||
inline
|
|
||||||
BOOL
|
|
||||||
__objc_responds_to (id object, SEL sel)
|
|
||||||
{
|
|
||||||
void *res;
|
|
||||||
|
|
||||||
/* Install dispatch table if need be */
|
|
||||||
if (dtable_for_class(object->class_pointer) == __objc_uninstalled_dtable)
|
|
||||||
{
|
|
||||||
objc_mutex_lock (__objc_runtime_mutex);
|
|
||||||
if (dtable_for_class(object->class_pointer) == __objc_uninstalled_dtable)
|
|
||||||
{
|
|
||||||
__objc_install_dispatch_table_for_class (object->class_pointer);
|
|
||||||
}
|
|
||||||
objc_mutex_unlock (__objc_runtime_mutex);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Get the method from the dispatch table */
|
|
||||||
res = sarray_get_safe (dtable_for_class(object->class_pointer),
|
|
||||||
(size_t) sel->sel_id);
|
|
||||||
return (res != 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
extern id (*objc_proxy_lookup)(id receiver, SEL op);
|
|
||||||
/* This is the lookup function. All entries in the table are either a
|
|
||||||
valid method *or* zero. If zero then either the dispatch table
|
|
||||||
needs to be installed or it doesn't exist and forwarding is attempted. */
|
|
||||||
inline
|
|
||||||
IMP
|
|
||||||
objc_msg_lookup (id receiver, SEL op)
|
|
||||||
{
|
|
||||||
IMP result;
|
|
||||||
if (receiver)
|
|
||||||
{
|
|
||||||
result = sarray_get_imp (receiver->class_pointer->dtable,
|
|
||||||
PTR_TO_IDX(op->sel_id));
|
|
||||||
if (result == 0)
|
|
||||||
{
|
|
||||||
/** Get the dtable that we should be using for lookup. This will
|
|
||||||
* block if we are in the middle of running +initialize in another
|
|
||||||
* thread. */
|
|
||||||
void *dtable = dtable_for_class(receiver->class_pointer);
|
|
||||||
/* Not a valid method */
|
|
||||||
if (dtable == __objc_uninstalled_dtable)
|
|
||||||
{
|
|
||||||
/* The dispatch table needs to be installed.
|
|
||||||
This happens on the very first method call to the class. */
|
|
||||||
__objc_init_install_dtable (receiver, op);
|
|
||||||
|
|
||||||
/* Get real method for this in newly installed dtable */
|
|
||||||
result = get_imp (receiver->class_pointer, op);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* The dispatch table has been installed. Check again
|
|
||||||
if the method exists (just in case the dispatch table
|
|
||||||
has been installed by another thread after we did the
|
|
||||||
previous check that the method exists).
|
|
||||||
*/
|
|
||||||
result = sarray_get_imp (dtable, PTR_TO_IDX(op->sel_id));
|
|
||||||
if (result == 0)
|
|
||||||
{
|
|
||||||
/* Try again after giving the code a chance to install new
|
|
||||||
* methods. This lookup mechanism doesn't support forwarding
|
|
||||||
* to other objects, so only call the lookup recursively if
|
|
||||||
* the receiver is not changed.
|
|
||||||
*/
|
|
||||||
id newReceiver = objc_proxy_lookup (receiver, op);
|
|
||||||
if (newReceiver == receiver)
|
|
||||||
{
|
|
||||||
return objc_msg_lookup(receiver, op);
|
|
||||||
}
|
|
||||||
/* If the method still just doesn't exist for the
|
|
||||||
class, attempt to forward the method. */
|
|
||||||
result = __objc_get_forward_imp (receiver, op);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
return (IMP)nil_method;
|
|
||||||
}
|
|
||||||
|
|
||||||
IMP
|
|
||||||
objc_msg_lookup_super (Super_t super, SEL sel)
|
|
||||||
{
|
|
||||||
if (super->self)
|
|
||||||
return get_imp (super->class, sel);
|
|
||||||
else
|
|
||||||
return (IMP)nil_method;
|
|
||||||
}
|
|
||||||
|
|
||||||
int method_get_sizeof_arguments (Method *);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* TODO: This never worked properly. Delete it after checking no one is
|
|
||||||
* misguided enough to be using it.
|
|
||||||
*/
|
|
||||||
retval_t
|
|
||||||
objc_msg_sendv (id object, SEL op, arglist_t arg_frame)
|
|
||||||
{
|
|
||||||
fprintf(stderr, "objc_msg_sendv() never worked correctly. Don't use it.\n");
|
|
||||||
abort();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Send +initialize to class if not already done */
|
|
||||||
static void
|
|
||||||
__objc_send_initialize (Class class)
|
|
||||||
{
|
|
||||||
/* This *must* be a class object */
|
|
||||||
assert (CLS_ISCLASS (class));
|
|
||||||
assert (! CLS_ISMETA (class));
|
|
||||||
|
|
||||||
if (! CLS_ISINITIALIZED (class))
|
|
||||||
{
|
|
||||||
/* This is always called with the runtime lock, which guarantees
|
|
||||||
* atomicity, but we also need to make sure that the initialize lock is
|
|
||||||
* held so that we can create the premature dtable. */
|
|
||||||
LOCK(&initialize_lock);
|
|
||||||
if (! CLS_ISRESOLV (class))
|
|
||||||
objc_resolve_class(class);
|
|
||||||
|
|
||||||
|
|
||||||
/* Create the garbage collector type memory description */
|
|
||||||
__objc_generate_gc_type_description (class);
|
|
||||||
|
|
||||||
if (class->super_class)
|
|
||||||
__objc_send_initialize (class->super_class);
|
|
||||||
// Superclass +initialize might possibly send a message to this class, in
|
|
||||||
// which case this method would be called again. See NSObject and
|
|
||||||
// NSAutoreleasePool +initialize interaction in GNUstep.
|
|
||||||
if (CLS_ISINITIALIZED (class))
|
|
||||||
{
|
|
||||||
UNLOCK(&initialize_lock);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
CLS_SETINITIALIZED (class);
|
|
||||||
CLS_SETINITIALIZED (class->class_pointer);
|
|
||||||
/* Create the dtable, but don't install it on the class quite yet. */
|
|
||||||
|
|
||||||
void *dtable = create_dtable_for_class(class);
|
|
||||||
/* Taking a pointer to an on-stack object and storing it in a global is
|
|
||||||
* usually a silly idea. It is safe here, because we invert this
|
|
||||||
* transform before we return, and we use initialize_lock to make sure no
|
|
||||||
* other threads have access to this pointer. */
|
|
||||||
InitializingDtable buffer = { class, dtable, temporary_dtables };
|
|
||||||
temporary_dtables = &buffer;
|
|
||||||
|
|
||||||
{
|
|
||||||
SEL op = sel_register_name ("initialize");
|
|
||||||
IMP imp = 0;
|
|
||||||
MethodList_t method_list = class->class_pointer->methods;
|
|
||||||
|
|
||||||
while (method_list) {
|
|
||||||
int i;
|
|
||||||
Method_t method;
|
|
||||||
|
|
||||||
for (i = 0; i < method_list->method_count; i++) {
|
|
||||||
method = &(method_list->method_list[i]);
|
|
||||||
if (method->method_name
|
|
||||||
&& method->method_name->sel_id == op->sel_id) {
|
|
||||||
imp = method->method_imp;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if (imp)
|
|
||||||
break;
|
|
||||||
|
|
||||||
method_list = method_list->method_next;
|
|
||||||
|
|
||||||
}
|
|
||||||
if (imp)
|
|
||||||
(*imp) ((id) class, op);
|
|
||||||
|
|
||||||
}
|
|
||||||
class->dtable = dtable;
|
|
||||||
/* Note: We don't free the cache entry; it was allocated on the stack. */
|
|
||||||
if (temporary_dtables == &buffer)
|
|
||||||
{
|
|
||||||
temporary_dtables = temporary_dtables->next;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
InitializingDtable *prev = temporary_dtables;
|
|
||||||
while (prev->next->class != class)
|
|
||||||
{
|
|
||||||
prev = prev->next;
|
|
||||||
}
|
|
||||||
prev->next = buffer.next;
|
|
||||||
}
|
|
||||||
UNLOCK(&initialize_lock);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* This function is called by objc_msg_lookup when the
|
|
||||||
dispatch table needs to be installed; thus it is called once
|
|
||||||
for each class, namely when the very first message is sent to it. */
|
|
||||||
static void
|
|
||||||
__objc_init_install_dtable (id receiver, SEL op __attribute__ ((__unused__)))
|
|
||||||
{
|
|
||||||
objc_mutex_lock (__objc_runtime_mutex);
|
|
||||||
|
|
||||||
/* This may happen, if the programmer has taken the address of a
|
|
||||||
method before the dtable was initialized... too bad for him! */
|
|
||||||
if (dtable_for_class(receiver->class_pointer) != __objc_uninstalled_dtable)
|
|
||||||
{
|
|
||||||
objc_mutex_unlock (__objc_runtime_mutex);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (CLS_ISCLASS (receiver->class_pointer))
|
|
||||||
{
|
|
||||||
/* receiver is an ordinary object */
|
|
||||||
assert (CLS_ISCLASS (receiver->class_pointer));
|
|
||||||
|
|
||||||
/* call +initialize -- this will in turn install the factory
|
|
||||||
dispatch table if not already done :-) */
|
|
||||||
__objc_send_initialize (receiver->class_pointer);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
/* receiver is a class object */
|
|
||||||
assert (CLS_ISCLASS ((Class)receiver));
|
|
||||||
assert (CLS_ISMETA (receiver->class_pointer));
|
|
||||||
__objc_send_initialize ((Class)receiver);
|
|
||||||
}
|
|
||||||
objc_mutex_unlock (__objc_runtime_mutex);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* This function adds a method list to a class. This function is
|
|
||||||
typically called by another function specific to the run-time. As
|
|
||||||
such this function does not worry about thread safe issues.
|
|
||||||
|
|
||||||
This one is only called for categories. Class objects have their
|
|
||||||
methods installed right away, and their selectors are made into
|
|
||||||
SEL's by the function __objc_register_selectors_from_class. */
|
|
||||||
void
|
|
||||||
class_add_method_list (Class class, MethodList_t list)
|
|
||||||
{
|
|
||||||
/* Passing of a linked list is not allowed. Do multiple calls. */
|
|
||||||
assert (! list->method_next);
|
|
||||||
|
|
||||||
__objc_register_selectors_from_list(list);
|
|
||||||
|
|
||||||
/* Add the methods to the class's method list. */
|
|
||||||
list->method_next = class->methods;
|
|
||||||
class->methods = list;
|
|
||||||
|
|
||||||
/* Update the dispatch table of class */
|
|
||||||
__objc_update_dispatch_table_for_class (class);
|
|
||||||
}
|
|
||||||
|
|
||||||
Method_t
|
|
||||||
class_get_instance_method (Class class, SEL op)
|
|
||||||
{
|
|
||||||
return search_for_method_in_hierarchy (class, op);
|
|
||||||
}
|
|
||||||
|
|
||||||
Method_t
|
|
||||||
class_get_class_method (MetaClass class, SEL op)
|
|
||||||
{
|
|
||||||
return search_for_method_in_hierarchy (class, op);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* Search for a method starting from the current class up its hierarchy.
|
|
||||||
Return a pointer to the method's method structure if found. NULL
|
|
||||||
otherwise. */
|
|
||||||
|
|
||||||
static Method_t
|
|
||||||
search_for_method_in_hierarchy (Class cls, SEL sel)
|
|
||||||
{
|
|
||||||
Method_t method = NULL;
|
|
||||||
Class class;
|
|
||||||
|
|
||||||
if (! sel_is_mapped (sel))
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
/* Scan the method list of the class. If the method isn't found in the
|
|
||||||
list then step to its super class. */
|
|
||||||
for (class = cls; ((! method) && class); class = class->super_class)
|
|
||||||
method = search_for_method_in_list (class->methods, sel);
|
|
||||||
|
|
||||||
return method;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* Given a linked list of method and a method's name. Search for the named
|
|
||||||
method's method structure. Return a pointer to the method's method
|
|
||||||
structure if found. NULL otherwise. */
|
|
||||||
Method_t
|
|
||||||
search_for_method_in_list (MethodList_t list, SEL op)
|
|
||||||
{
|
|
||||||
MethodList_t method_list = list;
|
|
||||||
|
|
||||||
if (! sel_is_mapped (op))
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
/* If not found then we'll search the list. */
|
|
||||||
while (method_list)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
/* Search the method list. */
|
|
||||||
for (i = 0; i < method_list->method_count; ++i)
|
|
||||||
{
|
|
||||||
Method_t method = &method_list->method_list[i];
|
|
||||||
|
|
||||||
if (method->method_name)
|
|
||||||
if (method->method_name->sel_id == op->sel_id)
|
|
||||||
return method;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* The method wasn't found. Follow the link to the next list of
|
|
||||||
methods. */
|
|
||||||
method_list = method_list->method_next;
|
|
||||||
}
|
|
||||||
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Returns the uninstalled dispatch table indicator.
|
|
||||||
If a class' dispatch table points to __objc_uninstalled_dtable
|
|
||||||
then that means it needs its dispatch table to be installed. */
|
|
||||||
inline
|
|
||||||
struct sarray *
|
|
||||||
objc_get_uninstalled_dtable ()
|
|
||||||
{
|
|
||||||
return (void*)__objc_uninstalled_dtable;
|
|
||||||
}
|
|
||||||
|
|
||||||
// This is an ugly hack to make sure that the compiler can do inlining into
|
|
||||||
// sendmsg2.c from here. It should be removed and the two compiled separately
|
|
||||||
// once we drop support for compilers that are too primitive to do cross-module
|
|
||||||
// inlining.
|
|
||||||
#include "sendmsg2.c"
|
|
||||||
Loading…
Reference in New Issue