@@ -28,10 +28,11 @@ #ifdef HAVE_XLOCALE_H # include #endif #import "OFString.h" +#import "OFASPrintF.h" #import "OFArray.h" #import "OFCharacterSet.h" #import "OFData.h" #import "OFDictionary.h" #ifdef OF_HAVE_FILES @@ -57,11 +58,10 @@ #import "OFOutOfRangeException.h" #import "OFRetrieveItemAttributesFailedException.h" #import "OFTruncatedDataException.h" #import "OFUnsupportedProtocolException.h" -#import "of_asprintf.h" #import "unicode.h" /* * It seems strtod is buggy on Win32. * However, the MinGW version __strtod seems to be ok. @@ -87,49 +87,50 @@ #endif @interface OFString () - (size_t)of_getCString: (char *)cString maxLength: (size_t)maxLength - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding lossy: (bool)lossy OF_DIRECT; -- (const char *)of_cStringWithEncoding: (of_string_encoding_t)encoding +- (const char *)of_cStringWithEncoding: (OFStringEncoding)encoding lossy: (bool)lossy OF_DIRECT; -- (OFString *)of_JSONRepresentationWithOptions: (int)options - depth: (size_t)depth; +- (OFString *) + of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options + depth: (size_t)depth; @end @interface OFStringPlaceholder: OFString @end -extern bool of_unicode_to_iso_8859_2(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_iso_8859_3(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_iso_8859_15(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_windows_1251(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_windows_1252(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_codepage_437(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_codepage_850(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_codepage_858(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_mac_roman(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_koi8_r(const of_unichar_t *, unsigned char *, - size_t, bool); -extern bool of_unicode_to_koi8_u(const of_unichar_t *, unsigned char *, +extern bool OFUnicodeToISO8859_2(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToISO8859_3(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToISO8859_15(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToWindows1251(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToWindows1252(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToCodepage437(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToCodepage850(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToCodepage858(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToMacRoman(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToKOI8R(const OFUnichar *, unsigned char *, + size_t, bool); +extern bool OFUnicodeToKOI8U(const OFUnichar *, unsigned char *, size_t, bool); /* References for static linking */ void _references_to_categories_of_OFString(void) { - _OFString_CryptoHashing_reference = 1; + _OFString_CryptographicHashing_reference = 1; _OFString_JSONParsing_reference = 1; #ifdef OF_HAVE_FILES _OFString_PathAdditions_reference = 1; #endif _OFString_PropertyListParsing_reference = 1; @@ -143,106 +144,106 @@ _reference_to_OFConstantString(void) { [OFConstantString class]; } -of_string_encoding_t -of_string_parse_encoding(OFString *string) +OFStringEncoding +OFStringEncodingParseName(OFString *string) { void *pool = objc_autoreleasePoolPush(); - of_string_encoding_t encoding; + OFStringEncoding encoding; string = string.lowercaseString; if ([string isEqual: @"utf8"] || [string isEqual: @"utf-8"]) - encoding = OF_STRING_ENCODING_UTF_8; + encoding = OFStringEncodingUTF8; else if ([string isEqual: @"ascii"] || [string isEqual: @"us-ascii"]) - encoding = OF_STRING_ENCODING_ASCII; + encoding = OFStringEncodingASCII; else if ([string isEqual: @"iso-8859-1"] || [string isEqual: @"iso_8859-1"]) - encoding = OF_STRING_ENCODING_ISO_8859_1; + encoding = OFStringEncodingISO8859_1; else if ([string isEqual: @"iso-8859-2"] || [string isEqual: @"iso_8859-2"]) - encoding = OF_STRING_ENCODING_ISO_8859_2; + encoding = OFStringEncodingISO8859_2; else if ([string isEqual: @"iso-8859-3"] || [string isEqual: @"iso_8859-3"]) - encoding = OF_STRING_ENCODING_ISO_8859_3; + encoding = OFStringEncodingISO8859_3; else if ([string isEqual: @"iso-8859-15"] || [string isEqual: @"iso_8859-15"]) - encoding = OF_STRING_ENCODING_ISO_8859_15; + encoding = OFStringEncodingISO8859_15; else if ([string isEqual: @"windows-1251"] || [string isEqual: @"cp1251"] || [string isEqual: @"cp-1251"] || [string isEqual: @"1251"]) - encoding = OF_STRING_ENCODING_WINDOWS_1251; + encoding = OFStringEncodingWindows1251; else if ([string isEqual: @"windows-1252"] || [string isEqual: @"cp1252"] || [string isEqual: @"cp-1252"] || [string isEqual: @"1252"]) - encoding = OF_STRING_ENCODING_WINDOWS_1252; + encoding = OFStringEncodingWindows1252; else if ([string isEqual: @"cp437"] || [string isEqual: @"cp-437"] || [string isEqual: @"ibm437"] || [string isEqual: @"437"]) - encoding = OF_STRING_ENCODING_CODEPAGE_437; + encoding = OFStringEncodingCodepage437; else if ([string isEqual: @"cp850"] || [string isEqual: @"cp-850"] || [string isEqual: @"ibm850"] || [string isEqual: @"850"]) - encoding = OF_STRING_ENCODING_CODEPAGE_850; + encoding = OFStringEncodingCodepage850; else if ([string isEqual: @"cp858"] || [string isEqual: @"cp-858"] || [string isEqual: @"ibm858"] || [string isEqual: @"858"]) - encoding = OF_STRING_ENCODING_CODEPAGE_858; + encoding = OFStringEncodingCodepage858; else if ([string isEqual: @"macintosh"] || [string isEqual: @"mac"]) - encoding = OF_STRING_ENCODING_MAC_ROMAN; + encoding = OFStringEncodingMacRoman; else if ([string isEqual: @"koi8-r"]) - encoding = OF_STRING_ENCODING_KOI8_R; + encoding = OFStringEncodingKOI8R; else if ([string isEqual: @"koi8-u"]) - encoding = OF_STRING_ENCODING_KOI8_U; + encoding = OFStringEncodingKOI8U; else @throw [OFInvalidArgumentException exception]; objc_autoreleasePoolPop(pool); return encoding; } OFString * -of_string_name_of_encoding(of_string_encoding_t encoding) +OFStringEncodingName(OFStringEncoding encoding) { switch (encoding) { - case OF_STRING_ENCODING_UTF_8: + case OFStringEncodingUTF8: return @"UTF-8"; - case OF_STRING_ENCODING_ASCII: + case OFStringEncodingASCII: return @"ASCII"; - case OF_STRING_ENCODING_ISO_8859_1: + case OFStringEncodingISO8859_1: return @"ISO 8859-1"; - case OF_STRING_ENCODING_ISO_8859_2: + case OFStringEncodingISO8859_2: return @"ISO 8859-2"; - case OF_STRING_ENCODING_ISO_8859_3: + case OFStringEncodingISO8859_3: return @"ISO 8859-3"; - case OF_STRING_ENCODING_ISO_8859_15: + case OFStringEncodingISO8859_15: return @"ISO 8859-15"; - case OF_STRING_ENCODING_WINDOWS_1251: + case OFStringEncodingWindows1251: return @"Windows-1251"; - case OF_STRING_ENCODING_WINDOWS_1252: + case OFStringEncodingWindows1252: return @"Windows-1252"; - case OF_STRING_ENCODING_CODEPAGE_437: + case OFStringEncodingCodepage437: return @"Codepage 437"; - case OF_STRING_ENCODING_CODEPAGE_850: + case OFStringEncodingCodepage850: return @"Codepage 850"; - case OF_STRING_ENCODING_CODEPAGE_858: + case OFStringEncodingCodepage858: return @"Codepage 858"; - case OF_STRING_ENCODING_MAC_ROMAN: + case OFStringEncodingMacRoman: return @"Mac Roman"; - case OF_STRING_ENCODING_KOI8_R: + case OFStringEncodingKOI8R: return @"KOI8-R"; - case OF_STRING_ENCODING_KOI8_U: + case OFStringEncodingKOI8U: return @"KOI8-U"; - case OF_STRING_ENCODING_AUTODETECT: + case OFStringEncodingAutodetect: return @"autodetect"; } return nil; } size_t -of_string_utf8_encode(of_unichar_t character, char *buffer) +OFUTF8StringEncode(OFUnichar character, char *buffer) { if (character < 0x80) { buffer[0] = character; return 1; } else if (character < 0x800) { @@ -264,11 +265,11 @@ return 0; } ssize_t -of_string_utf8_decode(const char *buffer_, size_t length, of_unichar_t *ret) +OFUTF8StringDecode(const char *buffer_, size_t length, OFUnichar *ret) { const unsigned char *buffer = (const unsigned char *)buffer_; if (!(*buffer & 0x80)) { *ret = buffer[0]; @@ -314,11 +315,11 @@ return 0; } size_t -of_string_utf16_length(const of_char16_t *string) +OFUTF16StringLength(const OFChar16 *string) { size_t length = 0; while (*string++ != 0) length++; @@ -325,45 +326,53 @@ return length; } size_t -of_string_utf32_length(const of_char32_t *string) +OFUTF32StringLength(const OFChar32 *string) { size_t length = 0; while (*string++ != 0) length++; return length; } + +char * +OFStrDup(const char *string) +{ + size_t length = strlen(string); + char *copy = (char *)OFAllocMemory(1, length + 1); + memcpy(copy, string, length + 1); + + return copy; +} #ifdef OF_HAVE_UNICODE_TABLES static OFString * decomposedString(OFString *self, const char *const *const *table, size_t size) { OFMutableString *ret = [OFMutableString string]; void *pool = objc_autoreleasePoolPush(); - const of_unichar_t *characters = self.characters; + const OFUnichar *characters = self.characters; size_t length = self.length; for (size_t i = 0; i < length; i++) { - of_unichar_t c = characters[i]; + OFUnichar c = characters[i]; const char *const *page; if (c >= size) { - [ret appendCharacters: &c - length: 1]; + [ret appendCharacters: &c length: 1]; continue; } page = table[c >> 8]; if (page != NULL && page[c & 0xFF] != NULL) [ret appendUTF8String: page[c & 0xFF]]; else - [ret appendCharacters: &c - length: 1]; + [ret appendCharacters: &c length: 1]; } objc_autoreleasePoolPop(pool); return ret; @@ -381,11 +390,11 @@ OFUTF8String *string; size_t length; void *storage; length = strlen(UTF8String); - string = of_alloc_object([OFUTF8String class], length + 1, 1, &storage); + string = OFAllocObject([OFUTF8String class], length + 1, 1, &storage); return (id)[string of_initWithUTF8String: UTF8String length: length storage: storage]; } @@ -394,11 +403,11 @@ length: (size_t)UTF8StringLength { OFUTF8String *string; void *storage; - string = of_alloc_object([OFUTF8String class], UTF8StringLength + 1, 1, + string = OFAllocObject([OFUTF8String class], UTF8StringLength + 1, 1, &storage); return (id)[string of_initWithUTF8String: UTF8String length: UTF8StringLength storage: storage]; @@ -421,19 +430,19 @@ length: UTF8StringLength freeWhenDone: freeWhenDone]; } - (instancetype)initWithCString: (const char *)cString - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { - if (encoding == OF_STRING_ENCODING_UTF_8) { + if (encoding == OFStringEncodingUTF8) { OFUTF8String *string; size_t length; void *storage; length = strlen(cString); - string = of_alloc_object([OFUTF8String class], length + 1, 1, + string = OFAllocObject([OFUTF8String class], length + 1, 1, &storage); return (id)[string of_initWithUTF8String: cString length: length storage: storage]; @@ -442,19 +451,19 @@ return (id)[[OFUTF8String alloc] initWithCString: cString encoding: encoding]; } - (instancetype)initWithCString: (const char *)cString - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding length: (size_t)cStringLength { - if (encoding == OF_STRING_ENCODING_UTF_8) { + if (encoding == OFStringEncodingUTF8) { OFUTF8String *string; void *storage; - string = of_alloc_object([OFUTF8String class], - cStringLength + 1, 1, &storage); + string = OFAllocObject([OFUTF8String class], cStringLength + 1, + 1, &storage); return (id)[string of_initWithUTF8String: cString length: cStringLength storage: storage]; } @@ -463,11 +472,11 @@ encoding: encoding length: cStringLength]; } - (instancetype)initWithData: (OFData *)data - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return (id)[[OFUTF8String alloc] initWithData: data encoding: encoding]; } @@ -474,67 +483,67 @@ - (instancetype)initWithString: (OFString *)string { return (id)[[OFUTF8String alloc] initWithString: string]; } -- (instancetype)initWithCharacters: (const of_unichar_t *)string +- (instancetype)initWithCharacters: (const OFUnichar *)string length: (size_t)length { return (id)[[OFUTF8String alloc] initWithCharacters: string length: length]; } -- (instancetype)initWithUTF16String: (const of_char16_t *)string +- (instancetype)initWithUTF16String: (const OFChar16 *)string { return (id)[[OFUTF8String alloc] initWithUTF16String: string]; } -- (instancetype)initWithUTF16String: (const of_char16_t *)string +- (instancetype)initWithUTF16String: (const OFChar16 *)string length: (size_t)length { return (id)[[OFUTF8String alloc] initWithUTF16String: string length: length]; } -- (instancetype)initWithUTF16String: (const of_char16_t *)string - byteOrder: (of_byte_order_t)byteOrder +- (instancetype)initWithUTF16String: (const OFChar16 *)string + byteOrder: (OFByteOrder)byteOrder { return (id)[[OFUTF8String alloc] initWithUTF16String: string byteOrder: byteOrder]; } -- (instancetype)initWithUTF16String: (const of_char16_t *)string +- (instancetype)initWithUTF16String: (const OFChar16 *)string length: (size_t)length - byteOrder: (of_byte_order_t)byteOrder + byteOrder: (OFByteOrder)byteOrder { return (id)[[OFUTF8String alloc] initWithUTF16String: string length: length byteOrder: byteOrder]; } -- (instancetype)initWithUTF32String: (const of_char32_t *)string +- (instancetype)initWithUTF32String: (const OFChar32 *)string { return (id)[[OFUTF8String alloc] initWithUTF32String: string]; } -- (instancetype)initWithUTF32String: (const of_char32_t *)string +- (instancetype)initWithUTF32String: (const OFChar32 *)string length: (size_t)length { return (id)[[OFUTF8String alloc] initWithUTF32String: string length: length]; } -- (instancetype)initWithUTF32String: (const of_char32_t *)string - byteOrder: (of_byte_order_t)byteOrder +- (instancetype)initWithUTF32String: (const OFChar32 *)string + byteOrder: (OFByteOrder)byteOrder { return (id)[[OFUTF8String alloc] initWithUTF32String: string byteOrder: byteOrder]; } -- (instancetype)initWithUTF32String: (const of_char32_t *)string +- (instancetype)initWithUTF32String: (const OFChar32 *)string length: (size_t)length - byteOrder: (of_byte_order_t)byteOrder + byteOrder: (OFByteOrder)byteOrder { return (id)[[OFUTF8String alloc] initWithUTF32String: string length: length byteOrder: byteOrder]; } @@ -564,30 +573,28 @@ { return (id)[[OFUTF8String alloc] initWithContentsOfFile: path]; } - (instancetype)initWithContentsOfFile: (OFString *)path - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return (id)[[OFUTF8String alloc] initWithContentsOfFile: path encoding: encoding]; } #endif -#if defined(OF_HAVE_FILES) || defined(OF_HAVE_SOCKETS) - (instancetype)initWithContentsOfURL: (OFURL *)URL { return (id)[[OFUTF8String alloc] initWithContentsOfURL: URL]; } - (instancetype)initWithContentsOfURL: (OFURL *)URL - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return (id)[[OFUTF8String alloc] initWithContentsOfURL: URL encoding: encoding]; } -#endif - (instancetype)initWithSerialization: (OFXMLElement *)element { return (id)[[OFUTF8String alloc] initWithSerialization: element]; } @@ -670,27 +677,27 @@ length: UTF8StringLength freeWhenDone: freeWhenDone] autorelease]; } + (instancetype)stringWithCString: (const char *)cString - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return [[[self alloc] initWithCString: cString encoding: encoding] autorelease]; } + (instancetype)stringWithCString: (const char *)cString - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding length: (size_t)cStringLength { return [[[self alloc] initWithCString: cString encoding: encoding length: cStringLength] autorelease]; } + (instancetype)stringWithData: (OFData *)data - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return [[[self alloc] initWithData: data encoding: encoding] autorelease]; } @@ -697,67 +704,67 @@ + (instancetype)stringWithString: (OFString *)string { return [[[self alloc] initWithString: string] autorelease]; } -+ (instancetype)stringWithCharacters: (const of_unichar_t *)string ++ (instancetype)stringWithCharacters: (const OFUnichar *)string length: (size_t)length { return [[[self alloc] initWithCharacters: string length: length] autorelease]; } -+ (instancetype)stringWithUTF16String: (const of_char16_t *)string ++ (instancetype)stringWithUTF16String: (const OFChar16 *)string { return [[[self alloc] initWithUTF16String: string] autorelease]; } -+ (instancetype)stringWithUTF16String: (const of_char16_t *)string ++ (instancetype)stringWithUTF16String: (const OFChar16 *)string length: (size_t)length { return [[[self alloc] initWithUTF16String: string length: length] autorelease]; } -+ (instancetype)stringWithUTF16String: (const of_char16_t *)string - byteOrder: (of_byte_order_t)byteOrder ++ (instancetype)stringWithUTF16String: (const OFChar16 *)string + byteOrder: (OFByteOrder)byteOrder { return [[[self alloc] initWithUTF16String: string byteOrder: byteOrder] autorelease]; } -+ (instancetype)stringWithUTF16String: (const of_char16_t *)string ++ (instancetype)stringWithUTF16String: (const OFChar16 *)string length: (size_t)length - byteOrder: (of_byte_order_t)byteOrder + byteOrder: (OFByteOrder)byteOrder { return [[[self alloc] initWithUTF16String: string length: length byteOrder: byteOrder] autorelease]; } -+ (instancetype)stringWithUTF32String: (const of_char32_t *)string ++ (instancetype)stringWithUTF32String: (const OFChar32 *)string { return [[[self alloc] initWithUTF32String: string] autorelease]; } -+ (instancetype)stringWithUTF32String: (const of_char32_t *)string ++ (instancetype)stringWithUTF32String: (const OFChar32 *)string length: (size_t)length { return [[[self alloc] initWithUTF32String: string length: length] autorelease]; } -+ (instancetype)stringWithUTF32String: (const of_char32_t *)string - byteOrder: (of_byte_order_t)byteOrder ++ (instancetype)stringWithUTF32String: (const OFChar32 *)string + byteOrder: (OFByteOrder)byteOrder { return [[[self alloc] initWithUTF32String: string byteOrder: byteOrder] autorelease]; } -+ (instancetype)stringWithUTF32String: (const of_char32_t *)string ++ (instancetype)stringWithUTF32String: (const OFChar32 *)string length: (size_t)length - byteOrder: (of_byte_order_t)byteOrder + byteOrder: (OFByteOrder)byteOrder { return [[[self alloc] initWithUTF32String: string length: length byteOrder: byteOrder] autorelease]; } @@ -780,30 +787,28 @@ { return [[[self alloc] initWithContentsOfFile: path] autorelease]; } + (instancetype)stringWithContentsOfFile: (OFString *)path - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return [[[self alloc] initWithContentsOfFile: path encoding: encoding] autorelease]; } #endif -#if defined(OF_HAVE_FILES) || defined(OF_HAVE_SOCKETS) + (instancetype)stringWithContentsOfURL: (OFURL *)URL { return [[[self alloc] initWithContentsOfURL: URL] autorelease]; } + (instancetype)stringWithContentsOfURL: (OFURL *)URL - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return [[[self alloc] initWithContentsOfURL: URL encoding: encoding] autorelease]; } -#endif - (instancetype)init { if ([self isMemberOfClass: [OFString class]]) { @try { @@ -820,63 +825,62 @@ } - (instancetype)initWithUTF8String: (const char *)UTF8String { return [self initWithCString: UTF8String - encoding: OF_STRING_ENCODING_UTF_8 + encoding: OFStringEncodingUTF8 length: strlen(UTF8String)]; } - (instancetype)initWithUTF8String: (const char *)UTF8String length: (size_t)UTF8StringLength { return [self initWithCString: UTF8String - encoding: OF_STRING_ENCODING_UTF_8 + encoding: OFStringEncodingUTF8 length: UTF8StringLength]; } - (instancetype)initWithUTF8StringNoCopy: (char *)UTF8String freeWhenDone: (bool)freeWhenDone { id ret = [self initWithUTF8String: UTF8String]; if (freeWhenDone) - free(UTF8String); + OFFreeMemory(UTF8String); return ret; } - (instancetype)initWithUTF8StringNoCopy: (char *)UTF8String length: (size_t)UTF8StringLength freeWhenDone: (bool)freeWhenDone { - id ret = [self initWithUTF8String: UTF8String - length: UTF8StringLength]; + id ret = [self initWithUTF8String: UTF8String length: UTF8StringLength]; if (freeWhenDone) - free(UTF8String); + OFFreeMemory(UTF8String); return ret; } - (instancetype)initWithCString: (const char *)cString - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return [self initWithCString: cString encoding: encoding length: strlen(cString)]; } - (instancetype)initWithCString: (const char *)cString - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding length: (size_t)cStringLength { OF_INVALID_INIT_METHOD } - (instancetype)initWithData: (OFData *)data - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { @try { if (data.itemSize != 1) @throw [OFInvalidArgumentException exception]; } @catch (id e) { @@ -894,72 +898,72 @@ - (instancetype)initWithString: (OFString *)string { OF_INVALID_INIT_METHOD } -- (instancetype)initWithCharacters: (const of_unichar_t *)string - length: (size_t)length -{ - OF_INVALID_INIT_METHOD -} - -- (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 of_char16_t *)string - length: (size_t)length -{ - return [self initWithUTF16String: string - length: length - byteOrder: OF_BYTE_ORDER_NATIVE]; -} - -- (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 of_char16_t *)string - length: (size_t)length - byteOrder: (of_byte_order_t)byteOrder -{ - OF_INVALID_INIT_METHOD -} - -- (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 of_char32_t *)string - length: (size_t)length -{ - return [self initWithUTF32String: string - length: length - byteOrder: OF_BYTE_ORDER_NATIVE]; -} - -- (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 of_char32_t *)string - length: (size_t)length - byteOrder: (of_byte_order_t)byteOrder +- (instancetype)initWithCharacters: (const OFUnichar *)string + length: (size_t)length +{ + OF_INVALID_INIT_METHOD +} + +- (instancetype)initWithUTF16String: (const OFChar16 *)string +{ + return [self initWithUTF16String: string + length: OFUTF16StringLength(string) + byteOrder: OFByteOrderNative]; +} + +- (instancetype)initWithUTF16String: (const OFChar16 *)string + length: (size_t)length +{ + return [self initWithUTF16String: string + length: length + byteOrder: OFByteOrderNative]; +} + +- (instancetype)initWithUTF16String: (const OFChar16 *)string + byteOrder: (OFByteOrder)byteOrder +{ + return [self initWithUTF16String: string + length: OFUTF16StringLength(string) + byteOrder: byteOrder]; +} + +- (instancetype)initWithUTF16String: (const OFChar16 *)string + length: (size_t)length + byteOrder: (OFByteOrder)byteOrder +{ + OF_INVALID_INIT_METHOD +} + +- (instancetype)initWithUTF32String: (const OFChar32 *)string +{ + return [self initWithUTF32String: string + length: OFUTF32StringLength(string) + byteOrder: OFByteOrderNative]; +} + +- (instancetype)initWithUTF32String: (const OFChar32 *)string + length: (size_t)length +{ + return [self initWithUTF32String: string + length: length + byteOrder: OFByteOrderNative]; +} + +- (instancetype)initWithUTF32String: (const OFChar32 *)string + byteOrder: (OFByteOrder)byteOrder +{ + return [self initWithUTF32String: string + length: OFUTF32StringLength(string) + byteOrder: byteOrder]; +} + +- (instancetype)initWithUTF32String: (const OFChar32 *)string + length: (size_t)length + byteOrder: (OFByteOrder)byteOrder { OF_INVALID_INIT_METHOD } - (instancetype)initWithFormat: (OFConstantString *)format, ... @@ -966,12 +970,11 @@ { id ret; va_list arguments; va_start(arguments, format); - ret = [self initWithFormat: format - arguments: arguments]; + ret = [self initWithFormat: format arguments: arguments]; va_end(arguments); return ret; } @@ -983,15 +986,15 @@ #ifdef OF_HAVE_FILES - (instancetype)initWithContentsOfFile: (OFString *)path { return [self initWithContentsOfFile: path - encoding: OF_STRING_ENCODING_UTF_8]; + encoding: OFStringEncodingUTF8]; } - (instancetype)initWithContentsOfFile: (OFString *)path - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { char *tmp; unsigned long long fileSize; @try { @@ -1020,19 +1023,17 @@ * to use -[initWithUTF8StringNoCopy:length:freeWhenDone:]. */ if (SIZE_MAX - (size_t)fileSize < 1) @throw [OFOutOfRangeException exception]; - tmp = of_alloc((size_t)fileSize + 1, 1); + tmp = OFAllocMemory((size_t)fileSize + 1, 1); @try { - file = [[OFFile alloc] initWithPath: path - mode: @"r"]; - + file = [[OFFile alloc] initWithPath: path mode: @"r"]; [file readIntoBuffer: tmp exactLength: (size_t)fileSize]; } @catch (id e) { - free(tmp); + OFFreeMemory(tmp); @throw e; } @finally { [file release]; } @@ -1040,26 +1041,26 @@ } @catch (id e) { [self release]; @throw e; } - if (encoding == OF_STRING_ENCODING_UTF_8) { + if (encoding == OFStringEncodingUTF8) { @try { self = [self initWithUTF8StringNoCopy: tmp length: (size_t)fileSize freeWhenDone: true]; } @catch (id e) { - free(tmp); + OFFreeMemory(tmp); @throw e; } } else { @try { self = [self initWithCString: tmp encoding: encoding length: (size_t)fileSize]; } @finally { - free(tmp); + OFFreeMemory(tmp); } } return self; } @@ -1066,15 +1067,15 @@ #endif - (instancetype)initWithContentsOfURL: (OFURL *)URL { return [self initWithContentsOfURL: URL - encoding: OF_STRING_ENCODING_AUTODETECT]; + encoding: OFStringEncodingAutodetect]; } - (instancetype)initWithContentsOfURL: (OFURL *)URL - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { void *pool = objc_autoreleasePoolPush(); OFData *data; @try { @@ -1097,11 +1098,11 @@ { void *pool = objc_autoreleasePoolPush(); OFString *stringValue; @try { - if (![element.namespace isEqual: OF_SERIALIZATION_NS]) + if (![element.namespace isEqual: OFSerializationNS]) @throw [OFInvalidArgumentException exception]; if ([self isKindOfClass: [OFMutableString class]]) { if (![element.name isEqual: @"OFMutableString"]) @throw [OFInvalidArgumentException exception]; @@ -1123,24 +1124,23 @@ return self; } - (size_t)of_getCString: (char *)cString maxLength: (size_t)maxLength - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding lossy: (bool)lossy { - const of_unichar_t *characters = self.characters; + const OFUnichar *characters = self.characters; size_t i, length = self.length; switch (encoding) { - case OF_STRING_ENCODING_UTF_8:; + case OFStringEncodingUTF8:; size_t j = 0; for (i = 0; i < length; i++) { char buffer[4]; - size_t len = of_string_utf8_encode(characters[i], - buffer); + size_t len = OFUTF8StringEncode(characters[i], buffer); /* * Check for one more than the current index, as we * need one for the terminating zero. */ @@ -1167,11 +1167,11 @@ } cString[j] = '\0'; return j; - case OF_STRING_ENCODING_ASCII: + case OFStringEncodingASCII: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; for (i = 0; i < length; i++) { if OF_UNLIKELY (characters[i] > 0x80) { @@ -1185,11 +1185,11 @@ } cString[i] = '\0'; return length; - case OF_STRING_ENCODING_ISO_8859_1: + case OFStringEncodingISO8859_1: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; for (i = 0; i < length; i++) { if OF_UNLIKELY (characters[i] > 0xFF) { @@ -1204,146 +1204,146 @@ cString[i] = '\0'; return length; #ifdef HAVE_ISO_8859_2 - case OF_STRING_ENCODING_ISO_8859_2: + case OFStringEncodingISO8859_2: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_iso_8859_2(characters, - (unsigned char *)cString, length, lossy)) + if (!OFUnicodeToISO8859_2(characters, (unsigned char *)cString, + length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_ISO_8859_3 - case OF_STRING_ENCODING_ISO_8859_3: + case OFStringEncodingISO8859_3: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_iso_8859_3(characters, - (unsigned char *)cString, length, lossy)) + if (!OFUnicodeToISO8859_3(characters, (unsigned char *)cString, + length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_ISO_8859_15 - case OF_STRING_ENCODING_ISO_8859_15: + case OFStringEncodingISO8859_15: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_iso_8859_15(characters, - (unsigned char *)cString, length, lossy)) + if (!OFUnicodeToISO8859_15(characters, (unsigned char *)cString, + length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_WINDOWS_1251 - case OF_STRING_ENCODING_WINDOWS_1251: + case OFStringEncodingWindows1251: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_windows_1251(characters, + if (!OFUnicodeToWindows1251(characters, (unsigned char *)cString, length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_WINDOWS_1252 - case OF_STRING_ENCODING_WINDOWS_1252: + case OFStringEncodingWindows1252: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_windows_1252(characters, + if (!OFUnicodeToWindows1252(characters, (unsigned char *)cString, length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_CODEPAGE_437 - case OF_STRING_ENCODING_CODEPAGE_437: + case OFStringEncodingCodepage437: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_codepage_437(characters, + if (!OFUnicodeToCodepage437(characters, (unsigned char *)cString, length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_CODEPAGE_850 - case OF_STRING_ENCODING_CODEPAGE_850: + case OFStringEncodingCodepage850: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_codepage_850(characters, + if (!OFUnicodeToCodepage850(characters, (unsigned char *)cString, length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_CODEPAGE_858 - case OF_STRING_ENCODING_CODEPAGE_858: + case OFStringEncodingCodepage858: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_codepage_858(characters, + if (!OFUnicodeToCodepage858(characters, (unsigned char *)cString, length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_MAC_ROMAN - case OF_STRING_ENCODING_MAC_ROMAN: + case OFStringEncodingMacRoman: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_mac_roman(characters, - (unsigned char *)cString, length, lossy)) + if (!OFUnicodeToMacRoman(characters, (unsigned char *)cString, + length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_KOI8_R - case OF_STRING_ENCODING_KOI8_R: + case OFStringEncodingKOI8R: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_koi8_r(characters, - (unsigned char *)cString, length, lossy)) + if (!OFUnicodeToKOI8R(characters, (unsigned char *)cString, + length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; #endif #ifdef HAVE_KOI8_U - case OF_STRING_ENCODING_KOI8_U: + case OFStringEncodingKOI8U: if (length + 1 > maxLength) @throw [OFOutOfRangeException exception]; - if (!of_unicode_to_koi8_u(characters, - (unsigned char *)cString, length, lossy)) + if (!OFUnicodeToKOI8U(characters, (unsigned char *)cString, + length, lossy)) @throw [OFInvalidEncodingException exception]; cString[length] = '\0'; return length; @@ -1354,79 +1354,79 @@ } } - (size_t)getCString: (char *)cString maxLength: (size_t)maxLength - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return [self of_getCString: cString maxLength: maxLength encoding: encoding lossy: false]; } - (size_t)getLossyCString: (char *)cString maxLength: (size_t)maxLength - encoding: (of_string_encoding_t)encoding + encoding: (OFStringEncoding)encoding { return [self of_getCString: cString maxLength: maxLength encoding: encoding lossy: true]; } -- (const char *)of_cStringWithEncoding: (of_string_encoding_t)encoding +- (const char *)of_cStringWithEncoding: (OFStringEncoding)encoding lossy: (bool)lossy { size_t length = self.length; char *cString; size_t cStringLength; switch (encoding) { - case OF_STRING_ENCODING_UTF_8: - cString = of_alloc((length * 4) + 1, 1); + case OFStringEncodingUTF8: + cString = OFAllocMemory((length * 4) + 1, 1); @try { cStringLength = [self of_getCString: cString maxLength: (length * 4) + 1 - encoding: OF_STRING_ENCODING_UTF_8 + encoding: OFStringEncodingUTF8 lossy: lossy]; } @catch (id e) { - free(cString); + OFFreeMemory(cString); @throw e; } @try { - cString = of_realloc(cString, cStringLength + 1, 1); + cString = OFResizeMemory(cString, cStringLength + 1, 1); } @catch (OFOutOfMemoryException *e) { /* We don't care, as we only tried to make it smaller */ } break; - case OF_STRING_ENCODING_ASCII: - case OF_STRING_ENCODING_ISO_8859_1: - case OF_STRING_ENCODING_ISO_8859_2: - case OF_STRING_ENCODING_ISO_8859_3: - case OF_STRING_ENCODING_ISO_8859_15: - case OF_STRING_ENCODING_WINDOWS_1251: - case OF_STRING_ENCODING_WINDOWS_1252: - case OF_STRING_ENCODING_CODEPAGE_437: - case OF_STRING_ENCODING_CODEPAGE_850: - case OF_STRING_ENCODING_CODEPAGE_858: - case OF_STRING_ENCODING_MAC_ROMAN: - case OF_STRING_ENCODING_KOI8_R: - case OF_STRING_ENCODING_KOI8_U: - cString = of_alloc(length + 1, 1); + case OFStringEncodingASCII: + case OFStringEncodingISO8859_1: + case OFStringEncodingISO8859_2: + case OFStringEncodingISO8859_3: + case OFStringEncodingISO8859_15: + case OFStringEncodingWindows1251: + case OFStringEncodingWindows1252: + case OFStringEncodingCodepage437: + case OFStringEncodingCodepage850: + case OFStringEncodingCodepage858: + case OFStringEncodingMacRoman: + case OFStringEncodingKOI8R: + case OFStringEncodingKOI8U: + cString = OFAllocMemory(length + 1, 1); @try { cStringLength = [self of_getCString: cString maxLength: length + 1 encoding: encoding lossy: lossy]; } @catch (id e) { - free(cString); + OFFreeMemory(cString); @throw e; } break; default: @@ -1436,121 +1436,118 @@ @try { return [[OFData dataWithItemsNoCopy: cString count: cStringLength + 1 freeWhenDone: true] items]; } @catch (id e) { - free(cString); + OFFreeMemory(cString); @throw e; } } -- (const char *)cStringWithEncoding: (of_string_encoding_t)encoding +- (const char *)cStringWithEncoding: (OFStringEncoding)encoding { - return [self of_cStringWithEncoding: encoding - lossy: false]; + return [self of_cStringWithEncoding: encoding lossy: false]; } -- (const char *)lossyCStringWithEncoding: (of_string_encoding_t)encoding +- (const char *)lossyCStringWithEncoding: (OFStringEncoding)encoding { - return [self of_cStringWithEncoding: encoding - lossy: true]; + return [self of_cStringWithEncoding: encoding lossy: true]; } - (const char *)UTF8String { - return [self cStringWithEncoding: OF_STRING_ENCODING_UTF_8]; + return [self cStringWithEncoding: OFStringEncodingUTF8]; } - (size_t)length { OF_UNRECOGNIZED_SELECTOR } -- (size_t)cStringLengthWithEncoding: (of_string_encoding_t)encoding +- (size_t)cStringLengthWithEncoding: (OFStringEncoding)encoding { switch (encoding) { - case OF_STRING_ENCODING_UTF_8:; - const of_unichar_t *characters; + case OFStringEncodingUTF8:; + const OFUnichar *characters; size_t length, UTF8StringLength = 0; characters = self.characters; length = self.length; for (size_t i = 0; i < length; i++) { char buffer[4]; - size_t len = of_string_utf8_encode(characters[i], - buffer); + size_t len = OFUTF8StringEncode(characters[i], buffer); if (len == 0) @throw [OFInvalidEncodingException exception]; UTF8StringLength += len; } return UTF8StringLength; - case OF_STRING_ENCODING_ASCII: - case OF_STRING_ENCODING_ISO_8859_1: - case OF_STRING_ENCODING_ISO_8859_2: - case OF_STRING_ENCODING_ISO_8859_3: - case OF_STRING_ENCODING_ISO_8859_15: - case OF_STRING_ENCODING_WINDOWS_1251: - case OF_STRING_ENCODING_WINDOWS_1252: - case OF_STRING_ENCODING_CODEPAGE_437: - case OF_STRING_ENCODING_CODEPAGE_850: - case OF_STRING_ENCODING_CODEPAGE_858: - case OF_STRING_ENCODING_MAC_ROMAN: - case OF_STRING_ENCODING_KOI8_R: - case OF_STRING_ENCODING_KOI8_U: + case OFStringEncodingASCII: + case OFStringEncodingISO8859_1: + case OFStringEncodingISO8859_2: + case OFStringEncodingISO8859_3: + case OFStringEncodingISO8859_15: + case OFStringEncodingWindows1251: + case OFStringEncodingWindows1252: + case OFStringEncodingCodepage437: + case OFStringEncodingCodepage850: + case OFStringEncodingCodepage858: + case OFStringEncodingMacRoman: + case OFStringEncodingKOI8R: + case OFStringEncodingKOI8U: return self.length; default: @throw [OFInvalidEncodingException exception]; } } - (size_t)UTF8StringLength { - return [self cStringLengthWithEncoding: OF_STRING_ENCODING_UTF_8]; + return [self cStringLengthWithEncoding: OFStringEncodingUTF8]; } -- (of_unichar_t)characterAtIndex: (size_t)idx +- (OFUnichar)characterAtIndex: (size_t)idx { OF_UNRECOGNIZED_SELECTOR } -- (void)getCharacters: (of_unichar_t *)buffer - inRange: (of_range_t)range +- (void)getCharacters: (OFUnichar *)buffer + inRange: (OFRange)range { for (size_t i = 0; i < range.length; i++) buffer[i] = [self characterAtIndex: range.location + i]; } - (bool)isEqual: (id)object { void *pool; - OFString *otherString; - const of_unichar_t *characters, *otherCharacters; + OFString *string; + const OFUnichar *characters, *otherCharacters; size_t length; if (object == self) return true; if (![object isKindOfClass: [OFString class]]) return false; - otherString = object; + string = object; length = self.length; - if (otherString.length != length) + if (string.length != length) return false; pool = objc_autoreleasePoolPush(); characters = self.characters; - otherCharacters = otherString.characters; + otherCharacters = string.characters; if (memcmp(characters, otherCharacters, - length * sizeof(of_unichar_t)) != 0) { + length * sizeof(OFUnichar)) != 0) { objc_autoreleasePoolPop(pool); return false; } objc_autoreleasePoolPop(pool); @@ -1566,131 +1563,129 @@ - (id)mutableCopy { return [[OFMutableString alloc] initWithString: self]; } -- (of_comparison_result_t)compare: (id )object +- (OFComparisonResult)compare: (OFString *)string { void *pool; - OFString *otherString; - const of_unichar_t *characters, *otherCharacters; + const OFUnichar *characters, *otherCharacters; size_t minimumLength; - if (object == self) - return OF_ORDERED_SAME; + if (string == self) + return OFOrderedSame; - if (![(id)object isKindOfClass: [OFString class]]) + if (![string isKindOfClass: [OFString class]]) @throw [OFInvalidArgumentException exception]; - otherString = (OFString *)object; - minimumLength = (self.length > otherString.length - ? otherString.length : self.length); + minimumLength = (self.length > string.length + ? string.length : self.length); pool = objc_autoreleasePoolPush(); characters = self.characters; - otherCharacters = otherString.characters; + otherCharacters = string.characters; for (size_t i = 0; i < minimumLength; i++) { if (characters[i] > otherCharacters[i]) { objc_autoreleasePoolPop(pool); - return OF_ORDERED_DESCENDING; + return OFOrderedDescending; } if (characters[i] < otherCharacters[i]) { objc_autoreleasePoolPop(pool); - return OF_ORDERED_ASCENDING; + return OFOrderedAscending; } } objc_autoreleasePoolPop(pool); - if (self.length > otherString.length) - return OF_ORDERED_DESCENDING; - if (self.length < otherString.length) - return OF_ORDERED_ASCENDING; + if (self.length > string.length) + return OFOrderedDescending; + if (self.length < string.length) + return OFOrderedAscending; - return OF_ORDERED_SAME; + return OFOrderedSame; } -- (of_comparison_result_t)caseInsensitiveCompare: (OFString *)otherString +- (OFComparisonResult)caseInsensitiveCompare: (OFString *)string { void *pool = objc_autoreleasePoolPush(); - const of_unichar_t *characters, *otherCharacters; + const OFUnichar *characters, *otherCharacters; size_t length, otherLength, minimumLength; - if (otherString == self) - return OF_ORDERED_SAME; + if (string == self) + return OFOrderedSame; characters = self.characters; - otherCharacters = otherString.characters; + otherCharacters = string.characters; length = self.length; - otherLength = otherString.length; + otherLength = string.length; minimumLength = (length > otherLength ? otherLength : length); for (size_t i = 0; i < minimumLength; i++) { - of_unichar_t c = characters[i]; - of_unichar_t oc = otherCharacters[i]; + OFUnichar c = characters[i]; + OFUnichar oc = otherCharacters[i]; #ifdef OF_HAVE_UNICODE_TABLES - if (c >> 8 < OF_UNICODE_CASEFOLDING_TABLE_SIZE) { - of_unichar_t tc = - of_unicode_casefolding_table[c >> 8][c & 0xFF]; + if (c >> 8 < OFUnicodeCaseFoldingTableSize) { + OFUnichar tc = + OFUnicodeCaseFoldingTable[c >> 8][c & 0xFF]; if (tc) c = tc; } - if (oc >> 8 < OF_UNICODE_CASEFOLDING_TABLE_SIZE) { - of_unichar_t tc = - of_unicode_casefolding_table[oc >> 8][oc & 0xFF]; + if (oc >> 8 < OFUnicodeCaseFoldingTableSize) { + OFUnichar tc = + OFUnicodeCaseFoldingTable[oc >> 8][oc & 0xFF]; if (tc) oc = tc; } #else - c = of_ascii_toupper(c); - oc = of_ascii_toupper(oc); + c = OFASCIIToUpper(c); + oc = OFASCIIToUpper(oc); #endif if (c > oc) { objc_autoreleasePoolPop(pool); - return OF_ORDERED_DESCENDING; + return OFOrderedDescending; } if (c < oc) { objc_autoreleasePoolPop(pool); - return OF_ORDERED_ASCENDING; + return OFOrderedAscending; } } objc_autoreleasePoolPop(pool); if (length > otherLength) - return OF_ORDERED_DESCENDING; + return OFOrderedDescending; if (length < otherLength) - return OF_ORDERED_ASCENDING; + return OFOrderedAscending; - return OF_ORDERED_SAME; + return OFOrderedSame; } - (unsigned long)hash { - const of_unichar_t *characters = self.characters; + const OFUnichar *characters = self.characters; size_t length = self.length; - uint32_t hash; + unsigned long hash; - OF_HASH_INIT(hash); + OFHashInit(&hash); for (size_t i = 0; i < length; i++) { - const of_unichar_t c = characters[i]; + const OFUnichar c = characters[i]; - OF_HASH_ADD(hash, (c & 0xFF0000) >> 16); - OF_HASH_ADD(hash, (c & 0x00FF00) >> 8); - OF_HASH_ADD(hash, c & 0x0000FF); + OFHashAdd(&hash, (c & 0xFF0000) >> 16); + OFHashAdd(&hash, (c & 0x00FF00) >> 8); + OFHashAdd(&hash, c & 0x0000FF); } - OF_HASH_FINALIZE(hash); + OFHashFinalize(&hash); return hash; } - (OFString *)description @@ -1708,11 +1703,11 @@ className = @"OFMutableString"; else className = @"OFString"; element = [OFXMLElement elementWithName: className - namespace: OF_SERIALIZATION_NS + namespace: OFSerializationNS stringValue: self]; [element retain]; objc_autoreleasePoolPop(pool); @@ -1720,47 +1715,40 @@ return [element autorelease]; } - (OFString *)JSONRepresentation { - return [self of_JSONRepresentationWithOptions: 0 - depth: 0]; + return [self of_JSONRepresentationWithOptions: 0 depth: 0]; } -- (OFString *)JSONRepresentationWithOptions: (int)options +- (OFString *)JSONRepresentationWithOptions: + (OFJSONRepresentationOptions)options { - return [self of_JSONRepresentationWithOptions: options - depth: 0]; + return [self of_JSONRepresentationWithOptions: options depth: 0]; } -- (OFString *)of_JSONRepresentationWithOptions: (int)options - depth: (size_t)depth +- (OFString *) + of_JSONRepresentationWithOptions: (OFJSONRepresentationOptions)options + depth: (size_t)depth { OFMutableString *JSON = [[self mutableCopy] autorelease]; /* FIXME: This is slow! Write it in pure C! */ - [JSON replaceOccurrencesOfString: @"\\" - withString: @"\\\\"]; - [JSON replaceOccurrencesOfString: @"\"" - withString: @"\\\""]; - [JSON replaceOccurrencesOfString: @"\b" - withString: @"\\b"]; - [JSON replaceOccurrencesOfString: @"\f" - withString: @"\\f"]; - [JSON replaceOccurrencesOfString: @"\r" - withString: @"\\r"]; - [JSON replaceOccurrencesOfString: @"\t" - withString: @"\\t"]; - - if (options & OF_JSON_REPRESENTATION_JSON5) { - [JSON replaceOccurrencesOfString: @"\n" - withString: @"\\\n"]; - - if (options & OF_JSON_REPRESENTATION_IDENTIFIER) { + [JSON replaceOccurrencesOfString: @"\\" withString: @"\\\\"]; + [JSON replaceOccurrencesOfString: @"\"" withString: @"\\\""]; + [JSON replaceOccurrencesOfString: @"\b" withString: @"\\b"]; + [JSON replaceOccurrencesOfString: @"\f" withString: @"\\f"]; + [JSON replaceOccurrencesOfString: @"\r" withString: @"\\r"]; + [JSON replaceOccurrencesOfString: @"\t" withString: @"\\t"]; + + if (options & OFJSONRepresentationOptionJSON5) { + [JSON replaceOccurrencesOfString: @"\n" withString: @"\\\n"]; + + if (options & OFJSONRepresentationOptionIsIdentifier) { const char *cString = self.UTF8String; - if ((!of_ascii_isalpha(cString[0]) && + if ((!OFASCIIIsAlpha(cString[0]) && cString[0] != '_' && cString[0] != '$') || strpbrk(cString, " \n\r\t\b\f\\\"'") != NULL) { [JSON prependString: @"\""]; [JSON appendString: @"\""]; } @@ -1767,12 +1755,11 @@ } else { [JSON prependString: @"\""]; [JSON appendString: @"\""]; } } else { - [JSON replaceOccurrencesOfString: @"\n" - withString: @"\\n"]; + [JSON replaceOccurrencesOfString: @"\n" withString: @"\\n"]; [JSON prependString: @"\""]; [JSON appendString: @"\""]; } @@ -1789,100 +1776,88 @@ length = self.UTF8StringLength; if (length <= 31) { uint8_t tmp = 0xA0 | ((uint8_t)length & 0x1F); - data = [OFMutableData dataWithItemSize: 1 - capacity: length + 1]; - + data = [OFMutableData dataWithCapacity: length + 1]; [data addItem: &tmp]; } else if (length <= UINT8_MAX) { uint8_t type = 0xD9; uint8_t tmp = (uint8_t)length; - data = [OFMutableData dataWithItemSize: 1 - capacity: length + 2]; - + data = [OFMutableData dataWithCapacity: length + 2]; [data addItem: &type]; [data addItem: &tmp]; } else if (length <= UINT16_MAX) { uint8_t type = 0xDA; - uint16_t tmp = OF_BSWAP16_IF_LE((uint16_t)length); + uint16_t tmp = OFToBigEndian16((uint16_t)length); - data = [OFMutableData dataWithItemSize: 1 - capacity: length + 3]; - + data = [OFMutableData dataWithCapacity: length + 3]; [data addItem: &type]; - [data addItems: &tmp - count: sizeof(tmp)]; + [data addItems: &tmp count: sizeof(tmp)]; } else if (length <= UINT32_MAX) { uint8_t type = 0xDB; - uint32_t tmp = OF_BSWAP32_IF_LE((uint32_t)length); + uint32_t tmp = OFToBigEndian32((uint32_t)length); - data = [OFMutableData dataWithItemSize: 1 - capacity: length + 5]; - + data = [OFMutableData dataWithCapacity: length + 5]; [data addItem: &type]; - [data addItems: &tmp - count: sizeof(tmp)]; + [data addItems: &tmp count: sizeof(tmp)]; } else @throw [OFOutOfRangeException exception]; - [data addItems: self.UTF8String - count: length]; + [data addItems: self.UTF8String count: length]; return data; } -- (of_range_t)rangeOfString: (OFString *)string +- (OFRange)rangeOfString: (OFString *)string { return [self rangeOfString: string options: 0 - range: of_range(0, self.length)]; + range: OFRangeMake(0, self.length)]; } -- (of_range_t)rangeOfString: (OFString *)string - options: (int)options +- (OFRange)rangeOfString: (OFString *)string + options: (OFStringSearchOptions)options { return [self rangeOfString: string options: options - range: of_range(0, self.length)]; + range: OFRangeMake(0, self.length)]; } -- (of_range_t)rangeOfString: (OFString *)string - options: (int)options - range: (of_range_t)range +- (OFRange)rangeOfString: (OFString *)string + options: (OFStringSearchOptions)options + range: (OFRange)range { void *pool; - const of_unichar_t *searchCharacters; - of_unichar_t *characters; + const OFUnichar *searchCharacters; + OFUnichar *characters; size_t searchLength; if ((searchLength = string.length) == 0) - return of_range(0, 0); + return OFRangeMake(0, 0); if (searchLength > range.length) - return of_range(OF_NOT_FOUND, 0); + return OFRangeMake(OFNotFound, 0); - if (range.length > SIZE_MAX / sizeof(of_unichar_t)) + if (range.length > SIZE_MAX / sizeof(OFUnichar)) @throw [OFOutOfRangeException exception]; pool = objc_autoreleasePoolPush(); searchCharacters = string.characters; - characters = of_alloc(range.length, sizeof(of_unichar_t)); + characters = OFAllocMemory(range.length, sizeof(OFUnichar)); @try { - [self getCharacters: characters - inRange: range]; + [self getCharacters: characters inRange: range]; - if (options & OF_STRING_SEARCH_BACKWARDS) { + if (options & OFStringSearchBackwards) { for (size_t i = range.length - searchLength;; i--) { if (memcmp(characters + i, searchCharacters, - searchLength * sizeof(of_unichar_t)) == 0) { + searchLength * sizeof(OFUnichar)) == 0) { objc_autoreleasePoolPop(pool); - return of_range(range.location + i, + return OFRangeMake(range.location + i, searchLength); } /* No match and we're at the last character */ if (i == 0) @@ -1890,62 +1865,61 @@ } } else { for (size_t i = 0; i <= range.length - searchLength; i++) { if (memcmp(characters + i, searchCharacters, - searchLength * sizeof(of_unichar_t)) == 0) { + searchLength * sizeof(OFUnichar)) == 0) { objc_autoreleasePoolPop(pool); - return of_range(range.location + i, + return OFRangeMake(range.location + i, searchLength); } } } } @finally { - free(characters); + OFFreeMemory(characters); } objc_autoreleasePoolPop(pool); - return of_range(OF_NOT_FOUND, 0); + return OFRangeMake(OFNotFound, 0); } - (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet { return [self indexOfCharacterFromSet: characterSet options: 0 - range: of_range(0, self.length)]; -} - -- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet - options: (int)options -{ - return [self indexOfCharacterFromSet: characterSet - options: options - range: of_range(0, self.length)]; -} - -- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet - options: (int)options - range: (of_range_t)range -{ - bool (*characterIsMember)(id, SEL, of_unichar_t) = - (bool (*)(id, SEL, of_unichar_t))[characterSet - methodForSelector: @selector(characterIsMember:)]; - of_unichar_t *characters; - - if (range.length == 0) - return OF_NOT_FOUND; - - if (range.length > SIZE_MAX / sizeof(of_unichar_t)) - @throw [OFOutOfRangeException exception]; - - characters = of_alloc(range.length, sizeof(of_unichar_t)); - @try { - [self getCharacters: characters - inRange: range]; - - if (options & OF_STRING_SEARCH_BACKWARDS) { + range: OFRangeMake(0, self.length)]; +} + +- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet + options: (OFStringSearchOptions)options +{ + return [self indexOfCharacterFromSet: characterSet + options: options + range: OFRangeMake(0, self.length)]; +} + +- (size_t)indexOfCharacterFromSet: (OFCharacterSet *)characterSet + options: (OFStringSearchOptions)options + range: (OFRange)range +{ + bool (*characterIsMember)(id, SEL, OFUnichar) = + (bool (*)(id, SEL, OFUnichar))[characterSet + methodForSelector: @selector(characterIsMember:)]; + OFUnichar *characters; + + if (range.length == 0) + return OFNotFound; + + if (range.length > SIZE_MAX / sizeof(OFUnichar)) + @throw [OFOutOfRangeException exception]; + + characters = OFAllocMemory(range.length, sizeof(OFUnichar)); + @try { + [self getCharacters: characters inRange: range]; + + if (options & OFStringSearchBackwards) { for (size_t i = range.length - 1;; i--) { if (characterIsMember(characterSet, @selector(characterIsMember:), characters[i])) return range.location + i; @@ -1960,20 +1934,20 @@ @selector(characterIsMember:), characters[i])) return range.location + i; } } @finally { - free(characters); + OFFreeMemory(characters); } - return OF_NOT_FOUND; + return OFNotFound; } - (bool)containsString: (OFString *)string { void *pool; - const of_unichar_t *characters, *searchCharacters; + const OFUnichar *characters, *searchCharacters; size_t length, searchLength; if ((searchLength = string.length) == 0) return true; @@ -1985,11 +1959,11 @@ characters = self.characters; searchCharacters = string.characters; for (size_t i = 0; i <= length - searchLength; i++) { if (memcmp(characters + i, searchCharacters, - searchLength * sizeof(of_unichar_t)) == 0) { + searchLength * sizeof(OFUnichar)) == 0) { objc_autoreleasePoolPop(pool); return true; } } @@ -1998,19 +1972,19 @@ return false; } - (OFString *)substringFromIndex: (size_t)idx { - return [self substringWithRange: of_range(idx, self.length - idx)]; + return [self substringWithRange: OFRangeMake(idx, self.length - idx)]; } - (OFString *)substringToIndex: (size_t)idx { - return [self substringWithRange: of_range(0, idx)]; + return [self substringWithRange: OFRangeMake(0, idx)]; } -- (OFString *)substringWithRange: (of_range_t)range +- (OFString *)substringWithRange: (OFRange)range { void *pool; OFString *ret; if (range.length > SIZE_MAX - range.location || @@ -2042,210 +2016,174 @@ { OFString *ret; va_list arguments; va_start(arguments, format); - ret = [self stringByAppendingFormat: format - arguments: arguments]; + ret = [self stringByAppendingFormat: format arguments: arguments]; va_end(arguments); return ret; } - (OFString *)stringByAppendingFormat: (OFConstantString *)format arguments: (va_list)arguments { - OFMutableString *new; - - new = [OFMutableString stringWithString: self]; - [new appendFormat: format - arguments: arguments]; - + OFMutableString *new = [OFMutableString stringWithString: self]; + [new appendFormat: format arguments: arguments]; [new makeImmutable]; - return new; } - (OFString *)stringByPrependingString: (OFString *)string { OFMutableString *new = [[string mutableCopy] autorelease]; - [new appendString: self]; - [new makeImmutable]; - return new; } - (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string withString: (OFString *)replacement { OFMutableString *new = [[self mutableCopy] autorelease]; - - [new replaceOccurrencesOfString: string - withString: replacement]; - + [new replaceOccurrencesOfString: string withString: replacement]; [new makeImmutable]; - return new; } - (OFString *)stringByReplacingOccurrencesOfString: (OFString *)string withString: (OFString *)replacement options: (int)options - range: (of_range_t)range + range: (OFRange)range { OFMutableString *new = [[self mutableCopy] autorelease]; - [new replaceOccurrencesOfString: string withString: replacement options: options range: range]; - [new makeImmutable]; - return new; } - (OFString *)uppercaseString { OFMutableString *new = [[self mutableCopy] autorelease]; - [new uppercase]; - [new makeImmutable]; - return new; } - (OFString *)lowercaseString { OFMutableString *new = [[self mutableCopy] autorelease]; - [new lowercase]; - [new makeImmutable]; - return new; } - (OFString *)capitalizedString { OFMutableString *new = [[self mutableCopy] autorelease]; - [new capitalize]; - [new makeImmutable]; - return new; } - (OFString *)stringByDeletingLeadingWhitespaces { OFMutableString *new = [[self mutableCopy] autorelease]; - [new deleteLeadingWhitespaces]; - [new makeImmutable]; - return new; } - (OFString *)stringByDeletingTrailingWhitespaces { OFMutableString *new = [[self mutableCopy] autorelease]; - [new deleteTrailingWhitespaces]; - [new makeImmutable]; - return new; } - (OFString *)stringByDeletingEnclosingWhitespaces { OFMutableString *new = [[self mutableCopy] autorelease]; - [new deleteEnclosingWhitespaces]; - [new makeImmutable]; - return new; } - (bool)hasPrefix: (OFString *)prefix { - of_unichar_t *tmp; + OFUnichar *tmp; size_t prefixLength; bool hasPrefix; if ((prefixLength = prefix.length) > self.length) return false; - tmp = of_alloc(prefixLength, sizeof(of_unichar_t)); + tmp = OFAllocMemory(prefixLength, sizeof(OFUnichar)); @try { void *pool = objc_autoreleasePoolPush(); - [self getCharacters: tmp - inRange: of_range(0, prefixLength)]; + [self getCharacters: tmp inRange: OFRangeMake(0, prefixLength)]; hasPrefix = (memcmp(tmp, prefix.characters, - prefixLength * sizeof(of_unichar_t)) == 0); + prefixLength * sizeof(OFUnichar)) == 0); objc_autoreleasePoolPop(pool); } @finally { - free(tmp); + OFFreeMemory(tmp); } return hasPrefix; } - (bool)hasSuffix: (OFString *)suffix { - of_unichar_t *tmp; - const of_unichar_t *suffixCharacters; + OFUnichar *tmp; + const OFUnichar *suffixCharacters; size_t length, suffixLength; bool hasSuffix; if ((suffixLength = suffix.length) > self.length) return false; length = self.length; - tmp = of_alloc(suffixLength, sizeof(of_unichar_t)); + tmp = OFAllocMemory(suffixLength, sizeof(OFUnichar)); @try { void *pool = objc_autoreleasePoolPush(); [self getCharacters: tmp - inRange: of_range(length - suffixLength, + inRange: OFRangeMake(length - suffixLength, suffixLength)]; suffixCharacters = suffix.characters; hasSuffix = (memcmp(tmp, suffixCharacters, - suffixLength * sizeof(of_unichar_t)) == 0); + suffixLength * sizeof(OFUnichar)) == 0); objc_autoreleasePoolPop(pool); } @finally { - free(tmp); + OFFreeMemory(tmp); } return hasSuffix; } - (OFArray *)componentsSeparatedByString: (OFString *)delimiter { - return [self componentsSeparatedByString: delimiter - options: 0]; + return [self componentsSeparatedByString: delimiter options: 0]; } - (OFArray *)componentsSeparatedByString: (OFString *)delimiter - options: (int)options + options: (OFStringSeparationOptions)options { void *pool; OFMutableArray *array; - const of_unichar_t *characters, *delimiterCharacters; - bool skipEmpty = (options & OF_STRING_SKIP_EMPTY); + const OFUnichar *characters, *delimiterCharacters; + bool skipEmpty = (options & OFStringSkipEmptyComponents); size_t length = self.length; size_t delimiterLength = delimiter.length; size_t last; OFString *component; @@ -2271,21 +2209,22 @@ } last = 0; for (size_t i = 0; i <= length - delimiterLength; i++) { if (memcmp(characters + i, delimiterCharacters, - delimiterLength * sizeof(of_unichar_t)) != 0) + delimiterLength * sizeof(OFUnichar)) != 0) continue; - component = [self substringWithRange: of_range(last, i - last)]; + component = [self substringWithRange: + OFRangeMake(last, i - last)]; if (!skipEmpty || component.length > 0) [array addObject: component]; i += delimiterLength - 1; last = i + 1; } - component = [self substringWithRange: of_range(last, length - last)]; + component = [self substringWithRange: OFRangeMake(last, length - last)]; if (!skipEmpty || component.length > 0) [array addObject: component]; [array makeImmutable]; @@ -2301,38 +2240,38 @@ options: 0]; } - (OFArray *) componentsSeparatedByCharactersInSet: (OFCharacterSet *)characterSet - options: (int)options + options: (OFStringSeparationOptions)options { OFMutableArray *array = [OFMutableArray array]; void *pool = objc_autoreleasePoolPush(); - bool skipEmpty = (options & OF_STRING_SKIP_EMPTY); - const of_unichar_t *characters = self.characters; + bool skipEmpty = (options & OFStringSkipEmptyComponents); + const OFUnichar *characters = self.characters; size_t length = self.length; - bool (*characterIsMember)(id, SEL, of_unichar_t) = - (bool (*)(id, SEL, of_unichar_t))[characterSet + bool (*characterIsMember)(id, SEL, OFUnichar) = + (bool (*)(id, SEL, OFUnichar))[characterSet methodForSelector: @selector(characterIsMember:)]; size_t last; last = 0; for (size_t i = 0; i < length; i++) { if (characterIsMember(characterSet, @selector(characterIsMember:), characters[i])) { if (!skipEmpty || i != last) { OFString *component = [self substringWithRange: - of_range(last, i - last)]; + OFRangeMake(last, i - last)]; [array addObject: component]; } last = i + 1; } } if (!skipEmpty || length != last) { OFString *component = [self substringWithRange: - of_range(last, length - last)]; + OFRangeMake(last, length - last)]; [array addObject: component]; } [array makeImmutable]; @@ -2351,11 +2290,11 @@ void *pool = objc_autoreleasePoolPush(); const char *UTF8String = self.UTF8String; bool negative = false; long long value = 0; - while (of_ascii_isspace(*UTF8String)) + while (OFASCIIIsSpace(*UTF8String)) UTF8String++; switch (*UTF8String) { case '-': negative = true; @@ -2382,19 +2321,19 @@ if (base == 0) base = 10; while (*UTF8String != '\0') { - unsigned char c = of_ascii_toupper(*UTF8String++); + unsigned char c = OFASCIIToUpper(*UTF8String++); if (c >= '0' && c <= '9') c -= '0'; else if (c >= 'A' && c <= 'Z') c -= ('A' - 10); - else if (of_ascii_isspace(c)) { + else if (OFASCIIIsSpace(c)) { while (*UTF8String != '\0') - if (!of_ascii_isspace(*UTF8String++)) + if (!OFASCIIIsSpace(*UTF8String++)) @throw [OFInvalidFormatException exception]; break; } else @@ -2426,11 +2365,11 @@ { void *pool = objc_autoreleasePoolPush(); const char *UTF8String = self.UTF8String; unsigned long long value = 0; - while (of_ascii_isspace(*UTF8String)) + while (OFASCIIIsSpace(*UTF8String)) UTF8String++; switch (*UTF8String) { case '-': @throw [OFInvalidFormatException exception]; @@ -2457,19 +2396,19 @@ if (base == 0) base = 10; while (*UTF8String != '\0') { - unsigned char c = of_ascii_toupper(*UTF8String++); + unsigned char c = OFASCIIToUpper(*UTF8String++); if (c >= '0' && c <= '9') c -= '0'; else if (c >= 'A' && c <= 'Z') c -= ('A' - 10); - else if (of_ascii_isspace(c)) { + else if (OFASCIIIsSpace(c)) { while (*UTF8String != '\0') - if (!of_ascii_isspace(*UTF8String++)) + if (!OFASCIIIsSpace(*UTF8String++)) @throw [OFInvalidFormatException exception]; break; } else @@ -2493,19 +2432,19 @@ - (float)floatValue { void *pool = objc_autoreleasePoolPush(); OFString *stripped = self.stringByDeletingEnclosingWhitespaces; - if ([stripped caseInsensitiveCompare: @"INF"] == OF_ORDERED_SAME || - [stripped caseInsensitiveCompare: @"INFINITY"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"INF"] == OFOrderedSame || + [stripped caseInsensitiveCompare: @"INFINITY"] == OFOrderedSame) return INFINITY; - if ([stripped caseInsensitiveCompare: @"-INF"] == OF_ORDERED_SAME || - [stripped caseInsensitiveCompare: @"-INFINITY"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"-INF"] == OFOrderedSame || + [stripped caseInsensitiveCompare: @"-INFINITY"] == OFOrderedSame) return -INFINITY; - if ([stripped caseInsensitiveCompare: @"NAN"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"NAN"] == OFOrderedSame) return NAN; - if ([stripped caseInsensitiveCompare: @"-NAN"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"-NAN"] == OFOrderedSame) return -NAN; #ifdef HAVE_STRTOF_L const char *UTF8String = self.UTF8String; #else @@ -2516,28 +2455,28 @@ OFString *decimalPoint = [OFLocale decimalPoint]; const char *UTF8String = [self stringByReplacingOccurrencesOfString: @"." withString: decimalPoint].UTF8String; #endif - char *endPointer = NULL; + char *endPtr = NULL; float value; errno = 0; #ifdef HAVE_STRTOF_L - value = strtof_l(UTF8String, &endPointer, cLocale); + value = strtof_l(UTF8String, &endPtr, cLocale); #else - value = strtof(UTF8String, &endPointer); + value = strtof(UTF8String, &endPtr); #endif if (value == HUGE_VALF && errno == ERANGE) @throw [OFOutOfRangeException exception]; /* Check if there are any invalid chars left */ - if (endPointer != NULL) - for (; *endPointer != '\0'; endPointer++) + if (endPtr != NULL) + for (; *endPtr != '\0'; endPtr++) /* Use isspace since strtof uses the same. */ - if (!isspace((unsigned char)*endPointer)) + if (!isspace((unsigned char)*endPtr)) @throw [OFInvalidFormatException exception]; objc_autoreleasePoolPop(pool); return value; @@ -2546,19 +2485,19 @@ - (double)doubleValue { void *pool = objc_autoreleasePoolPush(); OFString *stripped = self.stringByDeletingEnclosingWhitespaces; - if ([stripped caseInsensitiveCompare: @"INF"] == OF_ORDERED_SAME || - [stripped caseInsensitiveCompare: @"INFINITY"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"INF"] == OFOrderedSame || + [stripped caseInsensitiveCompare: @"INFINITY"] == OFOrderedSame) return INFINITY; - if ([stripped caseInsensitiveCompare: @"-INF"] == OF_ORDERED_SAME || - [stripped caseInsensitiveCompare: @"-INFINITY"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"-INF"] == OFOrderedSame || + [stripped caseInsensitiveCompare: @"-INFINITY"] == OFOrderedSame) return -INFINITY; - if ([stripped caseInsensitiveCompare: @"NAN"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"NAN"] == OFOrderedSame) return NAN; - if ([stripped caseInsensitiveCompare: @"-NAN"] == OF_ORDERED_SAME) + if ([stripped caseInsensitiveCompare: @"-NAN"] == OFOrderedSame) return -NAN; #ifdef HAVE_STRTOD_L const char *UTF8String = self.UTF8String; #else @@ -2569,88 +2508,88 @@ OFString *decimalPoint = [OFLocale decimalPoint]; const char *UTF8String = [self stringByReplacingOccurrencesOfString: @"." withString: decimalPoint].UTF8String; #endif - char *endPointer = NULL; + char *endPtr = NULL; double value; errno = 0; #ifdef HAVE_STRTOD_L - value = strtod_l(UTF8String, &endPointer, cLocale); + value = strtod_l(UTF8String, &endPtr, cLocale); #else - value = strtod(UTF8String, &endPointer); + value = strtod(UTF8String, &endPtr); #endif if (value == HUGE_VAL && errno == ERANGE) @throw [OFOutOfRangeException exception]; /* Check if there are any invalid chars left */ - if (endPointer != NULL) - for (; *endPointer != '\0'; endPointer++) + if (endPtr != NULL) + for (; *endPtr != '\0'; endPtr++) /* Use isspace since strtod uses the same. */ - if (!isspace((unsigned char)*endPointer)) + if (!isspace((unsigned char)*endPtr)) @throw [OFInvalidFormatException exception]; objc_autoreleasePoolPop(pool); return value; } -- (const of_unichar_t *)characters +- (const OFUnichar *)characters { size_t length = self.length; - of_unichar_t *buffer; + OFUnichar *buffer; - buffer = of_alloc(length, sizeof(of_unichar_t)); + buffer = OFAllocMemory(length, sizeof(OFUnichar)); @try { - [self getCharacters: buffer - inRange: of_range(0, length)]; + [self getCharacters: buffer inRange: OFRangeMake(0, length)]; return [[OFData dataWithItemsNoCopy: buffer count: length - itemSize: sizeof(of_unichar_t) + itemSize: sizeof(OFUnichar) freeWhenDone: true] items]; } @catch (id e) { - free(buffer); + OFFreeMemory(buffer); @throw e; } } -- (const of_char16_t *)UTF16String +- (const OFChar16 *)UTF16String { - return [self UTF16StringWithByteOrder: OF_BYTE_ORDER_NATIVE]; + return [self UTF16StringWithByteOrder: OFByteOrderNative]; } -- (const of_char16_t *)UTF16StringWithByteOrder: (of_byte_order_t)byteOrder +- (const OFChar16 *)UTF16StringWithByteOrder: (OFByteOrder)byteOrder { void *pool = objc_autoreleasePoolPush(); - const of_unichar_t *characters = self.characters; + const OFUnichar *characters = self.characters; size_t length = self.length; - of_char16_t *buffer; + OFChar16 *buffer; size_t j; - bool swap = (byteOrder != OF_BYTE_ORDER_NATIVE); + bool swap = (byteOrder != OFByteOrderNative); /* Allocate memory for the worst case */ - buffer = of_alloc((length + 1) * 2, sizeof(of_char16_t)); + buffer = OFAllocMemory((length + 1) * 2, sizeof(OFChar16)); j = 0; for (size_t i = 0; i < length; i++) { - of_unichar_t c = characters[i]; + OFUnichar c = characters[i]; if (c > 0x10FFFF) { - free(buffer); + OFFreeMemory(buffer); @throw [OFInvalidEncodingException exception]; } if (swap) { if (c > 0xFFFF) { c -= 0x10000; - buffer[j++] = OF_BSWAP16(0xD800 | (c >> 10)); - buffer[j++] = OF_BSWAP16(0xDC00 | (c & 0x3FF)); + buffer[j++] = OFByteSwap16(0xD800 | (c >> 10)); + buffer[j++] = + OFByteSwap16(0xDC00 | (c & 0x3FF)); } else - buffer[j++] = OF_BSWAP16(c); + buffer[j++] = OFByteSwap16(c); } else { if (c > 0xFFFF) { c -= 0x10000; buffer[j++] = 0xD800 | (c >> 10); buffer[j++] = 0xDC00 | (c & 0x3FF); @@ -2659,31 +2598,31 @@ } } buffer[j] = 0; @try { - buffer = of_realloc(buffer, j + 1, sizeof(of_char16_t)); + buffer = OFResizeMemory(buffer, j + 1, sizeof(OFChar16)); } @catch (OFOutOfMemoryException *e) { /* We don't care, as we only tried to make it smaller */ } objc_autoreleasePoolPop(pool); @try { return [[OFData dataWithItemsNoCopy: buffer count: j + 1 - itemSize: sizeof(of_char16_t) + itemSize: sizeof(OFChar16) freeWhenDone: true] items]; } @catch (id e) { - free(buffer); + OFFreeMemory(buffer); @throw e; } } - (size_t)UTF16StringLength { - const of_unichar_t *characters = self.characters; + const OFUnichar *characters = self.characters; size_t length, UTF16StringLength; length = UTF16StringLength = self.length; for (size_t i = 0; i < length; i++) @@ -2691,41 +2630,40 @@ UTF16StringLength++; return UTF16StringLength; } -- (const of_char32_t *)UTF32String +- (const OFChar32 *)UTF32String { - return [self UTF32StringWithByteOrder: OF_BYTE_ORDER_NATIVE]; + return [self UTF32StringWithByteOrder: OFByteOrderNative]; } -- (const of_char32_t *)UTF32StringWithByteOrder: (of_byte_order_t)byteOrder +- (const OFChar32 *)UTF32StringWithByteOrder: (OFByteOrder)byteOrder { size_t length = self.length; - of_char32_t *buffer; + OFChar32 *buffer; - buffer = of_alloc(length + 1, sizeof(of_char32_t)); + buffer = OFAllocMemory(length + 1, sizeof(OFChar32)); @try { - [self getCharacters: buffer - inRange: of_range(0, length)]; + [self getCharacters: buffer inRange: OFRangeMake(0, length)]; buffer[length] = 0; - if (byteOrder != OF_BYTE_ORDER_NATIVE) + if (byteOrder != OFByteOrderNative) for (size_t i = 0; i < length; i++) - buffer[i] = OF_BSWAP32(buffer[i]); + buffer[i] = OFByteSwap32(buffer[i]); return [[OFData dataWithItemsNoCopy: buffer count: length + 1 - itemSize: sizeof(of_char32_t) + itemSize: sizeof(OFChar32) freeWhenDone: true] items]; } @catch (id e) { - free(buffer); + OFFreeMemory(buffer); @throw e; } } -- (OFData *)dataWithEncoding: (of_string_encoding_t)encoding +- (OFData *)dataWithEncoding: (OFStringEncoding)encoding { void *pool = objc_autoreleasePoolPush(); OFData *data = [OFData dataWithItems: [self cStringWithEncoding: encoding] count: [self cStringLengthWithEncoding: encoding]]; @@ -2738,18 +2676,18 @@ } #ifdef OF_HAVE_UNICODE_TABLES - (OFString *)decomposedStringWithCanonicalMapping { - return decomposedString(self, of_unicode_decomposition_table, - OF_UNICODE_DECOMPOSITION_TABLE_SIZE); + return decomposedString(self, OFUnicodeDecompositionTable, + OFUnicodeDecompositionTableSize); } - (OFString *)decomposedStringWithCompatibilityMapping { - return decomposedString(self, of_unicode_decomposition_compat_table, - OF_UNICODE_DECOMPOSITION_COMPAT_TABLE_SIZE); + return decomposedString(self, OFUnicodeDecompositionCompatTable, + OFUnicodeDecompositionCompatTableSize); } #endif #ifdef OF_WINDOWS - (OFString *)stringByExpandingWindowsEnvironmentStrings @@ -2763,11 +2701,11 @@ return self; return [OFString stringWithUTF16String: buffer length: length - 1]; } else { - of_string_encoding_t encoding = [OFLocale encoding]; + OFStringEncoding encoding = [OFLocale encoding]; char buffer[512]; size_t length; if ((length = ExpandEnvironmentStringsA( [self cStringWithEncoding: encoding], buffer, @@ -2782,58 +2720,47 @@ #endif #ifdef OF_HAVE_FILES - (void)writeToFile: (OFString *)path { - [self writeToFile: path - encoding: OF_STRING_ENCODING_UTF_8]; + [self writeToFile: path encoding: OFStringEncodingUTF8]; } -- (void)writeToFile: (OFString *)path - encoding: (of_string_encoding_t)encoding +- (void)writeToFile: (OFString *)path encoding: (OFStringEncoding)encoding { void *pool = objc_autoreleasePoolPush(); - OFFile *file; - - file = [OFFile fileWithPath: path - mode: @"w"]; - [file writeString: self - encoding: encoding]; - + OFFile *file = [OFFile fileWithPath: path mode: @"w"]; + [file writeString: self encoding: encoding]; objc_autoreleasePoolPop(pool); } #endif - (void)writeToURL: (OFURL *)URL { - [self writeToURL: URL - encoding: OF_STRING_ENCODING_UTF_8]; + [self writeToURL: URL encoding: OFStringEncodingUTF8]; } -- (void)writeToURL: (OFURL *)URL - encoding: (of_string_encoding_t)encoding +- (void)writeToURL: (OFURL *)URL encoding: (OFStringEncoding)encoding { void *pool = objc_autoreleasePoolPush(); OFURLHandler *URLHandler; OFStream *stream; if ((URLHandler = [OFURLHandler handlerForURL: URL]) == nil) @throw [OFUnsupportedProtocolException exceptionWithURL: URL]; - stream = [URLHandler openItemAtURL: URL - mode: @"w"]; - [stream writeString: self - encoding: encoding]; + stream = [URLHandler openItemAtURL: URL mode: @"w"]; + [stream writeString: self encoding: encoding]; objc_autoreleasePoolPop(pool); } #ifdef OF_HAVE_BLOCKS -- (void)enumerateLinesUsingBlock: (of_string_line_enumeration_block_t)block +- (void)enumerateLinesUsingBlock: (OFStringLineEnumerationBlock)block { void *pool = objc_autoreleasePoolPush(); - const of_unichar_t *characters = self.characters; + const OFUnichar *characters = self.characters; size_t i, last = 0, length = self.length; bool stop = false, lastCarriageReturn = false; for (i = 0; i < length && !stop; i++) { if (lastCarriageReturn && characters[i] == '\n') { @@ -2845,22 +2772,22 @@ if (characters[i] == '\n' || characters[i] == '\r') { void *pool2 = objc_autoreleasePoolPush(); block([self substringWithRange: - of_range(last, i - last)], &stop); + OFRangeMake(last, i - last)], &stop); last = i + 1; objc_autoreleasePoolPop(pool2); } lastCarriageReturn = (characters[i] == '\r'); } if (!stop) - block([self substringWithRange: of_range(last, i - last)], + block([self substringWithRange: OFRangeMake(last, i - last)], &stop); objc_autoreleasePoolPop(pool); } #endif @end