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