git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

In libobjc/: 2011-06-07 Nicola Pero <nicola.pero@meta-innovation.com> 

In libobjc/:
2011-06-07  Nicola Pero  <nicola.pero@meta-innovation.com>

	* class.c (objc_next_class): Removed.
	(class_pose_as): Removed.
	(CLASSOF): Removed.
	(class_table_replace): Removed.
	(objc_lookup_class): Removed.

From-SVN: r174767
This commit is contained in:
Nicola Pero 2011-06-07 21:20:42 +00:00 committed by Nicola Pero
parent ac07a61dda
commit 69c3298059
2 changed files with 9 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libobjc/ChangeLog
View File

@ -1,3 +1,11 @@
2011-06-07 Nicola Pero <nicola.pero@meta-innovation.com>
* class.c (objc_next_class): Removed.
(class_pose_as): Removed.
(CLASSOF): Removed.
(class_table_replace): Removed.
(objc_lookup_class): Removed.
2011-06-07 Nicola Pero <nicola.pero@meta-innovation.com> 2011-06-07 Nicola Pero <nicola.pero@meta-innovation.com>
Removed the Traditional Objective-C runtime public API. Removed the Traditional Objective-C runtime public API.

152
libobjc/class.c
View File

@ -203,41 +203,6 @@ class_table_insert (const char *class_name, Class class_pointer)
objc_mutex_unlock (__class_table_lock); objc_mutex_unlock (__class_table_lock);
} }
/* Replace a class in the table (used only by poseAs:). */
static void
class_table_replace (Class old_class_pointer, Class new_class_pointer)
{
int hash;
class_node_ptr node;
objc_mutex_lock (__class_table_lock);
hash = 0;
node = class_table_array[hash];
while (hash < CLASS_TABLE_SIZE)
{
if (node == NULL)
{
hash++;
if (hash < CLASS_TABLE_SIZE)
node = class_table_array[hash];
}
else
{
Class class1 = node->pointer;
if (class1 == old_class_pointer)
node->pointer = new_class_pointer;
node = node->next;
}
}
objc_mutex_unlock (__class_table_lock);
}
/* Get a class from the table. This does not need mutex protection. /* Get a class from the table. This does not need mutex protection.
Currently, this function is called each time you call a static Currently, this function is called each time you call a static
method, this is why it must be very fast. */ method, this is why it must be very fast. */
@ -760,16 +725,6 @@ objc_disposeClassPair (Class class_)
objc_free (class_); objc_free (class_);
} }
/* Traditional GNU Objective-C Runtime API. */
/* Get the class object for the class named NAME. If NAME does not
identify a known class, the hook _objc_lookup_class is called. If
this fails, nil is returned. */
Class
objc_lookup_class (const char *name)
{
return objc_getClass (name);
}
/* Traditional GNU Objective-C Runtime API. Important: this method is /* Traditional GNU Objective-C Runtime API. Important: this method is
called automatically by the compiler while messaging (if using the called automatically by the compiler while messaging (if using the
traditional ABI), so it is worth keeping it fast; don't make it traditional ABI), so it is worth keeping it fast; don't make it
@ -802,38 +757,13 @@ objc_get_class (const char *name)
return 0; return 0;
} }
/* This is used by the compiler too. */
Class Class
objc_get_meta_class (const char *name) objc_get_meta_class (const char *name)
{ {
return objc_get_class (name)->class_pointer; return objc_get_class (name)->class_pointer;
} }
/* This function provides a way to enumerate all the classes in the
executable. Pass *ENUM_STATE == NULL to start the enumeration. The
function will return 0 when there are no more classes.
For example:
id class;
void *es = NULL;
while ((class = objc_next_class (&es)))
... do something with class;
*/
Class
objc_next_class (void **enum_state)
{
Class class;
objc_mutex_lock (__objc_runtime_mutex);
/* Make sure the table is there. */
assert (__class_table_lock);
class = class_table_next ((struct class_table_enumerator **) enum_state);
objc_mutex_unlock (__objc_runtime_mutex);
return class;
}
/* This is used when the implementation of a method changes. It goes /* This is used when the implementation of a method changes. It goes
through all classes, looking for the ones that have these methods through all classes, looking for the ones that have these methods
(either method_a or method_b; method_b can be NULL), and reloads (either method_a or method_b; method_b can be NULL), and reloads
@ -1035,83 +965,3 @@ class_getInstanceSize (Class class_)
return class_->instance_size; return class_->instance_size;
} }
#define CLASSOF(c) ((c)->class_pointer)
Class
class_pose_as (Class impostor, Class super_class)
{
if (! CLS_ISRESOLV (impostor))
__objc_resolve_class_links ();
/* Preconditions */
assert (impostor);
assert (super_class);
assert (impostor->super_class == super_class);
assert (CLS_ISCLASS (impostor));
assert (CLS_ISCLASS (super_class));
assert (impostor->instance_size == super_class->instance_size);
{
Class *subclass = &(super_class->subclass_list);
/* Move subclasses of super_class to impostor. */
while (*subclass)
{
Class nextSub = (*subclass)->sibling_class;
if (*subclass != impostor)
{
Class sub = *subclass;
/* Classes */
sub->sibling_class = impostor->subclass_list;
sub->super_class = impostor;
impostor->subclass_list = sub;
/* It will happen that SUB is not a class object if it is
the top of the meta class hierarchy chain (root
meta-class objects inherit their class object). If
that is the case... don't mess with the meta-meta
class. */
if (CLS_ISCLASS (sub))
{
/* Meta classes */
CLASSOF (sub)->sibling_class =
CLASSOF (impostor)->subclass_list;
CLASSOF (sub)->super_class = CLASSOF (impostor);
CLASSOF (impostor)->subclass_list = CLASSOF (sub);
}
}
*subclass = nextSub;
}
/* Set subclasses of superclass to be impostor only. */
super_class->subclass_list = impostor;
CLASSOF (super_class)->subclass_list = CLASSOF (impostor);
/* Set impostor to have no sibling classes. */
impostor->sibling_class = 0;
CLASSOF (impostor)->sibling_class = 0;
}
/* Check relationship of impostor and super_class is kept. */
assert (impostor->super_class == super_class);
assert (CLASSOF (impostor)->super_class == CLASSOF (super_class));
/* This is how to update the lookup table. Regardless of what the
keys of the hashtable is, change all values that are superclass
into impostor. */
objc_mutex_lock (__objc_runtime_mutex);
class_table_replace (super_class, impostor);
objc_mutex_unlock (__objc_runtime_mutex);
/* Next, we update the dispatch tables... */
__objc_update_dispatch_table_for_class (CLASSOF (impostor));
__objc_update_dispatch_table_for_class (impostor);
return impostor;
}