Subversion Repositories openrisc

/* 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;
}