ObjFW  Diff

@synthesize getter = _getter, setter = _setter, iVar = _iVar;

- (instancetype)init
{
	OF_INVALID_INIT_METHOD
}

#if defined(OF_OBJFW_RUNTIME)
- (instancetype)of_initWithProperty: (struct objc_property *)property
{
	self = [super init];

	@try {
		_name = [[OFString alloc] initWithUTF8String: property->name];
		_attributes =
		    property->attributes | (property->extendedAttributes << 8);

		if (property->getter.name != NULL)
			_getter = [[OFString alloc]
			    initWithUTF8String: property->getter.name];
		if (property->setter.name != NULL)
			_setter = [[OFString alloc]
			    initWithUTF8String: property->setter.name];
	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}
#elif defined(OF_APPLE_RUNTIME)
- (instancetype)of_initWithProperty: (objc_property_t)property
{
	self = [super init];

	@try {
		const char *attributes;
		char *value;

		_name = [[OFString alloc]
		    initWithUTF8String: property_getName(property)];

		if ((attributes = property_getAttributes(property)) == NULL)
			@throw [OFInitializationFailedException
			    exceptionWithClass: self.class];

		value = property_copyAttributeValue(property, "G");
		while (*attributes != '\0') {
			const char *start;

		if (value != NULL) {
			switch (*attributes) {
			case 'T':
				while (*attributes != ',' &&
				    *attributes != '\0')
					attributes++;
				break;
			case 'R':
				_attributes |= OF_PROPERTY_READONLY;
				attributes++;
				break;
			case 'C':
				_attributes |= OF_PROPERTY_COPY;
				attributes++;
				break;
			case '&':
				_attributes |= OF_PROPERTY_RETAIN;
				attributes++;
				break;
			case 'N':
				_attributes |= OF_PROPERTY_NONATOMIC;
				attributes++;
				break;
			case 'G':
				start = ++attributes;

			@try {
				if (_getter != nil)
					@throw [OFInitializationFailedException
					    exceptionWithClass: self.class];

				while (*attributes != ',' &&
				    *attributes != '\0')
					attributes++;

				_getter = [[OFString alloc]
				    initWithUTF8String: start
				    initWithUTF8String: value];
						length: attributes - start];

			} @finally {
				free(value);
			}
				break;
			case 'S':
				start = ++attributes;

		}
				if (_setter != nil)
					@throw [OFInitializationFailedException
					    exceptionWithClass: self.class];

				while (*attributes != ',' &&
				    *attributes != '\0')
		value = property_copyAttributeValue(property, "S");
		if (value != NULL) {
					attributes++;

			@try {
				_setter = [[OFString alloc]
				    initWithUTF8String: start
						length: attributes - start];

				break;
				    initWithUTF8String: value];
			} @finally {
				free(value);
			}
		}

			case 'D':
				_attributes |= OF_PROPERTY_DYNAMIC;
				attributes++;
#define BOOL_ATTRIBUTE(name, flag)					\
		value = property_copyAttributeValue(property, name);	\
				break;
			case 'W':
				_attributes |= OF_PROPERTY_WEAK;
		if (value != NULL) {					\
			_attributes |= flag;				\
				attributes++;
				break;
			free(value);					\
			case 'P':
				attributes++;
				break;
			case 'V':
				start = ++attributes;

		}
				if (_iVar != nil)
					@throw [OFInitializationFailedException
					    exceptionWithClass: self.class];

				while (*attributes != ',' &&
				    *attributes != '\0')
					attributes++;
		BOOL_ATTRIBUTE("R", OF_PROPERTY_READONLY)
		BOOL_ATTRIBUTE("C", OF_PROPERTY_COPY)
		BOOL_ATTRIBUTE("&", OF_PROPERTY_RETAIN)
		BOOL_ATTRIBUTE("N", OF_PROPERTY_NONATOMIC)
		BOOL_ATTRIBUTE("D", OF_PROPERTY_DYNAMIC)
		BOOL_ATTRIBUTE("W", OF_PROPERTY_WEAK)
#undef BOOL_ATTRIBUTE

		value = property_copyAttributeValue(property, "V");
		if (value != NULL) {
			@try {
				_iVar = [[OFString alloc]
				    initWithUTF8String: start
				    initWithUTF8String: value];
						length: attributes - start];

			} @finally {
				break;
			default:
				@throw [OFInitializationFailedException
				    exceptionWithClass: self.class];
			}

				free(value);
			if (*attributes != ',' && *attributes != '\0')
				@throw [OFInitializationFailedException
				    exceptionWithClass: self.class];

			}
			if (*attributes != '\0')
				attributes++;
		}

		if (!(_attributes & OF_PROPERTY_READONLY))
			_attributes |= OF_PROPERTY_READWRITE;

		if (!(_attributes & OF_PROPERTY_COPY) &&
		    !(_attributes & OF_PROPERTY_RETAIN))

	} @catch (id e) {
		[self release];
		@throw e;
	}

	return self;
}
#else
# error Invalid ObjC runtime!
#endif

- (void)dealloc
{
	[_name release];
	[_getter release];
	[_setter release];

- (instancetype)initWithClass: (Class)class
{
	self = [super init];

	@try {
		Method *methodList;
		Ivar *iVarList;
#if defined(OF_OBJFW_RUNTIME)
		struct objc_property_list *propertyList;
#elif defined(OF_APPLE_RUNTIME)
		objc_property_t *propertyList;
#endif
		unsigned count;
		void *pool;

		_classMethods = [[OFMutableArray alloc] init];
		_instanceMethods = [[OFMutableArray alloc] init];
		_properties = [[OFMutableArray alloc] init];
		_instanceVariables = [[OFMutableArray alloc] init];

				    of_initWithIVar: iVarList[i]] autorelease]];

			objc_autoreleasePoolPop(pool);
		} @finally {
			free(iVarList);
		}

#if defined(OF_OBJFW_RUNTIME)
		for (propertyList = class->properties; propertyList != NULL;
		    propertyList = propertyList->next) {
			pool = objc_autoreleasePoolPush();

			for (unsigned int i = 0; i < propertyList->count; i++)
				[_properties addObject: [[[OFProperty alloc]
				    of_initWithProperty:
				    &propertyList->properties[i]] autorelease]];

			objc_autoreleasePoolPop(pool);
		}
#elif defined(OF_APPLE_RUNTIME)
		propertyList = class_copyPropertyList(class, &count);
		@try {
			pool = objc_autoreleasePoolPush();

			for (unsigned int i = 0; i < count; i++)
				[_properties addObject: [[[OFProperty alloc]
				    of_initWithProperty: propertyList[i]]
				    autorelease]];

			objc_autoreleasePoolPop(pool);
		} @finally {
			free(propertyList);
		}
#else
# error Invalid ObjC runtime!
#endif

		[_classMethods makeImmutable];
		[_instanceMethods makeImmutable];
		[_properties makeImmutable];
		[_instanceVariables makeImmutable];
	} @catch (id e) {
		[self release];