ICU-64260.0.1.tar.gz

[apple/icu.git] / icuSources / common / loadednormalizer2impl.cpp

diff --git a/icuSources/common/loadednormalizer2impl.cpp b/icuSources/common/loadednormalizer2impl.cpp
index 288a7d69536a57530c05a16ce4a1ecb85e0d8014..e4b36f1055f15d24b3d8392fa3ed03691c3b4997 100644 (file)
--- a/icuSources/common/loadednormalizer2impl.cpp
+++ b/icuSources/common/loadednormalizer2impl.cpp
@@ -18,6 +18,7 @@
 #include "unicode/udata.h"
 #include "unicode/localpointer.h"
 #include "unicode/normalizer2.h"
 #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 "unicode/unistr.h"
 #include "unicode/unorm.h"
 #include "cstring.h"


@@ -42,12 +43,12 @@ private:
     isAcceptable(void *context, const char *type, const char *name, const UDataInfo *pInfo);
 
     UDataMemory *memory;
     isAcceptable(void *context, const char *type, const char *name, const UDataInfo *pInfo);
 
     UDataMemory *memory;

-    UTrie2 *ownedTrie;
+    UCPTrie *ownedTrie;

 };
 
 LoadedNormalizer2Impl::~LoadedNormalizer2Impl() {
     udata_close(memory);
 };
 
 LoadedNormalizer2Impl::~LoadedNormalizer2Impl() {
     udata_close(memory);

-    utrie2_close(ownedTrie);
+    ucptrie_close(ownedTrie);

 }
 
 UBool U_CALLCONV
 }
 
 UBool U_CALLCONV


@@ -62,7 +63,7 @@ LoadedNormalizer2Impl::isAcceptable(void * /*context*/,
         pInfo->dataFormat[1]==0x72 &&
         pInfo->dataFormat[2]==0x6d &&
         pInfo->dataFormat[3]==0x32 &&
         pInfo->dataFormat[1]==0x72 &&
         pInfo->dataFormat[2]==0x6d &&
         pInfo->dataFormat[3]==0x32 &&

-        pInfo->formatVersion[0]==3
+        pInfo->formatVersion[0]==4

     ) {
         // Normalizer2Impl *me=(Normalizer2Impl *)context;
         // uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4);
     ) {
         // Normalizer2Impl *me=(Normalizer2Impl *)context;
         // uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4);


@@ -91,9 +92,9 @@ LoadedNormalizer2Impl::load(const char *packageName, const char *name, UErrorCod
 
     int32_t offset=inIndexes[IX_NORM_TRIE_OFFSET];
     int32_t nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
 
     int32_t offset=inIndexes[IX_NORM_TRIE_OFFSET];
     int32_t nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];

-    ownedTrie=utrie2_openFromSerialized(UTRIE2_16_VALUE_BITS,
-                                        inBytes+offset, nextOffset-offset, NULL,
-                                        &errorCode);
+    ownedTrie=ucptrie_openFromBinary(UCPTRIE_TYPE_FAST, UCPTRIE_VALUE_BITS_16,
+                                     inBytes+offset, nextOffset-offset, NULL,
+                                     &errorCode);

     if(U_FAILURE(errorCode)) {
         return;
     }
     if(U_FAILURE(errorCode)) {
         return;
     }


@@ -131,21 +132,32 @@ U_CDECL_BEGIN
 static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup();
 U_CDECL_END
 
 static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup();
 U_CDECL_END
 

-static Norm2AllModes *nfkcSingleton;
-static Norm2AllModes *nfkc_cfSingleton;
-static UHashtable    *cache=NULL;
+#if !NORM2_HARDCODE_NFC_DATA
+static Norm2AllModes *nfcSingleton;
+static icu::UInitOnce nfcInitOnce = U_INITONCE_INITIALIZER;
+#endif

 
 

+static Norm2AllModes *nfkcSingleton;

 static icu::UInitOnce nfkcInitOnce = U_INITONCE_INITIALIZER;
 static icu::UInitOnce nfkcInitOnce = U_INITONCE_INITIALIZER;

+
+static Norm2AllModes *nfkc_cfSingleton;

 static icu::UInitOnce nfkc_cfInitOnce = U_INITONCE_INITIALIZER;
 
 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) {
 // 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 {

-        U_ASSERT(FALSE);   // Unknown singleton
+        UPRV_UNREACHABLE;   // Unknown singleton

     }
     ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
 }
     }
     ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
 }


@@ -157,19 +169,36 @@ static void U_CALLCONV deleteNorm2AllModes(void *allModes) {
 }
 
 static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup() {
 }
 
 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;
     uhash_close(cache);
     cache=NULL;

-    nfkcInitOnce.reset(); 
-    nfkc_cfInitOnce.reset(); 

     return TRUE;
 }
 
 U_CDECL_END
 
     return TRUE;
 }
 
 U_CDECL_END
 

+#if !NORM2_HARDCODE_NFC_DATA
+const Norm2AllModes *
+Norm2AllModes::getNFCInstance(UErrorCode &errorCode) {
+    if(U_FAILURE(errorCode)) { return NULL; }
+    umtx_initOnce(nfcInitOnce, &initSingletons, "nfc", errorCode);
+    return nfcSingleton;
+}
+#endif
+

 const Norm2AllModes *
 Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) {
     if(U_FAILURE(errorCode)) { return NULL; }
 const Norm2AllModes *
 Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) {
     if(U_FAILURE(errorCode)) { return NULL; }


@@ -184,6 +213,36 @@ Norm2AllModes::getNFKC_CFInstance(UErrorCode &errorCode) {
     return nfkc_cfSingleton;
 }
 
     return nfkc_cfSingleton;
 }
 

+#if !NORM2_HARDCODE_NFC_DATA
+const Normalizer2 *
+Normalizer2::getNFCInstance(UErrorCode &errorCode) {
+    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
+    return allModes!=NULL ? &allModes->comp : NULL;
+}
+
+const Normalizer2 *
+Normalizer2::getNFDInstance(UErrorCode &errorCode) {
+    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
+    return allModes!=NULL ? &allModes->decomp : NULL;
+}
+
+const Normalizer2 *Normalizer2Factory::getFCDInstance(UErrorCode &errorCode) {
+    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
+    return allModes!=NULL ? &allModes->fcd : NULL;
+}
+
+const Normalizer2 *Normalizer2Factory::getFCCInstance(UErrorCode &errorCode) {
+    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
+    return allModes!=NULL ? &allModes->fcc : NULL;
+}
+
+const Normalizer2Impl *
+Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) {
+    const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
+    return allModes!=NULL ? allModes->impl : NULL;
+}
+#endif
+

 const Normalizer2 *
 Normalizer2::getNFKCInstance(UErrorCode &errorCode) {
     const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
 const Normalizer2 *
 Normalizer2::getNFKCInstance(UErrorCode &errorCode) {
     const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);


@@ -247,7 +306,7 @@ Normalizer2::getInstance(const char *packageName,
                 }
                 void *temp=uhash_get(cache, name);
                 if(temp==NULL) {
                 }
                 void *temp=uhash_get(cache, name);
                 if(temp==NULL) {

-                    int32_t keyLength=uprv_strlen(name)+1;
+                    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;
                     char *nameCopy=(char *)uprv_malloc(keyLength);
                     if(nameCopy==NULL) {
                         errorCode=U_MEMORY_ALLOCATION_ERROR;