Index: src/OFApplication.m
==================================================================
--- src/OFApplication.m
+++ src/OFApplication.m
@@ -208,11 +208,11 @@
 		_environment = [[OFMutableDictionary alloc] init];
 
 		atexit(atexitHandler);
 
 #if defined(OF_WINDOWS)
-		char16_t *env, *env0;
+		of_char16_t *env, *env0;
 		env = env0 = GetEnvironmentStringsW();
 
 		while (*env != 0) {
 			void *pool = objc_autoreleasePoolPush();
 			OFString *tmp, *key, *value;

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

Index: src/OFMutableString.m
==================================================================
--- src/OFMutableString.m
+++ src/OFMutableString.m
@@ -85,61 +85,61 @@
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithCharacters: characters
 							     length: length];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF16String: string];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			     length: (size_t)length
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF16String: string
 							      length: length];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFMutableString_UTF8 alloc]
 	    initWithUTF16String: string
 		      byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFMutableString_UTF8 alloc]
 	    initWithUTF16String: string
 			 length: length
 		      byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF32String: string];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			     length: (size_t)length
 {
 	return (id)[[OFMutableString_UTF8 alloc] initWithUTF32String: string
 							      length: length];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFMutableString_UTF8 alloc]
 	    initWithUTF32String: string
 		      byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_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
@@ -57,11 +57,11 @@
 - (void)of_getArgv: (char ***)argv
     forProgramName: (OFString *)programName
       andArguments: (OFArray *)arguments;
 - (char **)of_environmentForDictionary: (OFDictionary *)dictionary;
 #else
-- (char16_t *)of_environmentForDictionary: (OFDictionary *)dictionary;
+- (of_char16_t *)of_environmentForDictionary: (OFDictionary *)dictionary;
 #endif
 @end
 
 @implementation OFProcess
 + (instancetype)processWithProgram: (OFString *)program
@@ -223,11 +223,11 @@
 		SECURITY_ATTRIBUTES sa;
 		PROCESS_INFORMATION pi;
 		STARTUPINFOW si;
 		void *pool;
 		OFMutableString *argumentsString;
-		char16_t *argumentsCopy;
+		of_char16_t *argumentsCopy;
 		size_t length;
 
 		sa.nLength = sizeof(sa);
 		sa.bInheritHandle = TRUE;
 		sa.lpSecurityDescriptor = NULL;
@@ -292,11 +292,11 @@
 			if (containsSpaces)
 				[argumentsString appendString: @"\""];
 		}
 
 		length = [argumentsString UTF16StringLength];
-		argumentsCopy = [self allocMemoryWithSize: sizeof(char16_t)
+		argumentsCopy = [self allocMemoryWithSize: sizeof(of_char16_t)
 						    count: length + 1];
 		memcpy(argumentsCopy, [argumentsString UTF16String],
 		    ([argumentsString UTF16StringLength] + 1) * 2);
 		@try {
 			if (!CreateProcessW([program UTF16String],
@@ -398,22 +398,22 @@
 	envp[i] = NULL;
 
 	return envp;
 }
 #else
-- (char16_t *)of_environmentForDictionary: (OFDictionary *)environment
+- (of_char16_t *)of_environmentForDictionary: (OFDictionary *)environment
 {
 	OFMutableData *env;
 	OFEnumerator *keyEnumerator, *objectEnumerator;
 	OFString *key, *object;
-	const char16_t equal = '=';
-	const char16_t zero[2] = { 0, 0 };
+	const of_char16_t equal = '=';
+	const of_char16_t zero[2] = { 0, 0 };
 
 	if (environment == nil)
 		return NULL;
 
-	env = [OFMutableData dataWithItemSize: sizeof(char16_t)];
+	env = [OFMutableData dataWithItemSize: sizeof(of_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
@@ -22,12 +22,12 @@
 OF_ASSUME_NONNULL_BEGIN
 
 @interface OFStdIOStream_Win32Console: OFStdIOStream
 {
 	HANDLE _handle;
-	char16_t _incompleteUTF16Surrogate;
+	of_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
@@ -105,17 +105,17 @@
 - (size_t)lowlevelReadIntoBuffer: (void *)buffer_
 			  length: (size_t)length
 {
 	void *pool = objc_autoreleasePoolPush();
 	char *buffer = buffer_;
-	char16_t *UTF16;
+	of_char16_t *UTF16;
 	size_t j = 0;
 
 	if (length > sizeof(UINT32_MAX))
 		@throw [OFOutOfRangeException exception];
 
-	UTF16 = [self allocMemoryWithSize: sizeof(char16_t)
+	UTF16 = [self allocMemoryWithSize: sizeof(of_char16_t)
 				    count: length];
 	@try {
 		DWORD UTF16Len;
 		OFMutableData *rest = nil;
 		size_t i = 0;
@@ -160,11 +160,11 @@
 			/* Missing high surrogate */
 			if ((c & 0xFC00) == 0xDC00)
 				@throw [OFInvalidEncodingException exception];
 
 			if ((c & 0xFC00) == 0xD800) {
-				char16_t next;
+				of_char16_t next;
 
 				if (UTF16Len <= i + 1) {
 					_incompleteUTF16Surrogate = c;
 
 					if (rest != nil) {
@@ -221,19 +221,19 @@
 
 - (size_t)lowlevelWriteBuffer: (const void *)buffer_
 		       length: (size_t)length
 {
 	const char *buffer = buffer_;
-	char16_t *tmp;
+	of_char16_t *tmp;
 	size_t i = 0, j = 0;
 
 	if (length > SIZE_MAX / 2)
 		@throw [OFOutOfRangeException exception];
 
 	if (_incompleteUTF8SurrogateLen > 0) {
 		of_unichar_t c;
-		char16_t UTF16[2];
+		of_char16_t UTF16[2];
 		ssize_t UTF8Len;
 		size_t toCopy;
 		DWORD UTF16Len, bytesWritten;
 
 		UTF8Len = -of_string_utf8_decode(
@@ -289,11 +289,11 @@
 
 		_incompleteUTF8SurrogateLen = 0;
 		i += toCopy;
 	}
 
-	tmp = [self allocMemoryWithSize: sizeof(char16_t)
+	tmp = [self allocMemoryWithSize: sizeof(of_char16_t)
 				  count: length * 2];
 	@try {
 		DWORD bytesWritten;
 
 		while (i < length) {

Index: src/OFString+JSONValue.m
==================================================================
--- src/OFString+JSONValue.m
+++ src/OFString+JSONValue.m
@@ -105,14 +105,14 @@
 		skipWhitespaces(pointer, stop, line);
 		skipComment(pointer, stop, line);
 	}
 }
 
-static inline char16_t
+static inline of_char16_t
 parseUnicodeEscape(const char *pointer, const char *stop)
 {
-	char16_t ret = 0;
+	of_char16_t ret = 0;
 
 	if (pointer + 5 >= stop)
 		return 0xFFFF;
 
 	if (pointer[0] != '\\' || pointer[1] != 'u')
@@ -186,11 +186,11 @@
 				buffer[i++] = '\t';
 				(*pointer)++;
 				break;
 			/* Parse Unicode escape sequence */
 			case 'u':;
-				char16_t c1, c2;
+				of_char16_t c1, c2;
 				of_unichar_t c;
 				size_t l;
 
 				c1 = parseUnicodeEscape(*pointer - 1, stop);
 				if (c1 == 0xFFFF) {
@@ -305,11 +305,11 @@
 		    **pointer == '_' || **pointer == '$' ||
 		    (**pointer & 0x80)) {
 			buffer[i++] = **pointer;
 			(*pointer)++;
 		} else if (**pointer == '\\') {
-			char16_t c1, c2;
+			of_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
@@ -40,15 +40,18 @@
 
 /*! @file */
 
 @class OFConstantString;
 
-#if !defined(__cplusplus) || __cplusplus < 201103L
-typedef uint_least16_t char16_t;
-typedef uint_least32_t char32_t;
+#if defined(__cplusplus) && __cplusplus >= 201103L
+typedef char16_t of_char16_t;
+typedef char32_t of_char32_t;
+#else
+typedef uint_least16_t of_char16_t;
+typedef uint_least32_t of_char32_t;
 #endif
-typedef char32_t of_unichar_t;
+typedef of_char32_t of_unichar_t;
 
 /*!
  * @brief The encoding of a string.
  */
 typedef enum of_string_encoding_t {
@@ -262,11 +265,11 @@
  *
  * The result is valid until the autorelease pool is released. If you want to
  * use the result outside the scope of the current autorelease pool, you have to
  * copy it.
  */
-@property (readonly, nonatomic) const char16_t *UTF16String
+@property (readonly, nonatomic) const of_char16_t *UTF16String
     OF_RETURNS_INNER_POINTER;
 
 /*!
  * @brief The length of the string in UTF-16 characters.
  */
@@ -277,11 +280,11 @@
  *
  * The result is valid until the autorelease pool is released. If you want to
  * use the result outside the scope of the current autorelease pool, you have to
  * copy it.
  */
-@property (readonly, nonatomic) const char32_t *UTF32String
+@property (readonly, nonatomic) const of_char32_t *UTF32String
     OF_RETURNS_INNER_POINTER;
 
 /*!
  * @brief The string with leading whitespaces deleted.
  */
@@ -428,21 +431,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 char16_t *)string;
++ (instancetype)stringWithUTF16String: (const of_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 char16_t *)string
++ (instancetype)stringWithUTF16String: (const of_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.
@@ -449,11 +452,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 char16_t *)string
++ (instancetype)stringWithUTF16String: (const of_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
@@ -462,31 +465,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 char16_t *)string
++ (instancetype)stringWithUTF16String: (const of_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 char32_t *)string;
++ (instancetype)stringWithUTF32String: (const of_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 char32_t *)string
++ (instancetype)stringWithUTF32String: (const of_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.
@@ -493,11 +496,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 char32_t *)string
++ (instancetype)stringWithUTF32String: (const of_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
@@ -506,11 +509,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 char32_t *)string
++ (instancetype)stringWithUTF32String: (const of_char32_t *)string
 			       length: (size_t)length
 			    byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Creates a new OFString from a format string.
@@ -696,21 +699,21 @@
  * @brief Initializes an already allocated OFString with a UTF-16 string.
  *
  * @param string The UTF-16 string
  * @return An initialized OFString
  */
-- (instancetype)initWithUTF16String: (const char16_t *)string;
+- (instancetype)initWithUTF16String: (const of_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
  */
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_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.
@@ -717,11 +720,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
  */
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_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
@@ -730,31 +733,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
  */
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_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
  */
-- (instancetype)initWithUTF32String: (const char32_t *)string;
+- (instancetype)initWithUTF32String: (const of_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
  */
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_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.
@@ -761,11 +764,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
  */
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_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
@@ -774,11 +777,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
  */
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder;
 
 /*!
  * @brief Initializes an already allocated OFString with a format string.
@@ -1173,11 +1176,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 char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const of_char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
     OF_RETURNS_INNER_POINTER;
 
 /*!
  * @brief Returns the string in UTF-32 encoding with the specified byte order.
  *
@@ -1186,11 +1189,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 char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
     OF_RETURNS_INNER_POINTER;
 
 /*!
  * @brief Returns the string as OFData with the specified encoding.
  *
@@ -1248,12 +1251,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 char16_t *);
-extern size_t of_string_utf32_length(const char32_t *);
+extern size_t of_string_utf16_length(const of_char16_t *);
+extern size_t of_string_utf32_length(const of_char32_t *);
 #ifdef __cplusplus
 }
 #endif
 
 OF_ASSUME_NONNULL_END

Index: src/OFString.m
==================================================================
--- src/OFString.m
+++ src/OFString.m
@@ -262,11 +262,11 @@
 
 	return 0;
 }
 
 size_t
-of_string_utf16_length(const char16_t *string)
+of_string_utf16_length(const of_char16_t *string)
 {
 	size_t length = 0;
 
 	while (*string++ != 0)
 		length++;
@@ -273,11 +273,11 @@
 
 	return length;
 }
 
 size_t
-of_string_utf32_length(const char32_t *string)
+of_string_utf32_length(const of_char32_t *string)
 {
 	size_t length = 0;
 
 	while (*string++ != 0)
 		length++;
@@ -490,58 +490,58 @@
 {
 	return (id)[[OFString_UTF8 alloc] initWithCharacters: string
 						      length: length];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			     length: (size_t)length
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string
 						       length: length];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string
 						    byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF16String: string
 						       length: length
 						    byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			     length: (size_t)length
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string
 						       length: length];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string
 						    byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return (id)[[OFString_UTF8 alloc] initWithUTF32String: string
 						       length: length
@@ -713,58 +713,58 @@
 {
 	return [[[self alloc] initWithCharacters: string
 					  length: length] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const char16_t *)string
++ (instancetype)stringWithUTF16String: (const of_char16_t *)string
 {
 	return [[[self alloc] initWithUTF16String: string] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const char16_t *)string
++ (instancetype)stringWithUTF16String: (const of_char16_t *)string
 			       length: (size_t)length
 {
 	return [[[self alloc] initWithUTF16String: string
 					   length: length] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const char16_t *)string
++ (instancetype)stringWithUTF16String: (const of_char16_t *)string
 			    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [[[self alloc] initWithUTF16String: string
 					byteOrder: byteOrder] autorelease];
 }
 
-+ (instancetype)stringWithUTF16String: (const char16_t *)string
++ (instancetype)stringWithUTF16String: (const of_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 char32_t *)string
++ (instancetype)stringWithUTF32String: (const of_char32_t *)string
 {
 	return [[[self alloc] initWithUTF32String: string] autorelease];
 }
 
-+ (instancetype)stringWithUTF32String: (const char32_t *)string
++ (instancetype)stringWithUTF32String: (const of_char32_t *)string
 			       length: (size_t)length
 {
 	return [[[self alloc] initWithUTF32String: string
 					   length: length] autorelease];
 }
 
-+ (instancetype)stringWithUTF32String: (const char32_t *)string
++ (instancetype)stringWithUTF32String: (const of_char32_t *)string
 			    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [[[self alloc] initWithUTF32String: string
 					byteOrder: byteOrder] autorelease];
 }
 
-+ (instancetype)stringWithUTF32String: (const char32_t *)string
++ (instancetype)stringWithUTF32String: (const of_char32_t *)string
 			       length: (size_t)length
 			    byteOrder: (of_byte_order_t)byteOrder
 {
 	return [[[self alloc] initWithUTF32String: string
 					   length: length
@@ -926,64 +926,64 @@
 			    length: (size_t)length
 {
 	OF_INVALID_INIT_METHOD
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 {
 	return [self initWithUTF16String: string
 				  length: of_string_utf16_length(string)
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			     length: (size_t)length
 {
 	return [self initWithUTF16String: string
 				  length: length
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return [self initWithUTF16String: string
 				  length: of_string_utf16_length(string)
 			       byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	OF_INVALID_INIT_METHOD
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 {
 	return [self initWithUTF32String: string
 				  length: of_string_utf32_length(string)
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			     length: (size_t)length
 {
 	return [self initWithUTF32String: string
 				  length: length
 			       byteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	return [self initWithUTF32String: string
 				  length: of_string_utf32_length(string)
 			       byteOrder: byteOrder];
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)string
+- (instancetype)initWithUTF32String: (const of_char32_t *)string
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	OF_INVALID_INIT_METHOD
 }
@@ -2755,27 +2755,27 @@
 		    inRange: of_range(0, length)];
 
 	return ret;
 }
 
-- (const char16_t *)UTF16String
+- (const of_char16_t *)UTF16String
 {
 	return [self UTF16StringWithByteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (const char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const of_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];
-	char16_t *ret;
+	of_char16_t *ret;
 	size_t j;
 	bool swap = (byteOrder != OF_BYTE_ORDER_NATIVE);
 
 	/* Allocate memory for the worst case */
-	ret = [object allocMemoryWithSize: sizeof(char16_t)
+	ret = [object allocMemoryWithSize: sizeof(of_char16_t)
 				    count: (length + 1) * 2];
 
 	j = 0;
 	for (size_t i = 0; i < length; i++) {
 		of_unichar_t c = characters[i];
@@ -2801,11 +2801,11 @@
 	}
 	ret[j] = 0;
 
 	@try {
 		ret = [object resizeMemory: ret
-				      size: sizeof(char16_t)
+				      size: sizeof(of_char16_t)
 				     count: j + 1];
 	} @catch (OFOutOfMemoryException *e) {
 		/* We don't care, as we only tried to make it smaller */
 	}
 
@@ -2826,22 +2826,22 @@
 			UTF16StringLength++;
 
 	return UTF16StringLength;
 }
 
-- (const char32_t *)UTF32String
+- (const of_char32_t *)UTF32String
 {
 	return [self UTF32StringWithByteOrder: OF_BYTE_ORDER_NATIVE];
 }
 
-- (const char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
 {
 	OFObject *object = [[[OFObject alloc] init] autorelease];
 	size_t length = [self length];
-	char32_t *ret;
+	of_char32_t *ret;
 
-	ret = [object allocMemoryWithSize: sizeof(char32_t)
+	ret = [object allocMemoryWithSize: sizeof(of_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
@@ -38,31 +38,31 @@
 #import "OFOutOfRangeException.h"
 
 #import "of_asprintf.h"
 #import "unicode.h"
 
-extern const char16_t of_iso_8859_2_table[];
+extern const of_char16_t of_iso_8859_2_table[];
 extern const size_t of_iso_8859_2_table_offset;
-extern const char16_t of_iso_8859_3_table[];
+extern const of_char16_t of_iso_8859_3_table[];
 extern const size_t of_iso_8859_3_table_offset;
-extern const char16_t of_iso_8859_15_table[];
+extern const of_char16_t of_iso_8859_15_table[];
 extern const size_t of_iso_8859_15_table_offset;
-extern const char16_t of_windows_1251_table[];
+extern const of_char16_t of_windows_1251_table[];
 extern const size_t of_windows_1251_table_offset;
-extern const char16_t of_windows_1252_table[];
+extern const of_char16_t of_windows_1252_table[];
 extern const size_t of_windows_1252_table_offset;
-extern const char16_t of_codepage_437_table[];
+extern const of_char16_t of_codepage_437_table[];
 extern const size_t of_codepage_437_table_offset;
-extern const char16_t of_codepage_850_table[];
+extern const of_char16_t of_codepage_850_table[];
 extern const size_t of_codepage_850_table_offset;
-extern const char16_t of_codepage_858_table[];
+extern const of_char16_t of_codepage_858_table[];
 extern const size_t of_codepage_858_table_offset;
-extern const char16_t of_mac_roman_table[];
+extern const of_char16_t of_mac_roman_table[];
 extern const size_t of_mac_roman_table_offset;
-extern const char16_t of_koi8_r_table[];
+extern const of_char16_t of_koi8_r_table[];
 extern const size_t of_koi8_r_table_offset;
-extern const char16_t of_koi8_u_table[];
+extern const of_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)
 {
@@ -232,11 +232,11 @@
 			 length: (size_t)cStringLength
 {
 	self = [super init];
 
 	@try {
-		const char16_t *table;
+		const of_char16_t *table;
 		size_t tableOffset, j;
 
 		if (encoding == OF_STRING_ENCODING_UTF_8 &&
 		    cStringLength >= 3 &&
 		    memcmp(cString, "\xEF\xBB\xBF", 3) == 0) {
@@ -512,11 +512,11 @@
 	}
 
 	return self;
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)string
+- (instancetype)initWithUTF16String: (const of_char16_t *)string
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];
 
@@ -548,11 +548,11 @@
 			/* Missing high surrogate */
 			if ((character & 0xFC00) == 0xDC00)
 				@throw [OFInvalidEncodingException exception];
 
 			if ((character & 0xFC00) == 0xD800) {
-				char16_t nextCharacter;
+				of_char16_t nextCharacter;
 
 				if (length <= i + 1)
 					@throw [OFInvalidEncodingException
 					    exception];
 
@@ -597,11 +597,11 @@
 	}
 
 	return self;
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)characters
+- (instancetype)initWithUTF32String: (const of_char32_t *)characters
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];
 
@@ -1281,14 +1281,14 @@
 	}
 
 	return ret;
 }
 
-- (const char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
 {
 	OFObject *object = [[[OFObject alloc] init] autorelease];
-	char32_t *ret;
+	of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_codepage_437_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_codepage_850_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_codepage_858_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_iso_8859_15_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_iso_8859_2_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_iso_8859_3_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_koi8_r_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_koi8_u_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_mac_roman_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_windows_1251_table[] = {
+const of_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
@@ -19,11 +19,11 @@
 
 #import "OFString.h"
 
 #import "common.h"
 
-const char16_t of_windows_1252_table[] = {
+const of_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
@@ -113,11 +113,11 @@
 	}
 
 	return self;
 }
 
-- (instancetype)initWithUTF16String: (const char16_t *)UTF16String
+- (instancetype)initWithUTF16String: (const of_char16_t *)UTF16String
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];
 
@@ -132,11 +132,11 @@
 	}
 
 	return self;
 }
 
-- (instancetype)initWithUTF32String: (const char32_t *)UTF32String
+- (instancetype)initWithUTF32String: (const of_char32_t *)UTF32String
 			     length: (size_t)length
 			  byteOrder: (of_byte_order_t)byteOrder
 {
 	self = [super init];