Finished implementing the new runtime APIs.

git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/libobjc2/trunk@33964 72102866-910b-0410-8b05-ffd578937521

Author: theraven

ANNOUNCE

@@ -6,12 +6,13 @@ libobjc2).  This runtime was designed to support the features of Objective-C 2
 for use with GNUstep and other Objective-C programs.  Highlights of this
 release include:
 
+- Compatibility with the new runtime APIs introduced with Mac OS X 10.7.
 - Support for small objects (ones hidden inside a pointer).  On 32-bit systems,
   the runtime permits one small object class, on 64-bit systems it permits 4.
 - Support for prototype-style object orientation.  You can now add methods, as
   well as associated references, to individual objects, as well as cloning
   them.  The runtime now supports everything required for the JavaScript object
-  model.
+  model, including the ability to use blocks as methods.
 
 You may obtain the code for this release from subversion at the following
 subversion branch:

Test/PropertyIntrospectionTest.m

@@ -0,0 +1,36 @@
+#import <objc/runtime.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+@interface Foo
+@property (getter=bar, setter=setBar:, nonatomic, copy) id foo;
+@end
+@interface Foo(Bar)
+-(id)bar;
+-(void)setBar:(id)b;
+@end 
+@implementation Foo
+@synthesize  foo;
+@end
+
+int main(void)
+{
+	objc_property_t p = class_getProperty(objc_getClass("Foo"), "foo");
+	unsigned int count;
+	objc_property_attribute_t *l = property_copyAttributeList(p, &count);
+	for (unsigned int i=0 ; i<count ; i++)
+	{
+		switch (l[i].name[0])
+		{
+			case 'T': assert(0==strcmp(l[i].value, "@")); break;
+			case 'C': assert(0==strcmp(l[i].value, "")); break;
+			case 'N': assert(0==strcmp(l[i].value, "")); break;
+			case 'G': assert(0==strcmp(l[i].value, "bar")); break;
+			case 'S': assert(0==strcmp(l[i].value, "setBar:")); break;
+			case 'B': assert(0==strcmp(l[i].value, "foo")); break;
+		}
+	}
+	assert(0 == property_copyAttributeList(0, &count));
+	return 0;
+}

Test/ProtocolCreation.m

@@ -0,0 +1,28 @@
+#import <objc/runtime.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+@protocol Test2 @end
+
+int main(void)
+{
+	Protocol *p = objc_allocateProtocol("Test");
+	protocol_addMethodDescription(p, @selector(someMethod), "@:", YES, NO);
+	assert(objc_getProtocol("Test2"));
+	protocol_addProtocol(p, objc_getProtocol("Test2"));
+	objc_property_attribute_t attrs[] = { {"T", "@" } };
+	protocol_addProperty(p, "foo", attrs, 1, YES, YES);
+	objc_registerProtocol(p);
+	Protocol *p1 = objc_getProtocol("Test");
+	assert(p == p1);
+	struct objc_method_description d = protocol_getMethodDescription(p1, @selector(someMethod), YES, NO);
+	assert(strcmp(sel_getName(d.name), "someMethod") == 0);
+	assert(strcmp((d.types), "@:") == 0);
+	assert(protocol_conformsToProtocol(p1, objc_getProtocol("Test2")));
+	unsigned int count;
+	objc_property_t *props = protocol_copyPropertyList(p1, &count);
+	assert(count == 1);
+	assert(strcmp("T@,Vfoo", property_getAttributes(*props)) == 0);
+	return 0;
+}

class_table.c

@@ -460,6 +460,17 @@ int objc_getClassList(Class *buffer, int bufferLen)
 	}
 	return count;
 }
+Class *objc_copyClassList(unsigned int *outCount)
+{
+	int count = class_table->table_used;
+	Class *buffer = calloc(sizeof(Class), count);
+	if (NULL != outCount)
+	{
+		*outCount = count;
+	}
+	objc_getClassList(buffer, count);
+	return buffer;
+}
 
 Class class_getSuperclass(Class cls)
 {

encoding2.c

@@ -41,6 +41,7 @@ const char *objc_skip_argspec(const char *type)
 
 PRIVATE size_t lengthOfTypeEncoding(const char *types)
 {
+	if ((NULL == types) || ('\0' == types[0])) { return 0; }
 	const char *end = objc_skip_typespec(types);
 	size_t length = end - types;
 	return length;

objc/runtime.h

@@ -163,6 +163,26 @@ struct objc_method_description
 	const char *types;
 };
 
+/**
+ * The objc_property_attribute_t type is used to store attributes for
+ * properties.  This is used to store a decomposed version of the property
+ * encoding, with each flag stored in the name and each value in the value.
+ *
+ * All of the strings that these refer to are internal to the runtime and
+ * should not be freed.
+ */
+typedef struct
+{
+	/**
+	 * The flag that this attribute describes.  All current flags are single characters,
+	 */
+	const char *name;
+	/**
+	 */
+	const char *value;
+} objc_property_attribute_t;
+
+
 
 #ifndef YES
 #	define YES ((BOOL)1)
@@ -520,6 +540,12 @@ id objc_getClass(const char *name);
  * Otherwise, it copies classes and returns the number copied.
  */
 int objc_getClassList(Class *buffer, int bufferLen);
+/**
+ * Returns a copy of the list of all classes in the system.  The caller is
+ * responsible for freeing this list.  The number of classes is returned in the
+ * parameter.
+ */
+Class *objc_copyClassList(unsigned int *outCount);
 
 /**
  * Returns the metaclass with the specified name.  This is equivalent to
@@ -544,6 +570,41 @@ id objc_lookUpClass(const char *name);
  * Returns the protocol with the specified name.
  */
 Protocol *objc_getProtocol(const char *name);
+/**
+ * Allocates a new protocol.  This returns NULL if a protocol with the same
+ * name already exists in the system.
+ *
+ * Protocols are immutable after they have been registered, so may only be
+ * modified between calling this function and calling objc_registerProtocol().
+ */
+Protocol *objc_allocateProtocol(const char *name);
+/**
+ * Registers a protocol with the runtime.  After this point, the protocol may
+ * not be modified.
+ */
+void objc_registerProtocol(Protocol *proto);
+/**
+ * Adds a method to the protocol.
+ */
+void protocol_addMethodDescription(Protocol *aProtocol,
+                                   SEL name,
+                                   const char *types,
+                                   BOOL isRequiredMethod,
+                                   BOOL isInstanceMethod);
+/**
+ * Adds a protocol to the protocol.
+ */
+void protocol_addProtocol(Protocol *aProtocol, Protocol *addition);
+/**
+ * Adds a property to the protocol.
+ */
+void protocol_addProperty(Protocol *aProtocol,
+                          const char *name,
+                          const objc_property_attribute_t *attributes,
+                          unsigned int attributeCount,
+                          BOOL isRequiredProperty,
+                          BOOL isInstanceProperty);
+
 
 /**
  * Registers a new class and its metaclass with the runtime.  This function
@@ -600,6 +661,36 @@ const char *property_getName(objc_property_t property);
  */
 const char *property_getAttributes(objc_property_t property);
 
+/**
+ * Returns an array of attributes for this property.
+ */
+objc_property_attribute_t *property_copyAttributeList(objc_property_t property,
+                                                      unsigned int *outCount);
+/**
+ * Adds a property to the class, given a specified set of attributes.  Note
+ * that this only sets the property metadata.  The property accessor methods
+ * must already be created.
+ */
+BOOL class_addProperty(Class cls,
+                       const char *name,
+                       const objc_property_attribute_t *attributes, 
+                       unsigned int attributeCount);
+
+/**
+ * Replaces property metadata.  If the property does not exist, then this is
+ * equivalent to calling class_addProperty().
+ */
+void class_replaceProperty(Class cls,
+                           const char *name,
+                           const objc_property_attribute_t *attributes,
+                           unsigned int attributeCount);
+
+/**
+ * Returns a copy of a single attribute.
+ */
+char *property_copyAttributeValue(objc_property_t property,
+                                  const char *attributeName);
+
 /**
  * Testswhether a protocol conforms to another protocol.
  */

properties.h

@@ -1,3 +1,4 @@
+#include "visibility.h"
 
 enum PropertyAttributeKind 
 {
@@ -55,7 +56,7 @@ struct objc_property
 	 * Attributes for this property.  Made by ORing together
 	 * PropertyAttributeKinds.
 	 */
-	const char attributes;
+	char attributes;
 	/**
 	 * Flag set if the property is synthesized.
 	 */
@@ -88,8 +89,7 @@ struct objc_property_list
 	 */
 	int count;
 	/* 
-	 * UNUSED.  In future, categories will be allowed to add properties and
-	 * then this will be used to link the declarations together.
+	 * The next property in a linked list.
 	 */
 	struct objc_property_list *next; 
 	/**
@@ -98,3 +98,8 @@ struct objc_property_list
 	struct objc_property properties[];
 };
 
+/**
+ * Constructs a property description from a list of attributes.
+ */
+PRIVATE struct objc_property propertyFromAttrs(const objc_property_attribute_t *attributes,
+                                               unsigned int attributeCount);