CoreFoundation/String.subproj/CFStringTransform.c - third_party/swift-corelibs-foundation - Git at Google

 // This source file is part of the Swift.org open source project
 //
 // Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //

 /*  CFStringTransform.c
     Copyright (c) 2004-2015, Apple Inc. All rights reserved.

 !!! For performance reasons, it's important that all functions marked CF_INLINE in this file are inlined.
 */

 #include <CoreFoundation/CFBase.h>
 #include <CoreFoundation/CFString.h>
 #include <CoreFoundation/CFUniChar.h>
 #include <CoreFoundation/CFPriv.h>
 #include "CFInternal.h"
 #include <unicode/utrans.h>

 static const char *__CFStringTransformGetICUIdentifier(CFStringRef identifier);

 #define INSTRUMENT_CACHE 0

 #if INSTRUMENT_CACHE
 #include <stdio.h>
 #endif

 #if DEPLOYMENT_TARGET_EMBEDDED
 #define LITE_CACHE 1
 #endif

 #if LITE_CACHE
 static CFStringRef __CFStringTransformCacheID = NULL;
 static UTransliterator *__CFStringTransformCacheTL = NULL;
 static Boolean __CFStringTransformCacheRev = false;
 #else
 static CFMutableDictionaryRef __CFStringTransformCache = NULL;
 #endif
 static CFLock_t __CFStringTransformGlobalLock = CFLockInit;

 #define kCFStringTransformStackBufferSize 1024

 CF_INLINE void __CFStringTransformLockGlobal(void) {
     __CFLock(&__CFStringTransformGlobalLock);
 }

 CF_INLINE void __CFStringTransformUnlockGlobal(void) {
     __CFUnlock(&__CFStringTransformGlobalLock);
 }

 #if !LITE_CACHE
 struct transform_element {
     struct transform_element *_next;
     UTransliterator *_transliterator;
 };

 struct transform_head {
     struct transform_element *_forward_q;
     struct transform_element *_reverse_q;
 };
 #endif

 /* Create an element for the transform cache, including the ICU transliterator
 */

 #if LITE_CACHE
 static UTransliterator *
 #else
 static struct transform_element *
 #endif
 __CFStringTransformCreate(CFStringRef identifier, bool reverse) {
 #if INSTRUMENT_CACHE
     fprintf(stderr, "Create %s transform ", reverse?"reverse":"forward");
     CFShow(identifier);
 #endif
     UTransliterator *made = NULL;
     UErrorCode icuStatus = U_ZERO_ERROR;

     const char *known = __CFStringTransformGetICUIdentifier(identifier);
     if (known) {
 	UniChar buff[kCFStringTransformStackBufferSize];
 	CFIndex len = strlen(known);
 	CFIndex idx;
 	for (idx = 0; idx < len; idx++) {
 	    buff[idx] = known[idx];
 	}
 	made = utrans_openU((const UChar *)buff, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
     } else {
 	CFIndex len = CFStringGetLength(identifier);
 	const UniChar *ucp = CFStringGetCharactersPtr(identifier);
 	if (ucp != NULL) {
 	    made = utrans_openU((const UChar *)ucp, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
 	} else if (len <= kCFStringTransformStackBufferSize) {
 	    UniChar buff[kCFStringTransformStackBufferSize];
 	    CFStringGetCharacters(identifier, CFRangeMake(0, len), buff);
 	    made = utrans_openU((const UChar *)buff, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
 	} else {
 	    UniChar *buff = (UniChar *) CFAllocatorAllocate(kCFAllocatorSystemDefault, len * sizeof(UniChar), 0);
 	    if (buff == NULL)
 		return NULL;
 	    CFStringGetCharacters(identifier, CFRangeMake(0, len), buff);
 	    made = utrans_openU((const UChar *)buff, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
 	    CFAllocatorDeallocate(kCFAllocatorSystemDefault, buff);
 	}
     }

     if (U_FAILURE(icuStatus)) {
         if (made)
             utrans_close(made);
         return NULL;
     }

 #if LITE_CACHE
     return made;
 #else
     struct transform_element *result = NULL;
     result = (struct transform_element *) CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(struct transform_element), 0);
     if (result == NULL) {
         utrans_close(made);
         return NULL;
     }

     result->_next = NULL;
     result->_transliterator = made;
 #if INSTRUMENT_CACHE
     fprintf(stderr, "Created\n");
 #endif
     return result;
 #endif
 }

 /* Acquire a transform element from the cache
 */

 #if LITE_CACHE
 static UTransliterator *
 #else
 static struct transform_element *
 #endif
 __CFStringTransformAcquire(CFStringRef identifier, bool reverse) {
 #if LITE_CACHE
     __CFStringTransformLockGlobal();
     if (__CFStringTransformCacheID && (reverse == __CFStringTransformCacheRev) && (identifier == __CFStringTransformCacheID || CFEqual(identifier, __CFStringTransformCacheID))) {
         CFRelease(__CFStringTransformCacheID);
         __CFStringTransformCacheID = NULL;
         UTransliterator *cached = __CFStringTransformCacheTL;
 	__CFStringTransformCacheTL = NULL;
         __CFStringTransformUnlockGlobal();
         return cached;
     }
     __CFStringTransformUnlockGlobal();

     UTransliterator *made = __CFStringTransformCreate(identifier, reverse);
     return made;
 #else
     struct transform_head *head = NULL, *second_head = NULL;
     struct transform_element *element = NULL;
     CFMutableDictionaryRef cache = NULL;
 #if INSTRUMENT_CACHE
     fprintf(stderr, "Acquire %s transform ", reverse?"reverse":"forward");
     CFShow(identifier);
 #endif
     __CFStringTransformLockGlobal();

     /* Fetch the cache, creating it if necessary
     */
     if (__CFStringTransformCache == NULL) {
         __CFStringTransformUnlockGlobal();
 #if INSTRUMENT_CACHE
         fprintf(stderr, "Create cache\n");
 #endif
         cache = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFCopyStringDictionaryKeyCallBacks, NULL);
         if (cache == NULL)
             return NULL;
         __CFStringTransformLockGlobal();
         if (__CFStringTransformCache == NULL) {
             __CFStringTransformCache = cache;
         }
         else {
 #if INSTRUMENT_CACHE
             fprintf(stderr, "Redundant cache created\n");
 #endif
             CFRelease(cache);
         }
     }
     cache = __CFStringTransformCache;

     /* Now we have the cache. Fetch the head element. Create it if necessary.
     */
     head = (struct transform_head *) CFDictionaryGetValue(cache, identifier);
     if (head == NULL) {
         __CFStringTransformUnlockGlobal();

 #if INSTRUMENT_CACHE
         fprintf(stderr, "Cache entry head not found\n");
 #endif
         /* Make the element first in case it's a bogus transform
         */
         element = __CFStringTransformCreate(identifier, reverse);

         if (element == NULL)
             return NULL;

         /* Create a new head element
         */
         head = (struct transform_head *) CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(struct transform_head), 0);
         if (head == NULL) {
             utrans_close(element->_transliterator);
             CFAllocatorDeallocate(kCFAllocatorSystemDefault, element);
             return NULL;
         }
         head->_forward_q = NULL;
         head->_reverse_q = NULL;

 #if INSTRUMENT_CACHE
         fprintf(stderr, "Cache head element created\n");
 #endif

         __CFStringTransformLockGlobal();

         /* Check the head element again in case someone else made it first.
         */
         second_head = (struct transform_head *) CFDictionaryGetValue(cache, identifier);
         if (second_head == NULL) {
             CFDictionaryAddValue(cache, identifier, head);
         }
     }

     /* If we don't already have a transliterator, get one from the queue or create one.
     */
     if (element == NULL) {      // if element is NULL head cannot be NULL
         if (reverse) {
             element = head->_reverse_q;
             if (element != NULL) {
                 head->_reverse_q = element->_next;
             }
         }
         else {
             element = head->_forward_q;
             if (element != NULL) {
                 head->_forward_q = element->_next;
             }
         }
     }

     __CFStringTransformUnlockGlobal();

     /* If we made a head and someone else did too, dump ours.
     */
     if (second_head != NULL) {
         CFAllocatorDeallocate(kCFAllocatorSystemDefault, head);
 #if INSTRUMENT_CACHE
         fprintf(stderr, "Cache head element was redundant\n");
 #endif
     }

     /* Did we get something? If not, make a new one. It will go on the queue later.
     */
     if (element == NULL) {
         element = __CFStringTransformCreate(identifier, reverse);
     }
 #if INSTRUMENT_CACHE
     else {
         fprintf(stderr, "Transform reused from queue\n");
     }

     if (element) {
         fprintf(stderr, "Transform acquired\n");
     }
 #endif

     return element;
 #endif
 }

 /* Release a transform element back to the cache
 */

 static void __CFStringTransformRelease(CFStringRef identifier, bool reverse,
 #if LITE_CACHE
  UTransliterator *tl
 #else
  struct transform_element *element
 #endif
 ) {
 #if DISABLE_CACHE

         utrans_close(element->_transliterator);
 	CFAllocatorDeallocate(kCFAllocatorSystemDefault, element);
 	return;
 #endif

 #if LITE_CACHE
     __CFStringTransformLockGlobal();
     if (__CFStringTransformCacheID) {
         CFRelease(__CFStringTransformCacheID);
         utrans_close(__CFStringTransformCacheTL);
     }
     __CFStringTransformCacheID = CFStringCreateCopy(kCFAllocatorSystemDefault, identifier);
     __CFStringTransformCacheTL = tl;
     __CFStringTransformCacheRev = reverse;
     __CFStringTransformUnlockGlobal();
     return;
 #else

 #if INSTRUMENT_CACHE
     fprintf(stderr, "Releasing %s transform element ", reverse?"reverse":"forward");
     CFShow(identifier);
 #endif
     __CFStringTransformLockGlobal();

     /* We cannot have a transform_element if there wasn't a head created for it, so we don't need to check that here. We also don't need to check for the cache being present.
     */
     struct transform_head *head = (struct transform_head *)CFDictionaryGetValue(__CFStringTransformCache, identifier);
     if (reverse) {
         element->_next = head->_reverse_q;
         head->_reverse_q = element;
     }
     else {
         element->_next = head->_forward_q;
         head->_forward_q = element;
     }

     __CFStringTransformUnlockGlobal();
 #endif
 }

 /* Callback functions for UReplaceable and CFMutableStringRef
 */

 typedef struct {
     CFMutableStringRef _source;
     CFIndex _sourceLength;
     CFStringInlineBuffer _buffer;
     CFMutableStringRef _externalMutable;
 } _CFStringUReplaceable;

 static int32_t __CFStringReplaceableLength(const UReplaceable *rep)
 {
     return (int32_t) ((const _CFStringUReplaceable *)rep)->_sourceLength;
 }

 static UChar __CFStringReplaceableCharAt(const UReplaceable* rep, int32_t offset)
 {

     _CFStringUReplaceable *myrep = (_CFStringUReplaceable *)rep;
     if (offset >= myrep->_sourceLength)
         return 0xFFFF;
     return (UChar) CFStringGetCharacterFromInlineBuffer(&myrep->_buffer, (CFIndex)offset);
 }

 static UChar32 __CFStringReplaceableChar32At(const UReplaceable *rep, int32_t offset)
 {
     _CFStringUReplaceable *myrep = (_CFStringUReplaceable *)rep;
     if (offset >= myrep->_sourceLength)
         return 0xFFFF;
     UniChar character = CFStringGetCharacterFromInlineBuffer(&myrep->_buffer, (CFIndex)offset);
     if (!CFUniCharIsSurrogateHighCharacter(character) || offset >= myrep->_sourceLength-1)
         return (UChar32) character;

     UTF32Char result = character;
     UniChar second = CFStringGetCharacterFromInlineBuffer(&myrep->_buffer, (CFIndex)offset+1);
     if (CFUniCharIsSurrogateLowCharacter(second)) {
         result = CFUniCharGetLongCharacterForSurrogatePair(character, second);
     }

     return (UChar32) result;
 }

 static void __CFStringReplaceableReplace(UReplaceable *rep, int32_t start, int32_t limit, const UChar *text, int32_t textLimit)
 {
     /* We're using a mutable string here so we can reuse it. We will never actually change the characters themselves, despite casting away const.
     */
     _CFStringUReplaceable *myrep = (_CFStringUReplaceable *)rep;
     if (myrep->_externalMutable == NULL) {
         myrep->_externalMutable = CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorSystemDefault, (UniChar *)text, (CFIndex) textLimit, (CFIndex) textLimit, kCFAllocatorNull);
     }
     else {
         CFStringSetExternalCharactersNoCopy(myrep->_externalMutable, (UniChar *)text, (CFIndex) textLimit, (CFIndex) textLimit);
     }
     CFStringReplace(myrep->_source, CFRangeMake((CFIndex)start, (CFIndex)(limit-start)), myrep->_externalMutable);
     myrep->_sourceLength = CFStringGetLength(myrep->_source);
     CFStringInitInlineBuffer(myrep->_source, &myrep->_buffer, CFRangeMake(0, myrep->_sourceLength));
 }

 static void __CFStringReplaceableExtract(UReplaceable *rep, int32_t start, int32_t limit, UChar *dst)
 {
     _CFStringUReplaceable *myrep = (_CFStringUReplaceable *)rep;
     CFStringGetCharactersFromInlineBuffer(&myrep->_buffer, CFRangeMake((CFIndex)start, (CFIndex)(limit-start)), (UniChar *)dst);
 }

 static void __CFStringReplaceableCopy(UReplaceable *rep, int32_t start, int32_t limit, int32_t dest)
 {
     _CFStringUReplaceable *myrep = (_CFStringUReplaceable *)rep;
     CFStringRef sub = CFStringCreateWithSubstring(kCFAllocatorSystemDefault, myrep->_source, CFRangeMake((CFIndex)start, (CFIndex)(limit-start)));
     CFStringInsert(myrep->_source, (CFIndex)dest, sub);
     CFRelease(sub);
     myrep->_sourceLength = CFStringGetLength(myrep->_source);
     CFStringInitInlineBuffer(myrep->_source, &myrep->_buffer, CFRangeMake(0, myrep->_sourceLength));
 }

 static UReplaceableCallbacks __CFStringReplaceableCallbacks =
 {
     __CFStringReplaceableLength,
     __CFStringReplaceableCharAt,
     __CFStringReplaceableChar32At,
     __CFStringReplaceableReplace,
     __CFStringReplaceableExtract,
     __CFStringReplaceableCopy
 };

 /* End UReplaceable CFMutableStringRef callbacks
 */


 /* Constant strings for predefined transforms
 */

 struct transform_map {
     const CFStringRef *from;
     const char *to;
 };

 /* Use leading ) to avoid collisions with legal ICU identifiers
 */
 CONST_STRING_DECL(kCFStringTransformStripCombiningMarks, ")kCFStringTransformStripCombiningMarks")
 CONST_STRING_DECL(kCFStringTransformToLatin, ")kCFStringTransformToLatin")
 CONST_STRING_DECL(kCFStringTransformFullwidthHalfwidth, ")kCFStringTransformFullwidthHalfwidth")
 CONST_STRING_DECL(kCFStringTransformLatinKatakana, ")kCFStringTransformLatinKatakana")
 CONST_STRING_DECL(kCFStringTransformLatinHiragana, ")kCFStringTransformLatinHiragana")
 CONST_STRING_DECL(kCFStringTransformHiraganaKatakana, ")kCFStringTransformHiraganaKatakana")
 CONST_STRING_DECL(kCFStringTransformMandarinLatin, ")kCFStringTransformMandarinLatin")
 CONST_STRING_DECL(kCFStringTransformLatinHangul, ")kCFStringTransformLatinHangul")
 CONST_STRING_DECL(kCFStringTransformLatinArabic, ")kCFStringTransformLatinArabic")
 CONST_STRING_DECL(kCFStringTransformLatinHebrew, ")kCFStringTransformLatinHebrew")
 CONST_STRING_DECL(kCFStringTransformLatinThai, ")kCFStringTransformLatinThai")
 CONST_STRING_DECL(kCFStringTransformLatinCyrillic, ")kCFStringTransformLatinCyrillic")
 CONST_STRING_DECL(kCFStringTransformLatinGreek, ")kCFStringTransformLatinGreek")
 CONST_STRING_DECL(kCFStringTransformToXMLHex, ")kCFStringTransformToXMLHex")
 CONST_STRING_DECL(kCFStringTransformToUnicodeName, ")kCFStringTransformToUnicodeName")
 CONST_STRING_DECL(kCFStringTransformStripDiacritics, ")kCFStringTransformStripDiacritics")

 static struct transform_map __CFStringTransformNameMap[] = {
     {&kCFStringTransformStripCombiningMarks, "NFD; [:Mn:] Remove; NFC"},
     {&kCFStringTransformToLatin, "Any-Latin"},
     {&kCFStringTransformFullwidthHalfwidth, "Fullwidth-Halfwidth"},
     {&kCFStringTransformLatinKatakana, "Latin-Katakana"},
     {&kCFStringTransformLatinHiragana, "Latin-Hiragana"},
     {&kCFStringTransformHiraganaKatakana, "Hiragana-Katakana"},
     {&kCFStringTransformMandarinLatin, "Han-Latin"},
     {&kCFStringTransformLatinHangul, "Latin-Hangul"},
     {&kCFStringTransformLatinArabic, "Latin-Arabic"},
     {&kCFStringTransformLatinHebrew, "Latin-Hebrew"},
     {&kCFStringTransformLatinThai, "Latin-Thai"},
     {&kCFStringTransformLatinCyrillic, "Latin-Cyrillic"},
     {&kCFStringTransformLatinGreek, "Latin-Greek"},
     {&kCFStringTransformToXMLHex, "[^[:ASCII:]-[:C:]]; Any-Hex/XML"},
     {&kCFStringTransformToUnicodeName, "[^[:ASCII:]-[:C:]]; Any-Name"},
     {&kCFStringTransformStripDiacritics, "NFD; [[[:Mn:]&[:Diacritic:]]-[:Grapheme_Link:]-[:ccc=0:]-[:ccc=8:]-[\\u0338]] Remove; NFC"},
     {0,0}
 };

 /* Translation of constant strings to ICU transliterator IDs
 */

 static const char *__CFStringTransformGetICUIdentifier(CFStringRef identifier) {
     if (CFStringGetLength(identifier) > 0 && CFStringGetCharacterAtIndex(identifier, 0) == ')') {
         CFIndex slot;
         for (slot = 0; __CFStringTransformNameMap[slot].from != NULL; ++slot) {
             if (*__CFStringTransformNameMap[slot].from == identifier) {
 		return __CFStringTransformNameMap[slot].to;
             }
         }
         for (slot = 0; __CFStringTransformNameMap[slot].from != NULL; ++slot) {
             if (CFEqual(*__CFStringTransformNameMap[slot].from, identifier)) {
 		return __CFStringTransformNameMap[slot].to;
             }
         }
     }
     return NULL;
 }

 /* Main entry point
 */

 Boolean CFStringTransform(CFMutableStringRef string, CFRange *range, CFStringRef transform, Boolean reverse)
 {
     Boolean result = false;
 #if LITE_CACHE
     UTransliterator *tl = __CFStringTransformAcquire(transform, (reverse != 0));
     if (!tl) return false;
 #else
     struct transform_element *element = __CFStringTransformAcquire(transform, (reverse != 0));
     if (element == NULL)
         return false;
     UTransliterator *tl = element->_transliterator;
 #endif

     CFRange everything;
     if (range == NULL) {
         everything.location = 0;
         everything.length = CFStringGetLength(string);
         range = &everything;
     }

     /* Set up the UReplaceable
     */
     _CFStringUReplaceable replaceable;
     replaceable._source = string;
     replaceable._sourceLength = CFStringGetLength(string);
     CFStringInitInlineBuffer(string, &replaceable._buffer, CFRangeMake(0, replaceable._sourceLength));
     replaceable._externalMutable = NULL;

     /* Actually do the transform
     */
     UErrorCode icuStatus = U_ZERO_ERROR;
     int32_t limit = range->location + range->length;
     utrans_trans(tl, (UReplaceable *)&replaceable, &__CFStringReplaceableCallbacks, (int32_t) range->location, &limit, &icuStatus);

     /* Get rid of the utility CFMutableString if we allocated it.
     */
     if (replaceable._externalMutable != NULL) {
         CFRelease(replaceable._externalMutable);
     }

     if (U_SUCCESS(icuStatus)) {
         range->length = limit - range->location;
         result = true;
     }

 #if LITE_CACHE
     __CFStringTransformRelease(transform, (reverse != 0), tl);
 #else
     __CFStringTransformRelease(transform, (reverse != 0), element);
 #endif

     return result;
 }
	// This source file is part of the Swift.org open source project
	//
	// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
	// Licensed under Apache License v2.0 with Runtime Library Exception
	//
	// See http://swift.org/LICENSE.txt for license information
	// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
	//

	/* CFStringTransform.c
	Copyright (c) 2004-2015, Apple Inc. All rights reserved.

	!!! For performance reasons, it's important that all functions marked CF_INLINE in this file are inlined.
	*/

	#include <CoreFoundation/CFBase.h>
	#include <CoreFoundation/CFString.h>
	#include <CoreFoundation/CFUniChar.h>
	#include <CoreFoundation/CFPriv.h>
	#include "CFInternal.h"
	#include <unicode/utrans.h>

	static const char *__CFStringTransformGetICUIdentifier(CFStringRef identifier);

	#define INSTRUMENT_CACHE 0

	#if INSTRUMENT_CACHE
	#include <stdio.h>
	#endif

	#if DEPLOYMENT_TARGET_EMBEDDED
	#define LITE_CACHE 1
	#endif

	#if LITE_CACHE
	static CFStringRef __CFStringTransformCacheID = NULL;
	static UTransliterator *__CFStringTransformCacheTL = NULL;
	static Boolean __CFStringTransformCacheRev = false;
	#else
	static CFMutableDictionaryRef __CFStringTransformCache = NULL;
	#endif
	static CFLock_t __CFStringTransformGlobalLock = CFLockInit;

	#define kCFStringTransformStackBufferSize 1024

	CF_INLINE void __CFStringTransformLockGlobal(void) {
	__CFLock(&__CFStringTransformGlobalLock);
	}

	CF_INLINE void __CFStringTransformUnlockGlobal(void) {
	__CFUnlock(&__CFStringTransformGlobalLock);
	}

	#if !LITE_CACHE
	struct transform_element {
	struct transform_element *_next;
	UTransliterator *_transliterator;
	};

	struct transform_head {
	struct transform_element *_forward_q;
	struct transform_element *_reverse_q;
	};
	#endif

	/* Create an element for the transform cache, including the ICU transliterator
	*/

	#if LITE_CACHE
	static UTransliterator *
	#else
	static struct transform_element *
	#endif
	__CFStringTransformCreate(CFStringRef identifier, bool reverse) {
	#if INSTRUMENT_CACHE
	fprintf(stderr, "Create %s transform ", reverse?"reverse":"forward");
	CFShow(identifier);
	#endif
	UTransliterator *made = NULL;
	UErrorCode icuStatus = U_ZERO_ERROR;

	const char *known = __CFStringTransformGetICUIdentifier(identifier);
	if (known) {
	UniChar buff[kCFStringTransformStackBufferSize];
	CFIndex len = strlen(known);
	CFIndex idx;
	for (idx = 0; idx < len; idx++) {
	buff[idx] = known[idx];
	}
	made = utrans_openU((const UChar *)buff, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
	} else {
	CFIndex len = CFStringGetLength(identifier);
	const UniChar *ucp = CFStringGetCharactersPtr(identifier);
	if (ucp != NULL) {
	made = utrans_openU((const UChar *)ucp, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
	} else if (len <= kCFStringTransformStackBufferSize) {
	UniChar buff[kCFStringTransformStackBufferSize];
	CFStringGetCharacters(identifier, CFRangeMake(0, len), buff);
	made = utrans_openU((const UChar *)buff, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
	} else {
	UniChar buff = (UniChar ) CFAllocatorAllocate(kCFAllocatorSystemDefault, len * sizeof(UniChar), 0);
	if (buff == NULL)
	return NULL;
	CFStringGetCharacters(identifier, CFRangeMake(0, len), buff);
	made = utrans_openU((const UChar *)buff, len, reverse?UTRANS_REVERSE:UTRANS_FORWARD, NULL, 0, NULL, &icuStatus);
	CFAllocatorDeallocate(kCFAllocatorSystemDefault, buff);
	}
	}

	if (U_FAILURE(icuStatus)) {
	if (made)
	utrans_close(made);
	return NULL;
	}

	#if LITE_CACHE
	return made;
	#else
	struct transform_element *result = NULL;
	result = (struct transform_element *) CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(struct transform_element), 0);
	if (result == NULL) {
	utrans_close(made);
	return NULL;
	}

	result->_next = NULL;
	result->_transliterator = made;
	#if INSTRUMENT_CACHE
	fprintf(stderr, "Created\n");
	#endif
	return result;
	#endif
	}

	/* Acquire a transform element from the cache
	*/

	#if LITE_CACHE
	static UTransliterator *
	#else
	static struct transform_element *
	#endif
	__CFStringTransformAcquire(CFStringRef identifier, bool reverse) {
	#if LITE_CACHE
	__CFStringTransformLockGlobal();
	if (__CFStringTransformCacheID && (reverse == __CFStringTransformCacheRev) && (identifier == __CFStringTransformCacheID \|\| CFEqual(identifier, __CFStringTransformCacheID))) {
	CFRelease(__CFStringTransformCacheID);
	__CFStringTransformCacheID = NULL;
	UTransliterator *cached = __CFStringTransformCacheTL;
	__CFStringTransformCacheTL = NULL;
	__CFStringTransformUnlockGlobal();
	return cached;
	}
	__CFStringTransformUnlockGlobal();

	UTransliterator *made = __CFStringTransformCreate(identifier, reverse);
	return made;
	#else
	struct transform_head head = NULL, second_head = NULL;
	struct transform_element *element = NULL;
	CFMutableDictionaryRef cache = NULL;
	#if INSTRUMENT_CACHE
	fprintf(stderr, "Acquire %s transform ", reverse?"reverse":"forward");
	CFShow(identifier);
	#endif
	__CFStringTransformLockGlobal();

	/* Fetch the cache, creating it if necessary
	*/
	if (__CFStringTransformCache == NULL) {
	__CFStringTransformUnlockGlobal();
	#if INSTRUMENT_CACHE
	fprintf(stderr, "Create cache\n");
	#endif
	cache = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFCopyStringDictionaryKeyCallBacks, NULL);
	if (cache == NULL)
	return NULL;
	__CFStringTransformLockGlobal();
	if (__CFStringTransformCache == NULL) {
	__CFStringTransformCache = cache;
	}
	else {
	#if INSTRUMENT_CACHE
	fprintf(stderr, "Redundant cache created\n");
	#endif
	CFRelease(cache);
	}
	}
	cache = __CFStringTransformCache;

	/* Now we have the cache. Fetch the head element. Create it if necessary.
	*/
	head = (struct transform_head *) CFDictionaryGetValue(cache, identifier);
	if (head == NULL) {
	__CFStringTransformUnlockGlobal();

	#if INSTRUMENT_CACHE
	fprintf(stderr, "Cache entry head not found\n");
	#endif
	/* Make the element first in case it's a bogus transform
	*/
	element = __CFStringTransformCreate(identifier, reverse);

	if (element == NULL)
	return NULL;

	/* Create a new head element
	*/
	head = (struct transform_head *) CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(struct transform_head), 0);
	if (head == NULL) {
	utrans_close(element->_transliterator);
	CFAllocatorDeallocate(kCFAllocatorSystemDefault, element);
	return NULL;
	}
	head->_forward_q = NULL;
	head->_reverse_q = NULL;

	#if INSTRUMENT_CACHE
	fprintf(stderr, "Cache head element created\n");
	#endif

	__CFStringTransformLockGlobal();

	/* Check the head element again in case someone else made it first.
	*/
	second_head = (struct transform_head *) CFDictionaryGetValue(cache, identifier);
	if (second_head == NULL) {
	CFDictionaryAddValue(cache, identifier, head);
	}
	}

	/* If we don't already have a transliterator, get one from the queue or create one.
	*/
	if (element == NULL) { // if element is NULL head cannot be NULL
	if (reverse) {
	element = head->_reverse_q;
	if (element != NULL) {
	head->_reverse_q = element->_next;
	}
	}
	else {
	element = head->_forward_q;
	if (element != NULL) {
	head->_forward_q = element->_next;
	}
	}
	}

	__CFStringTransformUnlockGlobal();

	/* If we made a head and someone else did too, dump ours.
	*/
	if (second_head != NULL) {
	CFAllocatorDeallocate(kCFAllocatorSystemDefault, head);
	#if INSTRUMENT_CACHE
	fprintf(stderr, "Cache head element was redundant\n");
	#endif
	}

	/* Did we get something? If not, make a new one. It will go on the queue later.
	*/
	if (element == NULL) {
	element = __CFStringTransformCreate(identifier, reverse);
	}
	#if INSTRUMENT_CACHE
	else {
	fprintf(stderr, "Transform reused from queue\n");
	}

	if (element) {
	fprintf(stderr, "Transform acquired\n");
	}
	#endif

	return element;
	#endif
	}

	/* Release a transform element back to the cache
	*/

	static void __CFStringTransformRelease(CFStringRef identifier, bool reverse,
	#if LITE_CACHE
	UTransliterator *tl
	#else
	struct transform_element *element
	#endif
	) {
	#if DISABLE_CACHE

	utrans_close(element->_transliterator);
	CFAllocatorDeallocate(kCFAllocatorSystemDefault, element);
	return;
	#endif

	#if LITE_CACHE
	__CFStringTransformLockGlobal();
	if (__CFStringTransformCacheID) {
	CFRelease(__CFStringTransformCacheID);
	utrans_close(__CFStringTransformCacheTL);
	}
	__CFStringTransformCacheID = CFStringCreateCopy(kCFAllocatorSystemDefault, identifier);
	__CFStringTransformCacheTL = tl;
	__CFStringTransformCacheRev = reverse;
	__CFStringTransformUnlockGlobal();
	return;
	#else

	#if INSTRUMENT_CACHE
	fprintf(stderr, "Releasing %s transform element ", reverse?"reverse":"forward");
	CFShow(identifier);
	#endif
	__CFStringTransformLockGlobal();

	/* We cannot have a transform_element if there wasn't a head created for it, so we don't need to check that here. We also don't need to check for the cache being present.
	*/
	struct transform_head head = (struct transform_head )CFDictionaryGetValue(__CFStringTransformCache, identifier);
	if (reverse) {
	element->_next = head->_reverse_q;
	head->_reverse_q = element;
	}
	else {
	element->_next = head->_forward_q;
	head->_forward_q = element;
	}

	__CFStringTransformUnlockGlobal();
	#endif
	}

	/* Callback functions for UReplaceable and CFMutableStringRef
	*/

	typedef struct {
	CFMutableStringRef _source;
	CFIndex _sourceLength;
	CFStringInlineBuffer _buffer;
	CFMutableStringRef _externalMutable;
	} _CFStringUReplaceable;

	static int32_t __CFStringReplaceableLength(const UReplaceable *rep)
	{
	return (int32_t) ((const _CFStringUReplaceable *)rep)->_sourceLength;
	}

	static UChar __CFStringReplaceableCharAt(const UReplaceable* rep, int32_t offset)
	{

	_CFStringUReplaceable myrep = (_CFStringUReplaceable )rep;
	if (offset >= myrep->_sourceLength)
	return 0xFFFF;
	return (UChar) CFStringGetCharacterFromInlineBuffer(&myrep->_buffer, (CFIndex)offset);
	}

	static UChar32 __CFStringReplaceableChar32At(const UReplaceable *rep, int32_t offset)
	{
	_CFStringUReplaceable myrep = (_CFStringUReplaceable )rep;
	if (offset >= myrep->_sourceLength)
	return 0xFFFF;
	UniChar character = CFStringGetCharacterFromInlineBuffer(&myrep->_buffer, (CFIndex)offset);
	if (!CFUniCharIsSurrogateHighCharacter(character) \|\| offset >= myrep->_sourceLength-1)
	return (UChar32) character;

	UTF32Char result = character;
	UniChar second = CFStringGetCharacterFromInlineBuffer(&myrep->_buffer, (CFIndex)offset+1);
	if (CFUniCharIsSurrogateLowCharacter(second)) {
	result = CFUniCharGetLongCharacterForSurrogatePair(character, second);
	}

	return (UChar32) result;
	}

	static void __CFStringReplaceableReplace(UReplaceable rep, int32_t start, int32_t limit, const UChar text, int32_t textLimit)
	{
	/* We're using a mutable string here so we can reuse it. We will never actually change the characters themselves, despite casting away const.
	*/
	_CFStringUReplaceable myrep = (_CFStringUReplaceable )rep;
	if (myrep->_externalMutable == NULL) {
	myrep->_externalMutable = CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorSystemDefault, (UniChar *)text, (CFIndex) textLimit, (CFIndex) textLimit, kCFAllocatorNull);
	}
	else {
	CFStringSetExternalCharactersNoCopy(myrep->_externalMutable, (UniChar *)text, (CFIndex) textLimit, (CFIndex) textLimit);
	}
	CFStringReplace(myrep->_source, CFRangeMake((CFIndex)start, (CFIndex)(limit-start)), myrep->_externalMutable);
	myrep->_sourceLength = CFStringGetLength(myrep->_source);
	CFStringInitInlineBuffer(myrep->_source, &myrep->_buffer, CFRangeMake(0, myrep->_sourceLength));
	}

	static void __CFStringReplaceableExtract(UReplaceable rep, int32_t start, int32_t limit, UChar dst)
	{
	_CFStringUReplaceable myrep = (_CFStringUReplaceable )rep;
	CFStringGetCharactersFromInlineBuffer(&myrep->_buffer, CFRangeMake((CFIndex)start, (CFIndex)(limit-start)), (UniChar *)dst);
	}

	static void __CFStringReplaceableCopy(UReplaceable *rep, int32_t start, int32_t limit, int32_t dest)
	{
	_CFStringUReplaceable myrep = (_CFStringUReplaceable )rep;
	CFStringRef sub = CFStringCreateWithSubstring(kCFAllocatorSystemDefault, myrep->_source, CFRangeMake((CFIndex)start, (CFIndex)(limit-start)));
	CFStringInsert(myrep->_source, (CFIndex)dest, sub);
	CFRelease(sub);
	myrep->_sourceLength = CFStringGetLength(myrep->_source);
	CFStringInitInlineBuffer(myrep->_source, &myrep->_buffer, CFRangeMake(0, myrep->_sourceLength));
	}

	static UReplaceableCallbacks __CFStringReplaceableCallbacks =
	{
	__CFStringReplaceableLength,
	__CFStringReplaceableCharAt,
	__CFStringReplaceableChar32At,
	__CFStringReplaceableReplace,
	__CFStringReplaceableExtract,
	__CFStringReplaceableCopy
	};

	/* End UReplaceable CFMutableStringRef callbacks
	*/


	/* Constant strings for predefined transforms
	*/

	struct transform_map {
	const CFStringRef *from;
	const char *to;
	};

	/* Use leading ) to avoid collisions with legal ICU identifiers
	*/
	CONST_STRING_DECL(kCFStringTransformStripCombiningMarks, ")kCFStringTransformStripCombiningMarks")
	CONST_STRING_DECL(kCFStringTransformToLatin, ")kCFStringTransformToLatin")
	CONST_STRING_DECL(kCFStringTransformFullwidthHalfwidth, ")kCFStringTransformFullwidthHalfwidth")
	CONST_STRING_DECL(kCFStringTransformLatinKatakana, ")kCFStringTransformLatinKatakana")
	CONST_STRING_DECL(kCFStringTransformLatinHiragana, ")kCFStringTransformLatinHiragana")
	CONST_STRING_DECL(kCFStringTransformHiraganaKatakana, ")kCFStringTransformHiraganaKatakana")
	CONST_STRING_DECL(kCFStringTransformMandarinLatin, ")kCFStringTransformMandarinLatin")
	CONST_STRING_DECL(kCFStringTransformLatinHangul, ")kCFStringTransformLatinHangul")
	CONST_STRING_DECL(kCFStringTransformLatinArabic, ")kCFStringTransformLatinArabic")
	CONST_STRING_DECL(kCFStringTransformLatinHebrew, ")kCFStringTransformLatinHebrew")
	CONST_STRING_DECL(kCFStringTransformLatinThai, ")kCFStringTransformLatinThai")
	CONST_STRING_DECL(kCFStringTransformLatinCyrillic, ")kCFStringTransformLatinCyrillic")
	CONST_STRING_DECL(kCFStringTransformLatinGreek, ")kCFStringTransformLatinGreek")
	CONST_STRING_DECL(kCFStringTransformToXMLHex, ")kCFStringTransformToXMLHex")
	CONST_STRING_DECL(kCFStringTransformToUnicodeName, ")kCFStringTransformToUnicodeName")
	CONST_STRING_DECL(kCFStringTransformStripDiacritics, ")kCFStringTransformStripDiacritics")

	static struct transform_map __CFStringTransformNameMap[] = {
	{&kCFStringTransformStripCombiningMarks, "NFD; [:Mn:] Remove; NFC"},
	{&kCFStringTransformToLatin, "Any-Latin"},
	{&kCFStringTransformFullwidthHalfwidth, "Fullwidth-Halfwidth"},
	{&kCFStringTransformLatinKatakana, "Latin-Katakana"},
	{&kCFStringTransformLatinHiragana, "Latin-Hiragana"},
	{&kCFStringTransformHiraganaKatakana, "Hiragana-Katakana"},
	{&kCFStringTransformMandarinLatin, "Han-Latin"},
	{&kCFStringTransformLatinHangul, "Latin-Hangul"},
	{&kCFStringTransformLatinArabic, "Latin-Arabic"},
	{&kCFStringTransformLatinHebrew, "Latin-Hebrew"},
	{&kCFStringTransformLatinThai, "Latin-Thai"},
	{&kCFStringTransformLatinCyrillic, "Latin-Cyrillic"},
	{&kCFStringTransformLatinGreek, "Latin-Greek"},
	{&kCFStringTransformToXMLHex, "[^[:ASCII:]-[:C:]]; Any-Hex/XML"},
	{&kCFStringTransformToUnicodeName, "[^[:ASCII:]-[:C:]]; Any-Name"},
	{&kCFStringTransformStripDiacritics, "NFD; [[[:Mn:]&[:Diacritic:]]-[:Grapheme_Link:]-[:ccc=0:]-[:ccc=8:]-[\\u0338]] Remove; NFC"},
	{0,0}
	};

	/* Translation of constant strings to ICU transliterator IDs
	*/

	static const char *__CFStringTransformGetICUIdentifier(CFStringRef identifier) {
	if (CFStringGetLength(identifier) > 0 && CFStringGetCharacterAtIndex(identifier, 0) == ')') {
	CFIndex slot;
	for (slot = 0; __CFStringTransformNameMap[slot].from != NULL; ++slot) {
	if (*__CFStringTransformNameMap[slot].from == identifier) {
	return __CFStringTransformNameMap[slot].to;
	}
	}
	for (slot = 0; __CFStringTransformNameMap[slot].from != NULL; ++slot) {
	if (CFEqual(*__CFStringTransformNameMap[slot].from, identifier)) {
	return __CFStringTransformNameMap[slot].to;
	}
	}
	}
	return NULL;
	}

	/* Main entry point
	*/

	Boolean CFStringTransform(CFMutableStringRef string, CFRange *range, CFStringRef transform, Boolean reverse)
	{
	Boolean result = false;
	#if LITE_CACHE
	UTransliterator *tl = __CFStringTransformAcquire(transform, (reverse != 0));
	if (!tl) return false;
	#else
	struct transform_element *element = __CFStringTransformAcquire(transform, (reverse != 0));
	if (element == NULL)
	return false;
	UTransliterator *tl = element->_transliterator;
	#endif

	CFRange everything;
	if (range == NULL) {
	everything.location = 0;
	everything.length = CFStringGetLength(string);
	range = &everything;
	}

	/* Set up the UReplaceable
	*/
	_CFStringUReplaceable replaceable;
	replaceable._source = string;
	replaceable._sourceLength = CFStringGetLength(string);
	CFStringInitInlineBuffer(string, &replaceable._buffer, CFRangeMake(0, replaceable._sourceLength));
	replaceable._externalMutable = NULL;

	/* Actually do the transform
	*/
	UErrorCode icuStatus = U_ZERO_ERROR;
	int32_t limit = range->location + range->length;
	utrans_trans(tl, (UReplaceable *)&replaceable, &__CFStringReplaceableCallbacks, (int32_t) range->location, &limit, &icuStatus);

	/* Get rid of the utility CFMutableString if we allocated it.
	*/
	if (replaceable._externalMutable != NULL) {
	CFRelease(replaceable._externalMutable);
	}

	if (U_SUCCESS(icuStatus)) {
	range->length = limit - range->location;
	result = true;
	}

	#if LITE_CACHE
	__CFStringTransformRelease(transform, (reverse != 0), tl);
	#else
	__CFStringTransformRelease(transform, (reverse != 0), element);
	#endif

	return result;
	}