@@ -62,11 +62,11 @@
 	return self;
 }
 
 - (unsigned int)retainCount
 {
-	return OF_RETAIN_COUNT_MAX;
+	return OFMaxRetainCount;
 }
 
 - (void)release
 {
 }
@@ -104,26 +104,26 @@
 }
 
 - (void)finishInitialization
 {
 	@synchronized (self) {
-		struct of_string_utf8_ivars *ivars;
+		struct OFUTF8StringIvars *ivars;
 
 		if ([self isMemberOfClass: [OFConstantUTF8String class]])
 			return;
 
-		ivars = of_alloc_zeroed(1, sizeof(*ivars));
+		ivars = OFAllocZeroedMemory(1, sizeof(*ivars));
 		ivars->cString = _cString;
 		ivars->cStringLength = _cStringLength;
 
-		switch (of_string_utf8_check(ivars->cString,
-		    ivars->cStringLength, &ivars->length)) {
+		switch (OFUTF8StringCheck(ivars->cString, ivars->cStringLength,
+		    &ivars->length)) {
 		case 1:
 			ivars->isUTF8 = true;
 			break;
 		case -1:
-			free(ivars);
+			OFFreeMemory(ivars);
 			@throw [OFInvalidEncodingException exception];
 		}
 
 		_cString = (char *)ivars;
 		object_setClass(self, [OFConstantUTF8String class]);
@@ -145,11 +145,11 @@
 	return self;
 }
 
 - (unsigned int)retainCount
 {
-	return OF_RETAIN_COUNT_MAX;
+	return OFMaxRetainCount;
 }
 
 - (void)release
 {
 }
@@ -166,521 +166,442 @@
 
 /* From protocol OFCopying */
 - (id)copy
 {
 	[self finishInitialization];
-
 	return [self copy];
 }
 
 /* From protocol OFMutableCopying */
 - (id)mutableCopy
 {
 	[self finishInitialization];
-
 	return [self mutableCopy];
 }
 
-/* From protocol OFComparing */
-- (of_comparison_result_t)compare: (id <OFComparing>)object
+/* From protocol OFComparing,  but overridden in OFString */
+- (OFComparisonResult)compare: (OFString *)string
 {
 	[self finishInitialization];
-
-	return [self compare: object];
+	return [self compare: string];
 }
 
 /* From OFObject, but reimplemented in OFString */
 - (bool)isEqual: (id)object
 {
 	[self finishInitialization];
-
 	return [self isEqual: object];
 }
 
 - (unsigned long)hash
 {
 	[self finishInitialization];
-
 	return self.hash;
 }
 
 - (OFString *)description
 {
 	[self finishInitialization];
-
 	return self.description;
 }
 
 /* From OFString */
 - (const char *)UTF8String
 {
 	[self finishInitialization];
-
 	return self.UTF8String;
 }
 
 - (size_t)getCString: (char *)cString_
 	   maxLength: (size_t)maxLength
-	    encoding: (of_string_encoding_t)encoding
+	    encoding: (OFStringEncoding)encoding
 {
 	[self finishInitialization];
-
 	return [self getCString: cString_
 		      maxLength: maxLength
 		       encoding: encoding];
 }
 
-- (const char *)cStringWithEncoding: (of_string_encoding_t)encoding
+- (const char *)cStringWithEncoding: (OFStringEncoding)encoding
 {
 	[self finishInitialization];
-
 	return [self cStringWithEncoding: encoding];
 }
 
 - (size_t)length
 {
 	[self finishInitialization];
-
 	return self.length;
 }
 
 - (size_t)UTF8StringLength
 {
 	[self finishInitialization];
-
 	return self.UTF8StringLength;
 }
 
-- (size_t)cStringLengthWithEncoding: (of_string_encoding_t)encoding
+- (size_t)cStringLengthWithEncoding: (OFStringEncoding)encoding
 {
 	[self finishInitialization];
-
 	return [self cStringLengthWithEncoding: encoding];
 }
 
-- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)otherString
+- (OFComparisonResult)caseInsensitiveCompare: (OFString *)string
 {
 	[self finishInitialization];
-
-	return [self caseInsensitiveCompare: otherString];
+	return [self caseInsensitiveCompare: string];
 }
 
-- (of_unichar_t)characterAtIndex: (size_t)idx
+- (OFUnichar)characterAtIndex: (size_t)idx
 {
 	[self finishInitialization];
-
 	return [self characterAtIndex: idx];
 }
 
-- (void)getCharacters: (of_unichar_t *)buffer
-	      inRange: (of_range_t)range
+- (void)getCharacters: (OFUnichar *)buffer inRange: (OFRange)range
 {
 	[self finishInitialization];
-
-	[self getCharacters: buffer
-		    inRange: range];
+	[self getCharacters: buffer inRange: range];
 }
 
-- (of_range_t)rangeOfString: (OFString *)string
+- (OFRange)rangeOfString: (OFString *)string
 {
 	[self finishInitialization];
-
 	return [self rangeOfString: string];
 }
 
-- (of_range_t)rangeOfString: (OFString *)string
-		    options: (int)options
-{
-	[self finishInitialization];
-
-	return [self rangeOfString: string
-			   options: options];
-}
-
-- (of_range_t)rangeOfString: (OFString *)string
-		    options: (int)options
-		      range: (of_range_t)range
-{
-	[self finishInitialization];
-
-	return [self rangeOfString: string
-			   options: options
-			     range: range];
+- (OFRange)rangeOfString: (OFString *)string
+		 options: (OFStringSearchOptions)options
+{
+	[self finishInitialization];
+	return [self rangeOfString: string options: options];
+}
+
+- (OFRange)rangeOfString: (OFString *)string
+		 options: (OFStringSearchOptions)options
+		   range: (OFRange)range
+{
+	[self finishInitialization];
+	return [self rangeOfString: string options: options range: range];
 }
 
 - (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
 {
 	[self finishInitialization];
-
 	return [self indexOfCharacterFromSet: characterSet];
 }
 
 - (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
-			  options: (int)options
+			  options: (OFStringSearchOptions)options
 {
 	[self finishInitialization];
-
-	return [self indexOfCharacterFromSet: characterSet
-				     options: options];
+	return [self indexOfCharacterFromSet: characterSet options: options];
 }
 
 - (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet
-			  options: (int)options
-			    range: (of_range_t)range
+			  options: (OFStringSearchOptions)options
+			    range: (OFRange)range
 {
 	[self finishInitialization];
-
 	return [self indexOfCharacterFromSet: characterSet
 				     options: options
 				       range: range];
 }
 
 - (bool)containsString: (OFString *)string
 {
 	[self finishInitialization];
-
 	return [self containsString: string];
 }
 
 - (OFString *)substringFromIndex: (size_t)idx
 {
 	[self finishInitialization];
-
 	return [self substringFromIndex: idx];
 }
 
 - (OFString *)substringToIndex: (size_t)idx
 {
 	[self finishInitialization];
-
 	return [self substringToIndex: idx];
 }
 
-- (OFString *)substringWithRange: (of_range_t)range
+- (OFString *)substringWithRange: (OFRange)range
 {
 	[self finishInitialization];
-
 	return [self substringWithRange: range];
 }
 
 - (OFString *)stringByAppendingString: (OFString *)string
 {
 	[self finishInitialization];
-
 	return [self stringByAppendingString: string];
 }
 
 - (OFString *)stringByAppendingFormat: (OFConstantString *)format
 			    arguments: (va_list)arguments
 {
 	[self finishInitialization];
-
-	return [self stringByAppendingFormat: format
-				   arguments: arguments];
+	return [self stringByAppendingFormat: format arguments: arguments];
 }
 
 - (OFString *)stringByAppendingPathComponent: (OFString *)component
 {
 	[self finishInitialization];
-
 	return [self stringByAppendingPathComponent: component];
 }
 
 - (OFString *)stringByPrependingString: (OFString *)string
 {
 	[self finishInitialization];
-
 	return [self stringByPrependingString: string];
 }
 
 - (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string
 					withString: (OFString *)replacement
 {
 	[self finishInitialization];
-
 	return [self stringByReplacingOccurrencesOfString: string
 					       withString: replacement];
 }
 
 - (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string
 					withString: (OFString *)replacement
 					   options: (int)options
-					     range: (of_range_t)range
+					     range: (OFRange)range
 {
 	[self finishInitialization];
-
 	return [self stringByReplacingOccurrencesOfString: string
 					       withString: replacement
 						  options: options
 						    range: range];
 }
 
 - (OFString *)uppercaseString
 {
 	[self finishInitialization];
-
 	return self.uppercaseString;
 }
 
 - (OFString *)lowercaseString
 {
 	[self finishInitialization];
-
 	return self.lowercaseString;
 }
 
 - (OFString *)capitalizedString
 {
 	[self finishInitialization];
-
 	return self.capitalizedString;
 }
 
 - (OFString *)stringByDeletingLeadingWhitespaces
 {
 	[self finishInitialization];
-
 	return self.stringByDeletingLeadingWhitespaces;
 }
 
 - (OFString *)stringByDeletingTrailingWhitespaces
 {
 	[self finishInitialization];
-
 	return self.stringByDeletingTrailingWhitespaces;
 }
 
 - (OFString *)stringByDeletingEnclosingWhitespaces
 {
 	[self finishInitialization];
-
 	return self.stringByDeletingEnclosingWhitespaces;
 }
 
 - (bool)hasPrefix: (OFString *)prefix
 {
 	[self finishInitialization];
-
 	return [self hasPrefix: prefix];
 }
 
 - (bool)hasSuffix: (OFString *)suffix
 {
 	[self finishInitialization];
-
 	return [self hasSuffix: suffix];
 }
 
 - (OFArray *)componentsSeparatedByString: (OFString *)delimiter
 {
 	[self finishInitialization];
-
 	return [self componentsSeparatedByString: delimiter];
 }
 
 - (OFArray *)componentsSeparatedByString: (OFString *)delimiter
-				 options: (int)options
+				 options: (OFStringSeparationOptions)options
 {
 	[self finishInitialization];
-
-	return [self componentsSeparatedByString: delimiter
-					 options: options];
+	return [self componentsSeparatedByString: delimiter options: options];
 }
 
 - (OFArray *)
     componentsSeparatedByCharactersInSet: (OFCharacterSet *)characterSet
 {
 	[self finishInitialization];
-
 	return [self componentsSeparatedByCharactersInSet: characterSet];
 }
 
 - (OFArray *)
     componentsSeparatedByCharactersInSet: (OFCharacterSet *)characterSet
-				 options: (int)options
+				 options: (OFStringSeparationOptions)options
 {
 	[self finishInitialization];
-
 	return [self componentsSeparatedByCharactersInSet: characterSet
 						  options: options];
 }
 
 - (OFArray *)pathComponents
 {
 	[self finishInitialization];
-
 	return self.pathComponents;
 }
 
 - (OFString *)lastPathComponent
 {
 	[self finishInitialization];
-
 	return self.lastPathComponent;
 }
 
 - (OFString *)stringByDeletingLastPathComponent
 {
 	[self finishInitialization];
-
 	return self.stringByDeletingLastPathComponent;
 }
 
 - (long long)longLongValue
 {
 	[self finishInitialization];
-
 	return self.longLongValue;
 }
 
 - (long long)longLongValueWithBase: (int)base
 {
 	[self finishInitialization];
-
 	return [self longLongValueWithBase: base];
 }
 
 - (unsigned long long)unsignedLongLongValue
 {
 	[self finishInitialization];
-
 	return self.unsignedLongLongValue;
 }
 
 - (unsigned long long)unsignedLongLongValueWithBase: (int)base
 {
 	[self finishInitialization];
-
 	return [self unsignedLongLongValueWithBase: base];
 }
 
 - (float)floatValue
 {
 	[self finishInitialization];
-
 	return self.floatValue;
 }
 
 - (double)doubleValue
 {
 	[self finishInitialization];
-
 	return self.doubleValue;
 }
 
-- (const of_unichar_t *)characters
+- (const OFUnichar *)characters
 {
 	[self finishInitialization];
-
 	return self.characters;
 }
 
-- (const of_char16_t *)UTF16String
+- (const OFChar16 *)UTF16String
 {
 	[self finishInitialization];
-
 	return self.UTF16String;
 }
 
-- (const of_char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const OFChar16 *)UTF16StringWithByteOrder: (OFByteOrder)byteOrder
 {
 	[self finishInitialization];
-
 	return [self UTF16StringWithByteOrder: byteOrder];
 }
 
 - (size_t)UTF16StringLength
 {
 	[self finishInitialization];
-
 	return self.UTF16StringLength;
 }
 
-- (const of_char32_t *)UTF32String
+- (const OFChar32 *)UTF32String
 {
 	[self finishInitialization];
-
 	return self.UTF32String;
 }
 
-- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder
+- (const OFChar32 *)UTF32StringWithByteOrder: (OFByteOrder)byteOrder
 {
 	[self finishInitialization];
-
 	return [self UTF32StringWithByteOrder: byteOrder];
 }
 
-- (OFData *)dataWithEncoding: (of_string_encoding_t)encoding
+- (OFData *)dataWithEncoding: (OFStringEncoding)encoding
 {
 	[self finishInitialization];
-
 	return [self dataWithEncoding: encoding];
 }
 
 #ifdef OF_HAVE_UNICODE_TABLES
 - (OFString *)decomposedStringWithCanonicalMapping
 {
 	[self finishInitialization];
-
 	return self.decomposedStringWithCanonicalMapping;
 }
 
 - (OFString *)decomposedStringWithCompatibilityMapping
 {
 	[self finishInitialization];
-
 	return self.decomposedStringWithCompatibilityMapping;
 }
 #endif
 
 #ifdef OF_WINDOWS
 - (OFString *)stringByExpandingWindowsEnvironmentStrings
 {
 	[self finishInitialization];
-
 	return self.stringByExpandingWindowsEnvironmentStrings;
 }
 #endif
 
 #ifdef OF_HAVE_FILES
 - (void)writeToFile: (OFString *)path
 {
 	[self finishInitialization];
-
 	[self writeToFile: path];
 }
 
-- (void)writeToFile: (OFString *)path
-	   encoding: (of_string_encoding_t)encoding
+- (void)writeToFile: (OFString *)path encoding: (OFStringEncoding)encoding
 {
 	[self finishInitialization];
-
-	[self writeToFile: path
-		 encoding: encoding];
+	[self writeToFile: path encoding: encoding];
 }
 #endif
 
 - (void)writeToURL: (OFURL *)URL
 {
 	[self finishInitialization];
-
 	[self writeToURL: URL];
 }
 
-- (void)writeToURL: (OFURL *)URL
-	  encoding: (of_string_encoding_t)encoding
+- (void)writeToURL: (OFURL *)URL encoding: (OFStringEncoding)encoding
 {
 	[self finishInitialization];
-
-	[self writeToURL: URL
-		encoding: encoding];
+	[self writeToURL: URL encoding: encoding];
 }
 
 #ifdef OF_HAVE_BLOCKS
-- (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block
+- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block
 {
 	[self finishInitialization];
-
 	[self enumerateLinesUsingBlock: block];
 }
 #endif
 @end