CF-550.tar.gz

[apple/cf.git] / CFString.c

diff --git a/CFString.c b/CFString.c
index a9b5c501c7b93413908b1d719dd3ba17f2237f1b..ce1f36fb23d51c900cf0e1f3249e246e0da6ddd9 100644 (file)
--- a/CFString.c
+++ b/CFString.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2009 Apple Inc. All rights reserved.

  *
  * @APPLE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_LICENSE_HEADER_START@
  * 


@@ -21,7 +21,7 @@
  * @APPLE_LICENSE_HEADER_END@
  */
 /*     CFString.c
  * @APPLE_LICENSE_HEADER_END@
  */
 /*     CFString.c

-       Copyright 1998-2002, Apple, Inc. All rights reserved.
+       Copyright (c) 1998-2009, Apple Inc. All rights reserved.

        Responsibility: Ali Ozer
         
 !!! For performance reasons, it's important that all functions marked CF_INLINE in this file are inlined.
        Responsibility: Ali Ozer
         
 !!! For performance reasons, it's important that all functions marked CF_INLINE in this file are inlined.


@@ -30,18 +30,22 @@
 #include <CoreFoundation/CFBase.h>
 #include <CoreFoundation/CFString.h>
 #include <CoreFoundation/CFDictionary.h>
 #include <CoreFoundation/CFBase.h>
 #include <CoreFoundation/CFString.h>
 #include <CoreFoundation/CFDictionary.h>

-#include "CFStringEncodingConverterExt.h"
-#include "CFUniChar.h"
-#include "CFUnicodeDecomposition.h"
-#include "CFUnicodePrecomposition.h"
-#include "CFPriv.h"
+#include <CoreFoundation/CFStringEncodingConverterExt.h>
+#include <CoreFoundation/CFUniChar.h>
+#include <CoreFoundation/CFUnicodeDecomposition.h>
+#include <CoreFoundation/CFUnicodePrecomposition.h>
+#include <CoreFoundation/CFPriv.h>

 #include "CFInternal.h"
 #include "CFInternal.h"

+#include "CFLocaleInternal.h"

 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>

-#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD

 #include <unistd.h>
 #endif
 #include <unistd.h>
 #endif

+#if DEPLOYMENT_TARGET_WINDOWS
+#define strncasecmp_l(a, b, c, d) _strnicmp(a, b, c)
+#endif

 
 #if defined(__GNUC__)
 #define LONG_DOUBLE_SUPPORT 1
 
 #if defined(__GNUC__)
 #define LONG_DOUBLE_SUPPORT 1


@@ -58,8 +62,7 @@
 #define INSTRUMENT_SHARED_STRINGS 0
 #endif
 
 #define INSTRUMENT_SHARED_STRINGS 0
 #endif
 

-
-__private_extern__ CFStringRef __kCFLocaleCollatorID;
+__private_extern__ const CFStringRef __kCFLocaleCollatorID;

 
 #if INSTRUMENT_SHARED_STRINGS
 #include <sys/stat.h> /* for umask() */
 
 #if INSTRUMENT_SHARED_STRINGS
 #include <sys/stat.h> /* for umask() */


@@ -77,7 +80,7 @@ static void __CFRecordStringAllocationEvent(const char *encoding, const char *by
        if (! name) name = "UNKNOWN";
        umask(0);
        char path[1024];
        if (! name) name = "UNKNOWN";
        umask(0);
        char path[1024];

-       sprintf(path, "/tmp/CFSharedStringInstrumentation_%s_%d.txt", name, getpid());
+       snprintf(path, sizeof(path), "/tmp/CFSharedStringInstrumentation_%s_%d.txt", name, getpid());

        fd = open(path, O_WRONLY | O_APPEND | O_CREAT, 0666);
        if (fd <= 0) {
            int error = errno;
        fd = open(path, O_WRONLY | O_APPEND | O_CREAT, 0666);
        if (fd <= 0) {
            int error = errno;


@@ -88,7 +91,7 @@ static void __CFRecordStringAllocationEvent(const char *encoding, const char *by
     if (fd > 0) {
        char *buffer = NULL;
        char formatString[256];
     if (fd > 0) {
        char *buffer = NULL;
        char formatString[256];

-       sprintf(formatString, "%%-8d\t%%-16s\t%%.%lds\n", byteCount);
+       snprintf(formatString, sizeof(formatString), "%%-8d\t%%-16s\t%%.%lds\n", byteCount);

        int resultCount = asprintf(&buffer, formatString, getpid(), encoding, bytes);
        if (buffer && resultCount > 0) write(fd, buffer, resultCount);
        else puts("Couldn't record allocation event");
        int resultCount = asprintf(&buffer, formatString, getpid(), encoding, bytes);
        if (buffer && resultCount > 0) write(fd, buffer, resultCount);
        else puts("Couldn't record allocation event");


@@ -102,7 +105,7 @@ static void __CFRecordStringAllocationEvent(const char *encoding, const char *by
 
 typedef Boolean (*UNI_CHAR_FUNC)(UInt32 flags, UInt8 ch, UniChar *unicodeChar);
 
 
 typedef Boolean (*UNI_CHAR_FUNC)(UInt32 flags, UInt8 ch, UniChar *unicodeChar);
 

-#if DEPLOYMENT_TARGET_MACOSX
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED

 extern size_t malloc_good_size(size_t size);
 #endif
 extern void __CFStrConvertBytesToUnicode(const uint8_t *bytes, UniChar *buffer, CFIndex numChars);
 extern size_t malloc_good_size(size_t size);
 #endif
 extern void __CFStrConvertBytesToUnicode(const uint8_t *bytes, UniChar *buffer, CFIndex numChars);


@@ -333,7 +336,7 @@ Boolean __CFStringIsEightBit(CFStringRef str) {
 */
 CF_INLINE void __CFStrSetContentPtr(CFStringRef str, const void *p) {
     // XXX_PCB catch all writes for mutable string case.
 */
 CF_INLINE void __CFStrSetContentPtr(CFStringRef str, const void *p) {
     // XXX_PCB catch all writes for mutable string case.

-    CF_WRITE_BARRIER_BASE_ASSIGN(__CFGetAllocator(str), str, ((CFMutableStringRef)str)->variants.notInlineImmutable1.buffer, (void *)p);
+    __CFAssignWithWriteBarrier((void **)&((CFMutableStringRef)str)->variants.notInlineImmutable1.buffer, (void *)p);

 }
 CF_INLINE void __CFStrSetInfoBits(CFStringRef str, UInt32 v)           {__CFBitfieldSetValue(((CFMutableStringRef)str)->base._cfinfo[CF_INFO_BITS], 6, 0, v);}
 
 }
 CF_INLINE void __CFStrSetInfoBits(CFStringRef str, UInt32 v)           {__CFBitfieldSetValue(((CFMutableStringRef)str)->base._cfinfo[CF_INFO_BITS], 6, 0, v);}
 


@@ -385,7 +388,7 @@ static void __CFStrDeallocateMutableContents(CFMutableStringRef str, void *buffe
     CFAllocatorRef alloc = (__CFStrHasContentsAllocator(str)) ? __CFStrContentsAllocator(str) : __CFGetAllocator(str);
     if (CF_IS_COLLECTABLE_ALLOCATOR(alloc)) {
         // GC:  for finalization safety, let collector reclaim the buffer in the next GC cycle.
     CFAllocatorRef alloc = (__CFStrHasContentsAllocator(str)) ? __CFStrContentsAllocator(str) : __CFGetAllocator(str);
     if (CF_IS_COLLECTABLE_ALLOCATOR(alloc)) {
         // GC:  for finalization safety, let collector reclaim the buffer in the next GC cycle.

-        auto_zone_release(__CFCollectableZone, buffer);
+        auto_zone_release(auto_zone(), buffer);

     } else {
         CFAllocatorDeallocate(alloc, buffer);
     }
     } else {
         CFAllocatorDeallocate(alloc, buffer);
     }


@@ -411,24 +414,22 @@ static CFStringEncoding __CFDefaultSystemEncoding = kCFStringEncodingInvalidId;
 static CFStringEncoding __CFDefaultFileSystemEncoding = kCFStringEncodingInvalidId;
 CFStringEncoding __CFDefaultEightBitStringEncoding = kCFStringEncodingInvalidId;
 
 static CFStringEncoding __CFDefaultFileSystemEncoding = kCFStringEncodingInvalidId;
 CFStringEncoding __CFDefaultEightBitStringEncoding = kCFStringEncodingInvalidId;
 

-CFStringEncoding CFStringGetSystemEncoding(void) {

 
 

-    if (__CFDefaultSystemEncoding == kCFStringEncodingInvalidId) {
-        const CFStringEncodingConverter *converter = NULL;
-#if DEPLOYMENT_TARGET_MACOSX
-            __CFDefaultSystemEncoding = kCFStringEncodingMacRoman; // MacRoman is built-in so always available
-#elif defined(__WIN32__)
-            __CFDefaultSystemEncoding = kCFStringEncodingWindowsLatin1; // WinLatin1 is built-in so always available
-#elif DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
-            __CFDefaultSystemEncoding = kCFStringEncodingISOLatin1; // a reasonable default
-#else // Solaris && HP-UX ?
-            __CFDefaultSystemEncoding = kCFStringEncodingISOLatin1; // a reasonable default
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
+#define __defaultEncoding kCFStringEncodingMacRoman
+#elif DEPLOYMENT_TARGET_WINDOWS
+#define __defaultEncoding kCFStringEncodingWindowsLatin1
+#else
+#warning This value must match __CFGetConverter condition in CFStringEncodingConverter.c
+#define __defaultEncoding kCFStringEncodingISOLatin1

 #endif
 #endif

-            converter = CFStringEncodingGetConverter(__CFDefaultSystemEncoding);

 
 

-               __CFSetCharToUniCharFunc(converter->encodingClass == kCFStringEncodingConverterCheapEightBit ? (UNI_CHAR_FUNC)converter->toUnicode : NULL);
+CFStringEncoding CFStringGetSystemEncoding(void) {
+    if (__CFDefaultSystemEncoding == kCFStringEncodingInvalidId) {
+        __CFDefaultSystemEncoding = __defaultEncoding; 
+        const CFStringEncodingConverter *converter = CFStringEncodingGetConverter(__CFDefaultSystemEncoding);
+        __CFSetCharToUniCharFunc(converter->encodingClass == kCFStringEncodingConverterCheapEightBit ? (UNI_CHAR_FUNC)converter->toUnicode : NULL);

     }
     }

-

     return __CFDefaultSystemEncoding;
 }
 
     return __CFDefaultSystemEncoding;
 }
 


@@ -441,7 +442,7 @@ CF_INLINE CFStringEncoding __CFStringGetSystemEncoding(void) {
 
 CFStringEncoding CFStringFileSystemEncoding(void) {
     if (__CFDefaultFileSystemEncoding == kCFStringEncodingInvalidId) {
 
 CFStringEncoding CFStringFileSystemEncoding(void) {
     if (__CFDefaultFileSystemEncoding == kCFStringEncodingInvalidId) {

-#if DEPLOYMENT_TARGET_MACOSX
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS

         __CFDefaultFileSystemEncoding = kCFStringEncodingUTF8;
 #else
         __CFDefaultFileSystemEncoding = CFStringGetSystemEncoding();
         __CFDefaultFileSystemEncoding = kCFStringEncodingUTF8;
 #else
         __CFDefaultFileSystemEncoding = CFStringGetSystemEncoding();


@@ -452,21 +453,26 @@ CFStringEncoding CFStringFileSystemEncoding(void) {
 }
 
 /* ??? Is returning length when no other answer is available the right thing?
 }
 
 /* ??? Is returning length when no other answer is available the right thing?

+   !!! All of the (length > (LONG_MAX / N)) type checks are to avoid wrap-around and eventual malloc overflow in the client

 */
 CFIndex CFStringGetMaximumSizeForEncoding(CFIndex length, CFStringEncoding encoding) {
     if (encoding == kCFStringEncodingUTF8) {
 */
 CFIndex CFStringGetMaximumSizeForEncoding(CFIndex length, CFStringEncoding encoding) {
     if (encoding == kCFStringEncodingUTF8) {

-        return _CFExecutableLinkedOnOrAfter(CFSystemVersionPanther) ? (length * 3) : (length * 6); // 1 Unichar could expand to 3 bytes; we return 6 for older apps for compatibility
+        if (_CFExecutableLinkedOnOrAfter(CFSystemVersionPanther)) {     // 1 Unichar can expand to 3 bytes; we return 6 for older apps for compatibility
+            return (length > (LONG_MAX / 3)) ? kCFNotFound : (length * 3);
+        } else {
+            return (length > (LONG_MAX / 6)) ? kCFNotFound : (length * 6);
+        }

     } else if ((encoding == kCFStringEncodingUTF32) || (encoding == kCFStringEncodingUTF32BE) || (encoding == kCFStringEncodingUTF32LE)) { // UTF-32
     } else if ((encoding == kCFStringEncodingUTF32) || (encoding == kCFStringEncodingUTF32BE) || (encoding == kCFStringEncodingUTF32LE)) { // UTF-32

-        return length * sizeof(UTF32Char);
+        return (length > (LONG_MAX / sizeof(UTF32Char))) ? kCFNotFound : (length * sizeof(UTF32Char));

     } else {
         encoding &= 0xFFF; // Mask off non-base part
     }
     switch (encoding) {
         case kCFStringEncodingUnicode:
     } else {
         encoding &= 0xFFF; // Mask off non-base part
     }
     switch (encoding) {
         case kCFStringEncodingUnicode:

-            return length * sizeof(UniChar);
+            return (length > (LONG_MAX / sizeof(UniChar))) ? kCFNotFound : (length * sizeof(UniChar));

 
         case kCFStringEncodingNonLossyASCII:
 
         case kCFStringEncodingNonLossyASCII:

-            return length * 6; // 1 Unichar could expand to 6 bytes
+            return (length > (LONG_MAX / 6)) ? kCFNotFound : (length * 6);      // 1 Unichar can expand to 6 bytes

 
         case kCFStringEncodingMacRoman:
         case kCFStringEncodingWindowsLatin1:
 
         case kCFStringEncodingMacRoman:
         case kCFStringEncodingWindowsLatin1:


@@ -529,7 +535,9 @@ CF_INLINE Boolean __CFBytesInASCII(const uint8_t *bytes, CFIndex len) {
 /* Returns whether the provided 8-bit string in the specified encoding can be stored in an 8-bit CFString. 
 */
 CF_INLINE Boolean __CFCanUseEightBitCFStringForBytes(const uint8_t *bytes, CFIndex len, CFStringEncoding encoding) {
 /* Returns whether the provided 8-bit string in the specified encoding can be stored in an 8-bit CFString. 
 */
 CF_INLINE Boolean __CFCanUseEightBitCFStringForBytes(const uint8_t *bytes, CFIndex len, CFStringEncoding encoding) {

-    if (encoding == __CFStringGetEightBitStringEncoding()) return true;
+    // If the encoding is the same as the 8-bit CFString encoding, we can just use the bytes as-is.
+    // One exception is ASCII, which unfortunately needs to mean ISOLatin1 for compatibility reasons <rdar://problem/5458321>.
+    if (encoding == __CFStringGetEightBitStringEncoding() && encoding != kCFStringEncodingASCII) return true;

     if (__CFStringEncodingIsSupersetOfASCII(encoding) && __CFBytesInASCII(bytes, len)) return true;
     return false;
 }
     if (__CFStringEncodingIsSupersetOfASCII(encoding) && __CFBytesInASCII(bytes, len)) return true;
     return false;
 }


@@ -553,7 +561,7 @@ CF_INLINE Boolean __CFCanUseLengthByte(CFIndex len) {
 #define __CFAssertIfFixedLengthIsOK(cf, reqLen) CFAssert2(!__CFStrIsFixed(cf) || (reqLen <= __CFStrDesiredCapacity(cf)), __kCFLogAssertion, "%s(): length %d too large", __PRETTY_FUNCTION__, reqLen)
 
 
 #define __CFAssertIfFixedLengthIsOK(cf, reqLen) CFAssert2(!__CFStrIsFixed(cf) || (reqLen <= __CFStrDesiredCapacity(cf)), __kCFLogAssertion, "%s(): length %d too large", __PRETTY_FUNCTION__, reqLen)
 
 

-/* Basic algorithm is to shrink memory when capacity is SHRINKFACTOR times the required capacity or to allocate memory when the capacity is less than GROWFACTOR times the required capacity.
+/* Basic algorithm is to shrink memory when capacity is SHRINKFACTOR times the required capacity or to allocate memory when the capacity is less than GROWFACTOR times the required capacity.  This function will return -1 if the new capacity is just too big (> LONG_MAX).

 Additional complications are applied in the following order:
 - desiredCapacity, which is the minimum (except initially things can be at zero)
 - rounding up to factor of 8
 Additional complications are applied in the following order:
 - desiredCapacity, which is the minimum (except initially things can be at zero)
 - rounding up to factor of 8


@@ -568,27 +576,28 @@ Additional complications are applied in the following order:
 #define GROWFACTOR(c) (((c) >= (ULONG_MAX / 3UL)) ? __CFMax(LONG_MAX - 4095, (c)) : (((unsigned long)c * 3 + 1) / 2))
 #endif
 
 #define GROWFACTOR(c) (((c) >= (ULONG_MAX / 3UL)) ? __CFMax(LONG_MAX - 4095, (c)) : (((unsigned long)c * 3 + 1) / 2))
 #endif
 

-CF_INLINE CFIndex __CFStrNewCapacity(CFMutableStringRef str, CFIndex reqCapacity, CFIndex capacity, Boolean leaveExtraRoom, CFIndex charSize) {
+CF_INLINE CFIndex __CFStrNewCapacity(CFMutableStringRef str, unsigned long reqCapacity, CFIndex capacity, Boolean leaveExtraRoom, CFIndex charSize) {

     if (capacity != 0 || reqCapacity != 0) {   /* If initially zero, and space not needed, leave it at that... */
         if ((capacity < reqCapacity) ||                /* We definitely need the room... */
             (!__CFStrCapacityProvidedExternally(str) &&        /* Assuming we control the capacity... */
                ((reqCapacity < SHRINKFACTOR(capacity)) ||              /* ...we have too much room! */
                  (!leaveExtraRoom && (reqCapacity < capacity))))) {    /* ...we need to eliminate the extra space... */
     if (capacity != 0 || reqCapacity != 0) {   /* If initially zero, and space not needed, leave it at that... */
         if ((capacity < reqCapacity) ||                /* We definitely need the room... */
             (!__CFStrCapacityProvidedExternally(str) &&        /* Assuming we control the capacity... */
                ((reqCapacity < SHRINKFACTOR(capacity)) ||              /* ...we have too much room! */
                  (!leaveExtraRoom && (reqCapacity < capacity))))) {    /* ...we need to eliminate the extra space... */

-            CFIndex newCapacity = leaveExtraRoom ? GROWFACTOR(reqCapacity) : reqCapacity;      /* Grow by 3/2 if extra room is desired */
+           if (reqCapacity > LONG_MAX) return -1;  /* Too big any way you cut it */
+            unsigned long newCapacity = leaveExtraRoom ? GROWFACTOR(reqCapacity) : reqCapacity;        /* Grow by 3/2 if extra room is desired */

            CFIndex desiredCapacity = __CFStrDesiredCapacity(str) * charSize;
             if (newCapacity < desiredCapacity) {       /* If less than desired, bump up to desired */
                 newCapacity = desiredCapacity;
             } else if (__CFStrIsFixed(str)) {          /* Otherwise, if fixed, no need to go above the desired (fixed) capacity */
                 newCapacity = __CFMax(desiredCapacity, reqCapacity);   /* !!! So, fixed is not really fixed, but "tight" */
             }
            CFIndex desiredCapacity = __CFStrDesiredCapacity(str) * charSize;
             if (newCapacity < desiredCapacity) {       /* If less than desired, bump up to desired */
                 newCapacity = desiredCapacity;
             } else if (__CFStrIsFixed(str)) {          /* Otherwise, if fixed, no need to go above the desired (fixed) capacity */
                 newCapacity = __CFMax(desiredCapacity, reqCapacity);   /* !!! So, fixed is not really fixed, but "tight" */
             }

-           if (__CFStrHasContentsAllocator(str)) {     /* Also apply any preferred size from the allocator; should we do something for  */
+           if (__CFStrHasContentsAllocator(str)) {     /* Also apply any preferred size from the allocator  */

                 newCapacity = CFAllocatorGetPreferredSizeForSize(__CFStrContentsAllocator(str), newCapacity, 0);
                 newCapacity = CFAllocatorGetPreferredSizeForSize(__CFStrContentsAllocator(str), newCapacity, 0);

-#if DEPLOYMENT_TARGET_MACOSX
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED

             } else {
                 newCapacity = malloc_good_size(newCapacity);
 #endif
             }
             } else {
                 newCapacity = malloc_good_size(newCapacity);
 #endif
             }

-            return newCapacity; // If packing: __CFStrUnpackNumber(__CFStrPackNumber(newCapacity));
+            return (newCapacity > LONG_MAX) ? -1 : (CFIndex)newCapacity; // If packing: __CFStrUnpackNumber(__CFStrPackNumber(newCapacity));

         }
     }
     return capacity;
         }
     }
     return capacity;


@@ -744,8 +753,7 @@ static void copyBlocks(
 */
 static void __CFStringHandleOutOfMemory(CFTypeRef obj) {
     CFStringRef msg = CFSTR("Out of memory. We suggest restarting the application. If you have an unsaved document, create a backup copy in Finder, then try to save.");
 */
 static void __CFStringHandleOutOfMemory(CFTypeRef obj) {
     CFStringRef msg = CFSTR("Out of memory. We suggest restarting the application. If you have an unsaved document, create a backup copy in Finder, then try to save.");

-    CFBadErrorCallBack cb = _CFGetOutOfMemoryErrorCallBack();
-    if (NULL == cb || !cb(obj, CFSTR("NS/CFString"), msg)) {
+    {

        CFLog(kCFLogLevelCritical, CFSTR("%@"), msg);
     }
 }
        CFLog(kCFLogLevelCritical, CFSTR("%@"), msg);
     }
 }


@@ -755,7 +763,7 @@ static void __CFStringHandleOutOfMemory(CFTypeRef obj) {
 static void __CFStringChangeSizeMultiple(CFMutableStringRef str, const CFRange *deleteRanges, CFIndex numDeleteRanges, CFIndex insertLength, Boolean makeUnicode) {
     const uint8_t *curContents = (uint8_t *)__CFStrContents(str);
     CFIndex curLength = curContents ? __CFStrLength2(str, curContents) : 0;
 static void __CFStringChangeSizeMultiple(CFMutableStringRef str, const CFRange *deleteRanges, CFIndex numDeleteRanges, CFIndex insertLength, Boolean makeUnicode) {
     const uint8_t *curContents = (uint8_t *)__CFStrContents(str);
     CFIndex curLength = curContents ? __CFStrLength2(str, curContents) : 0;

-    CFIndex newLength;
+    unsigned long newLength;   // We use unsigned to better keep track of overflow

     
     // Compute new length of the string
     if (numDeleteRanges == 1) {
     
     // Compute new length of the string
     if (numDeleteRanges == 1) {


@@ -803,19 +811,19 @@ static void __CFStringChangeSizeMultiple(CFMutableStringRef str, const CFRange *
         Boolean useLengthAndNullBytes = !newIsUnicode /* && (newLength > 0) - implicit */;
         CFIndex numExtraBytes = useLengthAndNullBytes ? 2 : 0; /* 2 extra bytes to keep the length byte & null... */
         CFIndex curCapacity = __CFStrCapacity(str);
         Boolean useLengthAndNullBytes = !newIsUnicode /* && (newLength > 0) - implicit */;
         CFIndex numExtraBytes = useLengthAndNullBytes ? 2 : 0; /* 2 extra bytes to keep the length byte & null... */
         CFIndex curCapacity = __CFStrCapacity(str);

+       if (newLength > (LONG_MAX - numExtraBytes) / newCharSize) __CFStringHandleOutOfMemory(str);     // Does not return

         CFIndex newCapacity = __CFStrNewCapacity(str, newLength * newCharSize + numExtraBytes, curCapacity, true, newCharSize);
         CFIndex newCapacity = __CFStrNewCapacity(str, newLength * newCharSize + numExtraBytes, curCapacity, true, newCharSize);

+       if (newCapacity == -1) __CFStringHandleOutOfMemory(str);        // Does not return

         Boolean allocNewBuffer = (newCapacity != curCapacity) || (curLength > 0 && !oldIsUnicode && newIsUnicode);     /* We alloc new buffer if oldIsUnicode != newIsUnicode because the contents have to be copied */
        uint8_t *newContents;
        if (allocNewBuffer) {
            newContents = (uint8_t *)__CFStrAllocateMutableContents(str, newCapacity);
            if (!newContents) {     // Try allocating without extra room
                newCapacity = __CFStrNewCapacity(str, newLength * newCharSize + numExtraBytes, curCapacity, false, newCharSize);
         Boolean allocNewBuffer = (newCapacity != curCapacity) || (curLength > 0 && !oldIsUnicode && newIsUnicode);     /* We alloc new buffer if oldIsUnicode != newIsUnicode because the contents have to be copied */
        uint8_t *newContents;
        if (allocNewBuffer) {
            newContents = (uint8_t *)__CFStrAllocateMutableContents(str, newCapacity);
            if (!newContents) {     // Try allocating without extra room
                newCapacity = __CFStrNewCapacity(str, newLength * newCharSize + numExtraBytes, curCapacity, false, newCharSize);

+               // Since we checked for this above, it shouldn't be the case here, but just in case
+               if (newCapacity == -1) __CFStringHandleOutOfMemory(str);    // Does not return

                newContents = (uint8_t *)__CFStrAllocateMutableContents(str, newCapacity);
                newContents = (uint8_t *)__CFStrAllocateMutableContents(str, newCapacity);

-               if (!newContents) {
-                   __CFStringHandleOutOfMemory(str);
-                   // Ideally control doesn't come here at all since we expect the above call to raise an exception.
-                   // If control comes here, there isn't much we can do.
-               }
+               if (!newContents) __CFStringHandleOutOfMemory(str);         // Does not return

            }
        } else {
            newContents = (uint8_t *)curContents;
            }
        } else {
            newContents = (uint8_t *)curContents;


@@ -1186,7 +1194,7 @@ __private_extern__ CFStringRef __CFStringCreateImmutableFunnel3(
     else if (encoding == kCFStringEncodingUTF8) recordedEncoding = "UTF8";
     else if (encoding == kCFStringEncodingMacRoman) recordedEncoding = "MacRoman";
     else {
     else if (encoding == kCFStringEncodingUTF8) recordedEncoding = "UTF8";
     else if (encoding == kCFStringEncodingMacRoman) recordedEncoding = "MacRoman";
     else {

-       sprintf(encodingBuffer, "0x%lX", (unsigned long)encoding);
+       snprintf(encodingBuffer, sizeof(encodingBuffer), "0x%lX", (unsigned long)encoding);

        recordedEncoding = encodingBuffer;
     }
 #endif
        recordedEncoding = encodingBuffer;
     }
 #endif


@@ -1326,8 +1334,9 @@ __private_extern__ CFStringRef __CFStringCreateImmutableFunnel3(
     }
 
     // Now determine the necessary size
     }
 
     // Now determine the necessary size

-    
+#if INSTRUMENT_SHARED_STRINGS || USE_STRING_ROM

     Boolean stringSupportsROM = stringSupportsEightBitCFRepresentation;
     Boolean stringSupportsROM = stringSupportsEightBitCFRepresentation;

+#endif

 
 #if INSTRUMENT_SHARED_STRINGS
     if (stringSupportsROM) {
 
 #if INSTRUMENT_SHARED_STRINGS
     if (stringSupportsROM) {


@@ -1344,7 +1353,7 @@ __private_extern__ CFStringRef __CFStringCreateImmutableFunnel3(
     if (stringSupportsROM) {
         // Disable the string ROM if necessary
        static char sDisableStringROM = -1;
     if (stringSupportsROM) {
         // Disable the string ROM if necessary
        static char sDisableStringROM = -1;

-       if (sDisableStringROM == -1) sDisableStringROM = !! getenv("CFStringDisableROM");
+       if (sDisableStringROM == -1) sDisableStringROM = !! __CFgetenv("CFStringDisableROM");

 
        if (sDisableStringROM == 0) romResult = _CFSearchStringROM(bytes + !! hasLengthByte, numBytes - !! hasLengthByte);
     }
 
        if (sDisableStringROM == 0) romResult = _CFSearchStringROM(bytes + !! hasLengthByte, numBytes - !! hasLengthByte);
     }


@@ -1695,7 +1704,7 @@ static Boolean __CFStrIsConstantString(CFStringRef str) {
 #endif
 
 
 #endif
 
 

-#if 0
+#if DEPLOYMENT_TARGET_WINDOWS

 void __CFStringCleanup (void) {
     /* in case library is unloaded, release store for the constant string table */
     if (constantStringTable != NULL) {
 void __CFStringCleanup (void) {
     /* in case library is unloaded, release store for the constant string table */
     if (constantStringTable != NULL) {


@@ -1706,6 +1715,7 @@ void __CFStringCleanup (void) {
 #else 
         CFRelease(constantStringTable);
 #endif
 #else 
         CFRelease(constantStringTable);
 #endif

+        constantStringTable = NULL;

     }
 }
 #endif
     }
 }
 #endif


@@ -1966,6 +1976,19 @@ const char * CFStringGetCStringPtr(CFStringRef str, CFStringEncoding encoding) {
     if (__CFStrHasNullByte(str)) {
         // Note: this is called a lot, 27000 times to open a small xcode project with one file open.
         // Of these uses about 1500 are for cStrings/utf8strings.
     if (__CFStrHasNullByte(str)) {
         // Note: this is called a lot, 27000 times to open a small xcode project with one file open.
         // Of these uses about 1500 are for cStrings/utf8strings.

+#if 0
+        // Only sometimes when the stars are aligned will this call return a gc pointer
+        // under GC we can only really return a pointer to the start of a GC buffer for cString use
+        // (Is there a simpler way to ask if contents isGC?)
+        CFAllocatorRef alloc = (__CFStrHasContentsAllocator(str)) ? __CFStrContentsAllocator(str) : __CFGetAllocator(str);
+        if (CF_IS_COLLECTABLE_ALLOCATOR(alloc)) {
+            if (__CFStrSkipAnyLengthByte(str) != 0 || !__CFStrIsMutable(str)) {
+                static int counter = 0;
+                printf("CFString %dth unsafe safe string %s\n", ++counter, __CFStrContents(str) + __CFStrSkipAnyLengthByte(str));
+                return NULL;
+            }
+        }
+#endif

        return (const char *)__CFStrContents(str) + __CFStrSkipAnyLengthByte(str);
     } else {
        return NULL;
        return (const char *)__CFStrContents(str) + __CFStrSkipAnyLengthByte(str);
     } else {
        return NULL;


@@ -2063,6 +2086,9 @@ Boolean CFStringGetCString(CFStringRef str, char *buffer, CFIndex bufferSize, CF
     }
 }
 
     }
 }
 

+extern Boolean __CFLocaleGetNullLocale(struct __CFLocale *locale);
+extern void __CFLocaleSetNullLocale(struct __CFLocale *locale);
+

 static const char *_CFStrGetLanguageIdentifierForLocale(CFLocaleRef locale) {
     CFStringRef collatorID;
     const char *langID = NULL;
 static const char *_CFStrGetLanguageIdentifierForLocale(CFLocaleRef locale) {
     CFStringRef collatorID;
     const char *langID = NULL;


@@ -2070,6 +2096,8 @@ static const char *_CFStrGetLanguageIdentifierForLocale(CFLocaleRef locale) {
     static const char *lastLangID = NULL;
     static CFSpinLock_t lock = CFSpinLockInit;
 
     static const char *lastLangID = NULL;
     static CFSpinLock_t lock = CFSpinLockInit;
 

+    if (__CFLocaleGetNullLocale((struct __CFLocale *)locale)) return NULL;
+

     __CFSpinLock(&lock);
     if ((NULL != lastLocale) && (lastLocale == locale)) {
         __CFSpinUnlock(&lock);
     __CFSpinLock(&lock);
     if ((NULL != lastLocale) && (lastLocale == locale)) {
         __CFSpinUnlock(&lock);


@@ -2077,7 +2105,7 @@ static const char *_CFStrGetLanguageIdentifierForLocale(CFLocaleRef locale) {
     }
     __CFSpinUnlock(&lock);
 
     }
     __CFSpinUnlock(&lock);
 

-    collatorID = CFLocaleGetValue(locale, __kCFLocaleCollatorID);
+    collatorID = (CFStringRef)CFLocaleGetValue(locale, __kCFLocaleCollatorID);

 
     // This is somewhat depending on CFLocale implementation always creating CFString for locale identifer ???
     if (__CFStrLength(collatorID) > 1) {
 
     // This is somewhat depending on CFLocale implementation always creating CFString for locale identifer ???
     if (__CFStrLength(collatorID) > 1) {


@@ -2104,6 +2132,9 @@ static const char *_CFStrGetLanguageIdentifierForLocale(CFLocaleRef locale) {
         }
     }
 
         }
     }
 

+ 
+    if (langID == NULL) __CFLocaleSetNullLocale((struct __CFLocale *)locale);
+

     __CFSpinLock(&lock);
     lastLocale = locale;
     lastLangID = langID;
     __CFSpinLock(&lock);
     lastLocale = locale;
     lastLangID = langID;


@@ -2177,14 +2208,14 @@ static CFIndex __CFStringFoldCharacterClusterAtIndex(UTF32Char character, CFStri
             }
 
             // decompose
             }
 
             // decompose

-            if (flags & (kCFCompareDiacriticsInsensitiveCompatibilityMask|kCFCompareNonliteral)) {
+            if (flags & (kCFCompareDiacriticInsensitive|kCFCompareNonliteral)) {

                 if (CFUniCharIsMemberOfBitmap(character, ((0 == planeNo) ? decompBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharCanonicalDecomposableCharacterSet, planeNo)))) {
                     UTF32Char original = character;
 
                     filledLength = CFUniCharDecomposeCharacter(character, outCharacters, maxBufferLength);
                     character = *outCharacters;
 
                 if (CFUniCharIsMemberOfBitmap(character, ((0 == planeNo) ? decompBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharCanonicalDecomposableCharacterSet, planeNo)))) {
                     UTF32Char original = character;
 
                     filledLength = CFUniCharDecomposeCharacter(character, outCharacters, maxBufferLength);
                     character = *outCharacters;
 

-                    if ((flags & kCFCompareDiacriticsInsensitiveCompatibilityMask) && (character < 0x0510)) {
+                    if ((flags & kCFCompareDiacriticInsensitive) && (character < 0x0510)) {

                         filledLength = 1; // reset if Roman, Greek, Cyrillic
                     } else if (0 == (flags & kCFCompareNonliteral)) {
                         character = original;
                         filledLength = 1; // reset if Roman, Greek, Cyrillic
                     } else if (0 == (flags & kCFCompareNonliteral)) {
                         character = original;


@@ -2196,7 +2227,7 @@ static CFIndex __CFStringFoldCharacterClusterAtIndex(UTF32Char character, CFStri
             // fold case
             if (flags & kCFCompareCaseInsensitive) {
                 const uint8_t *nonBaseBitmap;
             // fold case
             if (flags & kCFCompareCaseInsensitive) {
                 const uint8_t *nonBaseBitmap;

-                bool filterNonBase = (((flags & kCFCompareDiacriticsInsensitiveCompatibilityMask) && (character < 0x0510)) ? true : false);
+                bool filterNonBase = (((flags & kCFCompareDiacriticInsensitive) && (character < 0x0510)) ? true : false);

                 static const uint8_t *lowerBMP = NULL;
                 static const uint8_t *caseFoldBMP = NULL;
                 
                 static const uint8_t *lowerBMP = NULL;
                 static const uint8_t *caseFoldBMP = NULL;
                 


@@ -2261,10 +2292,10 @@ static CFIndex __CFStringFoldCharacterClusterAtIndex(UTF32Char character, CFStri
         }
 
         // collect following combining marks
         }
 
         // collect following combining marks

-        if (flags & (kCFCompareDiacriticsInsensitiveCompatibilityMask|kCFCompareNonliteral)) {
+        if (flags & (kCFCompareDiacriticInsensitive|kCFCompareNonliteral)) {

             const uint8_t *nonBaseBitmap;
             const uint8_t *decompBitmap;
             const uint8_t *nonBaseBitmap;
             const uint8_t *decompBitmap;

-            bool doFill = (((flags & kCFCompareDiacriticsInsensitiveCompatibilityMask) && (character < 0x0510)) ? false : true);
+            bool doFill = (((flags & kCFCompareDiacriticInsensitive) && (character < 0x0510)) ? false : true);

 
             if (0 == filledLength) {
                 *outCharacters = character; // filledLength will be updated below on demand
 
             if (0 == filledLength) {
                 *outCharacters = character; // filledLength will be updated below on demand


@@ -2284,7 +2315,7 @@ static CFIndex __CFStringFoldCharacterClusterAtIndex(UTF32Char character, CFStri
                     if (CFUniCharIsMemberOfBitmap(nonBaseCharacter, nonBaseBitmap)) {
                         filledLength = 1; // For the base character
                         
                     if (CFUniCharIsMemberOfBitmap(nonBaseCharacter, nonBaseBitmap)) {
                         filledLength = 1; // For the base character
                         

-                        if ((0 == (flags & kCFCompareDiacriticsInsensitiveCompatibilityMask)) || (nonBaseCharacter > 0x050F)) {
+                        if ((0 == (flags & kCFCompareDiacriticInsensitive)) || (nonBaseCharacter > 0x050F)) {

                             if (CFUniCharIsMemberOfBitmap(nonBaseCharacter, decompBitmap)) {
                                 filledLength += CFUniCharDecomposeCharacter(nonBaseCharacter, &(outCharacters[filledLength]), maxBufferLength - filledLength);
                             } else {
                             if (CFUniCharIsMemberOfBitmap(nonBaseCharacter, decompBitmap)) {
                                 filledLength += CFUniCharDecomposeCharacter(nonBaseCharacter, &(outCharacters[filledLength]), maxBufferLength - filledLength);
                             } else {


@@ -2347,9 +2378,27 @@ static CFIndex __CFStringFoldCharacterClusterAtIndex(UTF32Char character, CFStri
     return filledLength;
 }
 
     return filledLength;
 }
 

-#define kCFStringStackBufferLength (64)
+static bool __CFStringFillCharacterSetInlineBuffer(CFCharacterSetInlineBuffer *buffer, CFStringCompareFlags compareOptions) {
+    if (0 != (compareOptions & kCFCompareIgnoreNonAlphanumeric)) {
+       static CFCharacterSetRef nonAlnumChars = NULL;
+
+       if (NULL == nonAlnumChars) {
+           CFMutableCharacterSetRef cset = CFCharacterSetCreateMutableCopy(NULL, CFCharacterSetGetPredefined(kCFCharacterSetAlphaNumeric));
+           CFCharacterSetInvert(cset);
+           if (!OSAtomicCompareAndSwapPtrBarrier(NULL, cset, (void **)&nonAlnumChars)) CFRelease(cset);
+       }
+
+       CFCharacterSetInitInlineBuffer(nonAlnumChars, buffer);
+
+       return true;
+    }
+
+    return false;
+}
+
+#define kCFStringStackBufferLength (__kCFStringInlineBufferLength)

 
 

-CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStringRef string2, CFRange rangeToCompare, CFOptionFlags compareOptions, CFLocaleRef locale) {
+CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStringRef string2, CFRange rangeToCompare, CFStringCompareFlags compareOptions, CFLocaleRef locale) {

     /* No objc dispatch needed here since CFStringInlineBuffer works with both CFString and NSString */
     UTF32Char strBuf1[kCFStringStackBufferLength];
     UTF32Char strBuf2[kCFStringStackBufferLength];
     /* No objc dispatch needed here since CFStringInlineBuffer works with both CFString and NSString */
     UTF32Char strBuf1[kCFStringStackBufferLength];
     UTF32Char strBuf2[kCFStringStackBufferLength];


@@ -2357,19 +2406,21 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
     UTF32Char str1Char, str2Char;
     CFIndex str1UsedLen, str2UsedLen;
     CFIndex str1Index = 0, str2Index = 0, strBuf1Index = 0, strBuf2Index = 0, strBuf1Len = 0, strBuf2Len = 0;
     UTF32Char str1Char, str2Char;
     CFIndex str1UsedLen, str2UsedLen;
     CFIndex str1Index = 0, str2Index = 0, strBuf1Index = 0, strBuf2Index = 0, strBuf1Len = 0, strBuf2Len = 0;

+    CFIndex str1LocalizedIndex = 0, str2LocalizedIndex = 0;
+    CFIndex forcedIndex1 = 0, forcedIndex2 = 0;

     CFIndex str2Len = CFStringGetLength(string2);
     bool caseInsensitive = ((compareOptions & kCFCompareCaseInsensitive) ? true : false);
     CFIndex str2Len = CFStringGetLength(string2);
     bool caseInsensitive = ((compareOptions & kCFCompareCaseInsensitive) ? true : false);

-    bool diacriticsInsensitive = ((compareOptions & kCFCompareDiacriticsInsensitiveCompatibilityMask) ? true : false);
-    bool equalityOptions = ((compareOptions & (kCFCompareCaseInsensitive|kCFCompareNonliteral|kCFCompareDiacriticsInsensitiveCompatibilityMask|kCFCompareWidthInsensitive)) ? true : false);
+    bool diacriticsInsensitive = ((compareOptions & kCFCompareDiacriticInsensitive) ? true : false);
+    bool equalityOptions = ((compareOptions & (kCFCompareCaseInsensitive|kCFCompareNonliteral|kCFCompareDiacriticInsensitive|kCFCompareWidthInsensitive)) ? true : false);

     bool numerically = ((compareOptions & kCFCompareNumerically) ? true : false);
     bool numerically = ((compareOptions & kCFCompareNumerically) ? true : false);

+    bool forceOrdering = ((compareOptions & kCFCompareForcedOrdering) ? true : false);

     const uint8_t *graphemeBMP = CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, 0);
     const uint8_t *langCode;
     CFComparisonResult compareResult = kCFCompareEqualTo;
     UTF16Char otherChar;
     Boolean freeLocale = false;
     const uint8_t *graphemeBMP = CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, 0);
     const uint8_t *langCode;
     CFComparisonResult compareResult = kCFCompareEqualTo;
     UTF16Char otherChar;
     Boolean freeLocale = false;

-
-    #define _CFCompareStringsWithLocale(A, B, C, D, E, F) (0)
-    locale = NULL;
+    CFCharacterSetInlineBuffer *ignoredChars = NULL;
+    CFCharacterSetInlineBuffer csetBuffer;

 
     if ((compareOptions & kCFCompareLocalized) && (NULL == locale)) {
         locale = CFLocaleCopyCurrent();
 
     if ((compareOptions & kCFCompareLocalized) && (NULL == locale)) {
         locale = CFLocaleCopyCurrent();


@@ -2378,7 +2429,12 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
 
     langCode = ((NULL == locale) ? NULL : (const uint8_t *)_CFStrGetLanguageIdentifierForLocale(locale));
 
 
     langCode = ((NULL == locale) ? NULL : (const uint8_t *)_CFStrGetLanguageIdentifierForLocale(locale));
 

-    if ((NULL == locale) && !numerically) { // could do binary comp (be careful when adding new flags)
+    if (__CFStringFillCharacterSetInlineBuffer(&csetBuffer, compareOptions)) {
+       ignoredChars = &csetBuffer;
+       equalityOptions = true;
+    }
+
+    if ((NULL == locale) && (NULL == ignoredChars) && !numerically) { // could do binary comp (be careful when adding new flags)

         CFStringEncoding eightBitEncoding = __CFStringGetEightBitStringEncoding();
         const uint8_t *str1Bytes = (const uint8_t *)CFStringGetCStringPtr(string, eightBitEncoding);
         const uint8_t *str2Bytes = (const uint8_t *)CFStringGetCStringPtr(string2, eightBitEncoding);
         CFStringEncoding eightBitEncoding = __CFStringGetEightBitStringEncoding();
         const uint8_t *str1Bytes = (const uint8_t *)CFStringGetCStringPtr(string, eightBitEncoding);
         const uint8_t *str2Bytes = (const uint8_t *)CFStringGetCStringPtr(string2, eightBitEncoding);


@@ -2387,7 +2443,7 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
         if ((NULL != str1Bytes) && (NULL != str2Bytes)) {
             compareOptions &= ~kCFCompareNonliteral; // remove non-literal
 
         if ((NULL != str1Bytes) && (NULL != str2Bytes)) {
             compareOptions &= ~kCFCompareNonliteral; // remove non-literal
 

-            if (kCFStringEncodingASCII == eightBitEncoding) {
+            if ((kCFStringEncodingASCII == eightBitEncoding) && (false == forceOrdering)) {

                 if (caseInsensitive) {
                     int cmpResult = strncasecmp_l((const char *)str1Bytes + rangeToCompare.location, (const char *)str2Bytes, __CFMin(rangeToCompare.length, str2Len), NULL);
                     
                 if (caseInsensitive) {
                     int cmpResult = strncasecmp_l((const char *)str1Bytes + rangeToCompare.location, (const char *)str2Bytes, __CFMin(rangeToCompare.length, str2Len), NULL);
                     


@@ -2406,6 +2462,7 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
 
                     if (str1Char != str2Char) {
                         if ((str1Char < 0x80) && (str2Char < 0x80)) {
 
                     if (str1Char != str2Char) {
                         if ((str1Char < 0x80) && (str2Char < 0x80)) {

+                           if (forceOrdering && (kCFCompareEqualTo == compareResult) && (str1Char != str2Char)) compareResult = ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan);

                             if ((str1Char >= 'A') && (str1Char <= 'Z')) str1Char += ('a' - 'A');
                             if ((str2Char >= 'A') && (str2Char <= 'Z')) str2Char += ('a' - 'A');
 
                             if ((str1Char >= 'A') && (str1Char <= 'Z')) str1Char += ('a' - 'A');
                             if ((str2Char >= 'A') && (str2Char <= 'Z')) str2Char += ('a' - 'A');
 


@@ -2423,7 +2480,7 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
                 if (str1Index == limitLength) {
                     int cmpResult = rangeToCompare.length - str2Len;
                     
                 if (str1Index == limitLength) {
                     int cmpResult = rangeToCompare.length - str2Len;
                     

-                    return ((0 == cmpResult) ? kCFCompareEqualTo : ((cmpResult < 0) ? kCFCompareLessThan : kCFCompareGreaterThan));
+                    return ((0 == cmpResult) ? compareResult : ((cmpResult < 0) ? kCFCompareLessThan : kCFCompareGreaterThan));

                 }
             }
         } else if (!equalityOptions && (NULL == str1Bytes) && (NULL == str2Bytes)) {
                 }
             }
         } else if (!equalityOptions && (NULL == str1Bytes) && (NULL == str2Bytes)) {


@@ -2457,25 +2514,41 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
     CFStringInitInlineBuffer(string, &inlineBuf1, rangeToCompare);
     CFStringInitInlineBuffer(string2, &inlineBuf2, CFRangeMake(0, str2Len));
 
     CFStringInitInlineBuffer(string, &inlineBuf1, rangeToCompare);
     CFStringInitInlineBuffer(string2, &inlineBuf2, CFRangeMake(0, str2Len));
 

+    if (NULL != locale) {
+       str1LocalizedIndex = str1Index;
+       str2LocalizedIndex = str2Index;
+
+       // We temporarily disable kCFCompareDiacriticInsensitive for SL <rdar://problem/6767096>. Should be revisited in NMOS <rdar://problem/7003830>
+       if (forceOrdering) {
+           diacriticsInsensitive = false;
+           compareOptions &= ~kCFCompareDiacriticInsensitive;
+       }
+    }

     while ((str1Index < rangeToCompare.length) && (str2Index < str2Len)) {
         if (strBuf1Len == 0) {
             str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);
     while ((str1Index < rangeToCompare.length) && (str2Index < str2Len)) {
         if (strBuf1Len == 0) {
             str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);

-            if (caseInsensitive && (str1Char >= 'A') && (str1Char <= 'Z') && ((NULL == langCode) || (str1Char != 'I'))) str1Char += ('a' - 'A');
+            if (caseInsensitive && (str1Char >= 'A') && (str1Char <= 'Z') && ((NULL == langCode) || (str1Char != 'I')) && ((false == forceOrdering) || (kCFCompareEqualTo != compareResult))) str1Char += ('a' - 'A');

             str1UsedLen = 1;
         } else {
             str1Char = strBuf1[strBuf1Index++];
         }
         if (strBuf2Len == 0) {
             str2Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index);
             str1UsedLen = 1;
         } else {
             str1Char = strBuf1[strBuf1Index++];
         }
         if (strBuf2Len == 0) {
             str2Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index);

-            if (caseInsensitive && (str2Char >= 'A') && (str2Char <= 'Z') && ((NULL == langCode) || (str2Char != 'I'))) str2Char += ('a' - 'A');
+            if (caseInsensitive && (str2Char >= 'A') && (str2Char <= 'Z') && ((NULL == langCode) || (str2Char != 'I')) && ((false == forceOrdering) || (kCFCompareEqualTo != compareResult))) str2Char += ('a' - 'A');

             str2UsedLen = 1;
         } else {
             str2Char = strBuf2[strBuf2Index++];
         }
             str2UsedLen = 1;
         } else {
             str2Char = strBuf2[strBuf2Index++];
         }

-        
+

         if (numerically && ((0 == strBuf1Len) && (str1Char <= '9') && (str1Char >= '0')) && ((0 == strBuf2Len) && (str2Char <= '9') && (str2Char >= '0'))) { // If both are not ASCII digits, then don't do numerical comparison here
             uint64_t intValue1 = 0, intValue2 = 0;     // !!! Doesn't work if numbers are > max uint64_t
 
         if (numerically && ((0 == strBuf1Len) && (str1Char <= '9') && (str1Char >= '0')) && ((0 == strBuf2Len) && (str2Char <= '9') && (str2Char >= '0'))) { // If both are not ASCII digits, then don't do numerical comparison here
             uint64_t intValue1 = 0, intValue2 = 0;     // !!! Doesn't work if numbers are > max uint64_t
 

+            if (forceOrdering && (kCFCompareEqualTo == compareResult) && (str1Char != str2Char)) {
+               compareResult = ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan);
+               forcedIndex1 = str1Index;
+               forcedIndex2 = str2Index;
+           }
+

             do {
                 intValue1 = (intValue1 * 10) + (str1Char - '0');
                 str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, ++str1Index);
             do {
                 intValue1 = (intValue1 * 10) + (str1Char - '0');
                 str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, ++str1Index);


@@ -2503,22 +2576,26 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
 
         if (str1Char != str2Char) {
             if (!equalityOptions) {
 
         if (str1Char != str2Char) {
             if (!equalityOptions) {

-               CFComparisonResult res = ((NULL == locale) ? ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(strBuf1Index, rangeToCompare.length - strBuf1Index), &inlineBuf2, CFRangeMake(strBuf2Index, str2Len - strBuf2Index), compareOptions, locale));
+               compareResult = ((NULL == locale) ? ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(str1Index, rangeToCompare.length - str1Index), &inlineBuf2, CFRangeMake(str2Index, str2Len - str2Index), compareOptions, locale));

                 if (freeLocale && locale) {
                     CFRelease(locale);
                 }
                 if (freeLocale && locale) {
                     CFRelease(locale);
                 }

-               return res;
+               return compareResult;

            }
 
            }
 

-            if ((compareOptions & kCFCompareForcedOrdering) && (kCFCompareEqualTo == compareResult)) compareResult = ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan);
+            if (forceOrdering && (kCFCompareEqualTo == compareResult)) {
+               compareResult = ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan);
+               forcedIndex1 = str1LocalizedIndex;
+               forcedIndex2 = str2LocalizedIndex;
+           }

 
 

-            if ((str1Char < 0x80) && (str2Char < 0x80)) {
+            if ((str1Char < 0x80) && (str2Char < 0x80) && (NULL == ignoredChars)) {

                 if (NULL != locale) {
                 if (NULL != locale) {

-                   CFComparisonResult res = _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(strBuf1Index, rangeToCompare.length - strBuf1Index), &inlineBuf2, CFRangeMake(strBuf2Index, str2Len - strBuf2Index), compareOptions, locale);
+                   compareResult = _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(str1Index, rangeToCompare.length - str1Index), &inlineBuf2, CFRangeMake(str2Index, str2Len - str2Index), compareOptions, locale);

                    if (freeLocale && locale) {
                        CFRelease(locale);
                    }
                    if (freeLocale && locale) {
                        CFRelease(locale);
                    }

-                   return res;
+                   return compareResult;

                 } else if (!caseInsensitive) {
                    if (freeLocale && locale) {
                        CFRelease(locale);
                 } else if (!caseInsensitive) {
                    if (freeLocale && locale) {
                        CFRelease(locale);


@@ -2537,6 +2614,21 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
                 str2UsedLen = 2;
             }
             
                 str2UsedLen = 2;
             }
             

+           if (NULL != ignoredChars) {
+               if (CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str1Char)) {
+                   if ((strBuf1Len > 0) && (strBuf1Index == strBuf1Len)) strBuf1Len = 0;
+                   if (strBuf1Len == 0) str1Index += str1UsedLen;
+                   if (strBuf2Len > 0) --strBuf2Index;
+                   continue;
+               }
+               if (CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str2Char)) {
+                   if ((strBuf2Len > 0) && (strBuf2Index == strBuf2Len)) strBuf2Len = 0;
+                   if (strBuf2Len == 0) str2Index += str2UsedLen;
+                   if (strBuf1Len > 0) -- strBuf1Index;
+                   continue;
+               }           
+           }
+           

             if (diacriticsInsensitive && (str1Index > 0)) {
                 bool str1Skip = false;
                 bool str2Skip = false;
             if (diacriticsInsensitive && (str1Index > 0)) {
                 bool str1Skip = false;
                 bool str2Skip = false;


@@ -2566,11 +2658,11 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
                 }
                 
                 if ((0 == strBuf1Len) && (0 < strBuf2Len)) {
                 }
                 
                 if ((0 == strBuf1Len) && (0 < strBuf2Len)) {

-                   CFComparisonResult res =  ((NULL == locale) ? ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(strBuf1Index, rangeToCompare.length - strBuf1Index), &inlineBuf2, CFRangeMake(strBuf2Index, str2Len - strBuf2Index), compareOptions, locale));
+                   compareResult =  ((NULL == locale) ? ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(str1LocalizedIndex, rangeToCompare.length - str1LocalizedIndex), &inlineBuf2, CFRangeMake(str2LocalizedIndex, str2Len - str2LocalizedIndex), compareOptions, locale));

                    if (freeLocale && locale) {
                        CFRelease(locale);
                    }
                    if (freeLocale && locale) {
                        CFRelease(locale);
                    }

-                   return res;
+                   return compareResult;

                }
                 
                 if ((0 == strBuf2Len) && ((0 == strBuf1Len) || (str1Char != str2Char))) {
                }
                 
                 if ((0 == strBuf2Len) && ((0 == strBuf1Len) || (str1Char != str2Char))) {


@@ -2580,11 +2672,11 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
                         strBuf2Index = 1;
                     }
                     if ((0 == strBuf2Len) || (str1Char != str2Char)) {
                         strBuf2Index = 1;
                     }
                     if ((0 == strBuf2Len) || (str1Char != str2Char)) {

-                       CFComparisonResult res = ((NULL == locale) ? ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(strBuf1Index, rangeToCompare.length - strBuf1Index), &inlineBuf2, CFRangeMake(strBuf2Index, str2Len - strBuf2Index), compareOptions, locale));
+                       compareResult = ((NULL == locale) ? ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(str1LocalizedIndex, rangeToCompare.length - str1LocalizedIndex), &inlineBuf2, CFRangeMake(str2LocalizedIndex, str2Len - str2LocalizedIndex), compareOptions, locale));

                        if (freeLocale && locale) {
                            CFRelease(locale);
                        }
                        if (freeLocale && locale) {
                            CFRelease(locale);
                        }

-                       return res;
+                       return compareResult;

                    }
                 }
             }
                    }
                 }
             }


@@ -2595,7 +2687,7 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
                     ++strBuf1Index; ++strBuf2Index;
                 }
                 if ((strBuf1Index < strBuf1Len) && (strBuf2Index < strBuf2Len)) {
                     ++strBuf1Index; ++strBuf2Index;
                 }
                 if ((strBuf1Index < strBuf1Len) && (strBuf2Index < strBuf2Len)) {

-                   CFComparisonResult res = ((NULL == locale) ? ((str1Char < str2Char) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(strBuf1Index, rangeToCompare.length - strBuf1Index), &inlineBuf2, CFRangeMake(strBuf2Index, str2Len - strBuf2Index), compareOptions, locale));
+                   CFComparisonResult res = ((NULL == locale) ? ((strBuf1[strBuf1Index] < strBuf2[strBuf2Index]) ? kCFCompareLessThan : kCFCompareGreaterThan) : _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(str1LocalizedIndex, rangeToCompare.length - str1LocalizedIndex), &inlineBuf2, CFRangeMake(str2LocalizedIndex, str2Len - str2LocalizedIndex), compareOptions, locale));

                    if (freeLocale && locale) {
                        CFRelease(locale);
                    }
                    if (freeLocale && locale) {
                        CFRelease(locale);
                    }


@@ -2609,31 +2701,37 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
         
         if (strBuf1Len == 0) str1Index += str1UsedLen;
         if (strBuf2Len == 0) str2Index += str2UsedLen;
         
         if (strBuf1Len == 0) str1Index += str1UsedLen;
         if (strBuf2Len == 0) str2Index += str2UsedLen;

+       if ((strBuf1Len == 0) && (strBuf2Len == 0)) {
+           str1LocalizedIndex = str1Index;
+           str2LocalizedIndex = str2Index;
+       }

     }
 
     }
 

-    if (diacriticsInsensitive) {
+    if (diacriticsInsensitive || (NULL != ignoredChars)) {

         while (str1Index < rangeToCompare.length) {
             str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);
         while (str1Index < rangeToCompare.length) {
             str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);

-            if (str1Char < 0x80) break; // found ASCII
+            if ((str1Char < 0x80) && (NULL == ignoredChars)) break; // found ASCII

 
             if (CFUniCharIsSurrogateHighCharacter(str1Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index + 1)))) str1Char = CFUniCharGetLongCharacterForSurrogatePair(str1Char, otherChar);
 
 
             if (CFUniCharIsSurrogateHighCharacter(str1Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index + 1)))) str1Char = CFUniCharGetLongCharacterForSurrogatePair(str1Char, otherChar);
 

-            if (!CFUniCharIsMemberOfBitmap(str1Char, ((str1Char < 0x10000) ? graphemeBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, (str1Char >> 16))))) break;
+            if ((!diacriticsInsensitive || !CFUniCharIsMemberOfBitmap(str1Char, ((str1Char < 0x10000) ? graphemeBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, (str1Char >> 16))))) && ((NULL == ignoredChars) || !CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str1Char))) break;

 
             str1Index += ((str1Char < 0x10000) ? 1 : 2);
         }
 
         while (str2Index < str2Len) {
             str2Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index);
 
             str1Index += ((str1Char < 0x10000) ? 1 : 2);
         }
 
         while (str2Index < str2Len) {
             str2Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index);

-            if (str2Char < 0x80) break; // found ASCII
+            if ((str2Char < 0x80) && (NULL == ignoredChars)) break; // found ASCII

                 
             if (CFUniCharIsSurrogateHighCharacter(str2Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index + 1)))) str2Char = CFUniCharGetLongCharacterForSurrogatePair(str2Char, otherChar);
 
                 
             if (CFUniCharIsSurrogateHighCharacter(str2Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index + 1)))) str2Char = CFUniCharGetLongCharacterForSurrogatePair(str2Char, otherChar);
 

-            if (!CFUniCharIsMemberOfBitmap(str2Char, ((str2Char < 0x10000) ? graphemeBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, (str2Char >> 16))))) break;
+            if ((!diacriticsInsensitive || !CFUniCharIsMemberOfBitmap(str2Char, ((str2Char < 0x10000) ? graphemeBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, (str2Char >> 16))))) && ((NULL == ignoredChars) || !CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str2Char))) break;

 
             str2Index += ((str2Char < 0x10000) ? 1 : 2);
         }
     }
 
             str2Index += ((str2Char < 0x10000) ? 1 : 2);
         }
     }

+    // Need to recalc localized result here for forced ordering
+    if ((NULL != locale) && (kCFCompareEqualTo != compareResult) && (str1Index == rangeToCompare.length) && (str2Index == str2Len)) compareResult = _CFCompareStringsWithLocale(&inlineBuf1, CFRangeMake(forcedIndex1, rangeToCompare.length - forcedIndex1), &inlineBuf2, CFRangeMake(forcedIndex2, str2Len - forcedIndex2), compareOptions, locale);

 
     if (freeLocale && locale) {
        CFRelease(locale);
 
     if (freeLocale && locale) {
        CFRelease(locale);


@@ -2643,23 +2741,30 @@ CFComparisonResult CFStringCompareWithOptionsAndLocale(CFStringRef string, CFStr
 }
 
 
 }
 
 

-CFComparisonResult CFStringCompareWithOptions(CFStringRef string, CFStringRef string2, CFRange rangeToCompare, CFOptionFlags compareOptions) { return CFStringCompareWithOptionsAndLocale(string, string2, rangeToCompare, compareOptions, NULL); }
+CFComparisonResult CFStringCompareWithOptions(CFStringRef string, CFStringRef string2, CFRange rangeToCompare, CFStringCompareFlags compareOptions) { return CFStringCompareWithOptionsAndLocale(string, string2, rangeToCompare, compareOptions, NULL); }

 
 CFComparisonResult CFStringCompare(CFStringRef string, CFStringRef str2, CFOptionFlags options) {
     return CFStringCompareWithOptions(string, str2, CFRangeMake(0, CFStringGetLength(string)), options);
 }
 
 
 CFComparisonResult CFStringCompare(CFStringRef string, CFStringRef str2, CFOptionFlags options) {
     return CFStringCompareWithOptions(string, str2, CFRangeMake(0, CFStringGetLength(string)), options);
 }
 

-Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions, CFLocaleRef locale, CFRange *result)  {
+Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringToFind, CFRange rangeToSearch, CFStringCompareFlags compareOptions, CFLocaleRef locale, CFRange *result)  {

     /* No objc dispatch needed here since CFStringInlineBuffer works with both CFString and NSString */
     CFIndex findStrLen = CFStringGetLength(stringToFind);
     Boolean didFind = false;
     /* No objc dispatch needed here since CFStringInlineBuffer works with both CFString and NSString */
     CFIndex findStrLen = CFStringGetLength(stringToFind);
     Boolean didFind = false;

-    bool lengthVariants = ((compareOptions & (kCFCompareCaseInsensitive|kCFCompareNonliteral|kCFCompareDiacriticsInsensitiveCompatibilityMask)) ? true : false);
+    bool lengthVariants = ((compareOptions & (kCFCompareCaseInsensitive|kCFCompareNonliteral|kCFCompareDiacriticInsensitive)) ? true : false);
+    CFCharacterSetInlineBuffer *ignoredChars = NULL;
+    CFCharacterSetInlineBuffer csetBuffer;
+
+    if (__CFStringFillCharacterSetInlineBuffer(&csetBuffer, compareOptions)) {
+       ignoredChars = &csetBuffer;
+       lengthVariants = true;
+    }

 
     if ((findStrLen > 0) && (rangeToSearch.length > 0) && ((findStrLen <= rangeToSearch.length) || lengthVariants)) {
         UTF32Char strBuf1[kCFStringStackBufferLength];
         UTF32Char strBuf2[kCFStringStackBufferLength];
         CFStringInlineBuffer inlineBuf1, inlineBuf2;
 
     if ((findStrLen > 0) && (rangeToSearch.length > 0) && ((findStrLen <= rangeToSearch.length) || lengthVariants)) {
         UTF32Char strBuf1[kCFStringStackBufferLength];
         UTF32Char strBuf2[kCFStringStackBufferLength];
         CFStringInlineBuffer inlineBuf1, inlineBuf2;

-        UTF32Char str1Char, str2Char;
+        UTF32Char str1Char = 0, str2Char = 0;

         CFStringEncoding eightBitEncoding = __CFStringGetEightBitStringEncoding();
         const uint8_t *str1Bytes = (const uint8_t *)CFStringGetCStringPtr(string, eightBitEncoding);
         const uint8_t *str2Bytes = (const uint8_t *)CFStringGetCStringPtr(stringToFind, eightBitEncoding);
         CFStringEncoding eightBitEncoding = __CFStringGetEightBitStringEncoding();
         const uint8_t *str1Bytes = (const uint8_t *)CFStringGetCStringPtr(string, eightBitEncoding);
         const uint8_t *str2Bytes = (const uint8_t *)CFStringGetCStringPtr(stringToFind, eightBitEncoding);


@@ -2668,8 +2773,11 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
         CFIndex fromLoc, toLoc;
         CFIndex str1Index, str2Index;
         CFIndex strBuf1Len, strBuf2Len;
         CFIndex fromLoc, toLoc;
         CFIndex str1Index, str2Index;
         CFIndex strBuf1Len, strBuf2Len;

+       CFIndex maxStr1Index = (rangeToSearch.location + rangeToSearch.length);

         bool equalityOptions = ((lengthVariants || (compareOptions & kCFCompareWidthInsensitive)) ? true : false);
         bool caseInsensitive = ((compareOptions & kCFCompareCaseInsensitive) ? true : false);
         bool equalityOptions = ((lengthVariants || (compareOptions & kCFCompareWidthInsensitive)) ? true : false);
         bool caseInsensitive = ((compareOptions & kCFCompareCaseInsensitive) ? true : false);

+       bool forwardAnchor = ((kCFCompareAnchored == (compareOptions & (kCFCompareBackwards|kCFCompareAnchored))) ? true : false);
+       bool backwardAnchor = (((kCFCompareBackwards|kCFCompareAnchored) == (compareOptions & (kCFCompareBackwards|kCFCompareAnchored))) ? true : false);

         int8_t delta;
 
         if (NULL == locale) {
         int8_t delta;
 
         if (NULL == locale) {


@@ -2696,7 +2804,6 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
         delta = ((fromLoc <= toLoc) ? 1 : -1);
 
         if ((NULL != str1Bytes) && (NULL != str2Bytes)) {
         delta = ((fromLoc <= toLoc) ? 1 : -1);
 
         if ((NULL != str1Bytes) && (NULL != str2Bytes)) {

-            CFIndex maxStr1Index = (rangeToSearch.location + rangeToSearch.length);

             uint8_t str1Byte, str2Byte;
 
             while (1) {
             uint8_t str1Byte, str2Byte;
 
             while (1) {


@@ -2721,6 +2828,12 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                                     strBuf1Len = 1;
                                 }
                             }
                                     strBuf1Len = 1;
                                 }
                             }

+
+                           if ((NULL != ignoredChars) && (forwardAnchor || (str1Index != fromLoc)) && CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, ((str1Byte < 0x80) ? str1Byte : str1Char))) {
+                               ++str1Index;
+                               continue;
+                           }
+

                             if ((str2Byte < 0x80) && ((NULL == langCode) || ('I' != str2Byte))) {
                                 if (caseInsensitive && (str2Byte >= 'A') && (str2Byte <= 'Z')) str2Byte += ('a' - 'A');
                                 *strBuf2 = str2Byte;
                             if ((str2Byte < 0x80) && ((NULL == langCode) || ('I' != str2Byte))) {
                                 if (caseInsensitive && (str2Byte >= 'A') && (str2Byte <= 'Z')) str2Byte += ('a' - 'A');
                                 *strBuf2 = str2Byte;


@@ -2734,6 +2847,11 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                                 }
                             }
 
                                 }
                             }
 

+                           if ((NULL != ignoredChars) && CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, ((str2Byte < 0x80) ? str2Byte : str2Char))) {
+                               ++str2Index;
+                               continue;
+                           }
+

                             if ((1 == strBuf1Len) && (1 == strBuf2Len)) { // normal case
                                 if (*strBuf1 != *strBuf2) break;
                             } else {
                             if ((1 == strBuf1Len) && (1 == strBuf2Len)) { // normal case
                                 if (*strBuf1 != *strBuf2) break;
                             } else {


@@ -2745,7 +2863,7 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                                 if (strBuf1Len < strBuf2Len) {
                                     delta = strBuf2Len - strBuf1Len;
 
                                 if (strBuf1Len < strBuf2Len) {
                                     delta = strBuf2Len - strBuf1Len;
 

-                                    if ((str1Index + strBuf1Len + delta) > (rangeToSearch.location + rangeToSearch.length)) break;
+                                    if ((str1Index + strBuf1Len + delta) > maxStr1Index) break;

 
                                     characters = &(strBuf2[strBuf1Len]);
                                     charactersLimit = characters + delta;
 
                                     characters = &(strBuf2[strBuf1Len]);
                                     charactersLimit = characters + delta;


@@ -2779,8 +2897,26 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                     ++str1Index; ++str2Index;
                 }
 
                     ++str1Index; ++str2Index;
                 }
 

+               if ((NULL != ignoredChars) && (str1Index == maxStr1Index) && (str2Index < findStrLen)) { // Process the stringToFind tail
+                   while (str2Index < findStrLen) {
+                       str2Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index);
+
+                       if (!CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str2Char)) break;
+                       ++str2Index;
+                   }
+               }
+

                 if (str2Index == findStrLen) {
                 if (str2Index == findStrLen) {

-                    if (((kCFCompareBackwards|kCFCompareAnchored) != (compareOptions & (kCFCompareBackwards|kCFCompareAnchored))) || (str1Index == (rangeToSearch.location + rangeToSearch.length))) {
+                   if ((NULL != ignoredChars) && backwardAnchor && (str1Index < maxStr1Index)) { // Process the anchor tail
+                       while (str1Index < maxStr1Index) {
+                           str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);
+                           
+                           if (!CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str1Char)) break;
+                           ++str1Index;
+                       }
+                   }
+
+                    if (!backwardAnchor || (str1Index == maxStr1Index)) {

                         didFind = true;
                         if (NULL != result) *result = CFRangeMake(fromLoc, str1Index - fromLoc);
                     }
                         didFind = true;
                         if (NULL != result) *result = CFRangeMake(fromLoc, str1Index - fromLoc);
                     }


@@ -2793,7 +2929,7 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
         } else if (equalityOptions) {
             UTF16Char otherChar;
             CFIndex str1UsedLen, str2UsedLen, strBuf1Index = 0, strBuf2Index = 0;
         } else if (equalityOptions) {
             UTF16Char otherChar;
             CFIndex str1UsedLen, str2UsedLen, strBuf1Index = 0, strBuf2Index = 0;

-            bool diacriticsInsensitive = ((compareOptions & kCFCompareDiacriticsInsensitiveCompatibilityMask) ? true : false);
+            bool diacriticsInsensitive = ((compareOptions & kCFCompareDiacriticInsensitive) ? true : false);

             const uint8_t *graphemeBMP = CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, 0);
             const uint8_t *combClassBMP = (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(kCFUniCharCombiningProperty, 0);
 
             const uint8_t *graphemeBMP = CFUniCharGetBitmapPtrForPlane(kCFUniCharGraphemeExtendCharacterSet, 0);
             const uint8_t *combClassBMP = (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(kCFUniCharCombiningProperty, 0);
 


@@ -2820,7 +2956,7 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                     }
 
                     if (str1Char != str2Char) {
                     }
 
                     if (str1Char != str2Char) {

-                        if ((str1Char < 0x80) && (str2Char < 0x80) && ((NULL == langCode) || !caseInsensitive)) break;
+                        if ((str1Char < 0x80) && (str2Char < 0x80) && (NULL == ignoredChars) && ((NULL == langCode) || !caseInsensitive)) break;

 
                         if (CFUniCharIsSurrogateHighCharacter(str1Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index + 1)))) {
                             str1Char = CFUniCharGetLongCharacterForSurrogatePair(str1Char, otherChar);
 
                         if (CFUniCharIsSurrogateHighCharacter(str1Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index + 1)))) {
                             str1Char = CFUniCharGetLongCharacterForSurrogatePair(str1Char, otherChar);


@@ -2832,6 +2968,21 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                             str2UsedLen = 2;
                         }
 
                             str2UsedLen = 2;
                         }
 

+                       if (NULL != ignoredChars) {
+                           if ((forwardAnchor || (str1Index != fromLoc)) && (str1Index < maxStr1Index) && CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str1Char)) {
+                               if ((strBuf1Len > 0) && (strBuf1Index == strBuf1Len)) strBuf1Len = 0;
+                               if (strBuf1Len == 0) str1Index += str1UsedLen;
+                               if (strBuf2Len > 0) --strBuf2Index;
+                               continue;
+                           }
+                           if (CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str2Char)) {
+                               if ((strBuf2Len > 0) && (strBuf2Index == strBuf2Len)) strBuf2Len = 0;
+                               if (strBuf2Len == 0) str2Index += str2UsedLen;
+                               if (strBuf1Len > 0) -- strBuf1Index;
+                               continue;
+                           }       
+                       }
+                       

                         if (diacriticsInsensitive && (str1Index > fromLoc)) {
                             bool str1Skip = false;
                             bool str2Skip = false;
                         if (diacriticsInsensitive && (str1Index > fromLoc)) {
                             bool str1Skip = false;
                             bool str2Skip = false;


@@ -2885,13 +3036,24 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                     if (strBuf2Len == 0) str2Index += str2UsedLen;
                 }
 
                     if (strBuf2Len == 0) str2Index += str2UsedLen;
                 }
 

+               if ((NULL != ignoredChars) && (str1Index == maxStr1Index) && (str2Index < findStrLen)) { // Process the stringToFind tail
+                   while (str2Index < findStrLen) {
+                       str2Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index);
+                        if (CFUniCharIsSurrogateHighCharacter(str2Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf2, str2Index + 1)))) {
+                            str2Char = CFUniCharGetLongCharacterForSurrogatePair(str2Char, otherChar);
+                        }
+                       if (!CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str2Char)) break;
+                       str2Index += ((str2Char < 0x10000) ? 1 : 2);
+                   }
+               }
+

                 if (str2Index == findStrLen) {
                     bool match = true;
 
                     if (strBuf1Len > 0) {
                         match = false;
 
                 if (str2Index == findStrLen) {
                     bool match = true;
 
                     if (strBuf1Len > 0) {
                         match = false;
 

-                        if ((compareOptions & kCFCompareDiacriticsInsensitiveCompatibilityMask) && (strBuf1[0] < 0x0510)) {
+                        if ((compareOptions & kCFCompareDiacriticInsensitive) && (strBuf1[0] < 0x0510)) {

                             while (strBuf1Index < strBuf1Len) {
                                 if (!CFUniCharIsMemberOfBitmap(strBuf1[strBuf1Index], ((strBuf1[strBuf1Index] < 0x10000) ? graphemeBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharCanonicalDecomposableCharacterSet, (strBuf1[strBuf1Index] >> 16))))) break;
                                 ++strBuf1Index;
                             while (strBuf1Index < strBuf1Len) {
                                 if (!CFUniCharIsMemberOfBitmap(strBuf1[strBuf1Index], ((strBuf1[strBuf1Index] < 0x10000) ? graphemeBMP : CFUniCharGetBitmapPtrForPlane(kCFUniCharCanonicalDecomposableCharacterSet, (strBuf1[strBuf1Index] >> 16))))) break;
                                 ++strBuf1Index;


@@ -2904,7 +3066,7 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                         }
                     }
 
                         }
                     }
 

-                    if (match && (compareOptions & (kCFCompareDiacriticsInsensitiveCompatibilityMask|kCFCompareNonliteral)) && (str1Index < (rangeToSearch.location + rangeToSearch.length))) {
+                    if (match && (compareOptions & (kCFCompareDiacriticInsensitive|kCFCompareNonliteral)) && (str1Index < maxStr1Index)) {

                         const uint8_t *nonBaseBitmap;
 
                         str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);
                         const uint8_t *nonBaseBitmap;
 
                         str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);


@@ -2926,9 +3088,7 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                                     } while (CFUniCharIsMemberOfBitmap(str1Char, graphemeBMP), (rangeToSearch.location < index));
 
                                     if (str1Char < 0x0510) {
                                     } while (CFUniCharIsMemberOfBitmap(str1Char, graphemeBMP), (rangeToSearch.location < index));
 
                                     if (str1Char < 0x0510) {

-                                        CFIndex maxIndex = (rangeToSearch.location + rangeToSearch.length);
-
-                                        while (++str1Index < maxIndex) if (!CFUniCharIsMemberOfBitmap(CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index), graphemeBMP)) break;
+                                        while (++str1Index < maxStr1Index) if (!CFUniCharIsMemberOfBitmap(CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index), graphemeBMP)) break;

                                     }
                                 }
                             } else {
                                     }
                                 }
                             } else {


@@ -2947,7 +3107,18 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
                     }
 
                     if (match) {
                     }
 
                     if (match) {

-                        if (((kCFCompareBackwards|kCFCompareAnchored) != (compareOptions & (kCFCompareBackwards|kCFCompareAnchored))) || (str1Index == (rangeToSearch.location + rangeToSearch.length))) {
+                       if ((NULL != ignoredChars) && backwardAnchor && (str1Index < maxStr1Index)) { // Process the anchor tail
+                           while (str1Index < maxStr1Index) {
+                               str1Char = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index);
+                               if (CFUniCharIsSurrogateHighCharacter(str1Char) && CFUniCharIsSurrogateLowCharacter((otherChar = CFStringGetCharacterFromInlineBuffer(&inlineBuf1, str1Index + 1)))) {
+                                   str1Char = CFUniCharGetLongCharacterForSurrogatePair(str1Char, otherChar);
+                               }
+                               if (!CFCharacterSetInlineBufferIsLongCharacterMember(ignoredChars, str1Char)) break;
+                               str1Index += ((str1Char < 0x10000) ? 1 : 2);
+                           }
+                       }
+
+                        if (!backwardAnchor || (str1Index == maxStr1Index)) {

                             didFind = true;
                             if (NULL != result) *result = CFRangeMake(fromLoc, str1Index - fromLoc);
                         }
                             didFind = true;
                             if (NULL != result) *result = CFRangeMake(fromLoc, str1Index - fromLoc);
                         }


@@ -2984,7 +3155,8 @@ Boolean CFStringFindWithOptionsAndLocale(CFStringRef string, CFStringRef stringT
     return didFind;
 }
 
     return didFind;
 }
 

-Boolean CFStringFindWithOptions(CFStringRef string, CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions, CFRange *result) { return CFStringFindWithOptionsAndLocale(string, stringToFind, rangeToSearch, compareOptions, NULL, result); }
+
+Boolean CFStringFindWithOptions(CFStringRef string, CFStringRef stringToFind, CFRange rangeToSearch, CFStringCompareFlags compareOptions, CFRange *result) { return CFStringFindWithOptionsAndLocale(string, stringToFind, rangeToSearch, compareOptions, NULL, result); }

 
 // Functions to deal with special arrays of CFRange, CFDataRef, created by CFStringCreateArrayWithFindResults()
 
 
 // Functions to deal with special arrays of CFRange, CFDataRef, created by CFStringCreateArrayWithFindResults()
 


@@ -3009,7 +3181,7 @@ static Boolean    __rangeEqual(const void *ptr1, const void *ptr2) {
 }
 
 
 }
 
 

-CFArrayRef CFStringCreateArrayWithFindResults(CFAllocatorRef alloc, CFStringRef string, CFStringRef stringToFind, CFRange rangeToSearch, CFOptionFlags compareOptions) {
+CFArrayRef CFStringCreateArrayWithFindResults(CFAllocatorRef alloc, CFStringRef string, CFStringRef stringToFind, CFRange rangeToSearch, CFStringCompareFlags compareOptions) {

     CFRange foundRange;
     Boolean backwards = ((compareOptions & kCFCompareBackwards) != 0);
     UInt32 endIndex = rangeToSearch.location + rangeToSearch.length;
     CFRange foundRange;
     Boolean backwards = ((compareOptions & kCFCompareBackwards) != 0);
     UInt32 endIndex = rangeToSearch.location + rangeToSearch.length;


@@ -3063,7 +3235,7 @@ CFArrayRef CFStringCreateArrayWithFindResults(CFAllocatorRef alloc, CFStringRef
 }
 
 
 }
 
 

-CFRange CFStringFind(CFStringRef string, CFStringRef stringToFind, CFOptionFlags compareOptions) {
+CFRange CFStringFind(CFStringRef string, CFStringRef stringToFind, CFStringCompareFlags compareOptions) {

     CFRange foundRange;
 
     if (CFStringFindWithOptions(string, stringToFind, CFRangeMake(0, CFStringGetLength(string)), compareOptions, &foundRange)) {
     CFRange foundRange;
 
     if (CFStringFindWithOptions(string, stringToFind, CFRangeMake(0, CFStringGetLength(string)), compareOptions, &foundRange)) {


@@ -3381,155 +3553,9 @@ CFRange CFStringGetRangeOfCharacterClusterAtIndex(CFStringRef string, CFIndex ch
     return range;
 }
 
     return range;
 }
 

-#if 1 /* Using the new implementation. Leaving the old implementation if'ed out for testing purposes for now */

 CFRange CFStringGetRangeOfComposedCharactersAtIndex(CFStringRef theString, CFIndex theIndex) {
     return CFStringGetRangeOfCharacterClusterAtIndex(theString, theIndex, kCFStringComposedCharacterCluster);
 }
 CFRange CFStringGetRangeOfComposedCharactersAtIndex(CFStringRef theString, CFIndex theIndex) {
     return CFStringGetRangeOfCharacterClusterAtIndex(theString, theIndex, kCFStringComposedCharacterCluster);
 }

-#else
-/*!
-       @function CFStringGetRangeOfComposedCharactersAtIndex
-       Returns the range of the composed character sequence at the specified index.
-       @param theString The CFString which is to be searched.  If this
-                               parameter is not a valid CFString, the behavior is
-                       undefined.
-       @param theIndex The index of the character contained in the
-                       composed character sequence.  If the index is
-                       outside the index space of the string (0 to N-1 inclusive,
-                       where N is the length of the string), the behavior is
-                       undefined.
-       @result The range of the composed character sequence.
-*/
-#define ExtHighHalfZoneLow 0xD800
-#define ExtHighHalfZoneHigh 0xDBFF
-#define ExtLowHalfZoneLow 0xDC00
-#define ExtLowHalfZoneHigh 0xDFFF
-#define JunseongStart 0x1160
-#define JonseongEnd 0x11F9
-CF_INLINE Boolean IsHighCode(UniChar X) { return (X >= ExtHighHalfZoneLow && X <= ExtHighHalfZoneHigh); }
-CF_INLINE Boolean IsLowCode(UniChar X) { return (X >= ExtLowHalfZoneLow && X <= ExtLowHalfZoneHigh); }
-#define IsHangulConjoiningJamo(X) (X >= JunseongStart && X <= JonseongEnd)
-#define IsHalfwidthKanaVoicedMark(X) ((X == 0xFF9E) || (X == 0xFF9F))
-CF_INLINE Boolean IsNonBaseChar(UniChar X, CFCharacterSetRef nonBaseSet) { return (CFCharacterSetIsCharacterMember(nonBaseSet, X) || IsHangulConjoiningJamo(X) || IsHalfwidthKanaVoicedMark(X) || (X & 0x1FFFF0) == 0xF870); } // combining char, hangul jamo, or Apple corporate variant tag
-#define ZWJ    0x200D
-#define ZWNJ   0x200C
-#define COMBINING_GRAPHEME_JOINER (0x034F)
-
-static CFCharacterSetRef nonBaseChars = NULL;
-static CFCharacterSetRef letterChars = NULL;
-static const void *__CFCombiningClassBMP = NULL;
-
-CF_INLINE bool IsVirama(UTF32Char character) {
-    return ((character == COMBINING_GRAPHEME_JOINER) ? true : ((character < 0x10000) && (CFUniCharGetCombiningPropertyForCharacter(character, __CFCombiningClassBMP) == 9) ? true : false));
-}
-
-CFRange CFStringGetRangeOfComposedCharactersAtIndex(CFStringRef theString, CFIndex theIndex) {
-    CFIndex left, current, save;
-    CFIndex len = CFStringGetLength(theString);
-    CFStringInlineBuffer stringBuffer;
-    static volatile Boolean _isInited = false;
-
-    if (theIndex >= len) return CFRangeMake(kCFNotFound, 0);
-
-    if (!_isInited) {
-        nonBaseChars = CFCharacterSetGetPredefined(kCFCharacterSetNonBase);
-        letterChars = CFCharacterSetGetPredefined(kCFCharacterSetLetter);
-        __CFCombiningClassBMP = CFUniCharGetUnicodePropertyDataForPlane(kCFUniCharCombiningProperty, 0);
-        _isInited = true;
-    }
-
-    save = current = theIndex;
-
-    CFStringInitInlineBuffer(theString, &stringBuffer, CFRangeMake(0, len));
-
-    /*
-     * First check for transcoding hints
-     */
-    {
-        CFRange theRange = (current > MAX_TRANSCODING_LENGTH  ? CFRangeMake(current - MAX_TRANSCODING_LENGTH, MAX_TRANSCODING_LENGTH + 1) : CFRangeMake(0, current + 1));
-
-        // Should check the next loc ?
-        if (current + 1 < len) ++theRange.length;
-
-        if (theRange.length > 1) {
-            UniChar characterBuffer[MAX_TRANSCODING_LENGTH + 2]; // Transcoding hint length + current loc + next loc
-
-            if (stringBuffer.directBuffer) {
-                memmove(characterBuffer, stringBuffer.directBuffer + theRange.location, theRange.length * sizeof(UniChar));
-            } else {
-                CFStringGetCharacters(theString, theRange, characterBuffer);
-            }
-
-            while (current >= theRange.location) {
-                if ((characterBuffer[current - theRange.location] & 0x1FFFF0) == 0xF860) {
-                    theRange = CFRangeMake(current, __CFTranscodingHintLength[characterBuffer[current - theRange.location] - 0xF860] + 1);
-                    if ((theRange.location + theRange.length) <= theIndex) break;
-                    if ((theRange.location + theRange.length) >= len) theRange.length = len - theRange.location;
-                    return theRange;
-                }
-                if (current == 0) break;
-                --current;
-            }
-            current = theIndex; // Reset current
-        }
-    }
-
-//#warning Aki 5/29/01 This does not support non-base chars in non-BMP planes (i.e. musical symbol combining stem in Unicode 3.1)
-    /*
-     * if we start NOT on a base, first move back to a base as appropriate.
-     */
-
-  roundAgain:
-
-    while ((current > 0) && IsNonBaseChar(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current), nonBaseChars)) --current;
-
-    if (current >= 1 && current < len && CFCharacterSetIsCharacterMember(letterChars, CFStringGetCharacterFromInlineBuffer(&stringBuffer, current)) && IsVirama(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current - 1))) {
-       --current;
-       goto roundAgain;
-    } else if ((current >= 2) && (CFStringGetCharacterFromInlineBuffer(&stringBuffer, current - 1) == ZWJ) && IsVirama(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current - 2))) {
-        current -= 2;
-       goto roundAgain;
-    }
-
-    /*
-     * Set the left position, then jump back to the saved original position.
-     */
-
-    if (current >= 1 && IsLowCode(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current)) && IsHighCode(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current - 1))) --current;
-    left = current;
-    current = save;
-
-    /*
-     * Now, presume we are on a base; move forward & look for the next base.
-     * Handle jumping over H/L codes.
-     */
-    if (IsHighCode(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current)) && (current + 1) < len && IsLowCode(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current + 1))) ++current;
-    ++current;
-
-  round2Again:
-
-    if (current < len)  {
-        while (IsNonBaseChar(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current), nonBaseChars)) {
-           ++current;
-           if (current >= len) break;
-       }
-       if ((current < len) && CFCharacterSetIsCharacterMember(letterChars, CFStringGetCharacterFromInlineBuffer(&stringBuffer, current))) {
-           if (IsVirama(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current - 1))) {
-               ++current; goto round2Again;
-           } else if ((current >= 2) && (CFStringGetCharacterFromInlineBuffer(&stringBuffer, current - 1) == ZWJ) && IsVirama(CFStringGetCharacterFromInlineBuffer(&stringBuffer, current - 2))) {
-               ++current; goto round2Again;
-           }
-       }
-    }
-    /*
-     * Now, "current" is a base, and "left" is a base.
-     * The junk between had better contain "save"!
-     */
-    if ((! (left <= save)) || (! (save <= current))) {
-       CFLog(kCFLogLevelWarning, CFSTR("CFString: CFStringGetRangeOfComposedCharactersAtIndex:%d returned invalid\n"), save);
-    }
-    return CFRangeMake(left, current - left);
-}
-#endif

 
 /*!
        @function CFStringFindCharacterFromSet
 
 /*!
        @function CFStringFindCharacterFromSet


@@ -3561,7 +3587,7 @@ CFRange CFStringGetRangeOfComposedCharactersAtIndex(CFStringRef theString, CFInd
 #define SURROGATE_START 0xD800
 #define SURROGATE_END 0xDFFF
 
 #define SURROGATE_START 0xD800
 #define SURROGATE_END 0xDFFF
 

-CF_EXPORT Boolean CFStringFindCharacterFromSet(CFStringRef theString, CFCharacterSetRef theSet, CFRange rangeToSearch, CFOptionFlags searchOptions, CFRange *result) {
+CF_EXPORT Boolean CFStringFindCharacterFromSet(CFStringRef theString, CFCharacterSetRef theSet, CFRange rangeToSearch, CFStringCompareFlags searchOptions, CFRange *result) {

     CFStringInlineBuffer stringBuffer;
     CFCharacterSetInlineBuffer csetBuffer;
     UniChar ch;
     CFStringInlineBuffer stringBuffer;
     CFCharacterSetInlineBuffer csetBuffer;
     UniChar ch;


@@ -3867,7 +3893,7 @@ CFDataRef CFStringCreateExternalRepresentation(CFAllocatorRef alloc, CFStringRef
     if (((encoding & 0x0FFF) == kCFStringEncodingUnicode) && ((encoding == kCFStringEncodingUnicode) || ((encoding > kCFStringEncodingUTF8) && (encoding <= kCFStringEncodingUTF32LE)))) {
         guessedByteLength = (length + 1) * ((((encoding >> 26)  & 2) == 0) ? sizeof(UTF16Char) : sizeof(UTF32Char)); // UTF32 format has the bit set
     } else if (((guessedByteLength = CFStringGetMaximumSizeForEncoding(length, encoding)) > length) && !CF_IS_OBJC(__kCFStringTypeID, string)) { // Multi byte encoding
     if (((encoding & 0x0FFF) == kCFStringEncodingUnicode) && ((encoding == kCFStringEncodingUnicode) || ((encoding > kCFStringEncodingUTF8) && (encoding <= kCFStringEncodingUTF32LE)))) {
         guessedByteLength = (length + 1) * ((((encoding >> 26)  & 2) == 0) ? sizeof(UTF16Char) : sizeof(UTF32Char)); // UTF32 format has the bit set
     } else if (((guessedByteLength = CFStringGetMaximumSizeForEncoding(length, encoding)) > length) && !CF_IS_OBJC(__kCFStringTypeID, string)) { // Multi byte encoding

-#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD

         if (__CFStrIsUnicode(string)) {
             CFIndex aLength = CFStringEncodingByteLengthForCharacters(encoding, kCFStringEncodingPrependBOM, __CFStrContents(string), __CFStrLength(string));
             if (aLength > 0) guessedByteLength = aLength;
         if (__CFStrIsUnicode(string)) {
             CFIndex aLength = CFStringEncodingByteLengthForCharacters(encoding, kCFStringEncodingPrependBOM, __CFStrContents(string), __CFStrLength(string));
             if (aLength > 0) guessedByteLength = aLength;


@@ -3881,7 +3907,7 @@ CFDataRef CFStringCreateExternalRepresentation(CFAllocatorRef alloc, CFStringRef
         if (guessedByteLength == length && __CFStrIsEightBit(string) && __CFStringEncodingIsSupersetOfASCII(encoding)) { // It's all ASCII !!
             return CFDataCreate(alloc, ((uint8_t *)__CFStrContents(string) + __CFStrSkipAnyLengthByte(string)), __CFStrLength(string));
         }
         if (guessedByteLength == length && __CFStrIsEightBit(string) && __CFStringEncodingIsSupersetOfASCII(encoding)) { // It's all ASCII !!
             return CFDataCreate(alloc, ((uint8_t *)__CFStrContents(string) + __CFStrSkipAnyLengthByte(string)), __CFStrLength(string));
         }

-#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD

         }
 #endif
     }
         }
 #endif
     }


@@ -4114,7 +4140,7 @@ void CFStringAppendFormat(CFMutableStringRef str, CFDictionaryRef formatOptions,
 }
 
 
 }
 
 

-CFIndex CFStringFindAndReplace(CFMutableStringRef string, CFStringRef stringToFind, CFStringRef replacementString, CFRange rangeToSearch, CFOptionFlags compareOptions) {
+CFIndex CFStringFindAndReplace(CFMutableStringRef string, CFStringRef stringToFind, CFStringRef replacementString, CFRange rangeToSearch, CFStringCompareFlags compareOptions) {

     CFRange foundRange;
     Boolean backwards = ((compareOptions & kCFCompareBackwards) != 0);
     UInt32 endIndex = rangeToSearch.location + rangeToSearch.length;
     CFRange foundRange;
     Boolean backwards = ((compareOptions & kCFCompareBackwards) != 0);
     UInt32 endIndex = rangeToSearch.location + rangeToSearch.length;


@@ -5301,7 +5327,7 @@ void CFStringAppendFormatAndArguments(CFMutableStringRef outputString, CFDiction
     _CFStringAppendFormatAndArgumentsAux(outputString, NULL, formatOptions, formatString, args);
 }
 
     _CFStringAppendFormatAndArgumentsAux(outputString, NULL, formatOptions, formatString, args);
 }
 

-#if DEPLOYMENT_TARGET_MACOSX
+#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED

 #define SNPRINTF(TYPE, WHAT) {                         \
     TYPE value = (TYPE) WHAT;                          \
     if (-1 != specs[curSpec].widthArgNum) {            \
 #define SNPRINTF(TYPE, WHAT) {                         \
     TYPE value = (TYPE) WHAT;                          \
     if (-1 != specs[curSpec].widthArgNum) {            \


@@ -5322,18 +5348,18 @@ void CFStringAppendFormatAndArguments(CFMutableStringRef outputString, CFDiction
     TYPE value = (TYPE) WHAT;                          \
     if (-1 != specs[curSpec].widthArgNum) {            \
        if (-1 != specs[curSpec].precArgNum) {          \
     TYPE value = (TYPE) WHAT;                          \
     if (-1 != specs[curSpec].widthArgNum) {            \
        if (-1 != specs[curSpec].precArgNum) {          \

-           snprintf(buffer, 255, formatBuffer, width, precision, value); \
+           sprintf(buffer, formatBuffer, width, precision, value); \

        } else {                                        \
        } else {                                        \

-           snprintf(buffer, 255, formatBuffer, width, value); \
+           sprintf(buffer, formatBuffer, width, value); \

        }                                               \
     } else {                                           \
        if (-1 != specs[curSpec].precArgNum) {          \
        }                                               \
     } else {                                           \
        if (-1 != specs[curSpec].precArgNum) {          \

-           snprintf(buffer, 255, formatBuffer, precision, value); \
+           sprintf(buffer, formatBuffer, precision, value); \

         } else {                                       \
         } else {                                       \

-           snprintf(buffer, 255, formatBuffer, value); \
+           sprintf(buffer, formatBuffer, value);       \

        }                                               \
     }}
        }                                               \
     }}

-#endif //__MACH__
+#endif

 
 void _CFStringAppendFormatAndArgumentsAux(CFMutableStringRef outputString, CFStringRef (*copyDescFunc)(void *, const void *), CFDictionaryRef formatOptions, CFStringRef formatString, va_list args) {
     SInt32 numSpecs, sizeSpecs, sizeArgNum, formatIdx, curSpec, argNum;
 
 void _CFStringAppendFormatAndArgumentsAux(CFMutableStringRef outputString, CFStringRef (*copyDescFunc)(void *, const void *), CFDictionaryRef formatOptions, CFStringRef formatString, va_list args) {
     SInt32 numSpecs, sizeSpecs, sizeArgNum, formatIdx, curSpec, argNum;


@@ -5608,7 +5634,7 @@ void _CFStringAppendFormatAndArgumentsAux(CFMutableStringRef outputString, CFStr
                        }
                        // See if we need to localize the decimal point
                         if (formatOptions) {   // We have localization info
                        }
                        // See if we need to localize the decimal point
                         if (formatOptions) {   // We have localization info

-                           CFStringRef decimalSeparator = (CFGetTypeID(formatOptions) == CFLocaleGetTypeID()) ? (CFStringRef)CFLocaleGetValue((CFLocaleRef)formatOptions, kCFLocaleDecimalSeparator) : (CFStringRef)CFDictionaryGetValue(formatOptions, CFSTR("NSDecimalSeparator"));
+                           CFStringRef decimalSeparator = (CFGetTypeID(formatOptions) == CFLocaleGetTypeID()) ? (CFStringRef)CFLocaleGetValue((CFLocaleRef)formatOptions, kCFLocaleDecimalSeparatorKey) : (CFStringRef)CFDictionaryGetValue(formatOptions, CFSTR("NSDecimalSeparator"));

                             if (decimalSeparator != NULL) {    // We have a decimal separator in there
                                 CFIndex decimalPointLoc = 0;
                                 while (buffer[decimalPointLoc] != 0 && buffer[decimalPointLoc] != '.') decimalPointLoc++;
                             if (decimalSeparator != NULL) {    // We have a decimal separator in there
                                 CFIndex decimalPointLoc = 0;
                                 while (buffer[decimalPointLoc] != 0 && buffer[decimalPointLoc] != '.') decimalPointLoc++;


@@ -5628,7 +5654,7 @@ void _CFStringAppendFormatAndArgumentsAux(CFMutableStringRef outputString, CFStr
                                if (dynamicBuffer) {
                                        CFAllocatorDeallocate(kCFAllocatorSystemDefault, dynamicBuffer);
                                }
                                if (dynamicBuffer) {
                                        CFAllocatorDeallocate(kCFAllocatorSystemDefault, dynamicBuffer);
                                }

-#endif         
+#endif

                        }
                 break;
        case CFFormatLiteralType:
                        }
                 break;
        case CFFormatLiteralType: