ObjFW  Check-in [6e19bd47ee]

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFArray

- initWithSerialization: (OFXMLElement*)element
{
	OF_INVALID_INIT_METHOD
}

- (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)getObjects: (id*)buffer
	   inRange: (of_range_t)range
{
	size_t i;

- mutableCopy
{
	return [[OFMutableArray alloc] initWithArray: self];
}

- (id)objectAtIndex: (size_t)index
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (id)objectAtIndexedSubscript: (size_t)index
{
	return [self objectAtIndex: index];
}

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFAutoreleasePool.h"
#import "OFAutoreleasePool+Private.h"

#import "macros.h"
#if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS)
# import "threading.h"

	}

	[super dealloc];
}

- retain
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- autorelease
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}
@end

	objc_registerClassPair((Class)&_NSConcreteMallocBlock);
# endif
#endif
}

+ alloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- init
{
	OF_INVALID_INIT_METHOD
}

- (void*)allocMemoryWithSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)ptr
		 size: (size_t)size
		count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)freeMemory: (void*)ptr
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- retain
{
	if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
		return Block_copy(self);

{
	if (object_getClass(self) == (Class)&_NSConcreteMallocBlock)
		Block_release(self);
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

#import "OFConstantString.h"
#import "OFString_UTF8.h"

#import "OFInitializationFailedException.h"
#import "OFInvalidEncodingException.h"
#import "OFOutOfMemoryException.h"

#import "macros.h"

#if defined(OF_APPLE_RUNTIME) && !defined(__OBJC2__)
# import <objc/runtime.h>

struct {
	struct class *isa, *super_class;
	const char *name;

@interface OFString_const: OFString_UTF8
@end

@implementation OFString_const
+ alloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}


- (void*)allocMemoryWithSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
		count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)freeMemory: (void*)pointer
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- retain
{
	return self;
}

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFConstantString

		_cString = (char*)ivars;
		object_setClass(self, [OFString_const class]);
	}
}

+ alloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)allocMemoryWithSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
		count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)freeMemory: (void*)pointer
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- retain
{
	return self;
}

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}

/*
 * In all following methods, the constant string is converted to an

#import "OFCountedSet.h"
#import "OFCountedSet_hashtable.h"
#import "OFNumber.h"
#import "OFString.h"
#import "OFXMLElement.h"

#import "autorelease.h"
#import "macros.h"

static struct {
	Class isa;
} placeholder;

@interface OFCountedSet_placeholder: OFCountedSet
@end

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFCountedSet

	}

	return [super init];
}

- (size_t)countForObject: (id)object
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (OFString*)description
{
	OFMutableString *ret;
	void *pool;
	OFEnumerator *enumerator;

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFDictionary

- initWithSerialization: (OFXMLElement*)element
{
	OF_INVALID_INIT_METHOD
}

- (id)objectForKey: (id)key
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (id)objectForKeyedSubscript: (id)key
{
	return [self objectForKey: key];
}

- (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- copy
{
	return [self retain];
}

	objc_autoreleasePoolPop(pool);

	return ret;
}

- (OFEnumerator*)objectEnumerator
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (OFEnumerator*)keyEnumerator
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
			   objects: (id*)objects
			     count: (int)count_
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

#if defined(OF_HAVE_BLOCKS) && defined(OF_HAVE_FAST_ENUMERATION)
- (void)enumerateKeysAndObjectsUsingBlock:
    (of_dictionary_enumeration_block_t)block
{
	bool stop = false;

#include <stdlib.h>

#import "OFEnumerator.h"
#import "OFArray.h"

#import "autorelease.h"
#import "macros.h"

@implementation OFEnumerator
- init
{
	if (object_getClass(self) == [OFEnumerator class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;
		}
	}

	return [super init];
}

- (id)nextObject
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (OFArray*)allObjects
{
	OFMutableArray *ret = [OFMutableArray array];
	void *pool = objc_autoreleasePoolPush();
	id object;

	while ((object = [self nextObject]) != nil)
		[ret addObject: object];

	[ret makeImmutable];

	objc_autoreleasePoolPop(pool);

	return ret;
}

- (void)reset
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}
@end

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#include <assert.h>

#import "OFMapTable.h"
#import "OFEnumerator.h"

	[_mapTable release];

	[super dealloc];
}

- (void*)nextValue
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)reset
{
	if (*_mutationsPtr != _mutations)
		@throw [OFEnumerationMutationException
		    exceptionWithObject: _mapTable];

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableArray

	[self insertObjectsFromArray: array
			     atIndex: [self count]];
}

- (void)insertObject: (id)object
	     atIndex: (size_t)index
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)insertObjectsFromArray: (OFArray*)array
		       atIndex: (size_t)index
{
	void *pool = objc_autoreleasePoolPush();
	OFEnumerator *enumerator = [array objectEnumerator];

	objc_autoreleasePoolPop(pool);
}

- (void)replaceObjectAtIndex: (size_t)index
		  withObject: (id)object
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

-    (void)setObject: (id)object
  atIndexedSubscript: (size_t)index
{
	[self replaceObjectAtIndex: index
			withObject: object];

			return;
		}
	}
}

- (void)removeObjectAtIndex: (size_t)index
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)removeObject: (id)object
{
	size_t i, count;

	if (object == nil)

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableDictionary

{
	OF_INVALID_INIT_METHOD
}

- (void)setObject: (id)object
	   forKey: (id)key
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

-   (void)setObject: (id)object
  forKeyedSubscript: (id)key
{
	[self setObject: object
		 forKey: key];
}

- (void)removeObjectForKey: (id)key
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)removeAllObjects
{
	void *pool = objc_autoreleasePoolPush();
	OFArray *keys = [self allKeys];
	OFEnumerator *enumerator = [keys objectEnumerator];

#include <assert.h>

#import "OFMutableSet.h"
#import "OFMutableSet_hashtable.h"

#import "autorelease.h"
#import "macros.h"

static struct {
	Class isa;
} placeholder;

@interface OFMutableSet_placeholder: OFMutableSet
@end

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableSet

	}

	return [super init];
}

- (void)addObject: (id)object
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)removeObject: (id)object
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)minusSet: (OFSet*)set
{
	void *pool = objc_autoreleasePoolPush();
	OFEnumerator *enumerator = [set objectEnumerator];
	id object;

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFMutableString

	[self replaceCharactersInRange: range
			    withString: @""];
}

- (void)replaceCharactersInRange: (of_range_t)range
		      withString: (OFString*)replacement
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)replaceOccurrencesOfString: (OFString*)string
			withString: (OFString*)replacement
{
	[self replaceOccurrencesOfString: string
			      withString: replacement

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFNull.h"
#import "OFString.h"
#import "OFXMLElement.h"
#import "OFDataArray.h"

#import "OFInvalidArgumentException.h"

#import "autorelease.h"
#import "macros.h"

static OFNull *null = nil;

@implementation OFNull
+ (void)initialize
{
	null = [[self alloc] init];

- (unsigned int)retainCount
{
	return OF_RETAIN_COUNT_MAX;
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

/*
 * Those are needed as the root class is the superclass of the root class's
 * metaclass and thus instance methods can be sent to class objects as well.
 */
+ (void*)allocMemoryWithSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

+ (void*)allocMemoryWithSize: (size_t)size
		       count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

+ (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

+ (void*)resizeMemory: (void*)pointer
		 size: (size_t)size
		count: (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

+ (void)freeMemory: (void*)pointer
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

+ retain
{
	return self;
}

+ (void)release
{
}

+ (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

+ copy
{
	return self;
}

+ mutableCopyWithZone: (void*)zone
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}
@end

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>
#include <string.h>

#ifndef _WIN32
# include <unistd.h>
# include <signal.h>
# include <sys/wait.h>
#endif

}

- (int)fileDescriptorForReading
{
#ifndef _WIN32
	return _readPipe[0];
#else
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
#endif
}

- (int)fileDescriptorForWriting
{
#ifndef _WIN32
	return _writePipe[1];
#else
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
#endif
}

- (void)closeForWriting
{
#ifndef _WIN32
	if (_writePipe[1] != -1)

#include "config.h"

#include <stdlib.h>
#include <stdio.h>

#import "OFSeekableStream.h"

#import "macros.h"

@implementation OFSeekableStream
- init
{
	if (object_getClass(self) == [OFSeekableStream class]) {
		@try {
			[self doesNotRecognizeSelector: _cmd];
			abort();
		} @catch (id e) {
			[self release];
			@throw e;
		}
	}

	return [super init];
}

- (off_t)lowlevelSeekToOffset: (off_t)offset
		       whence: (int)whence
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (off_t)seekToOffset: (off_t)offset
	       whence: (int)whence
{
	if (whence == SEEK_CUR)
		offset -= _readBufferLength;

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFSet

- initWithSerialization: (OFXMLElement*)element
{
	OF_INVALID_INIT_METHOD
}

- (size_t)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (bool)containsObject: (id)object
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (OFEnumerator*)objectEnumerator
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (int)countByEnumeratingWithState: (of_fast_enumeration_state_t*)state
			   objects: (id*)objects
			     count: (int)count
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (bool)isEqual: (id)object
{
	OFSet *otherSet;

	if (![object isKindOfClass: [OFSet class]])

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>
#import "OFSortedList.h"

#import "OFSortedList.h"
#import "macros.h"

@implementation OFSortedList
- (of_list_object_t*)appendObject: (id)object
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (of_list_object_t*)prependObject: (id)object
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (of_list_object_t*)insertObject: (id)object
		 beforeListObject: (of_list_object_t*)listObject
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (of_list_object_t*)insertObject: (id)object
		  afterListObject: (of_list_object_t*)listObject
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (of_list_object_t*)insertObject: (id <OFComparing>)object
{
	of_list_object_t *iter;

	for (iter = _lastListObject; iter != NULL; iter = iter->previous) {

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>
#include <unistd.h>

#import "OFStdIOStream.h"
#import "OFDate.h"
#import "OFApplication.h"

#import "OFReadFailedException.h"

- (unsigned int)retainCount
{
	return OF_RETAIN_COUNT_MAX;
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of stupid warning */
	[super dealloc];
}
@end

	_blocking = true;

	return self;
}

- (bool)lowlevelIsAtEndOfStream
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (size_t)lowlevelReadIntoBuffer: (void*)buffer
			  length: (size_t)length
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)lowlevelWriteBuffer: (const void*)buffer
		     length: (size_t)length
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- copy
{
	return [self retain];
}

	if (!readImplemented && !writeImplemented)
		@throw [OFNotImplementedException exceptionWithSelector: _cmd
								 object: self];

	_blocking = enable;
#else
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
#endif
}

- (int)fileDescriptorForReading
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (int)fileDescriptorForWriting
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

#ifdef OF_HAVE_SOCKETS
- (void)cancelAsyncRequests
{
	[OFRunLoop OF_cancelAsyncRequestsForStream: self];
}

	memcpy(_readBuffer, buffer, length);

	_readBufferLength += length;
}

- (void)close
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (bool)OF_isWaitingForDelimiter
{
	return _waitingForDelimiter;
}
@end

 * file.
 */

#include "config.h"

#define __NO_EXT_QNX

#include <stdlib.h>

#include <unistd.h>

#include <assert.h>

#import "OFStreamObserver.h"
#import "OFStreamObserver+Private.h"
#import "OFArray.h"

	}

	[self cancel];
}

- (void)OF_addFileDescriptorForReading: (int)fd
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)OF_addFileDescriptorForWriting: (int)fd
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)OF_removeFileDescriptorForReading: (int)fd
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)OF_removeFileDescriptorForWriting: (int)fd
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)OF_processQueue
{
#ifdef OF_HAVE_THREADS
	[_mutex lock];
#endif

- (void)observe
{
	[self observeForTimeInterval: -1];
}

- (bool)observeForTimeInterval: (double)timeInterval
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (bool)observeUntilDate: (OFDate*)date
{
	return [self observeForTimeInterval: [date timeIntervalSinceNow]];
}

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}
@end

@implementation OFString

- (const char*)UTF8String
{
	return [self cStringWithEncoding: OF_STRING_ENCODING_UTF_8];
}

- (size_t)length
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (size_t)cStringLengthWithEncoding: (of_string_encoding_t)encoding
{
	switch (encoding) {
	case OF_STRING_ENCODING_UTF_8:;
		const of_unichar_t *characters;

- (size_t)UTF8StringLength
{
	return [self cStringLengthWithEncoding: OF_STRING_ENCODING_UTF_8];
}

- (of_unichar_t)characterAtIndex: (size_t)index
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)getCharacters: (of_unichar_t*)buffer
	      inRange: (of_range_t)range
{
	size_t i;

#include "config.h"

#define __NO_EXT_QNX

#import "OFSystemInfo.h"

#include <stdlib.h>

#include <unistd.h>

#ifdef __QNX__
# include <sys/syspage.h>
#endif

#ifdef _WIN32
# include <windows.h>
#endif

#import "macros.h"

static size_t pageSize;
static size_t numberOfCPUs;

@implementation OFSystemInfo
+ (void)initialize
{

# endif
		numberOfCPUs = 1;
#endif
}

+ alloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

+ (size_t)pageSize
{
	return pageSize;
}

+ (size_t)numberOfCPUs
{
	return numberOfCPUs;
}
@end

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFXMLNode.h"
#import "OFString.h"

#import "macros.h"

@implementation OFXMLNode
- initWithSerialization: (OFXMLElement*)element
{
	OF_INVALID_INIT_METHOD
}

- (OFString*)stringValue
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (intmax_t)decimalValue
{
	return [[self stringValue] decimalValue];
}

	return [self XMLStringWithIndentation: 0
					level: 0];
}

- (OFString*)XMLStringWithIndentation: (unsigned int)indentation
				level: (unsigned int)level
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (OFString*)description
{
	return [self XMLStringWithIndentation: 2];
}

- (OFXMLElement*)XMLElementBySerializing
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- copy
{
	return [self retain];
}
@end

 * Public License, either version 2 or 3, which can be found in the file
 * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
 * file.
 */

#include "config.h"

#include <stdlib.h>

#import "OFAllocFailedException.h"
#import "OFString.h"

#import "macros.h"

@implementation OFAllocFailedException
+ alloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- init
{
	OF_INVALID_INIT_METHOD
}

- (void*)allocMemoryWithSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)allocMemoryForNItems: (size_t)nitems
                     withSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)ptr
	       toSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void*)resizeMemory: (void*)ptr
	     toNItems: (size_t)nitems
	     withSize: (size_t)size
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- (void)freeMemory: (void*)ptr
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();
}

- retain
{
	return self;
}

- (void)release
{
}

- (void)dealloc
{
	[self doesNotRecognizeSelector: _cmd];
	OF_UNRECOGNIZED_SELECTOR
	abort();

	/* Get rid of a stupid warning */
	[super dealloc];
}

- (OFString*)description
{
	return @"Allocating an object failed!";
}
@end

#define OF_IVAR_OFFSET(ivar) ((intptr_t)&ivar - (intptr_t)self)
#define OF_GETTER(ivar, atomic) \
	return objc_getProperty(self, _cmd, OF_IVAR_OFFSET(ivar), atomic);
#define OF_SETTER(ivar, value, atomic, copy) \
	objc_setProperty(self, _cmd, OF_IVAR_OFFSET(ivar), value, atomic, copy);

#define OF_UNRECOGNIZED_SELECTOR		\
	[self doesNotRecognizeSelector: _cmd];	\
	abort();
#define OF_INVALID_INIT_METHOD				\
	@try {						\
		[self doesNotRecognizeSelector: _cmd];	\
	} @catch (id e) {				\
		[self release];				\
		@throw e;				\
	}						\