Daily bump.
[official-gcc.git] / libobjc / protocols.c
blob0d62a8362ee87c3fc3247b4c294d6ce91d7d0984
1 /* GNU Objective C Runtime protocol related functions.
2 Copyright (C) 2010-2021 Free Software Foundation, Inc.
3 Contributed by Nicola Pero
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3, or (at your option) any later version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
13 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
14 details.
16 Under Section 7 of GPL version 3, you are granted additional
17 permissions described in the GCC Runtime Library Exception, version
18 3.1, as published by the Free Software Foundation.
20 You should have received a copy of the GNU General Public License and
21 a copy of the GCC Runtime Library Exception along with this program;
22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 <http://www.gnu.org/licenses/>. */
25 #include "objc-private/common.h"
26 #include "objc/runtime.h"
27 #include "objc-private/module-abi-8.h" /* For runtime structures */
28 #include "objc/thr.h"
29 #include "objc-private/runtime.h" /* the kitchen sink */
30 #include "objc-private/hash.h" /* For the hash table of protocols. */
31 #include "objc-private/protocols.h" /* For __objc_protocols_init() and
32 __objc_protocols_add_protocol(). */
33 #include <stdlib.h> /* For malloc. */
35 /* This is a table that maps a name to a Protocol instance with that
36 name. Because there may be multiple Protocol instances with the
37 same name (no harm in that) the table records only one
38 instance. */
39 static cache_ptr __protocols_hashtable;
41 /* A mutex protecting the protocol_hashtable. */
42 static objc_mutex_t __protocols_hashtable_lock = NULL;
44 /* Called at startup by init.c. */
45 void
46 __objc_protocols_init (void)
48 __protocols_hashtable_lock = objc_mutex_allocate ();
50 /* The keys in the table are strings, and the values are Protocol
51 objects. */
52 __protocols_hashtable = objc_hash_new (64, (hash_func_type) objc_hash_string,
53 (compare_func_type) objc_compare_strings);
56 /* Add a protocol to the hashtable. */
57 void
58 __objc_protocols_add_protocol (const char *name, struct objc_protocol *object)
60 objc_mutex_lock (__protocols_hashtable_lock);
62 /* If we find a protocol with the same name already in the
63 hashtable, we do not need to add the new one, because it will be
64 identical to it. This in the reasonable assumption that two
65 protocols with the same name are identical, which is expected in
66 any sane program. If we are really paranoid, we would compare
67 the protocols and abort if they are not identical.
68 Unfortunately, this would slow down the startup of all
69 Objective-C programs while trying to catch a problem that has
70 never been seen in practice, so we don't do it. */
71 if (! objc_hash_is_key_in_hash (__protocols_hashtable, name))
72 objc_hash_add (&__protocols_hashtable, name, object);
74 objc_mutex_unlock (__protocols_hashtable_lock);
77 Protocol *
78 objc_getProtocol (const char *name)
80 Protocol *protocol;
82 if (name == NULL)
83 return NULL;
85 objc_mutex_lock (__protocols_hashtable_lock);
86 protocol = (Protocol *)(objc_hash_value_for_key (__protocols_hashtable, name));
87 objc_mutex_unlock (__protocols_hashtable_lock);
89 return protocol;
92 Protocol **
93 objc_copyProtocolList (unsigned int *numberOfReturnedProtocols)
95 unsigned int count = 0;
96 Protocol **returnValue = NULL;
97 node_ptr node;
99 objc_mutex_lock (__protocols_hashtable_lock);
101 /* Count how many protocols we have. */
102 node = objc_hash_next (__protocols_hashtable, NULL);
103 while (node)
105 count++;
106 node = objc_hash_next (__protocols_hashtable, node);
109 if (count != 0)
111 unsigned int i = 0;
113 /* Allocate enough memory to hold them. */
114 returnValue = (Protocol **)(malloc (sizeof (Protocol *) * (count + 1)));
116 /* Copy the protocols. */
117 node = objc_hash_next (__protocols_hashtable, NULL);
118 while (node)
120 returnValue[i] = node->value;
121 i++;
122 node = objc_hash_next (__protocols_hashtable, node);
125 returnValue[i] = NULL;
127 objc_mutex_unlock (__protocols_hashtable_lock);
129 if (numberOfReturnedProtocols)
130 *numberOfReturnedProtocols = count;
132 return returnValue;
135 BOOL
136 class_addProtocol (Class class_, Protocol *protocol)
138 struct objc_protocol_list *protocols;
140 if (class_ == Nil || protocol == NULL)
141 return NO;
143 if (class_conformsToProtocol (class_, protocol))
144 return NO;
146 /* Check that it is a Protocol object before casting it to (struct
147 objc_protocol *). */
148 if (protocol->class_pointer != objc_lookUpClass ("Protocol"))
149 return NO;
151 objc_mutex_lock (__objc_runtime_mutex);
153 /* Create the objc_protocol_list. */
154 protocols = malloc (sizeof (struct objc_protocol_list));
155 protocols->count = 1;
156 protocols->list[0] = (struct objc_protocol *)protocol;
158 /* Attach it to the list of class protocols. */
159 protocols->next = class_->protocols;
160 class_->protocols = protocols;
162 objc_mutex_unlock (__objc_runtime_mutex);
164 return YES;
167 BOOL
168 class_conformsToProtocol (Class class_, Protocol *protocol)
170 struct objc_protocol_list* proto_list;
172 if (class_ == Nil || protocol == NULL)
173 return NO;
175 /* Check that it is a Protocol object before casting it to (struct
176 objc_protocol *). */
177 if (protocol->class_pointer != objc_lookUpClass ("Protocol"))
178 return NO;
180 /* Acquire the runtime lock because the list of protocols for a
181 class may be modified concurrently, for example if another thread
182 calls class_addProtocol(), or dynamically loads from a file a
183 category of the class. */
184 objc_mutex_lock (__objc_runtime_mutex);
185 proto_list = class_->protocols;
187 while (proto_list)
189 size_t i;
190 for (i = 0; i < proto_list->count; i++)
192 if (proto_list->list[i] == (struct objc_protocol *)protocol
193 || protocol_conformsToProtocol ((Protocol *)proto_list->list[i],
194 protocol))
196 objc_mutex_unlock (__objc_runtime_mutex);
197 return YES;
200 proto_list = proto_list->next;
203 objc_mutex_unlock (__objc_runtime_mutex);
204 return NO;
207 Protocol **
208 class_copyProtocolList (Class class_, unsigned int *numberOfReturnedProtocols)
210 unsigned int count = 0;
211 Protocol **returnValue = NULL;
212 struct objc_protocol_list* proto_list;
214 if (class_ == Nil)
216 if (numberOfReturnedProtocols)
217 *numberOfReturnedProtocols = 0;
218 return NULL;
221 /* Lock the runtime mutex because the class protocols may be
222 concurrently modified. */
223 objc_mutex_lock (__objc_runtime_mutex);
225 /* Count how many protocols we have. */
226 proto_list = class_->protocols;
228 while (proto_list)
230 count = count + proto_list->count;
231 proto_list = proto_list->next;
234 if (count != 0)
236 unsigned int i = 0;
238 /* Allocate enough memory to hold them. */
239 returnValue = (Protocol **)(malloc (sizeof (Protocol *) * (count + 1)));
241 /* Copy the protocols. */
242 proto_list = class_->protocols;
244 while (proto_list)
246 size_t j;
247 for (j = 0; j < proto_list->count; j++)
249 returnValue[i] = (Protocol *)proto_list->list[j];
250 i++;
252 proto_list = proto_list->next;
255 returnValue[i] = NULL;
257 objc_mutex_unlock (__objc_runtime_mutex);
259 if (numberOfReturnedProtocols)
260 *numberOfReturnedProtocols = count;
262 return returnValue;
265 BOOL
266 protocol_conformsToProtocol (Protocol *protocol, Protocol *anotherProtocol)
268 struct objc_protocol_list* proto_list;
270 if (protocol == NULL || anotherProtocol == NULL)
271 return NO;
273 if (protocol == anotherProtocol)
274 return YES;
276 /* Check that the objects are Protocol objects before casting them
277 to (struct objc_protocol *). */
278 if (protocol->class_pointer != anotherProtocol->class_pointer)
279 return NO;
281 if (protocol->class_pointer != objc_lookUpClass ("Protocol"))
282 return NO;
284 if (strcmp (((struct objc_protocol *)protocol)->protocol_name,
285 ((struct objc_protocol *)anotherProtocol)->protocol_name) == 0)
286 return YES;
288 /* We do not acquire any lock because protocols are currently
289 immutable. We can freely iterate over a protocol structure. */
290 proto_list = ((struct objc_protocol *)protocol)->protocol_list;
291 while (proto_list)
293 size_t i;
295 for (i = 0; i < proto_list->count; i++)
297 if (protocol_conformsToProtocol ((Protocol *)proto_list->list[i], anotherProtocol))
298 return YES;
300 proto_list = proto_list->next;
303 return NO;
306 BOOL
307 protocol_isEqual (Protocol *protocol, Protocol *anotherProtocol)
309 if (protocol == anotherProtocol)
310 return YES;
312 if (protocol == NULL || anotherProtocol == NULL)
313 return NO;
315 /* Check that the objects are Protocol objects before casting them
316 to (struct objc_protocol *). */
317 if (protocol->class_pointer != anotherProtocol->class_pointer)
318 return NO;
320 if (protocol->class_pointer != objc_lookUpClass ("Protocol"))
321 return NO;
323 /* Equality between formal protocols is only formal (nothing to do
324 with actually checking the list of methods they have!). Two
325 formal Protocols are equal if and only if they have the same
326 name.
328 Please note (for comparisons with other implementations) that
329 checking the names is equivalent to checking that Protocol A
330 conforms to Protocol B and Protocol B conforms to Protocol A,
331 because this happens iff they have the same name. If they have
332 different names, A conforms to B if and only if A includes B, but
333 the situation where A includes B and B includes A is a circular
334 dependency between Protocols which is forbidden by the compiler,
335 so A conforms to B and B conforms to A with A and B having
336 different names is an impossible case. */
337 if (strcmp (((struct objc_protocol *)protocol)->protocol_name,
338 ((struct objc_protocol *)anotherProtocol)->protocol_name) == 0)
339 return YES;
341 return NO;
344 const char *
345 protocol_getName (Protocol *protocol)
347 /* Check that it is a Protocol object before casting it to (struct
348 objc_protocol *). */
349 if (protocol->class_pointer != objc_lookUpClass ("Protocol"))
350 return NULL;
352 return ((struct objc_protocol *)protocol)->protocol_name;
355 struct objc_method_description protocol_getMethodDescription (Protocol *protocol,
356 SEL selector,
357 BOOL requiredMethod,
358 BOOL instanceMethod)
360 struct objc_method_description no_result = { NULL, NULL };
361 struct objc_method_description_list *methods;
362 int i;
364 /* TODO: New ABI. */
365 /* The current ABI does not have any information on optional protocol methods. */
366 if (! requiredMethod)
367 return no_result;
369 /* Check that it is a Protocol object before casting it to (struct
370 objc_protocol *). */
371 if (protocol->class_pointer != objc_lookUpClass ("Protocol"))
372 return no_result;
374 if (instanceMethod)
375 methods = ((struct objc_protocol *)protocol)->instance_methods;
376 else
377 methods = ((struct objc_protocol *)protocol)->class_methods;
379 if (methods)
381 for (i = 0; i < methods->count; i++)
383 if (sel_isEqual (methods->list[i].name, selector))
384 return methods->list[i];
386 if (strcmp (sel_getName (methods->list[i].name), selector_name) == 0)
387 return methods->list[i];
392 return no_result;
395 struct objc_method_description *protocol_copyMethodDescriptionList (Protocol *protocol,
396 BOOL requiredMethod,
397 BOOL instanceMethod,
398 unsigned int *numberOfReturnedMethods)
400 struct objc_method_description_list *methods;
401 unsigned int count = 0;
402 struct objc_method_description *returnValue = NULL;
404 /* TODO: New ABI */
405 /* The current ABI does not have any information on optional protocol methods. */
406 if (! requiredMethod)
408 if (numberOfReturnedMethods)
409 *numberOfReturnedMethods = 0;
411 return NULL;
414 /* Check that it is a Protocol object before casting it to (struct
415 objc_protocol *). */
416 if (protocol == NULL || protocol->class_pointer != objc_lookUpClass ("Protocol"))
418 if (numberOfReturnedMethods)
419 *numberOfReturnedMethods = 0;
421 return NULL;
424 /* We do not acquire any lock because protocols are currently
425 immutable. We can freely iterate over a protocol structure. */
427 if (instanceMethod)
428 methods = ((struct objc_protocol *)protocol)->instance_methods;
429 else
430 methods = ((struct objc_protocol *)protocol)->class_methods;
432 if (methods)
434 unsigned int i;
435 count = methods->count;
437 /* Allocate enough memory to hold them. */
438 returnValue = (struct objc_method_description *)(malloc (sizeof (struct objc_method_description) * (count + 1)));
440 /* Copy them. */
441 for (i = 0; i < count; i++)
443 returnValue[i].name = methods->list[i].name;
444 returnValue[i].types = methods->list[i].types;
446 returnValue[i].name = NULL;
447 returnValue[i].types = NULL;
450 if (numberOfReturnedMethods)
451 *numberOfReturnedMethods = count;
453 return returnValue;
456 Property protocol_getProperty (Protocol *protocol, const char *propertyName,
457 BOOL requiredProperty, BOOL instanceProperty)
459 if (protocol == NULL || propertyName == NULL)
460 return NULL;
462 if (!requiredProperty || !instanceProperty)
463 return NULL;
465 /* Check that it is a Protocol object before casting it to (struct
466 objc_protocol *). */
467 if (protocol->class_pointer != objc_lookUpClass ("Protocol"))
468 return NULL;
470 /* TODO: New ABI. */
471 /* The current ABI does not have any information on protocol properties. */
472 return NULL;
475 Property *protocol_copyPropertyList (Protocol *protocol, unsigned int *numberOfReturnedProperties)
477 unsigned int count = 0;
478 Property *returnValue = NULL;
480 /* Check that it is a Protocol object before casting it to (struct
481 objc_protocol *). */
482 if (protocol == NULL || protocol->class_pointer != objc_lookUpClass ("Protocol"))
484 if (numberOfReturnedProperties)
485 *numberOfReturnedProperties = 0;
487 return NULL;
490 /* We do not acquire any lock because protocols are currently
491 immutable. We can freely iterate over a protocol structure. */
493 /* TODO: New ABI. */
494 /* The current ABI does not have any information on protocol properties. */
495 if (numberOfReturnedProperties)
496 *numberOfReturnedProperties = count;
498 return returnValue;
501 Protocol **protocol_copyProtocolList (Protocol *protocol, unsigned int *numberOfReturnedProtocols)
503 unsigned int count = 0;
504 Protocol **returnValue = NULL;
505 struct objc_protocol_list* proto_list;
507 /* Check that it is a Protocol object before casting it to (struct
508 objc_protocol *). */
509 if (protocol == NULL || protocol->class_pointer != objc_lookUpClass ("Protocol"))
511 if (numberOfReturnedProtocols)
512 *numberOfReturnedProtocols = 0;
514 return NULL;
517 /* We do not acquire any lock because protocols are currently
518 immutable. We can freely iterate over a protocol structure. */
520 /* Count how many protocols we have. */
521 proto_list = ((struct objc_protocol *)protocol)->protocol_list;
523 while (proto_list)
525 count = count + proto_list->count;
526 proto_list = proto_list->next;
529 if (count != 0)
531 unsigned int i = 0;
533 /* Allocate enough memory to hold them. */
534 returnValue = (Protocol **)(malloc (sizeof (Protocol *) * (count + 1)));
536 /* Copy the protocols. */
537 proto_list = ((struct objc_protocol *)protocol)->protocol_list;
539 while (proto_list)
541 size_t j;
542 for (j = 0; j < proto_list->count; j++)
544 returnValue[i] = (Protocol *)proto_list->list[j];
545 i++;
547 proto_list = proto_list->next;
550 returnValue[i] = NULL;
553 if (numberOfReturnedProtocols)
554 *numberOfReturnedProtocols = count;
556 return returnValue;