In libobjc/: 2010-10-12 Nicola Pero <nicola.pero@meta-innovation.com>

In libobjc/:
2010-10-12  Nicola Pero  <nicola.pero@meta-innovation.com>

        * Makefile.in (C_SOURCE_FILES): Added protocols.c.
        * objc-private/protocols.h: New.
        * protocols.c: New.
        * init.c: Include objc-private/protocols.h.
        (__objc_exec_class): Call __objc_protocols_init on startup.
        (__objc_init_protocols): Call __objc_protocols_add_protocol.
        * objc-private/runtime.h: Use (struct objc_method_list *) instead
        of MethodList_t, and (struct objc_method *) instead of Method_t.
        * objc/deprecated/struct_objc_class.h: Define
        __objc_STRUCT_OBJC_CLASS_defined.
        * objc-private/module-abi-8.h (struct
        objc_method_description_list): New.
        (struct objc_class): Only define if
        __objc_STRUCT_OBJC_CLASS_defined is undefined.
        * objc/runtime.h (class_getName): New.
        (objc_getProtocol): New.
        (objc_copyProtocolList): New.
        (class_addProtocol): New.
        (class_conformsToProtocol): New.
        (class_copyProtocolList): New.
        (protocol_conformsToProtocol): New.
        (protocol_isEqual): New.
        (protocol_getName): New.
        (protocol_getMethodDescription): New.
        (protocol_copyMethodDescriptionList): New.
        (protocol_getProperty): New.
        (protocol_copyPropertyList): New.
        (protocol_copyProtocolList): New.
        * class.c (class_getName): New.
        * selector.c (sel_isEqual): New.

From-SVN: r165349

11 files changed, 822 insertions, 7 deletions

diff --git a/libobjc/ChangeLog b/libobjc/ChangeLog
index e66df6a..569d6a6 100644
--- a/libobjc/ChangeLog
+++ b/libobjc/ChangeLog
@@ -1,5 +1,38 @@
 2010-10-12  Nicola Pero  <nicola.pero@meta-innovation.com>
 
+	* Makefile.in (C_SOURCE_FILES): Added protocols.c.
+	* objc-private/protocols.h: New.
+	* protocols.c: New.
+	* init.c: Include objc-private/protocols.h.
+	(__objc_exec_class): Call __objc_protocols_init on startup.
+	(__objc_init_protocols): Call __objc_protocols_add_protocol.
+	* objc-private/runtime.h: Use (struct objc_method_list *) instead
+	of MethodList_t, and (struct objc_method *) instead of Method_t.
+	* objc/deprecated/struct_objc_class.h: Define
+	__objc_STRUCT_OBJC_CLASS_defined.
+	* objc-private/module-abi-8.h (struct
+	objc_method_description_list): New.
+	(struct objc_class): Only define if
+	__objc_STRUCT_OBJC_CLASS_defined is undefined.
+	* objc/runtime.h (class_getName): New.
+	(objc_getProtocol): New.
+	(objc_copyProtocolList): New.
+	(class_addProtocol): New.
+	(class_conformsToProtocol): New.
+	(class_copyProtocolList): New.
+	(protocol_conformsToProtocol): New.
+	(protocol_isEqual): New.
+	(protocol_getName): New.
+	(protocol_getMethodDescription): New.
+	(protocol_copyMethodDescriptionList): New.
+	(protocol_getProperty): New.
+	(protocol_copyPropertyList): New.
+	(protocol_copyProtocolList): New.
+	* class.c (class_getName): New.
+	* selector.c (sel_isEqual): New.
+	
+2010-10-12  Nicola Pero  <nicola.pero@meta-innovation.com>
+
 	* selector.c (sel_getName): Return "<null selector>" for a NULL
 	argument.
 	(sel_get_name): Return 0 for a NULL argument.
diff --git a/libobjc/Makefile.in b/libobjc/Makefile.in
index 86f65ba..4790f95 100644
--- a/libobjc/Makefile.in
+++ b/libobjc/Makefile.in
@@ -177,6 +177,7 @@ C_SOURCE_FILES = \
    objc-foreach.c \
    objc-sync.c \
    objects.c \
+   protocols.c \
    sarray.c \
    selector.c \
    sendmsg.c \
diff --git a/libobjc/class.c b/libobjc/class.c
index 216d6ac..727b26f 100644
--- a/libobjc/class.c
+++ b/libobjc/class.c
@@ -139,7 +139,8 @@ static class_node_ptr class_table_array[CLASS_TABLE_SIZE];
 /* The table writing mutex - we lock on writing to avoid conflicts
    between different writers, but we read without locks.  That is
    possible because we assume pointer assignment to be an atomic
-   operation.  */
+   operation.  TODO: This is only true under certain circumstances,
+   which should be clarified.  */
 static objc_mutex_t __class_table_lock = NULL;
 
 /* CLASS_TABLE_HASH is how we compute the hash of a class name.  It is
@@ -730,7 +731,14 @@ __objc_resolve_class_links (void)
   objc_mutex_unlock (__objc_runtime_mutex);
 }
 
+const char *
+class_getName (Class class_)
+{
+  if (class_ == Nil)
+    return "nil";
 
+  return class_->name;
+}
 
 #define CLASSOF(c) ((c)->class_pointer)
 
diff --git a/libobjc/init.c b/libobjc/init.c
index deb089d..9384f58 100644
--- a/libobjc/init.c
+++ b/libobjc/init.c
@@ -33,6 +33,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 #include "objc-private/objc-list.h" 
 #include "objc-private/runtime.h"
 #include "objc-private/objc-sync.h" /* For __objc_sync_init() */
+#include "objc-private/protocols.h" /* For __objc_protocols_init() and __objc_protocols_add_protocol() */
 
 /* The version number of this runtime.  This must match the number 
    defined in gcc (objc-act.c).  */
@@ -48,7 +49,17 @@ static struct objc_list *unclaimed_proto_list = 0; 	/* !T:MUTEX */
 /* List of unresolved static instances.  */
 static struct objc_list *uninitialized_statics = 0; 	/* !T:MUTEX */
 
-/* Global runtime "write" mutex.  */
+/* Global runtime "write" mutex.  Having a single mutex prevents
+   deadlocks, but reduces concurrency.  To improve concurrency, some
+   groups of functions in the runtime have their own separate mutex
+   (eg, __class_table_lock in class.c); to avoid deadlocks, these
+   routines must make sure that they never acquire any other lock
+   while holding their own local lock.  Ie, they should lock, execute
+   some C code that does not perform any calls to other runtime
+   functions which may potentially lock different locks, then unlock.
+   If they need to perform any calls to other runtime functions that
+   may potentially lock other locks, then they should use the global
+   __objc_runtime_mutex.  */
 objc_mutex_t __objc_runtime_mutex = 0;
 
 /* Number of threads that are alive.  */
@@ -551,6 +562,7 @@ __objc_exec_class (Module_t module)
       __objc_load_methods = objc_hash_new (128, 
 					   (hash_func_type)objc_hash_ptr,
 					   objc_compare_ptrs);
+      __objc_protocols_init ();
       __objc_sync_init ();
       previous_constructors = 1;
     }
@@ -862,10 +874,14 @@ __objc_init_protocols (struct objc_protocol_list *protos)
       struct objc_protocol *aProto = protos->list[i];
       if (((size_t)aProto->class_pointer) == PROTOCOL_VERSION)
 	{
-	  /* assign class pointer */
+	  /* Assign class pointer */
 	  aProto->class_pointer = proto_class;
 
-	  /* init super protocols */
+	  /* Register the protocol in the hashtable or protocols by
+	     name.  */
+	  __objc_protocols_add_protocol (aProto->protocol_name, aProto);
+
+	  /* Init super protocols */
 	  __objc_init_protocols (aProto->protocol_list);
 	}
       else if (protos->list[i]->class_pointer != proto_class)
diff --git a/libobjc/objc-private/module-abi-8.h b/libobjc/objc-private/module-abi-8.h
index a20e3a3..120f513 100644
--- a/libobjc/objc-private/module-abi-8.h
+++ b/libobjc/objc-private/module-abi-8.h
@@ -138,6 +138,24 @@ struct objc_method_list
 					     structure. */
 };
 
+/* Currently defined in Protocol.m (that definition should go away
+   once we include this file).  */
+struct objc_method_description_list
+{
+  int count;
+  struct objc_method_description list[1];
+};
+
+/* Currently defined by objc/objc.h.  */
+/*
+struct objc_protocol {
+  struct objc_class* class_pointer;
+  char *protocol_name;
+  struct objc_protocol_list *protocol_list;
+  struct objc_method_description_list *instance_methods, *class_methods; 
+};
+*/
+
 struct objc_protocol_list
 {
   struct objc_protocol_list *next;
@@ -155,6 +173,7 @@ struct objc_protocol_list
   some members change type. The compiler generates "char* const" and
   places a string in the following member variables: super_class.
 */
+#ifndef __objc_STRUCT_OBJC_CLASS_defined
 struct objc_class {     
   struct objc_class*  class_pointer;    /* Pointer to the class's meta
 					   class. */
@@ -197,6 +216,7 @@ struct objc_class {
   struct objc_protocol_list *protocols; /* Protocols conformed to */
   void* gc_object_type;
 };
+#endif /* __objc_STRUCT_OBJC_CLASS_defined */
 
 /* The compiler generates one of these structures for each category.
    A class may have many categories and contain both instance and
diff --git a/libobjc/objc-private/protocols.h b/libobjc/objc-private/protocols.h
new file mode 100644
index 0000000..49a2d92
--- /dev/null
+++ b/libobjc/objc-private/protocols.h
@@ -0,0 +1,46 @@
+/* GNU Objective C Runtime protocols - Private functions
+   Copyright (C) 2010 Free Software Foundation, Inc.
+   Contributed by Nicola Pero <nicola.pero@meta-innovation.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/>.  */
+
+#ifndef __objc_private_protocols_INCLUDE_GNU
+#define __objc_private_protocols_INCLUDE_GNU
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* This function needs to be called at startup by init.c.  */
+void
+__objc_protocols_init (void);
+
+/* This function adds a protocol to the internal hashtable of
+   protocols by name, which allows objc_getProtocol(name) to be
+   implemented efficiently.  */
+void
+__objc_protocols_add_protocol (const char *name, Protocol *object);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* not __objc_private_protocols_INCLUDE_GNU */
diff --git a/libobjc/objc-private/runtime.h b/libobjc/objc-private/runtime.h
index 690427e..3917c3e 100644
--- a/libobjc/objc-private/runtime.h
+++ b/libobjc/objc-private/runtime.h
@@ -58,18 +58,18 @@ extern void __objc_init_dispatch_tables(void); /* (objc-dispatch.c) */
 extern void __objc_install_premature_dtable(Class); /* (objc-dispatch.c) */
 extern void __objc_resolve_class_links(void);  /* (objc-class.c) */
 extern void __objc_register_selectors_from_class(Class); /* (objc-sel.c) */
-extern void __objc_register_selectors_from_list (MethodList_t); /* (selector.c) */
+extern void __objc_register_selectors_from_list (struct objc_method_list *); /* (selector.c) */
 extern void __objc_update_dispatch_table_for_class (Class);/* (objc-msg.c) */
 
 extern int  __objc_init_thread_system(void);    /* thread.c */
 extern int  __objc_fini_thread_system(void);    /* thread.c */
 extern void __objc_print_dtable_stats(void);    /* sendmsg.c */
 
-extern void class_add_method_list(Class, MethodList_t);
+extern void class_add_method_list(Class, struct objc_method_list *);
 
 /* Registering instance methods as class methods for root classes */
 extern void __objc_register_instance_methods_to_class(Class);
-extern Method_t search_for_method_in_list(MethodList_t list, SEL op);
+extern struct objc_method * search_for_method_in_list(struct objc_method_list * list, SEL op);
 
 /* True when class links has been resolved */     
 extern BOOL __objc_class_links_resolved;
diff --git a/libobjc/objc/deprecated/struct_objc_class.h b/libobjc/objc/deprecated/struct_objc_class.h
index 5a4859c..07927fe 100644
--- a/libobjc/objc/deprecated/struct_objc_class.h
+++ b/libobjc/objc/deprecated/struct_objc_class.h
@@ -1,4 +1,5 @@
 /* This structure used to be public, but is now private to the runtime.  */
+#define __objc_STRUCT_OBJC_CLASS_defined
 
 /*
 ** The compiler generates one of these structures for each class.  
diff --git a/libobjc/objc/runtime.h b/libobjc/objc/runtime.h
index f3a19ec..b5ae87b 100644
--- a/libobjc/objc/runtime.h
+++ b/libobjc/objc/runtime.h
@@ -356,6 +356,138 @@ objc_EXPORT int objc_getClassList (Class *returnValue, int maxNumberOfClassesToR
    the documentation is unclear on what they are supposed to do, and
    the GNU Objective-C Runtime currently does not provide them.  */
 
+/* Return the name of the class 'class_', or the string "nil" if the
+   class_ is Nil.  */
+objc_EXPORT const char * class_getName (Class class_);
+
+
+/** Implementation: the following functions are in protocols.c.  */
+
+/* Return the protocol with name 'name', or nil if it the protocol is
+   not known to the runtime.  */
+objc_EXPORT Protocol *objc_getProtocol (const char *name);
+
+/* Return all the protocols known to the runtime.  The return value of
+   the function is a pointer to an area, allocated with malloc(), that
+   contains all the protocols known to the runtime; the list is
+   terminated by NULL.  You should free this area using free() once
+   you no longer need it.  Optionally, if you pass a non-NULL
+   'numberOfReturnedProtocols' pointer, the unsigned int that it
+   points to will be filled with the number of protocols returned.  If
+   there are no protocols known to the runtime, NULL is returned.  */
+objc_EXPORT Protocol **objc_copyProtocolList (unsigned int *numberOfReturnedProtocols);
+
+/* Add a protocol to a class, and return YES if it was done
+   succesfully, and NO if not.  At the moment, NO should only happen
+   if class_ or protocol are nil, if the protocol is not a Protocol
+   object or if the class already conforms to the protocol.  */
+objc_EXPORT BOOL class_addProtocol (Class class_, Protocol *protocol);
+
+/* Return YES if the class 'class_' conforms to Protocol 'protocol',
+   and NO if not.  */
+objc_EXPORT BOOL class_conformsToProtocol (Class class_, Protocol *protocol);
+
+/* Return all the protocols that the class conforms to.  The return
+   value of the function is a pointer to an area, allocated with
+   malloc(), that contains all the protocols formally adopted by the
+   class.  It does not include protocols adopted by superclasses.  The
+   list is terminated by NULL.  Optionally, if you pass a non-NULL
+   'numberOfReturnedProtocols' pointer, the unsigned int that it
+   points to will be filled with the number of protocols returned.  */
+objc_EXPORT Protocol **class_copyProtocolList (Class class_, unsigned int *numberOfReturnedProtocols);
+
+/* Return YES if protocol 'protocol' conforms to protocol
+   'anotherProtocol', and NO if not.  Note that if one of the two
+   protocols is nil, it returns NO.  */
+objc_EXPORT BOOL protocol_conformsToProtocol (Protocol *protocol, Protocol *anotherProtocol);
+
+/* Return YES if protocol 'protocol' is the same as protocol
+   'anotherProtocol', and 'NO' if not.  Note that it returns YES if
+   the two protocols are both nil.  */
+objc_EXPORT BOOL protocol_isEqual (Protocol *protocol, Protocol *anotherProtocol);
+
+/* Return the name of protocol 'protocol'.  If 'protocol' is nil or is
+   not a Protocol, return NULL.  */
+objc_EXPORT const char *protocol_getName (Protocol *protocol);
+
+/* Return the method description for the method with selector
+   'selector' in protocol 'protocol'; if 'requiredMethod' is YES, the
+   function searches the list of required methods; if NO, the list of
+   optional methods.  If 'instanceMethod' is YES, the function search
+   for an instance method; if NO, for a class method.  If there is no
+   matching method, an objc_method_description structure with both
+   name and types set to NULL is returned.  This function will only
+   find methods that are directly declared in the protocol itself, not
+   in other protocols that this protocol adopts.
+
+   Note that the traditional ABI does not store the list of optional
+   methods of a protocol in a compiled module, so the traditional ABI
+   will always return (NULL, NULL) when requiredMethod == NO.  */
+objc_EXPORT struct objc_method_description protocol_getMethodDescription (Protocol *protocol, 
+									  SEL selector,
+									  BOOL requiredMethod,
+									  BOOL instanceMethod);
+
+/* Return the method descriptions of all the methods of the protocol.
+   The return value of the function is a pointer to an area, allocated
+   with malloc(), that contains all the method descriptions of the
+   methods of the protocol.  It does not recursively include methods
+   of the protocols adopted by this protocol.  The list is terminated
+   by a NULL objc_method_description (one with both fields set to
+   NULL).  Optionally, if you pass a non-NULL
+   'numberOfReturnedMethods' pointer, the unsigned int that it points
+   to will be filled with the number of properties returned.
+
+   Note that the traditional ABI does not store the list of optional
+   methods of a protocol in a compiled module, so the traditional ABI
+   will always return an empty list if requiredMethod is set to
+   NO.  */
+objc_EXPORT struct objc_method_description *protocol_copyMethodDescriptionList (Protocol *protocol,
+										BOOL requiredMethod,
+										BOOL instanceMethod,
+										unsigned int *numberOfReturnedMethods);
+
+/* Return the property with name 'propertyName' of the protocol
+   'protocol'.  If 'requiredProperty' is YES, the function searches
+   the list of required properties; if NO, the list of optional
+   properties.  If 'instanceProperty' is YES, the function searches
+   the list of instance properties; if NO, the list of class
+   properties.  At the moment, optional properties and class
+   properties are not part of the Objective-C language, so both
+   'requiredProperty' and 'instanceProperty' should be set to YES.
+   This function returns NULL if the required property can not be
+   found.
+
+   Note that the traditional ABI does not store the list of properties
+   of a protocol in a compiled module, so the traditional ABI will
+   always return NULL.  */
+objc_EXPORT Property protocol_getProperty (Protocol *protocol, const char *propertyName, 
+					   BOOL requiredProperty, BOOL instanceProperty);
+
+/* Return all the properties of the protocol.  The return value of the
+   function is a pointer to an area, allocated with malloc(), that
+   contains all the properties of the protocol.  It does not
+   recursively include properties of the protocols adopted by this
+   protocol.  The list is terminated by NULL.  Optionally, if you pass
+   a non-NULL 'numberOfReturnedProperties' pointer, the unsigned int
+   that it points to will be filled with the number of properties
+   returned.
+
+   Note that the traditional ABI does not store the list of properties
+   of a protocol in a compiled module, so the traditional ABI will
+   always return NULL and store 0 in numberOfReturnedProperties.  */
+objc_EXPORT Property *protocol_copyPropertyList (Protocol *protocol, unsigned int *numberOfReturnedProperties);
+
+/* Return all the protocols that the protocol conforms to.  The return
+   value of the function is a pointer to an area, allocated with
+   malloc(), that contains all the protocols formally adopted by the
+   protocol.  It does not recursively include protocols adopted by the
+   protocols adopted by this protocol.  The list is terminated by
+   NULL.  Optionally, if you pass a non-NULL
+   'numberOfReturnedProtocols' pointer, the unsigned int that it
+   points to will be filled with the number of protocols returned.  */
+objc_EXPORT Protocol **protocol_copyProtocolList (Protocol *protocol, unsigned int *numberOfReturnedProtocols);
+
 
 /* TODO: Add all the other functions in the API.  */
 
diff --git a/libobjc/protocols.c b/libobjc/protocols.c
new file mode 100644
index 0000000..af62a2d
--- /dev/null
+++ b/libobjc/protocols.c
@@ -0,0 +1,550 @@
+/* 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/objc.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() */
+
+/* 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, 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] = 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] == protocol
+	      || protocol_conformsToProtocol (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;
+
+  /* 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] = 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 (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 };
+  const char* selector_name;
+  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;
+
+  selector_name = sel_getName (selector);
+
+  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 (strcmp ((char*)(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] = proto_list->list[j];
+	      i++;
+	    }
+	  proto_list = proto_list->next;
+	}
+
+      returnValue[i] = NULL;
+    }
+
+  if (numberOfReturnedProtocols)
+    *numberOfReturnedProtocols = count;
+
+  return returnValue;
+}
diff --git a/libobjc/selector.c b/libobjc/selector.c
index e51dd20..0c12130 100644
--- a/libobjc/selector.c
+++ b/libobjc/selector.c
@@ -163,6 +163,14 @@ void __objc_register_instance_methods_to_class (Class class)
     __objc_update_dispatch_table_for_class (class->class_pointer);
 }
 
+BOOL
+sel_isEqual (SEL s1, SEL s2)
+{
+  if (s1 == 0 || s2 == 0)
+    return s1 == s2;
+  else
+    return s1->sel_id == s2->sel_id;
+}
 
 /* Returns YES iff t1 and t2 have same method types, but we ignore
    the argframe layout */