icuSources/common/loadednormalizer2impl.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2014, International Business Machines
   6 * Corporation and others.  All Rights Reserved.
   7 *******************************************************************************
   8 * loadednormalizer2impl.cpp
   9 *
  10 * created on: 2014sep03
  11 * created by: Markus W. Scherer
  12 */
  13
  14 #include "unicode/utypes.h"
  15
  16 #if !UCONFIG_NO_NORMALIZATION
  17
  18 #include "unicode/udata.h"
  19 #include "unicode/localpointer.h"
  20 #include "unicode/normalizer2.h"
  21 #include "unicode/unistr.h"
  22 #include "unicode/unorm.h"
  23 #include "cstring.h"
  24 #include "mutex.h"
  25 #include "norm2allmodes.h"
  26 #include "normalizer2impl.h"
  27 #include "uassert.h"
  28 #include "ucln_cmn.h"
  29 #include "uhash.h"
  30
  31 U_NAMESPACE_BEGIN
  32
  33 class LoadedNormalizer2Impl : public Normalizer2Impl {
  34 public:
  35     LoadedNormalizer2Impl() : memory(NULL), ownedTrie(NULL) {}
  36     virtual ~LoadedNormalizer2Impl();
  37
  38     void load(const char *packageName, const char *name, UErrorCode &errorCode);
  39
  40 private:
  41     static UBool U_CALLCONV
  42     isAcceptable(void *context, const char *type, const char *name, const UDataInfo *pInfo);
  43
  44     UDataMemory *memory;
  45     UTrie2 *ownedTrie;
  46 };
  47
  48 LoadedNormalizer2Impl::~LoadedNormalizer2Impl() {
  49     udata_close(memory);
  50     utrie2_close(ownedTrie);
  51 }
  52
  53 UBool U_CALLCONV
  54 LoadedNormalizer2Impl::isAcceptable(void * /*context*/,
  55                                     const char * /* type */, const char * /*name*/,
  56                                     const UDataInfo *pInfo) {
  57     if(
  58         pInfo->size>=20 &&
  59         pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
  60         pInfo->charsetFamily==U_CHARSET_FAMILY &&
  61         pInfo->dataFormat[0]==0x4e &&    /* dataFormat="Nrm2" */
  62         pInfo->dataFormat[1]==0x72 &&
  63         pInfo->dataFormat[2]==0x6d &&
  64         pInfo->dataFormat[3]==0x32 &&
  65         pInfo->formatVersion[0]==3
  66     ) {
  67         // Normalizer2Impl *me=(Normalizer2Impl *)context;
  68         // uprv_memcpy(me->dataVersion, pInfo->dataVersion, 4);
  69         return TRUE;
  70     } else {
  71         return FALSE;
  72     }
  73 }
  74
  75 void
  76 LoadedNormalizer2Impl::load(const char *packageName, const char *name, UErrorCode &errorCode) {
  77     if(U_FAILURE(errorCode)) {
  78         return;
  79     }
  80     memory=udata_openChoice(packageName, "nrm", name, isAcceptable, this, &errorCode);
  81     if(U_FAILURE(errorCode)) {
  82         return;
  83     }
  84     const uint8_t *inBytes=(const uint8_t *)udata_getMemory(memory);
  85     const int32_t *inIndexes=(const int32_t *)inBytes;
  86     int32_t indexesLength=inIndexes[IX_NORM_TRIE_OFFSET]/4;
  87     if(indexesLength<=IX_MIN_LCCC_CP) {
  88         errorCode=U_INVALID_FORMAT_ERROR;  // Not enough indexes.
  89         return;
  90     }
  91
  92     int32_t offset=inIndexes[IX_NORM_TRIE_OFFSET];
  93     int32_t nextOffset=inIndexes[IX_EXTRA_DATA_OFFSET];
  94     ownedTrie=utrie2_openFromSerialized(UTRIE2_16_VALUE_BITS,
  95                                         inBytes+offset, nextOffset-offset, NULL,
  96                                         &errorCode);
  97     if(U_FAILURE(errorCode)) {
  98         return;
  99     }
 100
 101     offset=nextOffset;
 102     nextOffset=inIndexes[IX_SMALL_FCD_OFFSET];
 103     const uint16_t *inExtraData=(const uint16_t *)(inBytes+offset);
 104
 105     // smallFCD: new in formatVersion 2
 106     offset=nextOffset;
 107     const uint8_t *inSmallFCD=inBytes+offset;
 108
 109     init(inIndexes, ownedTrie, inExtraData, inSmallFCD);
 110 }
 111
 112 // instance cache ---------------------------------------------------------- ***
 113
 114 Norm2AllModes *
 115 Norm2AllModes::createInstance(const char *packageName,
 116                               const char *name,
 117                               UErrorCode &errorCode) {
 118     if(U_FAILURE(errorCode)) {
 119         return NULL;
 120     }
 121     LoadedNormalizer2Impl *impl=new LoadedNormalizer2Impl;
 122     if(impl==NULL) {
 123         errorCode=U_MEMORY_ALLOCATION_ERROR;
 124         return NULL;
 125     }
 126     impl->load(packageName, name, errorCode);
 127     return createInstance(impl, errorCode);
 128 }
 129
 130 U_CDECL_BEGIN
 131 static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup();
 132 U_CDECL_END
 133
 134 static Norm2AllModes *nfkcSingleton;
 135 static Norm2AllModes *nfkc_cfSingleton;
 136 static UHashtable    *cache=NULL;
 137
 138 static icu::UInitOnce nfkcInitOnce = U_INITONCE_INITIALIZER;
 139 static icu::UInitOnce nfkc_cfInitOnce = U_INITONCE_INITIALIZER;
 140
 141 // UInitOnce singleton initialization function
 142 static void U_CALLCONV initSingletons(const char *what, UErrorCode &errorCode) {
 143     if (uprv_strcmp(what, "nfkc") == 0) {
 144         nfkcSingleton    = Norm2AllModes::createInstance(NULL, "nfkc", errorCode);
 145     } else if (uprv_strcmp(what, "nfkc_cf") == 0) {
 146         nfkc_cfSingleton = Norm2AllModes::createInstance(NULL, "nfkc_cf", errorCode);
 147     } else {
 148         U_ASSERT(FALSE);   // Unknown singleton
 149     }
 150     ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
 151 }
 152
 153 U_CDECL_BEGIN
 154
 155 static void U_CALLCONV deleteNorm2AllModes(void *allModes) {
 156     delete (Norm2AllModes *)allModes;
 157 }
 158
 159 static UBool U_CALLCONV uprv_loaded_normalizer2_cleanup() {
 160     delete nfkcSingleton;
 161     nfkcSingleton = NULL;
 162     delete nfkc_cfSingleton;
 163     nfkc_cfSingleton = NULL;
 164     uhash_close(cache);
 165     cache=NULL;
 166     nfkcInitOnce.reset();
 167     nfkc_cfInitOnce.reset();
 168     return TRUE;
 169 }
 170
 171 U_CDECL_END
 172
 173 const Norm2AllModes *
 174 Norm2AllModes::getNFKCInstance(UErrorCode &errorCode) {
 175     if(U_FAILURE(errorCode)) { return NULL; }
 176     umtx_initOnce(nfkcInitOnce, &initSingletons, "nfkc", errorCode);
 177     return nfkcSingleton;
 178 }
 179
 180 const Norm2AllModes *
 181 Norm2AllModes::getNFKC_CFInstance(UErrorCode &errorCode) {
 182     if(U_FAILURE(errorCode)) { return NULL; }
 183     umtx_initOnce(nfkc_cfInitOnce, &initSingletons, "nfkc_cf", errorCode);
 184     return nfkc_cfSingleton;
 185 }
 186
 187 const Normalizer2 *
 188 Normalizer2::getNFKCInstance(UErrorCode &errorCode) {
 189     const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
 190     return allModes!=NULL ? &allModes->comp : NULL;
 191 }
 192
 193 const Normalizer2 *
 194 Normalizer2::getNFKDInstance(UErrorCode &errorCode) {
 195     const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
 196     return allModes!=NULL ? &allModes->decomp : NULL;
 197 }
 198
 199 const Normalizer2 *
 200 Normalizer2::getNFKCCasefoldInstance(UErrorCode &errorCode) {
 201     const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
 202     return allModes!=NULL ? &allModes->comp : NULL;
 203 }
 204
 205 const Normalizer2 *
 206 Normalizer2::getInstance(const char *packageName,
 207                          const char *name,
 208                          UNormalization2Mode mode,
 209                          UErrorCode &errorCode) {
 210     if(U_FAILURE(errorCode)) {
 211         return NULL;
 212     }
 213     if(name==NULL || *name==0) {
 214         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
 215         return NULL;
 216     }
 217     const Norm2AllModes *allModes=NULL;
 218     if(packageName==NULL) {
 219         if(0==uprv_strcmp(name, "nfc")) {
 220             allModes=Norm2AllModes::getNFCInstance(errorCode);
 221         } else if(0==uprv_strcmp(name, "nfkc")) {
 222             allModes=Norm2AllModes::getNFKCInstance(errorCode);
 223         } else if(0==uprv_strcmp(name, "nfkc_cf")) {
 224             allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
 225         }
 226     }
 227     if(allModes==NULL && U_SUCCESS(errorCode)) {
 228         {
 229             Mutex lock;
 230             if(cache!=NULL) {
 231                 allModes=(Norm2AllModes *)uhash_get(cache, name);
 232             }
 233         }
 234         if(allModes==NULL) {
 235             ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
 236             LocalPointer<Norm2AllModes> localAllModes(
 237                 Norm2AllModes::createInstance(packageName, name, errorCode));
 238             if(U_SUCCESS(errorCode)) {
 239                 Mutex lock;
 240                 if(cache==NULL) {
 241                     cache=uhash_open(uhash_hashChars, uhash_compareChars, NULL, &errorCode);
 242                     if(U_FAILURE(errorCode)) {
 243                         return NULL;
 244                     }
 245                     uhash_setKeyDeleter(cache, uprv_free);
 246                     uhash_setValueDeleter(cache, deleteNorm2AllModes);
 247                 }
 248                 void *temp=uhash_get(cache, name);
 249                 if(temp==NULL) {
 250                     int32_t keyLength=uprv_strlen(name)+1;
 251                     char *nameCopy=(char *)uprv_malloc(keyLength);
 252                     if(nameCopy==NULL) {
 253                         errorCode=U_MEMORY_ALLOCATION_ERROR;
 254                         return NULL;
 255                     }
 256                     uprv_memcpy(nameCopy, name, keyLength);
 257                     allModes=localAllModes.getAlias();
 258                     uhash_put(cache, nameCopy, localAllModes.orphan(), &errorCode);
 259                 } else {
 260                     // race condition
 261                     allModes=(Norm2AllModes *)temp;
 262                 }
 263             }
 264         }
 265     }
 266     if(allModes!=NULL && U_SUCCESS(errorCode)) {
 267         switch(mode) {
 268         case UNORM2_COMPOSE:
 269             return &allModes->comp;
 270         case UNORM2_DECOMPOSE:
 271             return &allModes->decomp;
 272         case UNORM2_FCD:
 273             return &allModes->fcd;
 274         case UNORM2_COMPOSE_CONTIGUOUS:
 275             return &allModes->fcc;
 276         default:
 277             break;  // do nothing
 278         }
 279     }
 280     return NULL;
 281 }
 282
 283 const Normalizer2 *
 284 Normalizer2Factory::getInstance(UNormalizationMode mode, UErrorCode &errorCode) {
 285     if(U_FAILURE(errorCode)) {
 286         return NULL;
 287     }
 288     switch(mode) {
 289     case UNORM_NFD:
 290         return Normalizer2::getNFDInstance(errorCode);
 291     case UNORM_NFKD:
 292         return Normalizer2::getNFKDInstance(errorCode);
 293     case UNORM_NFC:
 294         return Normalizer2::getNFCInstance(errorCode);
 295     case UNORM_NFKC:
 296         return Normalizer2::getNFKCInstance(errorCode);
 297     case UNORM_FCD:
 298         return getFCDInstance(errorCode);
 299     default:  // UNORM_NONE
 300         return getNoopInstance(errorCode);
 301     }
 302 }
 303
 304 const Normalizer2Impl *
 305 Normalizer2Factory::getNFKCImpl(UErrorCode &errorCode) {
 306     const Norm2AllModes *allModes=Norm2AllModes::getNFKCInstance(errorCode);
 307     return allModes!=NULL ? allModes->impl : NULL;
 308 }
 309
 310 const Normalizer2Impl *
 311 Normalizer2Factory::getNFKC_CFImpl(UErrorCode &errorCode) {
 312     const Norm2AllModes *allModes=Norm2AllModes::getNFKC_CFInstance(errorCode);
 313     return allModes!=NULL ? allModes->impl : NULL;
 314 }
 315
 316 U_NAMESPACE_END
 317
 318 // C API ------------------------------------------------------------------- ***
 319
 320 U_NAMESPACE_USE
 321
 322 U_CAPI const UNormalizer2 * U_EXPORT2
 323 unorm2_getNFKCInstance(UErrorCode *pErrorCode) {
 324     return (const UNormalizer2 *)Normalizer2::getNFKCInstance(*pErrorCode);
 325 }
 326
 327 U_CAPI const UNormalizer2 * U_EXPORT2
 328 unorm2_getNFKDInstance(UErrorCode *pErrorCode) {
 329     return (const UNormalizer2 *)Normalizer2::getNFKDInstance(*pErrorCode);
 330 }
 331
 332 U_CAPI const UNormalizer2 * U_EXPORT2
 333 unorm2_getNFKCCasefoldInstance(UErrorCode *pErrorCode) {
 334     return (const UNormalizer2 *)Normalizer2::getNFKCCasefoldInstance(*pErrorCode);
 335 }
 336
 337 U_CAPI const UNormalizer2 * U_EXPORT2
 338 unorm2_getInstance(const char *packageName,
 339                    const char *name,
 340                    UNormalization2Mode mode,
 341                    UErrorCode *pErrorCode) {
 342     return (const UNormalizer2 *)Normalizer2::getInstance(packageName, name, mode, *pErrorCode);
 343 }
 344
 345 U_CFUNC UNormalizationCheckResult
 346 unorm_getQuickCheck(UChar32 c, UNormalizationMode mode) {
 347     if(mode<=UNORM_NONE || UNORM_FCD<=mode) {
 348         return UNORM_YES;
 349     }
 350     UErrorCode errorCode=U_ZERO_ERROR;
 351     const Normalizer2 *norm2=Normalizer2Factory::getInstance(mode, errorCode);
 352     if(U_SUCCESS(errorCode)) {
 353         return ((const Normalizer2WithImpl *)norm2)->getQuickCheck(c);
 354     } else {
 355         return UNORM_MAYBE;
 356     }
 357 }
 358
 359 #endif  // !UCONFIG_NO_NORMALIZATION