@@ -23,10 +23,11 @@
 # include <sys/types.h>
 #endif
 
 #import "OFUTF8String.h"
 #import "OFUTF8String+Private.h"
+#import "OFASPrintF.h"
 #import "OFArray.h"
 #import "OFData.h"
 #import "OFMutableUTF8String.h"
 
 #import "OFInitializationFailedException.h"
@@ -34,57 +35,56 @@
 #import "OFInvalidEncodingException.h"
 #import "OFInvalidFormatException.h"
 #import "OFOutOfMemoryException.h"
 #import "OFOutOfRangeException.h"
 
-#import "of_asprintf.h"
 #import "unicode.h"
 
-extern const of_char16_t of_iso_8859_2_table[];
-extern const size_t of_iso_8859_2_table_offset;
-extern const of_char16_t of_iso_8859_3_table[];
-extern const size_t of_iso_8859_3_table_offset;
-extern const of_char16_t of_iso_8859_15_table[];
-extern const size_t of_iso_8859_15_table_offset;
-extern const of_char16_t of_windows_1251_table[];
-extern const size_t of_windows_1251_table_offset;
-extern const of_char16_t of_windows_1252_table[];
-extern const size_t of_windows_1252_table_offset;
-extern const of_char16_t of_codepage_437_table[];
-extern const size_t of_codepage_437_table_offset;
-extern const of_char16_t of_codepage_850_table[];
-extern const size_t of_codepage_850_table_offset;
-extern const of_char16_t of_codepage_858_table[];
-extern const size_t of_codepage_858_table_offset;
-extern const of_char16_t of_mac_roman_table[];
-extern const size_t of_mac_roman_table_offset;
-extern const of_char16_t of_koi8_r_table[];
-extern const size_t of_koi8_r_table_offset;
-extern const of_char16_t of_koi8_u_table[];
-extern const size_t of_koi8_u_table_offset;
+extern const OFChar16 OFISO8859_2Table[];
+extern const size_t OFISO8859_2TableOffset;
+extern const OFChar16 OFISO8859_3Table[];
+extern const size_t OFISO8859_3TableOffset;
+extern const OFChar16 OFISO8859_15Table[];
+extern const size_t OFISO8859_15TableOffset;
+extern const OFChar16 OFWindows1251Table[];
+extern const size_t OFWindows1251TableOffset;
+extern const OFChar16 OFWindows1252Table[];
+extern const size_t OFWindows1252TableOffset;
+extern const OFChar16 OFCodepage437Table[];
+extern const size_t OFCodepage437TableOffset;
+extern const OFChar16 OFCodepage850Table[];
+extern const size_t OFCodepage850TableOffset;
+extern const OFChar16 OFCodepage858Table[];
+extern const size_t OFCodepage858TableOffset;
+extern const OFChar16 OFMacRomanTable[];
+extern const size_t OFMacRomanTableOffset;
+extern const OFChar16 OFKOI8RTable[];
+extern const size_t OFKOI8RTableOffset;
+extern const OFChar16 OFKOI8UTable[];
+extern const size_t OFKOI8UTableOffset;
 
 static inline int
 memcasecmp(const char *first, const char *second, size_t length)
 {
 	for (size_t i = 0; i < length; i++) {
 		unsigned char f = first[i];
 		unsigned char s = second[i];
 
-		f = of_ascii_toupper(f);
-		s = of_ascii_toupper(s);
+		f = OFASCIIToUpper(f);
+		s = OFASCIIToUpper(s);
 
 		if (f > s)
-			return OF_ORDERED_DESCENDING;
+			return OFOrderedDescending;
 		if (f < s)
-			return OF_ORDERED_ASCENDING;
+			return OFOrderedAscending;
 	}
 
-	return OF_ORDERED_SAME;
+	return OFOrderedSame;
 }
 
 int
-of_string_utf8_check(const char *UTF8String, size_t UTF8Length, size_t *length)
+OFUTF8StringCheck(const char *UTF8String, size_t UTF8Length, size_t *length)
 {
 	size_t tmpLength = UTF8Length;
 	int isUTF8 = 0;
 
 	for (size_t i = 0; i < UTF8Length; i++) {
@@ -147,11 +147,11 @@
 
 	return isUTF8;
 }
 
 size_t
-of_string_utf8_get_index(const char *string, size_t position)
+positionToIndex(const char *string, size_t position)
 {
 	size_t idx = position;
 
 	for (size_t i = 0; i < position; i++)
 		if OF_UNLIKELY ((string[i] & 0xC0) == 0x80)
@@ -159,11 +159,11 @@
 
 	return idx;
 }
 
 size_t
-of_string_utf8_get_position(const char *string, size_t idx, size_t length)
+OFUTF8StringIndexToPosition(const char *string, size_t idx, size_t length)
 {
 	for (size_t i = 0; i <= idx; i++)
 		if OF_UNLIKELY ((string[i] & 0xC0) == 0x80)
 			if (++idx > length)
 				@throw [OFInvalidFormatException exception];
@@ -177,11 +177,11 @@
 	self = [super init];
 
 	@try {
 		_s = &_storage;
 
-		_s->cString = of_alloc_zeroed(1, 1);
+		_s->cString = OFAllocZeroedMemory(1, 1);
 		_s->freeWhenDone = true;
 	} @catch (id e) {
 		[self release];
 		@throw e;
 	}
@@ -205,11 +205,11 @@
 		_s = &_storage;
 
 		_s->cString = storage;
 		_s->cStringLength = UTF8StringLength;
 
-		switch (of_string_utf8_check(UTF8String, UTF8StringLength,
+		switch (OFUTF8StringCheck(UTF8String, UTF8StringLength,
 		    &_s->length)) {
 		case 1:
 			_s->isUTF8 = true;
 			break;
 		case -1:
@@ -225,38 +225,38 @@
 
 	return self;
 }
 
 - (instancetype)initWithCString: (const char *)cString
-		       encoding: (of_string_encoding_t)encoding
+		       encoding: (OFStringEncoding)encoding
 			 length: (size_t)cStringLength
 {
 	self = [super init];
 
 	@try {
-		const of_char16_t *table;
+		const OFChar16 *table;
 		size_t tableOffset, j;
 
-		if (encoding == OF_STRING_ENCODING_UTF_8 &&
+		if (encoding == OFStringEncodingUTF8 &&
 		    cStringLength >= 3 &&
 		    memcmp(cString, "\xEF\xBB\xBF", 3) == 0) {
 			cString += 3;
 			cStringLength -= 3;
 		}
 
 		_s = &_storage;
 
-		_s->cString = of_alloc(cStringLength + 1, 1);
+		_s->cString = OFAllocMemory(cStringLength + 1, 1);
 		_s->cStringLength = cStringLength;
 		_s->freeWhenDone = true;
 
-		if (encoding == OF_STRING_ENCODING_UTF_8 ||
-		    encoding == OF_STRING_ENCODING_ASCII) {
-			switch (of_string_utf8_check(cString, cStringLength,
+		if (encoding == OFStringEncodingUTF8 ||
+		    encoding == OFStringEncodingASCII) {
+			switch (OFUTF8StringCheck(cString, cStringLength,
 			    &_s->length)) {
 			case 1:
-				if (encoding == OF_STRING_ENCODING_ASCII)
+				if (encoding == OFStringEncodingASCII)
 					@throw [OFInvalidEncodingException
 					    exception];
 
 				_s->isUTF8 = true;
 				break;
@@ -271,11 +271,11 @@
 		}
 
 		/* All other encodings we support are single byte encodings */
 		_s->length = cStringLength;
 
-		if (encoding == OF_STRING_ENCODING_ISO_8859_1) {
+		if (encoding == OFStringEncodingISO8859_1) {
 			j = 0;
 			for (size_t i = 0; i < cStringLength; i++) {
 				char buffer[4];
 				size_t bytes;
 
@@ -283,19 +283,19 @@
 					_s->cString[j++] = cString[i];
 					continue;
 				}
 
 				_s->isUTF8 = true;
-				bytes = of_string_utf8_encode(
+				bytes = OFUTF8StringEncode(
 				    (uint8_t)cString[i], buffer);
 
 				if (bytes == 0)
 					@throw [OFInvalidEncodingException
 					    exception];
 
 				_s->cStringLength += bytes - 1;
-				_s->cString = of_realloc(_s->cString,
+				_s->cString = OFResizeMemory(_s->cString,
 				    _s->cStringLength + 1, 1);
 
 				memcpy(_s->cString + j, buffer, bytes);
 				j += bytes;
 			}
@@ -307,54 +307,54 @@
 
 		switch (encoding) {
 #define CASE(encoding, var)				\
 		case encoding:				\
 			table = var;			\
-			tableOffset = var##_offset;	\
+			tableOffset = var##Offset;	\
 			break;
 #ifdef HAVE_ISO_8859_2
-		CASE(OF_STRING_ENCODING_ISO_8859_2, of_iso_8859_2_table)
+		CASE(OFStringEncodingISO8859_2, OFISO8859_2Table)
 #endif
 #ifdef HAVE_ISO_8859_3
-		CASE(OF_STRING_ENCODING_ISO_8859_3, of_iso_8859_3_table)
+		CASE(OFStringEncodingISO8859_3, OFISO8859_3Table)
 #endif
 #ifdef HAVE_ISO_8859_15
-		CASE(OF_STRING_ENCODING_ISO_8859_15, of_iso_8859_15_table)
+		CASE(OFStringEncodingISO8859_15, OFISO8859_15Table)
 #endif
 #ifdef HAVE_WINDOWS_1251
-		CASE(OF_STRING_ENCODING_WINDOWS_1251, of_windows_1251_table)
+		CASE(OFStringEncodingWindows1251, OFWindows1251Table)
 #endif
 #ifdef HAVE_WINDOWS_1252
-		CASE(OF_STRING_ENCODING_WINDOWS_1252, of_windows_1252_table)
+		CASE(OFStringEncodingWindows1252, OFWindows1252Table)
 #endif
 #ifdef HAVE_CODEPAGE_437
-		CASE(OF_STRING_ENCODING_CODEPAGE_437, of_codepage_437_table)
+		CASE(OFStringEncodingCodepage437, OFCodepage437Table)
 #endif
 #ifdef HAVE_CODEPAGE_850
-		CASE(OF_STRING_ENCODING_CODEPAGE_850, of_codepage_850_table)
+		CASE(OFStringEncodingCodepage850, OFCodepage850Table)
 #endif
 #ifdef HAVE_CODEPAGE_858
-		CASE(OF_STRING_ENCODING_CODEPAGE_858, of_codepage_858_table)
+		CASE(OFStringEncodingCodepage858, OFCodepage858Table)
 #endif
 #ifdef HAVE_MAC_ROMAN
-		CASE(OF_STRING_ENCODING_MAC_ROMAN, of_mac_roman_table)
+		CASE(OFStringEncodingMacRoman, OFMacRomanTable)
 #endif
 #ifdef HAVE_KOI8_R
-		CASE(OF_STRING_ENCODING_KOI8_R, of_koi8_r_table)
+		CASE(OFStringEncodingKOI8R, OFKOI8RTable)
 #endif
 #ifdef HAVE_KOI8_U
-		CASE(OF_STRING_ENCODING_KOI8_U, of_koi8_u_table)
+		CASE(OFStringEncodingKOI8U, OFKOI8UTable)
 #endif
 #undef CASE
 		default:
 			@throw [OFInvalidEncodingException exception];
 		}
 
 		j = 0;
 		for (size_t i = 0; i < cStringLength; i++) {
 			unsigned char character = (unsigned char)cString[i];
-			of_unichar_t unichar;
+			OFUnichar unichar;
 			char buffer[4];
 			size_t byteLength;
 
 			if (character < tableOffset) {
 				_s->cString[j++] = cString[i];
@@ -365,17 +365,17 @@
 
 			if (unichar == 0xFFFF)
 				@throw [OFInvalidEncodingException exception];
 
 			_s->isUTF8 = true;
-			byteLength = of_string_utf8_encode(unichar, buffer);
+			byteLength = OFUTF8StringEncode(unichar, buffer);
 
 			if (byteLength == 0)
 				@throw [OFInvalidEncodingException exception];
 
 			_s->cStringLength += byteLength - 1;
-			_s->cString = of_realloc(_s->cString,
+			_s->cString = OFResizeMemory(_s->cString,
 			    _s->cStringLength + 1, 1);
 
 			memcpy(_s->cString + j, buffer, byteLength);
 			j += byteLength;
 		}
@@ -411,11 +411,11 @@
 		    memcmp(UTF8String, "\xEF\xBB\xBF", 3) == 0) {
 			UTF8String += 3;
 			UTF8StringLength -= 3;
 		}
 
-		switch (of_string_utf8_check(UTF8String, UTF8StringLength,
+		switch (OFUTF8StringCheck(UTF8String, UTF8StringLength,
 		    &_s->length)) {
 		case 1:
 			_s->isUTF8 = true;
 			break;
 		case -1:
@@ -448,11 +448,11 @@
 		else
 			_s->isUTF8 = true;
 
 		_s->length = string.length;
 
-		_s->cString = of_alloc(_s->cStringLength + 1, 1);
+		_s->cString = OFAllocMemory(_s->cStringLength + 1, 1);
 		memcpy(_s->cString, string.UTF8String, _s->cStringLength + 1);
 		_s->freeWhenDone = true;
 	} @catch (id e) {
 		[self release];
 		@throw e;
@@ -459,27 +459,27 @@
 	}
 
 	return self;
 }
 
-- (instancetype)initWithCharacters: (const of_unichar_t *)characters
+- (instancetype)initWithCharacters: (const OFUnichar *)characters
 			    length: (size_t)length
 {
 	self = [super init];
 
 	@try {
 		size_t j;
 
 		_s = &_storage;
 
-		_s->cString = of_alloc((length * 4) + 1, 1);
+		_s->cString = OFAllocMemory((length * 4) + 1, 1);
 		_s->length = length;
 		_s->freeWhenDone = true;
 
 		j = 0;
 		for (size_t i = 0; i < length; i++) {
-			size_t len = of_string_utf8_encode(characters[i],
+			size_t len = OFUTF8StringEncode(characters[i],
 			    _s->cString + j);
 
 			if (len == 0)
 				@throw [OFInvalidEncodingException exception];
 
@@ -491,11 +491,11 @@
 
 		_s->cString[j] = '\0';
 		_s->cStringLength = j;
 
 		@try {
-			_s->cString = of_realloc(_s->cString, j + 1, 1);
+			_s->cString = OFResizeMemory(_s->cString, j + 1, 1);
 		} @catch (OFOutOfMemoryException *e) {
 			/* We don't care, as we only tried to make it smaller */
 		}
 	} @catch (id e) {
 		[self release];
@@ -503,13 +503,13 @@
 	}
 
 	return self;
 }
 
-- (instancetype)initWithUTF16String: (const of_char16_t *)string
+- (instancetype)initWithUTF16String: (const OFChar16 *)string
 			     length: (size_t)length
-			  byteOrder: (of_byte_order_t)byteOrder
+			  byteOrder: (OFByteOrder)byteOrder
 {
 	self = [super init];
 
 	@try {
 		size_t j;
@@ -520,38 +520,38 @@
 			length--;
 		} else if (length > 0 && *string == 0xFFFE) {
 			swap = true;
 			string++;
 			length--;
-		} else if (byteOrder != OF_BYTE_ORDER_NATIVE)
+		} else if (byteOrder != OFByteOrderNative)
 			swap = true;
 
 		_s = &_storage;
 
-		_s->cString = of_alloc((length * 4) + 1, 1);
+		_s->cString = OFAllocMemory((length * 4) + 1, 1);
 		_s->length = length;
 		_s->freeWhenDone = true;
 
 		j = 0;
 		for (size_t i = 0; i < length; i++) {
-			of_unichar_t character =
-			    (swap ? OF_BSWAP16(string[i]) : string[i]);
+			OFUnichar character =
+			    (swap ? OFByteSwap16(string[i]) : string[i]);
 			size_t len;
 
 			/* Missing high surrogate */
 			if ((character & 0xFC00) == 0xDC00)
 				@throw [OFInvalidEncodingException exception];
 
 			if ((character & 0xFC00) == 0xD800) {
-				of_char16_t nextCharacter;
+				OFChar16 nextCharacter;
 
 				if (length <= i + 1)
 					@throw [OFInvalidEncodingException
 					    exception];
 
 				nextCharacter = (swap
-				    ? OF_BSWAP16(string[i + 1])
+				    ? OFByteSwap16(string[i + 1])
 				    : string[i + 1]);
 
 				if ((nextCharacter & 0xFC00) != 0xDC00)
 					@throw [OFInvalidEncodingException
 					    exception];
@@ -561,11 +561,11 @@
 
 				i++;
 				_s->length--;
 			}
 
-			len = of_string_utf8_encode(character, _s->cString + j);
+			len = OFUTF8StringEncode(character, _s->cString + j);
 
 			if (len == 0)
 				@throw [OFInvalidEncodingException exception];
 
 			if (len > 1)
@@ -576,11 +576,11 @@
 
 		_s->cString[j] = '\0';
 		_s->cStringLength = j;
 
 		@try {
-			_s->cString = of_realloc(_s->cString, j + 1, 1);
+			_s->cString = OFResizeMemory(_s->cString, j + 1, 1);
 		} @catch (OFOutOfMemoryException *e) {
 			/* We don't care, as we only tried to make it smaller */
 		}
 	} @catch (id e) {
 		[self release];
@@ -588,13 +588,13 @@
 	}
 
 	return self;
 }
 
-- (instancetype)initWithUTF32String: (const of_char32_t *)characters
+- (instancetype)initWithUTF32String: (const OFChar32 *)characters
 			     length: (size_t)length
-			  byteOrder: (of_byte_order_t)byteOrder
+			  byteOrder: (OFByteOrder)byteOrder
 {
 	self = [super init];
 
 	@try {
 		size_t j;
@@ -605,24 +605,25 @@
 			length--;
 		} else if (length > 0 && *characters == 0xFFFE0000) {
 			swap = true;
 			characters++;
 			length--;
-		} else if (byteOrder != OF_BYTE_ORDER_NATIVE)
+		} else if (byteOrder != OFByteOrderNative)
 			swap = true;
 
 		_s = &_storage;
 
-		_s->cString = of_alloc((length * 4) + 1, 1);
+		_s->cString = OFAllocMemory((length * 4) + 1, 1);
 		_s->length = length;
 		_s->freeWhenDone = true;
 
 		j = 0;
 		for (size_t i = 0; i < length; i++) {
 			char buffer[4];
-			size_t len = of_string_utf8_encode(
-			    (swap ? OF_BSWAP32(characters[i]) : characters[i]),
+			size_t len = OFUTF8StringEncode((swap
+			    ? OFByteSwap32(characters[i])
+			    : characters[i]),
 			    buffer);
 
 			switch (len) {
 			case 1:
 				_s->cString[j++] = buffer[0];
@@ -643,11 +644,11 @@
 
 		_s->cString[j] = '\0';
 		_s->cStringLength = j;
 
 		@try {
-			_s->cString = of_realloc(_s->cString, j + 1, 1);
+			_s->cString = OFResizeMemory(_s->cString, j + 1, 1);
 		} @catch (OFOutOfMemoryException *e) {
 			/* We don't care, as we only tried to make it smaller */
 		}
 	} @catch (id e) {
 		[self release];
@@ -669,31 +670,31 @@
 		if (format == nil)
 			@throw [OFInvalidArgumentException exception];
 
 		_s = &_storage;
 
-		if ((cStringLength = of_vasprintf(&tmp, format.UTF8String,
+		if ((cStringLength = OFVASPrintF(&tmp, format.UTF8String,
 		    arguments)) == -1)
 			@throw [OFInvalidFormatException exception];
 
 		_s->cStringLength = cStringLength;
 
 		@try {
-			switch (of_string_utf8_check(tmp, cStringLength,
+			switch (OFUTF8StringCheck(tmp, cStringLength,
 			    &_s->length)) {
 			case 1:
 				_s->isUTF8 = true;
 				break;
 			case -1:
 				@throw [OFInvalidEncodingException exception];
 			}
 
-			_s->cString = of_alloc(cStringLength + 1, 1);
+			_s->cString = OFAllocMemory(cStringLength + 1, 1);
 			memcpy(_s->cString, tmp, cStringLength + 1);
 			_s->freeWhenDone = true;
 		} @finally {
-			free(tmp);
+			OFFreeMemory(tmp);
 		}
 	} @catch (id e) {
 		[self release];
 		@throw e;
 	}
@@ -702,25 +703,25 @@
 }
 
 - (void)dealloc
 {
 	if (_s != NULL && _s->freeWhenDone)
-		free(_s->cString);
+		OFFreeMemory(_s->cString);
 
 	[super dealloc];
 }
 
 - (size_t)getCString: (char *)cString
 	   maxLength: (size_t)maxLength
-	    encoding: (of_string_encoding_t)encoding
+	    encoding: (OFStringEncoding)encoding
 {
 	switch (encoding) {
-	case OF_STRING_ENCODING_ASCII:
+	case OFStringEncodingASCII:
 		if (_s->isUTF8)
 			@throw [OFInvalidEncodingException exception];
 		/* intentional fall-through */
-	case OF_STRING_ENCODING_UTF_8:
+	case OFStringEncodingUTF8:
 		if (_s->cStringLength + 1 > maxLength)
 			@throw [OFOutOfRangeException exception];
 
 		memcpy(cString, _s->cString, _s->cStringLength + 1);
 
@@ -730,18 +731,18 @@
 			       maxLength: maxLength
 				encoding: encoding];
 	}
 }
 
-- (const char *)cStringWithEncoding: (of_string_encoding_t)encoding
+- (const char *)cStringWithEncoding: (OFStringEncoding)encoding
 {
 	switch (encoding) {
-	case OF_STRING_ENCODING_ASCII:
+	case OFStringEncodingASCII:
 		if (_s->isUTF8)
 			@throw [OFInvalidEncodingException exception];
 		/* intentional fall-through */
-	case OF_STRING_ENCODING_UTF_8:
+	case OFStringEncodingUTF8:
 		return _s->cString;
 	default:
 		return [super cStringWithEncoding: encoding];
 	}
 }
@@ -754,15 +755,15 @@
 - (size_t)length
 {
 	return _s->length;
 }
 
-- (size_t)cStringLengthWithEncoding: (of_string_encoding_t)encoding
+- (size_t)cStringLengthWithEncoding: (OFStringEncoding)encoding
 {
 	switch (encoding) {
-	case OF_STRING_ENCODING_UTF_8:
-	case OF_STRING_ENCODING_ASCII:
+	case OFStringEncodingUTF8:
+	case OFStringEncodingASCII:
 		return _s->cStringLength;
 	default:
 		return [super cStringLengthWithEncoding: encoding];
 	}
 }
@@ -772,85 +773,79 @@
 	return _s->cStringLength;
 }
 
 - (bool)isEqual: (id)object
 {
-	OFUTF8String *otherString;
+	OFUTF8String *string;
 
 	if (object == self)
 		return true;
 
 	if (![object isKindOfClass: [OFString class]])
 		return false;
 
-	otherString = object;
+	string = object;
 
-	if (otherString.UTF8StringLength != _s->cStringLength ||
-	    otherString.length != _s->length)
+	if (string.UTF8StringLength != _s->cStringLength ||
+	    string.length != _s->length)
+		return false;
+
+	if (([string isKindOfClass: [OFUTF8String class]] ||
+	    [string isKindOfClass: [OFMutableUTF8String class]]) &&
+	    _s->hasHash && string->_s->hasHash && _s->hash != string->_s->hash)
 		return false;
 
-	if (([otherString isKindOfClass: [OFUTF8String class]] ||
-	    [otherString isKindOfClass: [OFMutableUTF8String class]]) &&
-	    _s->hashed && otherString->_s->hashed &&
-	    _s->hash != otherString->_s->hash)
-		return false;
-
-	if (strcmp(_s->cString, otherString.UTF8String) != 0)
+	if (strcmp(_s->cString, string.UTF8String) != 0)
 		return false;
 
 	return true;
 }
 
-- (of_comparison_result_t)compare: (id <OFComparing>)object
+- (OFComparisonResult)compare: (OFString *)string
 {
-	OFString *otherString;
 	size_t otherCStringLength, minimumCStringLength;
 	int compare;
 
-	if (object == self)
-		return OF_ORDERED_SAME;
+	if (string == self)
+		return OFOrderedSame;
 
-	if (![(id)object isKindOfClass: [OFString class]])
+	if (![string isKindOfClass: [OFString class]])
 		@throw [OFInvalidArgumentException exception];
 
-	otherString = (OFString *)object;
-	otherCStringLength = otherString.UTF8StringLength;
+	otherCStringLength = string.UTF8StringLength;
 	minimumCStringLength = (_s->cStringLength > otherCStringLength
 	    ? otherCStringLength : _s->cStringLength);
 
-	if ((compare = memcmp(_s->cString, otherString.UTF8String,
+	if ((compare = memcmp(_s->cString, string.UTF8String,
 	    minimumCStringLength)) == 0) {
 		if (_s->cStringLength > otherCStringLength)
-			return OF_ORDERED_DESCENDING;
+			return OFOrderedDescending;
 		if (_s->cStringLength < otherCStringLength)
-			return OF_ORDERED_ASCENDING;
-		return OF_ORDERED_SAME;
+			return OFOrderedAscending;
+		return OFOrderedSame;
 	}
 
 	if (compare > 0)
-		return OF_ORDERED_DESCENDING;
+		return OFOrderedDescending;
 	else
-		return OF_ORDERED_ASCENDING;
+		return OFOrderedAscending;
 }
 
-- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)otherString
+- (OFComparisonResult)caseInsensitiveCompare: (OFString *)string
 {
 	const char *otherCString;
 	size_t otherCStringLength, minimumCStringLength;
 #ifdef OF_HAVE_UNICODE_TABLES
 	size_t i, j;
 #endif
 	int compare;
 
-	if (otherString == self)
-		return OF_ORDERED_SAME;
-
-	if (![otherString isKindOfClass: [OFString class]])
-		@throw [OFInvalidArgumentException exception];
-
-	otherCString = otherString.UTF8String;
-	otherCStringLength = otherString.UTF8StringLength;
+	if (string == self)
+		return OFOrderedSame;
+
+	otherCString = string.UTF8String;
+	otherCStringLength = string.UTF8StringLength;
 
 #ifdef OF_HAVE_UNICODE_TABLES
 	if (!_s->isUTF8) {
 #endif
 		minimumCStringLength = (_s->cStringLength > otherCStringLength
@@ -857,142 +852,141 @@
 		    ? otherCStringLength : _s->cStringLength);
 
 		if ((compare = memcasecmp(_s->cString, otherCString,
 		    minimumCStringLength)) == 0) {
 			if (_s->cStringLength > otherCStringLength)
-				return OF_ORDERED_DESCENDING;
+				return OFOrderedDescending;
 			if (_s->cStringLength < otherCStringLength)
-				return OF_ORDERED_ASCENDING;
-			return OF_ORDERED_SAME;
+				return OFOrderedAscending;
+			return OFOrderedSame;
 		}
 
 		if (compare > 0)
-			return OF_ORDERED_DESCENDING;
+			return OFOrderedDescending;
 		else
-			return OF_ORDERED_ASCENDING;
+			return OFOrderedAscending;
 #ifdef OF_HAVE_UNICODE_TABLES
 	}
 
 	i = j = 0;
 
 	while (i < _s->cStringLength && j < otherCStringLength) {
-		of_unichar_t c1, c2;
+		OFUnichar c1, c2;
 		ssize_t l1, l2;
 
-		l1 = of_string_utf8_decode(_s->cString + i,
+		l1 = OFUTF8StringDecode(_s->cString + i,
 		    _s->cStringLength - i, &c1);
-		l2 = of_string_utf8_decode(otherCString + j,
+		l2 = OFUTF8StringDecode(otherCString + j,
 		    otherCStringLength - j, &c2);
 
 		if (l1 <= 0 || l2 <= 0 || c1 > 0x10FFFF || c2 > 0x10FFFF)
 			@throw [OFInvalidEncodingException exception];
 
-		if (c1 >> 8 < OF_UNICODE_CASEFOLDING_TABLE_SIZE) {
-			of_unichar_t tc =
-			    of_unicode_casefolding_table[c1 >> 8][c1 & 0xFF];
+		if (c1 >> 8 < OFUnicodeCaseFoldingTableSize) {
+			OFUnichar tc =
+			    OFUnicodeCaseFoldingTable[c1 >> 8][c1 & 0xFF];
 
 			if (tc)
 				c1 = tc;
 		}
 
-		if (c2 >> 8 < OF_UNICODE_CASEFOLDING_TABLE_SIZE) {
-			of_unichar_t tc =
-			    of_unicode_casefolding_table[c2 >> 8][c2 & 0xFF];
+		if (c2 >> 8 < OFUnicodeCaseFoldingTableSize) {
+			OFUnichar tc =
+			    OFUnicodeCaseFoldingTable[c2 >> 8][c2 & 0xFF];
 
 			if (tc)
 				c2 = tc;
 		}
 
 		if (c1 > c2)
-			return OF_ORDERED_DESCENDING;
+			return OFOrderedDescending;
 		if (c1 < c2)
-			return OF_ORDERED_ASCENDING;
+			return OFOrderedAscending;
 
 		i += l1;
 		j += l2;
 	}
 
 	if (_s->cStringLength - i > otherCStringLength - j)
-		return OF_ORDERED_DESCENDING;
+		return OFOrderedDescending;
 	else if (_s->cStringLength - i < otherCStringLength - j)
-		return OF_ORDERED_ASCENDING;
+		return OFOrderedAscending;
 #endif
 
-	return OF_ORDERED_SAME;
+	return OFOrderedSame;
 }
 
 - (unsigned long)hash
 {
-	uint32_t hash;
+	unsigned long hash;
 
-	if (_s->hashed)
+	if (_s->hasHash)
 		return _s->hash;
 
-	OF_HASH_INIT(hash);
+	OFHashInit(&hash);
 
 	for (size_t i = 0; i < _s->cStringLength; i++) {
-		of_unichar_t c;
+		OFUnichar c;
 		ssize_t length;
 
-		if ((length = of_string_utf8_decode(_s->cString + i,
+		if ((length = OFUTF8StringDecode(_s->cString + i,
 		    _s->cStringLength - i, &c)) <= 0)
 			@throw [OFInvalidEncodingException exception];
 
-		OF_HASH_ADD(hash, (c & 0xFF0000) >> 16);
-		OF_HASH_ADD(hash, (c & 0x00FF00) >> 8);
-		OF_HASH_ADD(hash, c & 0x0000FF);
+		OFHashAdd(&hash, (c & 0xFF0000) >> 16);
+		OFHashAdd(&hash, (c & 0x00FF00) >> 8);
+		OFHashAdd(&hash, c & 0x0000FF);
 
 		i += length - 1;
 	}
 
-	OF_HASH_FINALIZE(hash);
+	OFHashFinalize(&hash);
 
 	_s->hash = hash;
-	_s->hashed = true;
+	_s->hasHash = true;
 
 	return hash;
 }
 
-- (of_unichar_t)characterAtIndex: (size_t)idx
+- (OFUnichar)characterAtIndex: (size_t)idx
 {
-	of_unichar_t character;
+	OFUnichar character;
 
 	if (idx >= _s->length)
 		@throw [OFOutOfRangeException exception];
 
 	if (!_s->isUTF8)
 		return _s->cString[idx];
 
-	idx = of_string_utf8_get_position(_s->cString, idx, _s->cStringLength);
+	idx = OFUTF8StringIndexToPosition(_s->cString, idx, _s->cStringLength);
 
-	if (of_string_utf8_decode(_s->cString + idx,
-	    _s->cStringLength - idx, &character) <= 0)
+	if (OFUTF8StringDecode(_s->cString + idx, _s->cStringLength - idx,
+	    &character) <= 0)
 		@throw [OFInvalidEncodingException exception];
 
 	return character;
 }
 
-- (void)getCharacters: (of_unichar_t *)buffer
-	      inRange: (of_range_t)range
+- (void)getCharacters: (OFUnichar *)buffer inRange: (OFRange)range
 {
 	/* TODO: Could be slightly optimized */
 	void *pool = objc_autoreleasePoolPush();
-	const of_unichar_t *characters = self.characters;
+	const OFUnichar *characters = self.characters;
 
 	if (range.length > SIZE_MAX - range.location ||
 	    range.location + range.length > _s->length)
 		@throw [OFOutOfRangeException exception];
 
 	memcpy(buffer, characters + range.location,
-	    range.length * sizeof(of_unichar_t));
+	    range.length * sizeof(OFUnichar));
 
 	objc_autoreleasePoolPop(pool);
 }
 
-- (of_range_t)rangeOfString: (OFString *)string
-		    options: (int)options
-		      range: (of_range_t)range
+- (OFRange)rangeOfString: (OFString *)string
+		 options: (OFStringSearchOptions)options
+		   range: (OFRange)range
 {
 	const char *cString = string.UTF8String;
 	size_t cStringLength = string.UTF8StringLength;
 	size_t rangeLocation, rangeLength;
 
@@ -999,55 +993,55 @@
 	if (range.length > SIZE_MAX - range.location ||
 	    range.location + range.length > _s->length)
 		@throw [OFOutOfRangeException exception];
 
 	if (_s->isUTF8) {
-		rangeLocation = of_string_utf8_get_position(
+		rangeLocation = OFUTF8StringIndexToPosition(
 		    _s->cString, range.location, _s->cStringLength);
-		rangeLength = of_string_utf8_get_position(
+		rangeLength = OFUTF8StringIndexToPosition(
 		    _s->cString + rangeLocation, range.length,
 		    _s->cStringLength - rangeLocation);
 	} else {
 		rangeLocation = range.location;
 		rangeLength = range.length;
 	}
 
 	if (cStringLength == 0)
-		return of_range(0, 0);
+		return OFRangeMake(0, 0);
 
 	if (cStringLength > rangeLength)
-		return of_range(OF_NOT_FOUND, 0);
+		return OFRangeMake(OFNotFound, 0);
 
-	if (options & OF_STRING_SEARCH_BACKWARDS) {
+	if (options & OFStringSearchBackwards) {
 		for (size_t i = rangeLength - cStringLength;; i--) {
 			if (memcmp(_s->cString + rangeLocation + i, cString,
 			    cStringLength) == 0) {
-				range.location += of_string_utf8_get_index(
+				range.location += positionToIndex(
 				    _s->cString + rangeLocation, i);
 				range.length = string.length;
 
 				return range;
 			}
 
 			/* Did not match and we're at the last char */
 			if (i == 0)
-				return of_range(OF_NOT_FOUND, 0);
+				return OFRangeMake(OFNotFound, 0);
 		}
 	} else {
 		for (size_t i = 0; i <= rangeLength - cStringLength; i++) {
 			if (memcmp(_s->cString + rangeLocation + i, cString,
 			    cStringLength) == 0) {
-				range.location += of_string_utf8_get_index(
+				range.location += positionToIndex(
 				    _s->cString + rangeLocation, i);
 				range.length = string.length;
 
 				return range;
 			}
 		}
 	}
 
-	return of_range(OF_NOT_FOUND, 0);
+	return OFRangeMake(OFNotFound, 0);
 }
 
 - (bool)containsString: (OFString *)string
 {
 	const char *cString = string.UTF8String;
@@ -1064,22 +1058,22 @@
 			return true;
 
 	return false;
 }
 
-- (OFString *)substringWithRange: (of_range_t)range
+- (OFString *)substringWithRange: (OFRange)range
 {
 	size_t start = range.location;
 	size_t end = range.location + range.length;
 
 	if (range.length > SIZE_MAX - range.location || end > _s->length)
 		@throw [OFOutOfRangeException exception];
 
 	if (_s->isUTF8) {
-		start = of_string_utf8_get_position(_s->cString, start,
+		start = OFUTF8StringIndexToPosition(_s->cString, start,
 		    _s->cStringLength);
-		end = of_string_utf8_get_position(_s->cString, end,
+		end = OFUTF8StringIndexToPosition(_s->cString, end,
 		    _s->cStringLength);
 	}
 
 	return [OFString stringWithUTF8String: _s->cString + start
 				       length: end - start];
@@ -1105,17 +1099,17 @@
 	return (memcmp(_s->cString + (_s->cStringLength - cStringLength),
 	    suffix.UTF8String, cStringLength) == 0);
 }
 
 - (OFArray *)componentsSeparatedByString: (OFString *)delimiter
-				 options: (int)options
+				 options: (OFStringSeparationOptions)options
 {
 	void *pool;
 	OFMutableArray *array;
 	const char *cString;
 	size_t cStringLength;
-	bool skipEmpty = (options & OF_STRING_SKIP_EMPTY);
+	bool skipEmpty = (options & OFStringSkipEmptyComponents);
 	size_t last;
 	OFString *component;
 
 	if (delimiter == nil)
 		@throw [OFInvalidArgumentException exception];
@@ -1157,71 +1151,71 @@
 	objc_autoreleasePoolPop(pool);
 
 	return array;
 }
 
-- (const of_unichar_t *)characters
+- (const OFUnichar *)characters
 {
-	of_unichar_t *buffer = of_alloc(_s->length, sizeof(of_unichar_t));
+	OFUnichar *buffer = OFAllocMemory(_s->length, sizeof(OFUnichar));
 	size_t i = 0, j = 0;
 
 	while (i < _s->cStringLength) {
-		of_unichar_t c;
+		OFUnichar c;
 		ssize_t cLen;
 
-		cLen = of_string_utf8_decode(_s->cString + i,
+		cLen = OFUTF8StringDecode(_s->cString + i,
 		    _s->cStringLength - i, &c);
 
 		if (cLen <= 0 || c > 0x10FFFF) {
-			free(buffer);
+			OFFreeMemory(buffer);
 			@throw [OFInvalidEncodingException exception];
 		}
 
 		buffer[j++] = c;
 		i += cLen;
 	}
 
 	return [[OFData dataWithItemsNoCopy: buffer
 				      count: _s->length
-				   itemSize: sizeof(of_unichar_t)
+				   itemSize: sizeof(OFUnichar)
 			       freeWhenDone: true] items];
 }
 
-- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const OFChar32 *)UTF32StringWithByteOrder: (OFByteOrder)byteOrder
 {
-	of_char32_t *buffer = of_alloc(_s->length + 1, sizeof(of_char32_t));
+	OFChar32 *buffer = OFAllocMemory(_s->length + 1, sizeof(OFChar32));
 	size_t i = 0, j = 0;
 
 	while (i < _s->cStringLength) {
-		of_char32_t c;
+		OFChar32 c;
 		ssize_t cLen;
 
-		cLen = of_string_utf8_decode(_s->cString + i,
+		cLen = OFUTF8StringDecode(_s->cString + i,
 		    _s->cStringLength - i, &c);
 
 		if (cLen <= 0 || c > 0x10FFFF) {
-			free(buffer);
+			OFFreeMemory(buffer);
 			@throw [OFInvalidEncodingException exception];
 		}
 
-		if (byteOrder != OF_BYTE_ORDER_NATIVE)
-			buffer[j++] = OF_BSWAP32(c);
+		if (byteOrder != OFByteOrderNative)
+			buffer[j++] = OFByteSwap32(c);
 		else
 			buffer[j++] = c;
 
 		i += cLen;
 	}
 	buffer[j] = 0;
 
 	return [[OFData dataWithItemsNoCopy: buffer
 				      count: _s->length + 1
-				   itemSize: sizeof(of_char32_t)
+				   itemSize: sizeof(OFChar32)
 			       freeWhenDone: true] items];
 }
 
 #ifdef OF_HAVE_BLOCKS
-- (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block
+- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block
 {
 	void *pool;
 	const char *cString = _s->cString;
 	const char *last = cString;
 	bool stop = false, lastCarriageReturn = false;
@@ -1237,13 +1231,13 @@
 		}
 
 		if (*cString == '\n' || *cString == '\r') {
 			pool = objc_autoreleasePoolPush();
 
-			block([OFString
-			    stringWithUTF8String: last
-					  length: cString - last], &stop);
+			block([OFString stringWithUTF8String: last
+						      length: cString - last],
+			    &stop);
 			last = cString + 1;
 
 			objc_autoreleasePoolPop(pool);
 		}