Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 1 of 2.

1 files changed, 343 insertions, 343 deletions

diff --git a/contrib/libs/icu/common/loadednormalizer2impl.cpp b/contrib/libs/icu/common/loadednormalizer2impl.cpp
index e4b36f1055..adf62c3e4c 100644
--- a/contrib/libs/icu/common/loadednormalizer2impl.cpp
+++ b/contrib/libs/icu/common/loadednormalizer2impl.cpp
@@ -1,197 +1,197 @@
 // © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-*******************************************************************************
-* Copyright (C) 2014, International Business Machines
-* Corporation and others.  All Rights Reserved.
-*******************************************************************************
-* loadednormalizer2impl.cpp
-*
-* created on: 2014sep03
-* created by: Markus W. Scherer
-*/
-
-#include "unicode/utypes.h"
-
-#if !UCONFIG_NO_NORMALIZATION
-
-#include "unicode/udata.h"
-#include "unicode/localpointer.h"
-#include "unicode/normalizer2.h"
+// License & terms of use: http://www.unicode.org/copyright.html 
+/* 
+******************************************************************************* 
+* Copyright (C) 2014, International Business Machines 
+* Corporation and others.  All Rights Reserved. 
+******************************************************************************* 
+* loadednormalizer2impl.cpp 
+* 
+* created on: 2014sep03 
+* created by: Markus W. Scherer 
+*/ 
+ 
+#include "unicode/utypes.h" 
+ 
+#if !UCONFIG_NO_NORMALIZATION 
+ 
+#include "unicode/udata.h" 
+#include "unicode/localpointer.h" 
+#include "unicode/normalizer2.h" 
 #include "unicode/ucptrie.h"
-#include "unicode/unistr.h"
-#include "unicode/unorm.h"
-#include "cstring.h"
-#include "mutex.h"
-#include "norm2allmodes.h"
-#include "normalizer2impl.h"
-#include "uassert.h"
-#include "ucln_cmn.h"
-#include "uhash.h"
-
-U_NAMESPACE_BEGIN
-
-class LoadedNormalizer2Impl : public Normalizer2Impl {
-public:
-    LoadedNormalizer2Impl() : memory(NULL), ownedTrie(NULL) {}
-    virtual ~LoadedNormalizer2Impl();
-
-    void load(const char *packageName, const char *name, UErrorCode &errorCode);
-
-private:
-    static UBool U_CALLCONV
-    isAcceptable(void *context, const char *type, const char *name, const UDataInfo *pInfo);
-
-    UDataMemory *memory;
+#include "unicode/unistr.h" 
+#include "unicode/unorm.h" 
+#include "cstring.h" 
+#include "mutex.h" 
+#include "norm2allmodes.h" 
+#include "normalizer2impl.h" 
+#include "uassert.h" 
+#include "ucln_cmn.h" 
+#include "uhash.h" 
+ 
+U_NAMESPACE_BEGIN 
+ 
+class LoadedNormalizer2Impl : public Normalizer2Impl { 
+public: 
+    LoadedNormalizer2Impl() : memory(NULL), ownedTrie(NULL) {} 
+    virtual ~LoadedNormalizer2Impl(); 
+ 
+    void load(const char *packageName, const char *name, UErrorCode &errorCode); 
+ 
+private: 
+    static UBool U_CALLCONV 
+    isAcceptable(void *context, const char *type, const char *name, const UDataInfo *pInfo); 
+ 
+    UDataMemory *memory; 
     UCPTrie *ownedTrie;
-};
-
-LoadedNormalizer2Impl::~LoadedNormalizer2Impl() {
-    udata_close(memory);
+}; 
+ 
+LoadedNormalizer2Impl::~LoadedNormalizer2Impl() { 
+    udata_close(memory); 
     ucptrie_close(ownedTrie);
-}
-
-UBool U_CALLCONV
-LoadedNormalizer2Impl::isAcceptable(void * /*context*/,
-                                    const char * /* type */, const char * /*name*/,
-                                    const UDataInfo *pInfo) {
-    if(
-        pInfo->size>=20 &&
-        pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
-        pInfo->charsetFamily==U_CHARSET_FAMILY &&
-        pInfo->dataFormat[0]==0x4e &&    /* dataFormat="Nrm2" */
-        pInfo->dataFormat[1]==0x72 &&
-        pInfo->dataFormat[2]==0x6d &&
-        pInfo->dataFormat[3]==0x32 &&
+} 
+ 
+UBool U_CALLCONV 
+LoadedNormalizer2Impl::isAcceptable(void * /*context*/, 
+                                    const char * /* type */, const char * /*name*/, 
+                                    const UDataInfo *pInfo) { 
+    if( 
+        pInfo->size>=20 && 
+        pInfo->isBigEndian==U_IS_BIG_ENDIAN && 
+        pInfo->charsetFamily==U_CHARSET_FAMILY && 
+        pInfo->dataFormat[0]==0x4e &&    /* dataFormat="Nrm2" */ 
+        pInfo->dataFormat[1]==0x72 && 
+        pInfo->dataFormat[2]==0x6d && 
+        pInfo->dataFormat[3]==0x32 && 
         pInfo->formatVersion[0]==4
-    ) {
-        // Normalizer2Impl *me=(Normalizer2Impl *)context;
-        // uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4);
-        return TRUE;
-    } else {
-        return FALSE;
-    }
-}
-
-void
-LoadedNormalizer2Impl::load(const char *packageName, const char *name, UErrorCode &errorCode) {
-    if(U_FAILURE(errorCode)) {
-        return;
-    }
-    memory=udata_openChoice(packageName, "nrm", name, isAcceptable, this, &errorCode);
-    if(U_FAILURE(errorCode)) {
-        return;
-    }
-    const uint8_t *inBytes=(const uint8_t *)udata_getMemory(memory);
-    const int32_t *inIndexes=(const int32_t *)inBytes;
-    int32_t indexesLength=inIndexes[IX_NORM_TRIE_OFFSET]/4;
+    ) { 
+        // Normalizer2Impl *me=(Normalizer2Impl *)context; 
+        // uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4); 
+        return TRUE; 
+    } else { 
+        return FALSE; 
+    } 
+} 
+ 
+void 
+LoadedNormalizer2Impl::load(const char *packageName, const char *name, UErrorCode &errorCode) { 
+    if(U_FAILURE(errorCode)) { 
+        return; 
+    } 
+    memory=udata_openChoice(packageName, "nrm", name, isAcceptable, this, &errorCode); 
+    if(U_FAILURE(errorCode)) { 
+        return; 
+    } 
+    const uint8_t *inBytes=(const uint8_t *)udata_getMemory(memory); 
+    const int32_t *inIndexes=(const int32_t *)inBytes; 
+    int32_t indexesLength=inIndexes[IX_NORM_TRIE_OFFSET]/4; 
     if(indexesLength<=IX_MIN_LCCC_CP) {
-        errorCode=U_INVALID_FORMAT_ERROR;  // Not enough indexes.
-        return;
-    }
-
-    int32_t offset=inIndexes[IX_NORM_TRIE_OFFSET];
-    int32_t nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
+        errorCode=U_INVALID_FORMAT_ERROR;  // Not enough indexes. 
+        return; 
+    } 
+ 
+    int32_t offset=inIndexes[IX_NORM_TRIE_OFFSET]; 
+    int32_t nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET]; 
     ownedTrie=ucptrie_openFromBinary(UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16,
                                      inBytes+offset, nextOffset-offset, NULL,
                                      &errorCode);
-    if(U_FAILURE(errorCode)) {
-        return;
-    }
-
-    offset=nextOffset;
-    nextOffset=inIndexes[IX_SMALL_FCD_OFFSET];
-    const uint16_t *inExtraData=(const uint16_t *)(inBytes+offset);
-
-    // smallFCD: new in formatVersion 2
-    offset=nextOffset;
-    const uint8_t *inSmallFCD=inBytes+offset;
-
-    init(inIndexes, ownedTrie, inExtraData, inSmallFCD);
-}
-
-// instance cache ---------------------------------------------------------- ***
-
-Norm2AllModes *
-Norm2AllModes::createInstance(const char *packageName,
-                              const char *name,
-                              UErrorCode &errorCode) {
-    if(U_FAILURE(errorCode)) {
-        return NULL;
-    }
-    LoadedNormalizer2Impl *impl=new LoadedNormalizer2Impl;
-    if(impl==NULL) {
-        errorCode=U_MEMORY_ALLOCATION_ERROR;
-        return NULL;
-    }
-    impl->load(packageName, name, errorCode);
-    return createInstance(impl, errorCode);
-}
-
-U_CDECL_BEGIN
-static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup();
-U_CDECL_END
-
+    if(U_FAILURE(errorCode)) { 
+        return; 
+    } 
+ 
+    offset=nextOffset; 
+    nextOffset=inIndexes[IX_SMALL_FCD_OFFSET]; 
+    const uint16_t *inExtraData=(const uint16_t *)(inBytes+offset); 
+ 
+    // smallFCD: new in formatVersion 2 
+    offset=nextOffset; 
+    const uint8_t *inSmallFCD=inBytes+offset; 
+ 
+    init(inIndexes, ownedTrie, inExtraData, inSmallFCD); 
+} 
+ 
+// instance cache ---------------------------------------------------------- *** 
+ 
+Norm2AllModes * 
+Norm2AllModes::createInstance(const char *packageName, 
+                              const char *name, 
+                              UErrorCode &errorCode) { 
+    if(U_FAILURE(errorCode)) { 
+        return NULL; 
+    } 
+    LoadedNormalizer2Impl *impl=new LoadedNormalizer2Impl; 
+    if(impl==NULL) { 
+        errorCode=U_MEMORY_ALLOCATION_ERROR; 
+        return NULL; 
+    } 
+    impl->load(packageName, name, errorCode); 
+    return createInstance(impl, errorCode); 
+} 
+ 
+U_CDECL_BEGIN 
+static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup(); 
+U_CDECL_END 
+ 
 #if !NORM2_HARDCODE_NFC_DATA
 static Norm2AllModes *nfcSingleton;
 static icu::UInitOnce nfcInitOnce = U_INITONCE_INITIALIZER;
 #endif
 
-static Norm2AllModes *nfkcSingleton;
+static Norm2AllModes *nfkcSingleton; 
 static icu::UInitOnce nfkcInitOnce = U_INITONCE_INITIALIZER;
 
-static Norm2AllModes *nfkc_cfSingleton;
+static Norm2AllModes *nfkc_cfSingleton; 
 static icu::UInitOnce nfkc_cfInitOnce = U_INITONCE_INITIALIZER;
 
-static UHashtable    *cache=NULL;
-
-// UInitOnce singleton initialization function
-static void U_CALLCONV initSingletons(const char *what, UErrorCode &errorCode) {
+static UHashtable    *cache=NULL; 
+ 
+// UInitOnce singleton initialization function 
+static void U_CALLCONV initSingletons(const char *what, UErrorCode &errorCode) { 
 #if !NORM2_HARDCODE_NFC_DATA
     if (uprv_strcmp(what, "nfc") == 0) {
         nfcSingleton    = Norm2AllModes::createInstance(NULL, "nfc", errorCode);
     } else
 #endif
-    if (uprv_strcmp(what, "nfkc") == 0) {
-        nfkcSingleton    = Norm2AllModes::createInstance(NULL, "nfkc", errorCode);
-    } else if (uprv_strcmp(what, "nfkc_cf") == 0) {
-        nfkc_cfSingleton = Norm2AllModes::createInstance(NULL, "nfkc_cf", errorCode);
-    } else {
+    if (uprv_strcmp(what, "nfkc") == 0) { 
+        nfkcSingleton    = Norm2AllModes::createInstance(NULL, "nfkc", errorCode); 
+    } else if (uprv_strcmp(what, "nfkc_cf") == 0) { 
+        nfkc_cfSingleton = Norm2AllModes::createInstance(NULL, "nfkc_cf", errorCode); 
+    } else { 
         UPRV_UNREACHABLE;   // Unknown singleton
-    }
-    ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
-}
-
-U_CDECL_BEGIN
-
-static void U_CALLCONV deleteNorm2AllModes(void *allModes) {
-    delete (Norm2AllModes *)allModes;
-}
-
-static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup() {
+    } 
+    ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup); 
+} 
+ 
+U_CDECL_BEGIN 
+ 
+static void U_CALLCONV deleteNorm2AllModes(void *allModes) { 
+    delete (Norm2AllModes *)allModes; 
+} 
+ 
+static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup() { 
 #if !NORM2_HARDCODE_NFC_DATA
     delete nfcSingleton;
     nfcSingleton = NULL;
     nfcInitOnce.reset();
 #endif
 
-    delete nfkcSingleton;
-    nfkcSingleton = NULL;
+    delete nfkcSingleton; 
+    nfkcSingleton = NULL; 
     nfkcInitOnce.reset();
 
-    delete nfkc_cfSingleton;
-    nfkc_cfSingleton = NULL;
+    delete nfkc_cfSingleton; 
+    nfkc_cfSingleton = NULL; 
     nfkc_cfInitOnce.reset();
 
-    uhash_close(cache);
-    cache=NULL;
-    return TRUE;
-}
-
-U_CDECL_END
-
+    uhash_close(cache); 
+    cache=NULL; 
+    return TRUE; 
+} 
+ 
+U_CDECL_END 
+ 
 #if !NORM2_HARDCODE_NFC_DATA
-const Norm2AllModes *
+const Norm2AllModes * 
 Norm2AllModes::getNFCInstance(UErrorCode &errorCode) {
     if(U_FAILURE(errorCode)) { return NULL; }
     umtx_initOnce(nfcInitOnce, &initSingletons, "nfc", errorCode);
@@ -200,21 +200,21 @@ Norm2AllModes::getNFCInstance(UErrorCode &errorCode) {
 #endif
 
 const Norm2AllModes *
-Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) {
-    if(U_FAILURE(errorCode)) { return NULL; }
-    umtx_initOnce(nfkcInitOnce, &initSingletons, "nfkc", errorCode);
-    return nfkcSingleton;
-}
-
-const Norm2AllModes *
-Norm2AllModes::getNFKC_CFInstance(UErrorCode &errorCode) {
-    if(U_FAILURE(errorCode)) { return NULL; }
-    umtx_initOnce(nfkc_cfInitOnce, &initSingletons, "nfkc_cf", errorCode);
-    return nfkc_cfSingleton;
-}
-
+Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) { 
+    if(U_FAILURE(errorCode)) { return NULL; } 
+    umtx_initOnce(nfkcInitOnce, &initSingletons, "nfkc", errorCode); 
+    return nfkcSingleton; 
+} 
+ 
+const Norm2AllModes * 
+Norm2AllModes::getNFKC_CFInstance(UErrorCode &errorCode) { 
+    if(U_FAILURE(errorCode)) { return NULL; } 
+    umtx_initOnce(nfkc_cfInitOnce, &initSingletons, "nfkc_cf", errorCode); 
+    return nfkc_cfSingleton; 
+} 
+ 
 #if !NORM2_HARDCODE_NFC_DATA
-const Normalizer2 *
+const Normalizer2 * 
 Normalizer2::getNFCInstance(UErrorCode &errorCode) {
     const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
     return allModes!=NULL ? &allModes->comp : NULL;
@@ -244,175 +244,175 @@ Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) {
 #endif
 
 const Normalizer2 *
-Normalizer2::getNFKCInstance(UErrorCode &errorCode) {
-    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
-    return allModes!=NULL ? &allModes->comp : NULL;
-}
-
-const Normalizer2 *
-Normalizer2::getNFKDInstance(UErrorCode &errorCode) {
-    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
-    return allModes!=NULL ? &allModes->decomp : NULL;
-}
-
-const Normalizer2 *
-Normalizer2::getNFKCCasefoldInstance(UErrorCode &errorCode) {
-    const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
-    return allModes!=NULL ? &allModes->comp : NULL;
-}
-
-const Normalizer2 *
-Normalizer2::getInstance(const char *packageName,
-                         const char *name,
-                         UNormalization2Mode mode,
-                         UErrorCode &errorCode) {
-    if(U_FAILURE(errorCode)) {
-        return NULL;
-    }
-    if(name==NULL || *name==0) {
-        errorCode=U_ILLEGAL_ARGUMENT_ERROR;
-        return NULL;
-    }
-    const Norm2AllModes *allModes=NULL;
-    if(packageName==NULL) {
-        if(0==uprv_strcmp(name, "nfc")) {
-            allModes=Norm2AllModes::getNFCInstance(errorCode);
-        } else if(0==uprv_strcmp(name, "nfkc")) {
-            allModes=Norm2AllModes::getNFKCInstance(errorCode);
-        } else if(0==uprv_strcmp(name, "nfkc_cf")) {
-            allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
-        }
-    }
-    if(allModes==NULL && U_SUCCESS(errorCode)) {
-        {
-            Mutex lock;
-            if(cache!=NULL) {
-                allModes=(Norm2AllModes *)uhash_get(cache, name);
-            }
-        }
-        if(allModes==NULL) {
+Normalizer2::getNFKCInstance(UErrorCode &errorCode) { 
+    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode); 
+    return allModes!=NULL ? &allModes->comp : NULL; 
+} 
+ 
+const Normalizer2 * 
+Normalizer2::getNFKDInstance(UErrorCode &errorCode) { 
+    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode); 
+    return allModes!=NULL ? &allModes->decomp : NULL; 
+} 
+ 
+const Normalizer2 * 
+Normalizer2::getNFKCCasefoldInstance(UErrorCode &errorCode) { 
+    const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode); 
+    return allModes!=NULL ? &allModes->comp : NULL; 
+} 
+ 
+const Normalizer2 * 
+Normalizer2::getInstance(const char *packageName, 
+                         const char *name, 
+                         UNormalization2Mode mode, 
+                         UErrorCode &errorCode) { 
+    if(U_FAILURE(errorCode)) { 
+        return NULL; 
+    } 
+    if(name==NULL || *name==0) { 
+        errorCode=U_ILLEGAL_ARGUMENT_ERROR; 
+        return NULL; 
+    } 
+    const Norm2AllModes *allModes=NULL; 
+    if(packageName==NULL) { 
+        if(0==uprv_strcmp(name, "nfc")) { 
+            allModes=Norm2AllModes::getNFCInstance(errorCode); 
+        } else if(0==uprv_strcmp(name, "nfkc")) { 
+            allModes=Norm2AllModes::getNFKCInstance(errorCode); 
+        } else if(0==uprv_strcmp(name, "nfkc_cf")) { 
+            allModes=Norm2AllModes::getNFKC_CFInstance(errorCode); 
+        } 
+    } 
+    if(allModes==NULL && U_SUCCESS(errorCode)) { 
+        { 
+            Mutex lock; 
+            if(cache!=NULL) { 
+                allModes=(Norm2AllModes *)uhash_get(cache, name); 
+            } 
+        } 
+        if(allModes==NULL) { 
             ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
-            LocalPointer<Norm2AllModes> localAllModes(
-                Norm2AllModes::createInstance(packageName, name, errorCode));
-            if(U_SUCCESS(errorCode)) {
-                Mutex lock;
-                if(cache==NULL) {
-                    cache=uhash_open(uhash_hashChars, uhash_compareChars, NULL, &errorCode);
-                    if(U_FAILURE(errorCode)) {
-                        return NULL;
-                    }
-                    uhash_setKeyDeleter(cache, uprv_free);
-                    uhash_setValueDeleter(cache, deleteNorm2AllModes);
-                }
-                void *temp=uhash_get(cache, name);
-                if(temp==NULL) {
+            LocalPointer<Norm2AllModes> localAllModes( 
+                Norm2AllModes::createInstance(packageName, name, errorCode)); 
+            if(U_SUCCESS(errorCode)) { 
+                Mutex lock; 
+                if(cache==NULL) { 
+                    cache=uhash_open(uhash_hashChars, uhash_compareChars, NULL, &errorCode); 
+                    if(U_FAILURE(errorCode)) { 
+                        return NULL; 
+                    } 
+                    uhash_setKeyDeleter(cache, uprv_free); 
+                    uhash_setValueDeleter(cache, deleteNorm2AllModes); 
+                } 
+                void *temp=uhash_get(cache, name); 
+                if(temp==NULL) { 
                     int32_t keyLength= static_cast<int32_t>(uprv_strlen(name)+1);
-                    char *nameCopy=(char *)uprv_malloc(keyLength);
-                    if(nameCopy==NULL) {
-                        errorCode=U_MEMORY_ALLOCATION_ERROR;
-                        return NULL;
-                    }
-                    uprv_memcpy(nameCopy, name, keyLength);
-                    allModes=localAllModes.getAlias();
-                    uhash_put(cache, nameCopy, localAllModes.orphan(), &errorCode);
-                } else {
-                    // race condition
-                    allModes=(Norm2AllModes *)temp;
-                }
-            }
-        }
-    }
-    if(allModes!=NULL && U_SUCCESS(errorCode)) {
-        switch(mode) {
-        case UNORM2_COMPOSE:
-            return &allModes->comp;
-        case UNORM2_DECOMPOSE:
-            return &allModes->decomp;
-        case UNORM2_FCD:
-            return &allModes->fcd;
-        case UNORM2_COMPOSE_CONTIGUOUS:
-            return &allModes->fcc;
-        default:
-            break;  // do nothing
-        }
-    }
-    return NULL;
-}
-
-const Normalizer2 *
-Normalizer2Factory::getInstance(UNormalizationMode mode, UErrorCode &errorCode) {
-    if(U_FAILURE(errorCode)) {
-        return NULL;
-    }
-    switch(mode) {
-    case UNORM_NFD:
-        return Normalizer2::getNFDInstance(errorCode);
-    case UNORM_NFKD:
-        return Normalizer2::getNFKDInstance(errorCode);
-    case UNORM_NFC:
-        return Normalizer2::getNFCInstance(errorCode);
-    case UNORM_NFKC:
-        return Normalizer2::getNFKCInstance(errorCode);
-    case UNORM_FCD:
-        return getFCDInstance(errorCode);
-    default:  // UNORM_NONE
-        return getNoopInstance(errorCode);
-    }
-}
-
-const Normalizer2Impl *
-Normalizer2Factory::getNFKCImpl(UErrorCode &errorCode) {
-    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
-    return allModes!=NULL ? allModes->impl : NULL;
-}
-
-const Normalizer2Impl *
-Normalizer2Factory::getNFKC_CFImpl(UErrorCode &errorCode) {
-    const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
-    return allModes!=NULL ? allModes->impl : NULL;
-}
-
-U_NAMESPACE_END
-
-// C API ------------------------------------------------------------------- ***
-
-U_NAMESPACE_USE
-
-U_CAPI const UNormalizer2 * U_EXPORT2
-unorm2_getNFKCInstance(UErrorCode *pErrorCode) {
-    return (const UNormalizer2 *)Normalizer2::getNFKCInstance(*pErrorCode);
-}
-
-U_CAPI const UNormalizer2 * U_EXPORT2
-unorm2_getNFKDInstance(UErrorCode *pErrorCode) {
-    return (const UNormalizer2 *)Normalizer2::getNFKDInstance(*pErrorCode);
-}
-
-U_CAPI const UNormalizer2 * U_EXPORT2
-unorm2_getNFKCCasefoldInstance(UErrorCode *pErrorCode) {
-    return (const UNormalizer2 *)Normalizer2::getNFKCCasefoldInstance(*pErrorCode);
-}
-
-U_CAPI const UNormalizer2 * U_EXPORT2
-unorm2_getInstance(const char *packageName,
-                   const char *name,
-                   UNormalization2Mode mode,
-                   UErrorCode *pErrorCode) {
-    return (const UNormalizer2 *)Normalizer2::getInstance(packageName, name, mode, *pErrorCode);
-}
-
-U_CFUNC UNormalizationCheckResult
-unorm_getQuickCheck(UChar32 c, UNormalizationMode mode) {
-    if(mode<=UNORM_NONE || UNORM_FCD<=mode) {
-        return UNORM_YES;
-    }
-    UErrorCode errorCode=U_ZERO_ERROR;
-    const Normalizer2 *norm2=Normalizer2Factory::getInstance(mode, errorCode);
-    if(U_SUCCESS(errorCode)) {
-        return ((const Normalizer2WithImpl *)norm2)->getQuickCheck(c);
-    } else {
-        return UNORM_MAYBE;
-    }
-}
-
-#endif  // !UCONFIG_NO_NORMALIZATION
+                    char *nameCopy=(char *)uprv_malloc(keyLength); 
+                    if(nameCopy==NULL) { 
+                        errorCode=U_MEMORY_ALLOCATION_ERROR; 
+                        return NULL; 
+                    } 
+                    uprv_memcpy(nameCopy, name, keyLength); 
+                    allModes=localAllModes.getAlias(); 
+                    uhash_put(cache, nameCopy, localAllModes.orphan(), &errorCode); 
+                } else { 
+                    // race condition 
+                    allModes=(Norm2AllModes *)temp; 
+                } 
+            } 
+        } 
+    } 
+    if(allModes!=NULL && U_SUCCESS(errorCode)) { 
+        switch(mode) { 
+        case UNORM2_COMPOSE: 
+            return &allModes->comp; 
+        case UNORM2_DECOMPOSE: 
+            return &allModes->decomp; 
+        case UNORM2_FCD: 
+            return &allModes->fcd; 
+        case UNORM2_COMPOSE_CONTIGUOUS: 
+            return &allModes->fcc; 
+        default: 
+            break;  // do nothing 
+        } 
+    } 
+    return NULL; 
+} 
+ 
+const Normalizer2 * 
+Normalizer2Factory::getInstance(UNormalizationMode mode, UErrorCode &errorCode) { 
+    if(U_FAILURE(errorCode)) { 
+        return NULL; 
+    } 
+    switch(mode) { 
+    case UNORM_NFD: 
+        return Normalizer2::getNFDInstance(errorCode); 
+    case UNORM_NFKD: 
+        return Normalizer2::getNFKDInstance(errorCode); 
+    case UNORM_NFC: 
+        return Normalizer2::getNFCInstance(errorCode); 
+    case UNORM_NFKC: 
+        return Normalizer2::getNFKCInstance(errorCode); 
+    case UNORM_FCD: 
+        return getFCDInstance(errorCode); 
+    default:  // UNORM_NONE 
+        return getNoopInstance(errorCode); 
+    } 
+} 
+ 
+const Normalizer2Impl * 
+Normalizer2Factory::getNFKCImpl(UErrorCode &errorCode) { 
+    const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode); 
+    return allModes!=NULL ? allModes->impl : NULL; 
+} 
+ 
+const Normalizer2Impl * 
+Normalizer2Factory::getNFKC_CFImpl(UErrorCode &errorCode) { 
+    const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode); 
+    return allModes!=NULL ? allModes->impl : NULL; 
+} 
+ 
+U_NAMESPACE_END 
+ 
+// C API ------------------------------------------------------------------- *** 
+ 
+U_NAMESPACE_USE 
+ 
+U_CAPI const UNormalizer2 * U_EXPORT2 
+unorm2_getNFKCInstance(UErrorCode *pErrorCode) { 
+    return (const UNormalizer2 *)Normalizer2::getNFKCInstance(*pErrorCode); 
+} 
+ 
+U_CAPI const UNormalizer2 * U_EXPORT2 
+unorm2_getNFKDInstance(UErrorCode *pErrorCode) { 
+    return (const UNormalizer2 *)Normalizer2::getNFKDInstance(*pErrorCode); 
+} 
+ 
+U_CAPI const UNormalizer2 * U_EXPORT2 
+unorm2_getNFKCCasefoldInstance(UErrorCode *pErrorCode) { 
+    return (const UNormalizer2 *)Normalizer2::getNFKCCasefoldInstance(*pErrorCode); 
+} 
+ 
+U_CAPI const UNormalizer2 * U_EXPORT2 
+unorm2_getInstance(const char *packageName, 
+                   const char *name, 
+                   UNormalization2Mode mode, 
+                   UErrorCode *pErrorCode) { 
+    return (const UNormalizer2 *)Normalizer2::getInstance(packageName, name, mode, *pErrorCode); 
+} 
+ 
+U_CFUNC UNormalizationCheckResult 
+unorm_getQuickCheck(UChar32 c, UNormalizationMode mode) { 
+    if(mode<=UNORM_NONE || UNORM_FCD<=mode) { 
+        return UNORM_YES; 
+    } 
+    UErrorCode errorCode=U_ZERO_ERROR; 
+    const Normalizer2 *norm2=Normalizer2Factory::getInstance(mode, errorCode); 
+    if(U_SUCCESS(errorCode)) { 
+        return ((const Normalizer2WithImpl *)norm2)->getQuickCheck(c); 
+    } else { 
+        return UNORM_MAYBE; 
+    } 
+} 
+ 
+#endif  // !UCONFIG_NO_NORMALIZATION