URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libobjc/] [protocols.c] - Rev 827
Go to most recent revision | Compare with Previous | Blame | View Log
/* GNU Objective C Runtime protocol related functions. Copyright (C) 2010 Free Software Foundation, Inc. Contributed by Nicola Pero 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-private/common.h" #include "objc/runtime.h" #include "objc-private/module-abi-8.h" /* For runtime structures */ #include "objc/thr.h" #include "objc-private/runtime.h" /* the kitchen sink */ #include "objc-private/hash.h" /* For the hash table of protocols. */ #include "objc-private/protocols.h" /* For __objc_protocols_init() and __objc_protocols_add_protocol(). */ #include <stdlib.h> /* For malloc. */ /* This is a table that maps a name to a Protocol instance with that name. Because there may be multiple Protocol instances with the same name (no harm in that) the table records only one instance. */ static cache_ptr __protocols_hashtable; /* A mutex protecting the protocol_hashtable. */ static objc_mutex_t __protocols_hashtable_lock = NULL; /* Called at startup by init.c. */ void __objc_protocols_init (void) { __protocols_hashtable_lock = objc_mutex_allocate (); /* The keys in the table are strings, and the values are Protocol objects. */ __protocols_hashtable = objc_hash_new (64, (hash_func_type) objc_hash_string, (compare_func_type) objc_compare_strings); } /* Add a protocol to the hashtable. */ void __objc_protocols_add_protocol (const char *name, struct objc_protocol *object) { objc_mutex_lock (__protocols_hashtable_lock); /* If we find a protocol with the same name already in the hashtable, we do not need to add the new one, because it will be identical to it. This in the reasonable assumption that two protocols with the same name are identical, which is expected in any sane program. If we are really paranoid, we would compare the protocols and abort if they are not identical. Unfortunately, this would slow down the startup of all Objective-C programs while trying to catch a problem that has never been seen in practice, so we don't do it. */ if (! objc_hash_is_key_in_hash (__protocols_hashtable, name)) objc_hash_add (&__protocols_hashtable, name, object); objc_mutex_unlock (__protocols_hashtable_lock); } Protocol * objc_getProtocol (const char *name) { Protocol *protocol; if (name == NULL) return NULL; objc_mutex_lock (__protocols_hashtable_lock); protocol = (Protocol *)(objc_hash_value_for_key (__protocols_hashtable, name)); objc_mutex_unlock (__protocols_hashtable_lock); return protocol; } Protocol ** objc_copyProtocolList (unsigned int *numberOfReturnedProtocols) { unsigned int count = 0; Protocol **returnValue = NULL; node_ptr node; objc_mutex_lock (__protocols_hashtable_lock); /* Count how many protocols we have. */ node = objc_hash_next (__protocols_hashtable, NULL); while (node) { count++; node = objc_hash_next (__protocols_hashtable, node); } if (count != 0) { unsigned int i = 0; /* Allocate enough memory to hold them. */ returnValue = (Protocol **)(malloc (sizeof (Protocol *) * (count + 1))); /* Copy the protocols. */ node = objc_hash_next (__protocols_hashtable, NULL); while (node) { returnValue[i] = node->value; i++; node = objc_hash_next (__protocols_hashtable, node); } returnValue[i] = NULL; } objc_mutex_unlock (__protocols_hashtable_lock); if (numberOfReturnedProtocols) *numberOfReturnedProtocols = count; return returnValue; } BOOL class_addProtocol (Class class_, Protocol *protocol) { struct objc_protocol_list *protocols; if (class_ == Nil || protocol == NULL) return NO; if (class_conformsToProtocol (class_, protocol)) return NO; /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol->class_pointer != objc_lookUpClass ("Protocol")) return NO; objc_mutex_lock (__objc_runtime_mutex); /* Create the objc_protocol_list. */ protocols = malloc (sizeof (struct objc_protocol_list)); protocols->count = 1; protocols->list[0] = (struct objc_protocol *)protocol; /* Attach it to the list of class protocols. */ protocols->next = class_->protocols; class_->protocols = protocols; objc_mutex_unlock (__objc_runtime_mutex); return YES; } BOOL class_conformsToProtocol (Class class_, Protocol *protocol) { struct objc_protocol_list* proto_list; if (class_ == Nil || protocol == NULL) return NO; /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol->class_pointer != objc_lookUpClass ("Protocol")) return NO; /* Acquire the runtime lock because the list of protocols for a class may be modified concurrently, for example if another thread calls class_addProtocol(), or dynamically loads from a file a category of the class. */ objc_mutex_lock (__objc_runtime_mutex); proto_list = class_->protocols; while (proto_list) { size_t i; for (i = 0; i < proto_list->count; i++) { if (proto_list->list[i] == (struct objc_protocol *)protocol || protocol_conformsToProtocol ((Protocol *)proto_list->list[i], protocol)) { objc_mutex_unlock (__objc_runtime_mutex); return YES; } } proto_list = proto_list->next; } objc_mutex_unlock (__objc_runtime_mutex); return NO; } Protocol ** class_copyProtocolList (Class class_, unsigned int *numberOfReturnedProtocols) { unsigned int count = 0; Protocol **returnValue = NULL; struct objc_protocol_list* proto_list; if (class_ == Nil) { if (numberOfReturnedProtocols) *numberOfReturnedProtocols = 0; return NULL; } /* Lock the runtime mutex because the class protocols may be concurrently modified. */ objc_mutex_lock (__objc_runtime_mutex); /* Count how many protocols we have. */ proto_list = class_->protocols; while (proto_list) { count = count + proto_list->count; proto_list = proto_list->next; } if (count != 0) { unsigned int i = 0; /* Allocate enough memory to hold them. */ returnValue = (Protocol **)(malloc (sizeof (Protocol *) * (count + 1))); /* Copy the protocols. */ proto_list = class_->protocols; while (proto_list) { size_t j; for (j = 0; j < proto_list->count; j++) { returnValue[i] = (Protocol *)proto_list->list[j]; i++; } proto_list = proto_list->next; } returnValue[i] = NULL; } objc_mutex_unlock (__objc_runtime_mutex); if (numberOfReturnedProtocols) *numberOfReturnedProtocols = count; return returnValue; } BOOL protocol_conformsToProtocol (Protocol *protocol, Protocol *anotherProtocol) { struct objc_protocol_list* proto_list; if (protocol == NULL || anotherProtocol == NULL) return NO; if (protocol == anotherProtocol) return YES; /* Check that the objects are Protocol objects before casting them to (struct objc_protocol *). */ if (protocol->class_pointer != anotherProtocol->class_pointer) return NO; if (protocol->class_pointer != objc_lookUpClass ("Protocol")) return NO; if (strcmp (((struct objc_protocol *)protocol)->protocol_name, ((struct objc_protocol *)anotherProtocol)->protocol_name) == 0) return YES; /* We do not acquire any lock because protocols are currently immutable. We can freely iterate over a protocol structure. */ proto_list = ((struct objc_protocol *)protocol)->protocol_list; while (proto_list) { size_t i; for (i = 0; i < proto_list->count; i++) { if (protocol_conformsToProtocol ((Protocol *)proto_list->list[i], anotherProtocol)) return YES; } proto_list = proto_list->next; } return NO; } BOOL protocol_isEqual (Protocol *protocol, Protocol *anotherProtocol) { if (protocol == anotherProtocol) return YES; if (protocol == NULL || anotherProtocol == NULL) return NO; /* Check that the objects are Protocol objects before casting them to (struct objc_protocol *). */ if (protocol->class_pointer != anotherProtocol->class_pointer) return NO; if (protocol->class_pointer != objc_lookUpClass ("Protocol")) return NO; /* Equality between formal protocols is only formal (nothing to do with actually checking the list of methods they have!). Two formal Protocols are equal if and only if they have the same name. Please note (for comparisons with other implementations) that checking the names is equivalent to checking that Protocol A conforms to Protocol B and Protocol B conforms to Protocol A, because this happens iff they have the same name. If they have different names, A conforms to B if and only if A includes B, but the situation where A includes B and B includes A is a circular dependency between Protocols which is forbidden by the compiler, so A conforms to B and B conforms to A with A and B having different names is an impossible case. */ if (strcmp (((struct objc_protocol *)protocol)->protocol_name, ((struct objc_protocol *)anotherProtocol)->protocol_name) == 0) return YES; return NO; } const char * protocol_getName (Protocol *protocol) { /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol->class_pointer != objc_lookUpClass ("Protocol")) return NULL; return ((struct objc_protocol *)protocol)->protocol_name; } struct objc_method_description protocol_getMethodDescription (Protocol *protocol, SEL selector, BOOL requiredMethod, BOOL instanceMethod) { struct objc_method_description no_result = { NULL, NULL }; struct objc_method_description_list *methods; int i; /* TODO: New ABI. */ /* The current ABI does not have any information on optional protocol methods. */ if (! requiredMethod) return no_result; /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol->class_pointer != objc_lookUpClass ("Protocol")) return no_result; if (instanceMethod) methods = ((struct objc_protocol *)protocol)->instance_methods; else methods = ((struct objc_protocol *)protocol)->class_methods; if (methods) { for (i = 0; i < methods->count; i++) { if (sel_isEqual (methods->list[i].name, selector)) return methods->list[i]; /* if (strcmp (sel_getName (methods->list[i].name), selector_name) == 0) return methods->list[i]; */ } } return no_result; } struct objc_method_description *protocol_copyMethodDescriptionList (Protocol *protocol, BOOL requiredMethod, BOOL instanceMethod, unsigned int *numberOfReturnedMethods) { struct objc_method_description_list *methods; unsigned int count = 0; struct objc_method_description *returnValue = NULL; /* TODO: New ABI */ /* The current ABI does not have any information on optional protocol methods. */ if (! requiredMethod) { if (numberOfReturnedMethods) *numberOfReturnedMethods = 0; return NULL; } /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol == NULL || protocol->class_pointer != objc_lookUpClass ("Protocol")) { if (numberOfReturnedMethods) *numberOfReturnedMethods = 0; return NULL; } /* We do not acquire any lock because protocols are currently immutable. We can freely iterate over a protocol structure. */ if (instanceMethod) methods = ((struct objc_protocol *)protocol)->instance_methods; else methods = ((struct objc_protocol *)protocol)->class_methods; if (methods) { unsigned int i; count = methods->count; /* Allocate enough memory to hold them. */ returnValue = (struct objc_method_description *)(malloc (sizeof (struct objc_method_description) * (count + 1))); /* Copy them. */ for (i = 0; i < count; i++) { returnValue[i].name = methods->list[i].name; returnValue[i].types = methods->list[i].types; } returnValue[i].name = NULL; returnValue[i].types = NULL; } if (numberOfReturnedMethods) *numberOfReturnedMethods = count; return returnValue; } Property protocol_getProperty (Protocol *protocol, const char *propertyName, BOOL requiredProperty, BOOL instanceProperty) { if (protocol == NULL || propertyName == NULL) return NULL; if (!requiredProperty || !instanceProperty) return NULL; /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol->class_pointer != objc_lookUpClass ("Protocol")) return NULL; /* TODO: New ABI. */ /* The current ABI does not have any information on protocol properties. */ return NULL; } Property *protocol_copyPropertyList (Protocol *protocol, unsigned int *numberOfReturnedProperties) { unsigned int count = 0; Property *returnValue = NULL; /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol == NULL || protocol->class_pointer != objc_lookUpClass ("Protocol")) { if (numberOfReturnedProperties) *numberOfReturnedProperties = 0; return NULL; } /* We do not acquire any lock because protocols are currently immutable. We can freely iterate over a protocol structure. */ /* TODO: New ABI. */ /* The current ABI does not have any information on protocol properties. */ if (numberOfReturnedProperties) *numberOfReturnedProperties = count; return returnValue; } Protocol **protocol_copyProtocolList (Protocol *protocol, unsigned int *numberOfReturnedProtocols) { unsigned int count = 0; Protocol **returnValue = NULL; struct objc_protocol_list* proto_list; /* Check that it is a Protocol object before casting it to (struct objc_protocol *). */ if (protocol == NULL || protocol->class_pointer != objc_lookUpClass ("Protocol")) { if (numberOfReturnedProtocols) *numberOfReturnedProtocols = 0; return NULL; } /* We do not acquire any lock because protocols are currently immutable. We can freely iterate over a protocol structure. */ /* Count how many protocols we have. */ proto_list = ((struct objc_protocol *)protocol)->protocol_list; while (proto_list) { count = count + proto_list->count; proto_list = proto_list->next; } if (count != 0) { unsigned int i = 0; /* Allocate enough memory to hold them. */ returnValue = (Protocol **)(malloc (sizeof (Protocol *) * (count + 1))); /* Copy the protocols. */ proto_list = ((struct objc_protocol *)protocol)->protocol_list; while (proto_list) { size_t j; for (j = 0; j < proto_list->count; j++) { returnValue[i] = (Protocol *)proto_list->list[j]; i++; } proto_list = proto_list->next; } returnValue[i] = NULL; } if (numberOfReturnedProtocols) *numberOfReturnedProtocols = count; return returnValue; }
Go to most recent revision | Compare with Previous | Blame | View Log