Index: src/OFApplication.m
==================================================================
--- src/OFApplication.m
+++ src/OFApplication.m
@@ -208,11 +208,11 @@
 		void *pool;
 		OFMutableDictionary *environment;
 #if defined(OF_MACOS)
 		char **env = *_NSGetEnviron();
 #elif defined(OF_WINDOWS)
-		of_char16_t *env, *env0;
+		char16_t *env, *env0;
 #elif !defined(OF_IOS)
 		char **env = environ;
 #else
 		char *env;
 #endif

Index: src/OFConstantString.m
==================================================================
--- src/OFConstantString.m
+++ src/OFConstantString.m
@@ -570,18 +570,18 @@
 	[self finishInitialization];
 
 	return [self characters];
 }
 
-- (const of_char16_t *)UTF16String
+- (const char16_t *)UTF16String
 {
 	[self finishInitialization];
 
 	return [self UTF16String];
 }
 
-- (const of_char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
 {
 	[self finishInitialization];
 
 	return [self UTF16StringWithByteOrder: byteOrder];
 }
@@ -591,18 +591,18 @@
 	[self finishInitialization];
 
 	return [self UTF16StringLength];
 }
 
-- (const of_char32_t *)UTF32String
+- (const char32_t *)UTF32String
 {
 	[self finishInitialization];
 
 	return [self UTF32String];
 }
 
-- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
 {
 	[self finishInitialization];
 
 	return [self UTF32StringWithByteOrder: byteOrder];
 }

Index: src/OFMutableString.m
==================================================================
--- src/OFMutableString.m
+++ src/OFMutableString.m
@@ -86,61 +86,61 @@
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithCharacters: characters
 							     length: length];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF16String: string];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF16String: string
 							      length: length];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFMutableString_UTF8 alloc]
 	    initWithUTF16String: string
 		      byteOrder: byteOrder];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFMutableString_UTF8 alloc]
 	    initWithUTF16String: string
 			 length: length
 		      byteOrder: byteOrder];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF32String: string];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF32String: string
 							      length: length];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFMutableString_UTF8 alloc]
 	    initWithUTF32String: string
 		      byteOrder: byteOrder];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFMutableString_UTF8 alloc]
 	    initWithUTF32String: string

Index: src/OFProcess.m
==================================================================
--- src/OFProcess.m
+++ src/OFProcess.m
@@ -61,11 +61,11 @@
 - (void)OF_getArgV: (char ***)argv
     forProgramName: (OFString *)programName
       andArguments: (OFArray *)arguments;
 - (char **)OF_environmentForDictionary: (OFDictionary *)dictionary;
 #else
-- (of_char16_t *)OF_environmentForDictionary: (OFDictionary *)dictionary;
+- (char16_t *)OF_environmentForDictionary: (OFDictionary *)dictionary;
 #endif
 @end
 
 @implementation OFProcess
 + (instancetype)processWithProgram: (OFString *)program
@@ -227,11 +227,11 @@
 		SECURITY_ATTRIBUTES sa;
 		PROCESS_INFORMATION pi;
 		STARTUPINFOW si;
 		void *pool;
 		OFMutableString *argumentsString;
-		of_char16_t *argumentsCopy;
+		char16_t *argumentsCopy;
 		size_t length;
 
 		sa.nLength = sizeof(sa);
 		sa.bInheritHandle = TRUE;
 		sa.lpSecurityDescriptor = NULL;
@@ -296,11 +296,11 @@
 			if (containsSpaces)
 				[argumentsString appendString: @"\""];
 		}
 
 		length = [argumentsString UTF16StringLength];
-		argumentsCopy = [self allocMemoryWithSize: sizeof(of_char16_t)
+		argumentsCopy = [self allocMemoryWithSize: sizeof(char16_t)
 						    count: length + 1];
 		memcpy(argumentsCopy, [argumentsString UTF16String],
 		    ([argumentsString UTF16StringLength] + 1) * 2);
 		@try {
 			if (!CreateProcessW([program UTF16String],
@@ -402,22 +402,22 @@
 	envp[i] = NULL;
 
 	return envp;
 }
 #else
-- (of_char16_t *)OF_environmentForDictionary: (OFDictionary *)environment
+- (char16_t *)OF_environmentForDictionary: (OFDictionary *)environment
 {
 	OFDataArray *env;
 	OFEnumerator *keyEnumerator, *objectEnumerator;
 	OFString *key, *object;
-	const of_char16_t equal = '=';
-	const of_char16_t zero[2] = { 0, 0 };
+	const char16_t equal = '=';
+	const char16_t zero[2] = { 0, 0 };
 
 	if (environment == nil)
 		return NULL;
 
-	env = [OFDataArray dataArrayWithItemSize: sizeof(of_char16_t)];
+	env = [OFDataArray dataArrayWithItemSize: sizeof(char16_t)];
 
 	keyEnumerator = [environment keyEnumerator];
 	objectEnumerator = [environment objectEnumerator];
 	while ((key = [keyEnumerator nextObject]) != nil &&
 	    (object = [objectEnumerator nextObject]) != nil) {

Index: src/OFStdIOStream_Win32Console.h
==================================================================
--- src/OFStdIOStream_Win32Console.h
+++ src/OFStdIOStream_Win32Console.h
@@ -21,12 +21,12 @@
 OF_ASSUME_NONNULL_BEGIN
 
 @interface OFStdIOStream_Win32Console: OFStdIOStream
 {
 	HANDLE _handle;
-	of_char16_t _incompleteUTF16Surrogate;
+	char16_t _incompleteUTF16Surrogate;
 	char _incompleteUTF8Surrogate[4];
 	size_t _incompleteUTF8SurrogateLen;
 }
 @end
 
 OF_ASSUME_NONNULL_END

Index: src/OFStdIOStream_Win32Console.m
==================================================================
--- src/OFStdIOStream_Win32Console.m
+++ src/OFStdIOStream_Win32Console.m
@@ -103,17 +103,17 @@
 - (size_t)lowlevelReadIntoBuffer: (void *)buffer_
 			  length: (size_t)length
 {
 	void *pool = objc_autoreleasePoolPush();
 	char *buffer = buffer_;
-	of_char16_t *UTF16;
+	char16_t *UTF16;
 	size_t j = 0;
 
 	if (length > sizeof(UINT32_MAX))
 		@throw [OFOutOfRangeException exception];
 
-	UTF16 = [self allocMemoryWithSize: sizeof(of_char16_t)
+	UTF16 = [self allocMemoryWithSize: sizeof(char16_t)
 				    count: length];
 	@try {
 		DWORD UTF16Len;
 		OFDataArray *rest = nil;
 		size_t i = 0;
@@ -157,11 +157,11 @@
 			/* Missing high surrogate */
 			if ((c & 0xFC00) == 0xDC00)
 				@throw [OFInvalidEncodingException exception];
 
 			if ((c & 0xFC00) == 0xD800) {
-				of_char16_t next;
+				char16_t next;
 
 				if (UTF16Len <= i + 1) {
 					_incompleteUTF16Surrogate = c;
 
 					if (rest != nil) {
@@ -218,19 +218,19 @@
 
 - (void)lowlevelWriteBuffer: (const void *)buffer_
 		     length: (size_t)length
 {
 	const char *buffer = buffer_;
-	of_char16_t *tmp;
+	char16_t *tmp;
 	size_t i = 0, j = 0;
 
 	if (length > SIZE_MAX / 2)
 		@throw [OFOutOfRangeException exception];
 
 	if (_incompleteUTF8SurrogateLen > 0) {
 		of_unichar_t c;
-		of_char16_t UTF16[2];
+		char16_t UTF16[2];
 		ssize_t UTF8Len;
 		size_t toCopy;
 		DWORD UTF16Len, written;
 
 		UTF8Len = -of_string_utf8_decode(
@@ -277,11 +277,11 @@
 
 		_incompleteUTF8SurrogateLen = 0;
 		i += toCopy;
 	}
 
-	tmp = [self allocMemoryWithSize: sizeof(of_char16_t)
+	tmp = [self allocMemoryWithSize: sizeof(char16_t)
 				  count: length * 2];
 	@try {
 		DWORD written;
 
 		while (i < length) {

Index: src/OFString+JSONValue.m
==================================================================
--- src/OFString+JSONValue.m
+++ src/OFString+JSONValue.m
@@ -104,14 +104,14 @@
 		skipWhitespaces(pointer, stop, line);
 		skipComment(pointer, stop, line);
 	}
 }
 
-static inline of_char16_t
+static inline char16_t
 parseUnicodeEscape(const char *pointer, const char *stop)
 {
-	of_char16_t ret = 0;
+	char16_t ret = 0;
 
 	if (pointer + 5 >= stop)
 		return 0xFFFF;
 
 	if (pointer[0] != '\\' || pointer[1] != 'u')
@@ -185,11 +185,11 @@
 				buffer[i++] = '\t';
 				(*pointer)++;
 				break;
 			/* Parse Unicode escape sequence */
 			case 'u':;
-				of_char16_t c1, c2;
+				char16_t c1, c2;
 				of_unichar_t c;
 				size_t l;
 
 				c1 = parseUnicodeEscape(*pointer - 1, stop);
 				if (c1 == 0xFFFF) {
@@ -304,11 +304,11 @@
 		    **pointer == '_' || **pointer == '$' ||
 		    (**pointer & 0x80)) {
 			buffer[i++] = **pointer;
 			(*pointer)++;
 		} else if (**pointer == '\\') {
-			of_char16_t c1, c2;
+			char16_t c1, c2;
 			of_unichar_t c;
 			size_t l;
 
 			if (++(*pointer) >= stop || **pointer != 'u') {
 				free(buffer);

Index: src/OFString.h
==================================================================
--- src/OFString.h
+++ src/OFString.h
@@ -33,18 +33,15 @@
 
 /*! @file */
 
 @class OFConstantString;
 
-#if defined(__cplusplus) && __cplusplus >= 201103L
-typedef char16_t of_char16_t;
-typedef char32_t of_char32_t;
-#else
-typedef uint16_t of_char16_t;
-typedef uint32_t of_char32_t;
+#if !defined(__cplusplus) || __cplusplus < 201103L
+typedef uint_least16_t char16_t;
+typedef uint_least32_t char32_t;
 #endif
-typedef of_char32_t of_unichar_t;
+typedef char32_t of_unichar_t;
 
 /*!
  * @brief The encoding of a string.
  */
 typedef enum of_string_encoding_t {
@@ -194,21 +191,21 @@
  * @brief Creates a new OFString from a UTF-16 encoded string.
  *
  * @param string The UTF-16 string
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string;
++ (instancetype)stringWithUTF16String: (const char16_t *)string;
 
 /*!
  * @brief Creates a new OFString from a UTF-16 encoded string with the
  *	  specified length.
  *
  * @param string The UTF-16 string
  * @param length The length of the UTF-16 string
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string
++ (instancetype)stringWithUTF16String: (const char16_t *)string
 			       length: (size_t)length;
 
 /*!
  * @brief Creates a new OFString from a UTF-16 encoded string, assuming the
  *	  specified byte order if no byte order mark is found.
@@ -215,11 +212,11 @@
  *
  * @param string The UTF-16 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string
++ (instancetype)stringWithUTF16String: (const char16_t *)string
 			    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Creates a new OFString from a UTF-16 encoded string with the
  *	  specified length, assuming the specified byte order if no byte order
@@ -228,31 +225,31 @@
  * @param string The UTF-16 string
  * @param length The length of the UTF-16 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string
++ (instancetype)stringWithUTF16String: (const char16_t *)string
 			       length: (size_t)length
 			    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Creates a new OFString from a UTF-32 encoded string.
  *
  * @param string The UTF-32 string
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string;
++ (instancetype)stringWithUTF32String: (const char32_t *)string;
 
 /*!
  * @brief Creates a new OFString from a UTF-32 encoded string with the
  *	  specified length.
  *
  * @param string The UTF-32 string
  * @param length The length of the UTF-32 string
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string
++ (instancetype)stringWithUTF32String: (const char32_t *)string
 			       length: (size_t)length;
 
 /*!
  * @brief Creates a new OFString from a UTF-32 encoded string, assuming the
  *	  specified byte order if no byte order mark is found.
@@ -259,11 +256,11 @@
  *
  * @param string The UTF-32 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string
++ (instancetype)stringWithUTF32String: (const char32_t *)string
 			    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Creates a new OFString from a UTF-32 encoded string with the
  *	  specified length, assuming the specified byte order if no byte order
@@ -272,11 +269,11 @@
  * @param string The UTF-32 string
  * @param length The length of the UTF-32 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return A new autoreleased OFString
  */
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string
++ (instancetype)stringWithUTF32String: (const char32_t *)string
 			       length: (size_t)length
 			    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Creates a new OFString from a format string.
@@ -428,21 +425,21 @@
  * @brief Initializes an already allocated OFString with a UTF-16 string.
  *
  * @param string The UTF-16 string
  * @return An initialized OFString
  */
-- initWithUTF16String: (const of_char16_t *)string;
+- initWithUTF16String: (const char16_t *)string;
 
 /*!
  * @brief Initializes an already allocated OFString with a UTF-16 string with
  *	  the specified length.
  *
  * @param string The UTF-16 string
  * @param length The length of the UTF-16 string
  * @return An initialized OFString
  */
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length;
 
 /*!
  * @brief Initializes an already allocated OFString with a UTF-16 string,
  *	  assuming the specified byte order if no byte order mark is found.
@@ -449,11 +446,11 @@
  *
  * @param string The UTF-16 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return An initialized OFString
  */
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Initializes an already allocated OFString with a UTF-16 string with
  *	  the specified length, assuming the specified byte order if no byte
@@ -462,31 +459,31 @@
  * @param string The UTF-16 string
  * @param length The length of the UTF-16 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return An initialized OFString
  */
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Initializes an already allocated OFString with a UTF-32 string.
  *
  * @param string The UTF-32 string
  * @return An initialized OFString
  */
-- initWithUTF32String: (const of_char32_t *)string;
+- initWithUTF32String: (const char32_t *)string;
 
 /*!
  * @brief Initializes an already allocated OFString with a UTF-32 string with
  *	  the specified length
  *
  * @param string The UTF-32 string
  * @param length The length of the UTF-32 string
  * @return An initialized OFString
  */
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length;
 
 /*!
  * @brief Initializes an already allocated OFString with a UTF-32 string,
  *	  assuming the specified byte order if no byte order mark is found.
@@ -493,11 +490,11 @@
  *
  * @param string The UTF-32 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return An initialized OFString
  */
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Initializes an already allocated OFString with a UTF-32 string with
  *	  the specified length, assuming the specified byte order if no byte
@@ -506,11 +503,11 @@
  * @param string The UTF-32 string
  * @param length The length of the UTF-32 string
  * @param byteOrder The byte order to assume if there is no byte order mark
  * @return An initialized OFString
  */
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Initializes an already allocated OFString with a format string.
@@ -1057,11 +1054,11 @@
  * use the result outside the scope of the current autorelease pool, you have to
  * copy it.
  *
  * @return The string in UTF-16 encoding with native byte order
  */
-- (const of_char16_t *)UTF16String OF_RETURNS_INNER_POINTER;
+- (const char16_t *)UTF16String OF_RETURNS_INNER_POINTER;
 
 /*!
  * @brief Returns the string in UTF-16 encoding with the specified byte order.
  *
  * The result is valid until the autorelease pool is released. If you want to
@@ -1069,11 +1066,11 @@
  * copy it.
  *
  * @param byteOrder The byte order for the UTF-16 encoding
  * @return The string in UTF-16 encoding with the specified byte order
  */
-- (const of_char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
     OF_RETURNS_INNER_POINTER;
 
 /*!
  * @brief Returns the length of the string in UTF-16 characters.
  *
@@ -1088,11 +1085,11 @@
  * use the result outside the scope of the current autorelease pool, you have to
  * copy it.
  *
  * @return The string in UTF-32 encoding with native byte order
  */
-- (const of_char32_t *)UTF32String OF_RETURNS_INNER_POINTER;
+- (const char32_t *)UTF32String OF_RETURNS_INNER_POINTER;
 
 /*!
  * @brief Returns the string in UTF-32 encoding with the specified byte order.
  *
  * The result is valid until the autorelease pool is released. If you want to
@@ -1100,11 +1097,11 @@
  * copy it.
  *
  * @param byteOrder The byte order for the UTF-32 encoding
  * @return The string in UTF-32 encoding with the specified byte order
  */
-- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
     OF_RETURNS_INNER_POINTER;
 
 #ifdef OF_HAVE_FILES
 /*!
  * @brief Writes the string into the specified file using UTF-8 encoding.
@@ -1138,12 +1135,12 @@
 extern "C" {
 #endif
 extern of_string_encoding_t of_string_parse_encoding(OFString *);
 extern size_t of_string_utf8_encode(of_unichar_t, char *);
 extern ssize_t of_string_utf8_decode(const char *, size_t, of_unichar_t *);
-extern size_t of_string_utf16_length(const of_char16_t *);
-extern size_t of_string_utf32_length(const of_char32_t *);
+extern size_t of_string_utf16_length(const char16_t *);
+extern size_t of_string_utf32_length(const char32_t *);
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END

Index: src/OFString.m
==================================================================
--- src/OFString.m
+++ src/OFString.m
@@ -263,11 +263,11 @@
 
 	return 0;
 }
 
 size_t
-of_string_utf16_length(const of_char16_t *string)
+of_string_utf16_length(const char16_t *string)
 {
 	size_t length = 0;
 
 	while (*string++ != 0)
 		length++;
@@ -274,11 +274,11 @@
 
 	return length;
 }
 
 size_t
-of_string_utf32_length(const of_char32_t *string)
+of_string_utf32_length(const char32_t *string)
 {
 	size_t length = 0;
 
 	while (*string++ != 0)
 		length++;
@@ -450,58 +450,58 @@
 {
 	return (id)[[OFString_UTF8 alloc] initWithCharacters: string
 						      length: length];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string
 						       length: length];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string
 						    byteOrder: byteOrder];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string
 						       length: length
 						    byteOrder: byteOrder];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string
 						       length: length];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string
 						    byteOrder: byteOrder];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string
 						       length: length
@@ -656,58 +656,58 @@
 {
 	return [[[self alloc] initWithCharacters: string
 					  length: length] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string
++ (instancetype)stringWithUTF16String: (const char16_t *)string
 {
 	return [[[self alloc] initWithUTF16String: string] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string
++ (instancetype)stringWithUTF16String: (const char16_t *)string
 			       length: (size_t)length
 {
 	return [[[self alloc] initWithUTF16String: string
 					   length: length] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string
++ (instancetype)stringWithUTF16String: (const char16_t *)string
 			    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [[[self alloc] initWithUTF16String: string
 					byteOrder: byteOrder] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const of_char16_t *)string
++ (instancetype)stringWithUTF16String: (const char16_t *)string
 			       length: (size_t)length
 			    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [[[self alloc] initWithUTF16String: string
 					   length: length
 					byteOrder: byteOrder] autorelease];
 }
 
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string
++ (instancetype)stringWithUTF32String: (const char32_t *)string
 {
 	return [[[self alloc] initWithUTF32String: string] autorelease];
 }
 
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string
++ (instancetype)stringWithUTF32String: (const char32_t *)string
 			       length: (size_t)length
 {
 	return [[[self alloc] initWithUTF32String: string
 					   length: length] autorelease];
 }
 
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string
++ (instancetype)stringWithUTF32String: (const char32_t *)string
 			    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [[[self alloc] initWithUTF32String: string
 					byteOrder: byteOrder] autorelease];
 }
 
-+ (instancetype)stringWithUTF32String: (const of_char32_t *)string
++ (instancetype)stringWithUTF32String: (const char32_t *)string
 			       length: (size_t)length
 			    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [[[self alloc] initWithUTF32String: string
 					   length: length
@@ -833,64 +833,64 @@
 	      length: (size_t)length
 {
 	OF_INVALID_INIT_METHOD
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 {
 	return [self initWithUTF16String: string
 				  length: of_string_utf16_length(string)
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 {
 	return [self initWithUTF16String: string
 				  length: length
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [self initWithUTF16String: string
 				  length: of_string_utf16_length(string)
 			       byteOrder: byteOrder];
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	OF_INVALID_INIT_METHOD
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 {
 	return [self initWithUTF32String: string
 				  length: of_string_utf32_length(string)
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length
 {
 	return [self initWithUTF32String: string
 				  length: length
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [self initWithUTF32String: string
 				  length: of_string_utf32_length(string)
 			       byteOrder: byteOrder];
 }
 
-- initWithUTF32String: (const of_char32_t *)string
+- initWithUTF32String: (const char32_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	OF_INVALID_INIT_METHOD
 }
@@ -2611,27 +2611,27 @@
 		    inRange: of_range(0, length)];
 
 	return ret;
 }
 
-- (const of_char16_t *)UTF16String
+- (const char16_t *)UTF16String
 {
 	return [self UTF16StringWithByteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (const of_char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
 {
 	OFObject *object = [[[OFObject alloc] init] autorelease];
 	void *pool = objc_autoreleasePoolPush();
 	const of_unichar_t *characters = [self characters];
 	size_t length = [self length];
-	of_char16_t *ret;
+	char16_t *ret;
 	size_t j;
 	bool swap = (byteOrder != OF_BYTE_ORDER_NATIVE);
 
 	/* Allocate memory for the worst case */
-	ret = [object allocMemoryWithSize: sizeof(of_char16_t)
+	ret = [object allocMemoryWithSize: sizeof(char16_t)
 				    count: (length + 1) * 2];
 
 	j = 0;
 	for (size_t i = 0; i < length; i++) {
 		of_unichar_t c = characters[i];
@@ -2657,11 +2657,11 @@
 	}
 	ret[j] = 0;
 
 	@try {
 		ret = [object resizeMemory: ret
-				      size: sizeof(of_char16_t)
+				      size: sizeof(char16_t)
 				     count: j + 1];
 	} @catch (OFOutOfMemoryException *e) {
 		/* We don't care, as we only tried to make it smaller */
 	}
 
@@ -2682,22 +2682,22 @@
 			UTF16StringLength++;
 
 	return UTF16StringLength;
 }
 
-- (const of_char32_t *)UTF32String
+- (const char32_t *)UTF32String
 {
 	return [self UTF32StringWithByteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
 {
 	OFObject *object = [[[OFObject alloc] init] autorelease];
 	size_t length = [self length];
-	of_char32_t *ret;
+	char32_t *ret;
 
-	ret = [object allocMemoryWithSize: sizeof(of_char32_t)
+	ret = [object allocMemoryWithSize: sizeof(char32_t)
 				    count: length + 1];
 	[self getCharacters: ret
 		    inRange: of_range(0, length)];
 	ret[length] = 0;
 

Index: src/OFString_UTF8.m
==================================================================
--- src/OFString_UTF8.m
+++ src/OFString_UTF8.m
@@ -35,31 +35,31 @@
 #import "OFOutOfRangeException.h"
 
 #import "of_asprintf.h"
 #import "unicode.h"
 
-extern const of_char16_t of_iso_8859_2_table[];
+extern const 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 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 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 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 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 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 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 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 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 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 char16_t of_koi8_u_table[];
 extern const size_t of_koi8_u_table_offset;
 
 static inline int
 memcasecmp(const char *first, const char *second, size_t length)
 {
@@ -229,11 +229,11 @@
 	   length: (size_t)cStringLength
 {
 	self = [super init];
 
 	@try {
-		const of_char16_t *table;
+		const char16_t *table;
 		size_t tableOffset, j;
 
 		if (encoding == OF_STRING_ENCODING_UTF_8 &&
 		    cStringLength >= 3 &&
 		    memcmp(cString, "\xEF\xBB\xBF", 3) == 0) {
@@ -495,11 +495,11 @@
 	}
 
 	return self;
 }
 
-- initWithUTF16String: (const of_char16_t *)string
+- initWithUTF16String: (const char16_t *)string
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];
 
@@ -531,11 +531,11 @@
 			/* Missing high surrogate */
 			if ((character & 0xFC00) == 0xDC00)
 				@throw [OFInvalidEncodingException exception];
 
 			if ((character & 0xFC00) == 0xD800) {
-				of_char16_t nextCharacter;
+				char16_t nextCharacter;
 
 				if (length <= i + 1)
 					@throw [OFInvalidEncodingException
 					    exception];
 
@@ -580,11 +580,11 @@
 	}
 
 	return self;
 }
 
-- initWithUTF32String: (const of_char32_t *)characters
+- initWithUTF32String: (const char32_t *)characters
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];
 
@@ -1277,14 +1277,14 @@
 	}
 
 	return ret;
 }
 
-- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
 {
 	OFObject *object = [[[OFObject alloc] init] autorelease];
-	of_char32_t *ret;
+	char32_t *ret;
 	size_t i, j;
 
 	ret = [object allocMemoryWithSize: sizeof(of_unichar_t)
 				    count: _s->length + 1];
 

Index: src/encodings/codepage_437.m
==================================================================
--- src/encodings/codepage_437.m
+++ src/encodings/codepage_437.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_codepage_437_table[] = {
+const char16_t of_codepage_437_table[] = {
 	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
 	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
 	0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
 	0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
 	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,

Index: src/encodings/codepage_850.m
==================================================================
--- src/encodings/codepage_850.m
+++ src/encodings/codepage_850.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_codepage_850_table[] = {
+const char16_t of_codepage_850_table[] = {
 	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
 	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
 	0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
 	0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
 	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,

Index: src/encodings/codepage_858.m
==================================================================
--- src/encodings/codepage_858.m
+++ src/encodings/codepage_858.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_codepage_858_table[] = {
+const char16_t of_codepage_858_table[] = {
 	0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
 	0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
 	0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
 	0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
 	0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,

Index: src/encodings/iso_8859_15.m
==================================================================
--- src/encodings/iso_8859_15.m
+++ src/encodings/iso_8859_15.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_iso_8859_15_table[] = {
+const char16_t of_iso_8859_15_table[] = {
 	0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AC, 0x00A5, 0x0160, 0x00A7,
 	0x0161, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
 	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x017D, 0x00B5, 0x00B6, 0x00B7,
 	0x017E, 0x00B9, 0x00BA, 0x00BB, 0x0152, 0x0153, 0x0178, 0x00BF,
 	0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,

Index: src/encodings/iso_8859_2.m
==================================================================
--- src/encodings/iso_8859_2.m
+++ src/encodings/iso_8859_2.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_iso_8859_2_table[] = {
+const char16_t of_iso_8859_2_table[] = {
 	0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
 	0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
 	0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
 	0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
 	0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,

Index: src/encodings/iso_8859_3.m
==================================================================
--- src/encodings/iso_8859_3.m
+++ src/encodings/iso_8859_3.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_iso_8859_3_table[] = {
+const char16_t of_iso_8859_3_table[] = {
 	0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0xFFFF, 0x0124, 0x00A7,
 	0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0xFFFF, 0x017B,
 	0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7,
 	0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0xFFFF, 0x017C,
 	0x00C0, 0x00C1, 0x00C2, 0xFFFF, 0x00C4, 0x010A, 0x0108, 0x00C7,

Index: src/encodings/koi8_r.m
==================================================================
--- src/encodings/koi8_r.m
+++ src/encodings/koi8_r.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_koi8_r_table[] = {
+const char16_t of_koi8_r_table[] = {
 	0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
 	0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
 	0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219, 0x221A, 0x2248,
 	0x2264,	0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
 	0x2550, 0x2551, 0x2552, 0x0451, 0x2553, 0x2554, 0x2555, 0x2556,

Index: src/encodings/koi8_u.m
==================================================================
--- src/encodings/koi8_u.m
+++ src/encodings/koi8_u.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_koi8_u_table[] = {
+const char16_t of_koi8_u_table[] = {
 	0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
 	0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
 	0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2219, 0x221A, 0x2248,
 	0x2264,	0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
 	0x2550, 0x2551, 0x2552, 0x0451, 0x0454, 0x2554, 0x0456, 0x0457,

Index: src/encodings/mac_roman.m
==================================================================
--- src/encodings/mac_roman.m
+++ src/encodings/mac_roman.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_mac_roman_table[] = {
+const char16_t of_mac_roman_table[] = {
 	0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
 	0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
 	0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
 	0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
 	0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,

Index: src/encodings/windows_1251.m
==================================================================
--- src/encodings/windows_1251.m
+++ src/encodings/windows_1251.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_windows_1251_table[] = {
+const char16_t of_windows_1251_table[] = {
 	0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021,
 	0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
 	0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
 	0xFFFF, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
 	0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7,

Index: src/encodings/windows_1252.m
==================================================================
--- src/encodings/windows_1252.m
+++ src/encodings/windows_1252.m
@@ -18,11 +18,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const of_char16_t of_windows_1252_table[] = {
+const char16_t of_windows_1252_table[] = {
 	0x20AC, 0xFFFF, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
 	0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0xFFFF, 0x017D, 0xFFFF,
 	0xFFFF, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
 	0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0xFFFF, 0x017E, 0x0178,
 	0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,

Index: tests/OFStringTests.m
==================================================================
--- tests/OFStringTests.m
+++ tests/OFStringTests.m
@@ -111,11 +111,11 @@
 	}
 
 	return self;
 }
 
-- initWithUTF16String: (const of_char16_t *)UTF16String
+- initWithUTF16String: (const char16_t *)UTF16String
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];
 
@@ -130,11 +130,11 @@
 	}
 
 	return self;
 }
 
-- initWithUTF32String: (const of_char32_t *)UTF32String
+- initWithUTF32String: (const char32_t *)UTF32String
 	       length: (size_t)length
 	    byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];