ObjFW  Check-in [d87df02e8b]

+ bigArrayWithItemSize: (size_t)is
{
	return [[[OFBigArray alloc] initWithItemSize: is] autorelease];
}

- initWithItemSize: (size_t)is
{
	if ((self = [super init])) {

		data = NULL;
		itemsize = is;
		items = 0;
	}

	return self;
}

- (size_t)items
{
	return items;

	return hash;
}
@end

@implementation OFBigArray
- initWithItemSize: (size_t)is
{


	if (lastpagebyte == 0)
		lastpagebyte = getpagesize() - 1;

	if ((self = [super initWithItemSize: is]))
		size = 0;

	return self;
}

- add: (void*)item
{
	size_t nsize;

	[[pool_list last]->object addToPool: obj];
}

- init
{
	OFList *pool_list;

	if ((self = [super init])) {
		objects = nil;


		pool_list = get_tls(pool_list_key);

		if (pool_list == nil) {
			pool_list = [[OFList alloc]
			    initWithoutRetainAndRelease];
			set_tls(pool_list_key, pool_list);
		}

		listobj = [pool_list append: self];
	}

	return self;
}

- free
{
	[(OFList*)get_tls(pool_list_key) remove: listobj];

+ dictionaryWithHashSize: (int)hashsize
{
	return [[[OFDictionary alloc] initWithHashSize: hashsize] autorelease];
}

- init
{
	if ((self = [super init])) {

		size = 4096;

		@try {
			data = [self getMemForNItems: size
					      ofSize: sizeof(OFList*)];
		} @catch (OFException *e) {
			[self free];
			@throw e;
		}
		memset(data, 0, size);
	}

	return self;
}

- initWithHashSize: (int)hashsize
{
	if ((self = [super init])) {

		if (hashsize < 8 || hashsize > 31) {
			Class c = isa;
			[self free];
			@throw [OFInvalidArgumentException
			    newWithClass: c
			     andSelector: _cmd];
		}

		size = (size_t)1 << hashsize;

		@try {
			data = [self getMemForNItems: size
					      ofSize: sizeof(OFList*)];
		} @catch (OFException *e) {
			[self free];
			@throw e;
		}
		memset(data, 0, size);
	}

	return self;
}

- free
{
	size_t i;

+ newWithClass: (Class)class_
{
	return [[self alloc] initWithClass: class_];
}

- initWithClass: (Class)class_
{
	if ((self = [super init])) {

		class = class_;
		string = NULL;
	}

	return self;
}

- free
{
	if (string != NULL)

	return [[self alloc] initWithClass: class_
				   andSize: size];
}

- initWithClass: (Class)class_
	andSize: (size_t)size
{
	if ((self = [super initWithClass: class_]))

		req_size = size;

	return self;
}

- (const char*)cString
{
	if (string != NULL)

	return [[self alloc] initWithClass: class_
				andPointer: ptr];
}

- initWithClass: (Class)class_
     andPointer: (void*)ptr
{
	if ((self = [super initWithClass: class_]))

		pointer = ptr;

	return self;
}

- (const char*)cString
{
	if (string != NULL)

	return [[self alloc] initWithClass: class_
			       andSelector: selector_];
}

- initWithClass: (Class)class_
    andSelector: (SEL)selector_
{
	if ((self = [super initWithClass: class_]))

		selector = selector_;

	return self;
}

- (const char*)cString
{
	if (string != NULL)

	return [[self alloc] initWithClass: class_
			       andSelector: selector_];
}

- initWithClass: (Class)class_
    andSelector: (SEL)selector_
{
	if ((self = [super initWithClass: class_]))

		selector = selector_;

	return self;
}

- (const char*)cString
{
	if (string != NULL)

				   andMode: mode_];
}

- initWithClass: (Class)class_
	andPath: (const char*)path_
	andMode: (const char*)mode_
{
	if ((self = [super initWithClass: class_])) {

		path = (path_ != NULL ? strdup(path_) : NULL);
		mode = (mode_ != NULL ? strdup(mode_) : NULL);
		err = GET_ERR;
	}

	return self;
}

- free
{
	if (path != NULL)

				   andSize: size];
}

- initWithClass: (Class)class_
	andSize: (size_t)size
      andNItems: (size_t)nitems
{
	if ((self = [super initWithClass: class_])) {

		req_size = size;
		req_items = nitems;
		has_items = YES;
		err = GET_ERR;
	}

	return self;
}

- initWithClass: (Class)class_
	andSize: (size_t)size
{
	if ((self = [super initWithClass: class_])) {

		req_size = size;
		req_items = 0;
		has_items = NO;
		err = GET_ERR;
	}

	return self;
}

- (int)errNo
{
	return err;

		       andService: service_];
}

- initWithClass: (Class)class_
	andNode: (const char*)node_
     andService: (const char*)service_
{
	if ((self = [super initWithClass: class_])) {

		node = (node_ != NULL ? strdup(node_) : NULL);
		service = (service_ != NULL ? strdup(service_) : NULL);
		err = GET_SOCK_ERR;
	}

	return self;
}

- free
{
	if (node != NULL)

			  andPort: port_];
}

- initWithClass: (Class)class_
	andHost: (const char*)host_
	andPort: (uint16_t)port_
{
	if ((self = [super initWithClass: class_])) {

		host = (host_ != NULL ? strdup(host_) : NULL);
		port = port_;
		err = GET_SOCK_ERR;
	}

	return self;
}

- free
{
	if (host != NULL)

}

- initWithClass: (Class)class_
	andHost: (const char*)host_
	andPort: (uint16_t)port_
      andFamily: (int)family_
{
	if ((self = [super initWithClass: class_])) {

		host = (host_ != NULL ? strdup(host_) : NULL);
		port = port_;
		family = family_;
		err = GET_SOCK_ERR;
	}

	return self;
}

- free
{
	if (host != NULL)

	return [[self alloc] initWithClass: class_
				andBackLog: backlog_];
}

- initWithClass: (Class)class_
     andBackLog: (int)backlog_
{
	if ((self = [super initWithClass: class_])) {

		backlog = backlog_;
		err = GET_SOCK_ERR;
	}

	return self;
}

- (const char*)cString
{
	if (string != NULL)

	return backlog;
}
@end

@implementation OFAcceptFailedException
- initWithClass: (Class)class_
{
	if ((self = [super initWithClass: class_]))

		err = GET_SOCK_ERR;

	return self;
}

- (const char*)cString
{
	if (string != NULL)

}

- initWithPath: (const char*)path
       andMode: (const char*)mode
{
	Class c;

	if ((self = [super init])) {

		if ((fp = fopen(path, mode)) == NULL) {
			c = isa;
			[super free];
			@throw [OFOpenFileFailedException newWithClass: c 
							       andPath: path
							       andMode: mode];
		}
	}
	return self;
}

- free
{
	fclose(fp);

+ md5Hash
{
	return [[[OFMD5Hash alloc] init] autorelease];
}

- init
{
	if ((self = [super init])) {

		buf[0] = 0x67452301;
		buf[1] = 0xEFCDAB89;
		buf[2] = 0x98BADCFE;
		buf[3] = 0x10325476;

		bits[0] = 0;
		bits[1] = 0;

		calculated = NO;
	}

	return self;
}

- updateWithBuffer: (const char*)buffer
	    ofSize: (size_t)size
{

+ sha1Hash
{
	return [[[OFSHA1Hash alloc] init] autorelease];
}

- init
{
	if ((self = [super init])) {

		count = 0;
		state[0] = 0x67452301;
		state[1] = 0xEFCDAB89;
		state[2] = 0x98BADCFE;
		state[3] = 0x10325476;
		state[4] = 0xC3D2E1F0;
	}

	return self;
}

- updateWithBuffer: (const char*)buf
	    ofSize: (size_t)size
{

+ list
{
	return [[[OFList alloc] init] autorelease];
}

- init
{
	if ((self = [super init])) {

		first = NULL;
		last = NULL;
		retain_and_release = YES;
	}

	return self;
}

- initWithoutRetainAndRelease
{
	if ((self = [super init])) {

		first = NULL;
		last = NULL;
		retain_and_release = NO;
	}

	return self;
}

- free
{
	of_list_object_t *iter;

+ numberWithDouble: (double)double_
{
	return [[[OFNumber alloc] initWithDouble: double_] autorelease];
}

- initWithChar: (char)char_
{
	if ((self = [super init])) {

		value.char_ = char_;
		type = OF_NUMBER_CHAR;
	}

	return self;
}

- initWithShort: (short)short_
{
	if ((self = [super init])) {

		value.short_ = short_;
		type = OF_NUMBER_SHORT;
	}

	return self;
}

- initWithInt: (int)int_
{
	if ((self = [super init])) {

		value.int_ = int_;
		type = OF_NUMBER_INT;
	}

	return self;
}

- initWithLong: (long)long_
{
	if ((self = [super init])) {

		value.long_ = long_;
		type = OF_NUMBER_LONG;
	}

	return self;
}

- initWithUChar: (unsigned char)uchar
{
	if ((self = [super init])) {

		value.uchar = uchar;
		type = OF_NUMBER_UCHAR;
	}

	return self;
}

- initWithUShort: (unsigned short)ushort
{
	if ((self = [super init])) {

		value.ushort = ushort;
		type = OF_NUMBER_USHORT;
	}

	return self;
}

- initWithUInt: (unsigned int)uint
{
	if ((self = [super init])) {

		value.uint = uint;
		type = OF_NUMBER_UINT;
	}

	return self;
}

- initWithULong: (unsigned long)ulong
{
	if ((self = [super init])) {

		value.ulong = ulong;
		type = OF_NUMBER_ULONG;
	}

	return self;
}

- initWithInt8: (int8_t)int8
{
	if ((self = [super init])) {

		value.int8 = int8;
		type = OF_NUMBER_INT8;
	}

	return self;
}

- initWithInt16: (int16_t)int16
{
	if ((self = [super init])) {

		value.int16 = int16;
		type = OF_NUMBER_INT16;
	}

	return self;
}

- initWithInt32: (int32_t)int32
{
	if ((self = [super init])) {

		value.int32 = int32;
		type = OF_NUMBER_INT32;
	}

	return self;
}

- initWithInt64: (int64_t)int64
{
	if ((self = [super init])) {

		value.int64 = int64;
		type = OF_NUMBER_INT64;
	}

	return self;
}

- initWithUInt8: (uint8_t)uint8
{
	if ((self = [super init])) {

		value.uint8 = uint8;
		type = OF_NUMBER_UINT8;
	}

	return self;
}

- initWithUInt16: (uint16_t)uint16
{
	if ((self = [super init])) {

		value.uint16 = uint16;
		type = OF_NUMBER_UINT16;
	}

	return self;
}

- initWithUInt32: (uint32_t)uint32
{
	if ((self = [super init])) {

		value.uint32 = uint32;
		type = OF_NUMBER_UINT32;
	}

	return self;
}

- initWithUInt64: (uint64_t)uint64
{
	if ((self = [super init])) {

		value.uint64 = uint64;
		type = OF_NUMBER_UINT64;
	}

	return self;
}

- initWithSize: (size_t)size
{
	if ((self = [super init])) {

		value.size = size;
		type = OF_NUMBER_SIZE;
	}

	return self;
}

- initWithSSize: (ssize_t)ssize
{
	if ((self = [super init])) {

		value.ssize = ssize;
		type = OF_NUMBER_SSIZE;
	}

	return self;
}

- initWithIntMax: (intmax_t)intmax
{
	if ((self = [super init])) {

		value.intmax = intmax;
		type = OF_NUMBER_INTMAX;
	}

	return self;
}

- initWithUIntMax: (uintmax_t)uintmax
{
	if ((self = [super init])) {

		value.uintmax = uintmax;
		type = OF_NUMBER_UINTMAX;
	}

	return self;
}

- initWithPtrDiff: (ptrdiff_t)ptrdiff
{
	if ((self = [super init])) {

		value.ptrdiff = ptrdiff;
		type = OF_NUMBER_PTRDIFF;
	}

	return self;
}

- initWithIntPtr: (intptr_t)intptr
{
	if ((self = [super init])) {

		value.intptr = intptr;
		type = OF_NUMBER_INTPTR;
	}

	return self;
}

- initWithFloat: (float)float_
{
	if ((self = [super init])) {

		value.float_ = float_;
		type = OF_NUMBER_FLOAT;
	}

	return self;
}

- initWithDouble: (double)double_
{
	if ((self = [super init])) {

		value.double_ = double_;
		type = OF_NUMBER_DOUBLE;
	}

	return self;
}

- (enum of_number_type)type
{
	return type;

 * Derived classes can override this to execute their own code on
 * initialization.
 */
+ initialize;

/**
 * Allocates memory for an instance of the class.





 */
+ alloc;

/**
 * Allocated memory for an instance of the class and initializes the instance.
 */
+ new;

 */
+ (IMP)replaceMethod: (SEL)selector
 withMethodFromClass: (Class)class;

/**
 * Initialize the already allocated object.
 * Also sets up the memory pool for the object.




 *
 * \return An initialized object
 */
- init;

/**
 * \return A pointer to the class of the instance

{
	char *file;
	size_t pathlen, suffixlen;
	void *handle;
	OFPlugin *(*init_plugin)();
	OFPlugin *plugin;

	if ((self = [super init])) {
		pathlen = strlen(path);
		suffixlen = strlen(PLUGIN_SUFFIX);

		if ((file = malloc(pathlen + suffixlen + 1)) == NULL) {
			@throw [OFNoMemException newWithClass: self
						      andSize: pathlen +
							       suffixlen + 1];
		}
		memcpy(file, path, pathlen);
		memcpy(file + pathlen, PLUGIN_SUFFIX, suffixlen);
		file[pathlen + suffixlen] = 0;

		if ((handle = dlopen(file, RTLD_NOW)) == NULL) {
			free(file);
			@throw [OFInitializationFailedException
			    newWithClass: self];
		}
		free(file);

		if ((init_plugin = dlsym(handle, "init_plugin")) == NULL ||
		    (plugin = init_plugin()) == nil) {
			dlclose(handle);
			@throw [OFInitializationFailedException
			    newWithClass: self];
		}

		plugin->handle = handle;
		return plugin;
	}

	return self;
}

- free
{
	dlclose(handle);

	return [super free];
}
@end

{
	return [[[OFString alloc] initWithFormat: fmt
				andArguments: args] autorelease];
}

- init
{
	if ((self = [super init])) {

		length = 0;
		string = NULL;
		is_utf8 = NO;
	}

	return self;
}

- initWithCString: (const char*)str
{
	Class c;

	if ((self = [super init])) {

		if (str != NULL) {
			length = strlen(str);

			switch (check_utf8(str, length)) {
			case 1:
				is_utf8 = YES;
				break;
			case -1:
				c = isa;
				[super free];
				@throw [OFInvalidEncodingException
				    newWithClass: c];
			}

			@try {
				string = [self getMemWithSize: length + 1];
			} @catch (OFException *e) {
				[self free];
				@throw e;
			}
			memcpy(string, str, length + 1);
		}
	}

	return self;
}

- initWithFormat: (const char*)fmt, ...
{

- initWithFormat: (const char*)fmt
    andArguments: (va_list)args
{
	int t;
	Class c;

	if ((self = [super init])) {

		if (fmt == NULL) {
			c = isa;
			[super free];
			@throw [OFInvalidFormatException newWithClass: c];
		}

		if ((t = vasprintf(&string, fmt, args)) == -1) {
			c = isa;
			[super free];
			@throw [OFInitializationFailedException
			    newWithClass: c];
		}
		length = t;

		switch (check_utf8(string, length)) {
		case 1:
			is_utf8 = YES;
			break;
		case -1:
			free(string);
			c = isa;
			[super free];
			@throw [OFInvalidEncodingException newWithClass: c];
		}

		@try {
			[self addToMemoryPool: string];
		} @catch (OFException *e) {
			free(string);
			@throw e;
		}
	}

	return self;
}

- (const char*)cString
{

	return self;
}
#endif

- init
{
	if ((self = [super init])) {

		sock = INVALID_SOCKET;
		saddr = NULL;
		saddr_len = 0;
	}

	return self;
}

- free
{
	if (sock != INVALID_SOCKET)