ObjFW  Diff

#if !defined(OF_WINDOWS) && !defined(OF_MORPHOS)
# include <signal.h>
#endif

#import "OFStream.h"
#import "OFStream+Private.h"
#import "OFString.h"
#import "OFDataArray.h"
#import "OFData.h"
#import "OFSystemInfo.h"
#import "OFRunLoop.h"
#import "OFRunLoop+Private.h"

#import "OFInvalidArgumentException.h"
#import "OFInvalidFormatException.h"
#import "OFNotImplementedException.h"
#import "OFOutOfMemoryException.h"
#import "OFOutOfRangeException.h"
#import "OFSetOptionFailedException.h"
#import "OFTruncatedDataException.h"

#import "of_asprintf.h"

#define MIN_READ_SIZE 512

	for (size_t i = 0; i < count; i++)
		buffer[i] = OF_BSWAP_DOUBLE(buffer[i]);
#endif

	return size;
}

- (OFDataArray *)readDataArrayWithCount: (size_t)count
- (OFData *)readDataWithCount: (size_t)count
{
	return [self readDataArrayWithItemSize: 1
					 count: count];
	return [self readDataWithItemSize: 1
				    count: count];
}

- (OFDataArray *)readDataArrayWithItemSize: (size_t)itemSize
				     count: (size_t)count
- (OFData *)readDataWithItemSize: (size_t)itemSize
			   count: (size_t)count
{
	OFDataArray *dataArray;
	char *tmp;
	OFData *ret;
	char *buffer;

	if OF_UNLIKELY (count > SIZE_MAX / itemSize)
		@throw [OFOutOfRangeException exception];
	dataArray = [OFDataArray dataArrayWithItemSize: itemSize];
	tmp = [self allocMemoryWithSize: itemSize
				  count: count];

	if OF_UNLIKELY ((buffer = malloc(count * itemSize)) == NULL)
		@throw [OFOutOfMemoryException
		    exceptionWithRequestedSize: count * itemSize];

	@try {
		[self readIntoBuffer: tmp
		[self readIntoBuffer: buffer
			 exactLength: count * itemSize];

		[dataArray addItems: tmp
			      count: count];
	} @finally {
		[self freeMemory: tmp];
		ret = [OFData dataWithItemsNoCopy: buffer
					 itemSize: itemSize
					    count: count
				     freeWhenDone: true];
	} @catch (id e) {
		free(buffer);
		@throw e;
	}

	return dataArray;
	return ret;
}

- (OFDataArray *)readDataArrayTillEndOfStream
- (OFData *)readDataUntilEndOfStream
{
	OFDataArray *dataArray;
	size_t pageSize;
	char *buffer;

	OFMutableData *data = [OFMutableData data];
	dataArray = [OFDataArray dataArray];
	pageSize = [OFSystemInfo pageSize];
	buffer = [self allocMemoryWithSize: pageSize];
	size_t pageSize = [OFSystemInfo pageSize];
	char *buffer = [self allocMemoryWithSize: pageSize];

	@try {
		while (![self isAtEndOfStream]) {
			size_t length;

			length = [self readIntoBuffer: buffer
					       length: pageSize];
			[dataArray addItems: buffer
				      count: length];
			[data addItems: buffer
				 count: length];
		}
	} @finally {
		[self freeMemory: buffer];
	}

	[data makeImmutable];

	return dataArray;
	return data;
}

- (OFString *)readStringWithLength: (size_t)length
{
	return [self readStringWithLength: length
				 encoding: OF_STRING_ENCODING_UTF_8];
}

		[self freeMemory: tmp];
	}
#endif

	return size;
}

- (size_t)writeDataArray: (OFDataArray *)dataArray
- (size_t)writeData: (OFData *)data
{
	size_t length = [dataArray count] * [dataArray itemSize];
	size_t length = [data count] * [data itemSize];

	[self writeBuffer: [dataArray items]
	[self writeBuffer: [data items]
		   length: length];

	return length;
}

- (size_t)writeString: (OFString *)string
{