source/common/normalizer2.cpp

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 *
   6 *   Copyright (C) 2009-2016, International Business Machines
   7 *   Corporation and others.  All Rights Reserved.
   8 *
   9 *******************************************************************************
  10 *   file name:  normalizer2.cpp
  11 *   encoding:   US-ASCII
  12 *   tab size:   8 (not used)
  13 *   indentation:4
  14 *
  15 *   created on: 2009nov22
  16 *   created by: Markus W. Scherer
  17 */
  18
  19 #include "unicode/utypes.h"
  20
  21 #if !UCONFIG_NO_NORMALIZATION
  22
  23 #include "unicode/normalizer2.h"
  24 #include "unicode/unistr.h"
  25 #include "unicode/unorm.h"
  26 #include "cstring.h"
  27 #include "mutex.h"
  28 #include "norm2allmodes.h"
  29 #include "normalizer2impl.h"
  30 #include "uassert.h"
  31 #include "ucln_cmn.h"
  32
  33 using icu::Normalizer2Impl;
  34
  35 // NFC/NFD data machine-generated by gennorm2 --csource
  36 #define INCLUDED_FROM_NORMALIZER2_CPP
  37 #include "norm2_nfc_data.h"
  38
  39 U_NAMESPACE_BEGIN
  40
  41 // Public API dispatch via Normalizer2 subclasses -------------------------- ***
  42
  43 Normalizer2::~Normalizer2() {}
  44
  45 UBool
  46 Normalizer2::getRawDecomposition(UChar32, UnicodeString &) const {
  47     return FALSE;
  48 }
  49
  50 UChar32
  51 Normalizer2::composePair(UChar32, UChar32) const {
  52     return U_SENTINEL;
  53 }
  54
  55 uint8_t
  56 Normalizer2::getCombiningClass(UChar32 /*c*/) const {
  57     return 0;
  58 }
  59
  60 // Normalizer2 implementation for the old UNORM_NONE.
  61 class NoopNormalizer2 : public Normalizer2 {
  62     virtual ~NoopNormalizer2();
  63
  64     virtual UnicodeString &
  65     normalize(const UnicodeString &src,
  66               UnicodeString &dest,
  67               UErrorCode &errorCode) const {
  68         if(U_SUCCESS(errorCode)) {
  69             if(&dest!=&src) {
  70                 dest=src;
  71             } else {
  72                 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
  73             }
  74         }
  75         return dest;
  76     }
  77     virtual UnicodeString &
  78     normalizeSecondAndAppend(UnicodeString &first,
  79                              const UnicodeString &second,
  80                              UErrorCode &errorCode) const {
  81         if(U_SUCCESS(errorCode)) {
  82             if(&first!=&second) {
  83                 first.append(second);
  84             } else {
  85                 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
  86             }
  87         }
  88         return first;
  89     }
  90     virtual UnicodeString &
  91     append(UnicodeString &first,
  92            const UnicodeString &second,
  93            UErrorCode &errorCode) const {
  94         if(U_SUCCESS(errorCode)) {
  95             if(&first!=&second) {
  96                 first.append(second);
  97             } else {
  98                 errorCode=U_ILLEGAL_ARGUMENT_ERROR;
  99             }
 100         }
 101         return first;
 102     }
 103     virtual UBool
 104     getDecomposition(UChar32, UnicodeString &) const {
 105         return FALSE;
 106     }
 107     // No need to override the default getRawDecomposition().
 108     virtual UBool
 109     isNormalized(const UnicodeString &, UErrorCode &) const {
 110         return TRUE;
 111     }
 112     virtual UNormalizationCheckResult
 113     quickCheck(const UnicodeString &, UErrorCode &) const {
 114         return UNORM_YES;
 115     }
 116     virtual int32_t
 117     spanQuickCheckYes(const UnicodeString &s, UErrorCode &) const {
 118         return s.length();
 119     }
 120     virtual UBool hasBoundaryBefore(UChar32) const { return TRUE; }
 121     virtual UBool hasBoundaryAfter(UChar32) const { return TRUE; }
 122     virtual UBool isInert(UChar32) const { return TRUE; }
 123 };
 124
 125 NoopNormalizer2::~NoopNormalizer2() {}
 126
 127 Normalizer2WithImpl::~Normalizer2WithImpl() {}
 128
 129 DecomposeNormalizer2::~DecomposeNormalizer2() {}
 130
 131 ComposeNormalizer2::~ComposeNormalizer2() {}
 132
 133 FCDNormalizer2::~FCDNormalizer2() {}
 134
 135 // instance cache ---------------------------------------------------------- ***
 136
 137 Norm2AllModes::~Norm2AllModes() {
 138     delete impl;
 139 }
 140
 141 Norm2AllModes *
 142 Norm2AllModes::createInstance(Normalizer2Impl *impl, UErrorCode &errorCode) {
 143     if(U_FAILURE(errorCode)) {
 144         delete impl;
 145         return NULL;
 146     }
 147     Norm2AllModes *allModes=new Norm2AllModes(impl);
 148     if(allModes==NULL) {
 149         errorCode=U_MEMORY_ALLOCATION_ERROR;
 150         delete impl;
 151         return NULL;
 152     }
 153     return allModes;
 154 }
 155
 156 Norm2AllModes *
 157 Norm2AllModes::createNFCInstance(UErrorCode &errorCode) {
 158     if(U_FAILURE(errorCode)) {
 159         return NULL;
 160     }
 161     Normalizer2Impl *impl=new Normalizer2Impl;
 162     if(impl==NULL) {
 163         errorCode=U_MEMORY_ALLOCATION_ERROR;
 164         return NULL;
 165     }
 166     impl->init(norm2_nfc_data_indexes, &norm2_nfc_data_trie,
 167                norm2_nfc_data_extraData, norm2_nfc_data_smallFCD);
 168     return createInstance(impl, errorCode);
 169 }
 170
 171 U_CDECL_BEGIN
 172 static UBool U_CALLCONV uprv_normalizer2_cleanup();
 173 U_CDECL_END
 174
 175 static Norm2AllModes *nfcSingleton;
 176 static Normalizer2   *noopSingleton;
 177
 178 static icu::UInitOnce nfcInitOnce = U_INITONCE_INITIALIZER;
 179 static icu::UInitOnce noopInitOnce = U_INITONCE_INITIALIZER;
 180
 181 // UInitOnce singleton initialization functions
 182 static void U_CALLCONV initNFCSingleton(UErrorCode &errorCode) {
 183     nfcSingleton=Norm2AllModes::createNFCInstance(errorCode);
 184     ucln_common_registerCleanup(UCLN_COMMON_NORMALIZER2, uprv_normalizer2_cleanup);
 185 }
 186
 187 static void U_CALLCONV initNoopSingleton(UErrorCode &errorCode) {
 188     if(U_FAILURE(errorCode)) {
 189         return;
 190     }
 191     noopSingleton=new NoopNormalizer2;
 192     if(noopSingleton==NULL) {
 193         errorCode=U_MEMORY_ALLOCATION_ERROR;
 194         return;
 195     }
 196     ucln_common_registerCleanup(UCLN_COMMON_NORMALIZER2, uprv_normalizer2_cleanup);
 197 }
 198
 199 U_CDECL_BEGIN
 200
 201 static UBool U_CALLCONV uprv_normalizer2_cleanup() {
 202     delete nfcSingleton;
 203     nfcSingleton = NULL;
 204     delete noopSingleton;
 205     noopSingleton = NULL;
 206     nfcInitOnce.reset();
 207     noopInitOnce.reset();
 208     return TRUE;
 209 }
 210
 211 U_CDECL_END
 212
 213 const Norm2AllModes *
 214 Norm2AllModes::getNFCInstance(UErrorCode &errorCode) {
 215     if(U_FAILURE(errorCode)) { return NULL; }
 216     umtx_initOnce(nfcInitOnce, &initNFCSingleton, errorCode);
 217     return nfcSingleton;
 218 }
 219
 220 const Normalizer2 *
 221 Normalizer2::getNFCInstance(UErrorCode &errorCode) {
 222     const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
 223     return allModes!=NULL ? &allModes->comp : NULL;
 224 }
 225
 226 const Normalizer2 *
 227 Normalizer2::getNFDInstance(UErrorCode &errorCode) {
 228     const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
 229     return allModes!=NULL ? &allModes->decomp : NULL;
 230 }
 231
 232 const Normalizer2 *Normalizer2Factory::getFCDInstance(UErrorCode &errorCode) {
 233     const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
 234     return allModes!=NULL ? &allModes->fcd : NULL;
 235 }
 236
 237 const Normalizer2 *Normalizer2Factory::getFCCInstance(UErrorCode &errorCode) {
 238     const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
 239     return allModes!=NULL ? &allModes->fcc : NULL;
 240 }
 241
 242 const Normalizer2 *Normalizer2Factory::getNoopInstance(UErrorCode &errorCode) {
 243     if(U_FAILURE(errorCode)) { return NULL; }
 244     umtx_initOnce(noopInitOnce, &initNoopSingleton, errorCode);
 245     return noopSingleton;
 246 }
 247
 248 const Normalizer2Impl *
 249 Normalizer2Factory::getNFCImpl(UErrorCode &errorCode) {
 250     const Norm2AllModes *allModes=Norm2AllModes::getNFCInstance(errorCode);
 251     return allModes!=NULL ? allModes->impl : NULL;
 252 }
 253
 254 const Normalizer2Impl *
 255 Normalizer2Factory::getImpl(const Normalizer2 *norm2) {
 256     return &((Normalizer2WithImpl *)norm2)->impl;
 257 }
 258
 259 U_NAMESPACE_END
 260
 261 // C API ------------------------------------------------------------------- ***
 262
 263 U_NAMESPACE_USE
 264
 265 U_CAPI const UNormalizer2 * U_EXPORT2
 266 unorm2_getNFCInstance(UErrorCode *pErrorCode) {
 267     return (const UNormalizer2 *)Normalizer2::getNFCInstance(*pErrorCode);
 268 }
 269
 270 U_CAPI const UNormalizer2 * U_EXPORT2
 271 unorm2_getNFDInstance(UErrorCode *pErrorCode) {
 272     return (const UNormalizer2 *)Normalizer2::getNFDInstance(*pErrorCode);
 273 }
 274
 275 U_CAPI void U_EXPORT2
 276 unorm2_close(UNormalizer2 *norm2) {
 277     delete (Normalizer2 *)norm2;
 278 }
 279
 280 U_CAPI int32_t U_EXPORT2
 281 unorm2_normalize(const UNormalizer2 *norm2,
 282                  const UChar *src, int32_t length,
 283                  UChar *dest, int32_t capacity,
 284                  UErrorCode *pErrorCode) {
 285     if(U_FAILURE(*pErrorCode)) {
 286         return 0;
 287     }
 288     if( (src==NULL ? length!=0 : length<-1) ||
 289         (dest==NULL ? capacity!=0 : capacity<0) ||
 290         (src==dest && src!=NULL)
 291     ) {
 292         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 293         return 0;
 294     }
 295     UnicodeString destString(dest, 0, capacity);
 296     // length==0: Nothing to do, and n2wi->normalize(NULL, NULL, buffer, ...) would crash.
 297     if(length!=0) {
 298         const Normalizer2 *n2=(const Normalizer2 *)norm2;
 299         const Normalizer2WithImpl *n2wi=dynamic_cast<const Normalizer2WithImpl *>(n2);
 300         if(n2wi!=NULL) {
 301             // Avoid duplicate argument checking and support NUL-terminated src.
 302             ReorderingBuffer buffer(n2wi->impl, destString);
 303             if(buffer.init(length, *pErrorCode)) {
 304                 n2wi->normalize(src, length>=0 ? src+length : NULL, buffer, *pErrorCode);
 305             }
 306         } else {
 307             UnicodeString srcString(length<0, src, length);
 308             n2->normalize(srcString, destString, *pErrorCode);
 309         }
 310     }
 311     return destString.extract(dest, capacity, *pErrorCode);
 312 }
 313
 314 static int32_t
 315 normalizeSecondAndAppend(const UNormalizer2 *norm2,
 316                          UChar *first, int32_t firstLength, int32_t firstCapacity,
 317                          const UChar *second, int32_t secondLength,
 318                          UBool doNormalize,
 319                          UErrorCode *pErrorCode) {
 320     if(U_FAILURE(*pErrorCode)) {
 321         return 0;
 322     }
 323     if( (second==NULL ? secondLength!=0 : secondLength<-1) ||
 324         (first==NULL ? (firstCapacity!=0 || firstLength!=0) :
 325                        (firstCapacity<0 || firstLength<-1)) ||
 326         (first==second && first!=NULL)
 327     ) {
 328         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 329         return 0;
 330     }
 331     UnicodeString firstString(first, firstLength, firstCapacity);
 332     firstLength=firstString.length();  // In case it was -1.
 333     // secondLength==0: Nothing to do, and n2wi->normalizeAndAppend(NULL, NULL, buffer, ...) would crash.
 334     if(secondLength!=0) {
 335         const Normalizer2 *n2=(const Normalizer2 *)norm2;
 336         const Normalizer2WithImpl *n2wi=dynamic_cast<const Normalizer2WithImpl *>(n2);
 337         if(n2wi!=NULL) {
 338             // Avoid duplicate argument checking and support NUL-terminated src.
 339             UnicodeString safeMiddle;
 340             {
 341                 ReorderingBuffer buffer(n2wi->impl, firstString);
 342                 if(buffer.init(firstLength+secondLength+1, *pErrorCode)) {  // destCapacity>=-1
 343                     n2wi->normalizeAndAppend(second, secondLength>=0 ? second+secondLength : NULL,
 344                                              doNormalize, safeMiddle, buffer, *pErrorCode);
 345                 }
 346             }  // The ReorderingBuffer destructor finalizes firstString.
 347             if(U_FAILURE(*pErrorCode) || firstString.length()>firstCapacity) {
 348                 // Restore the modified suffix of the first string.
 349                 // This does not restore first[] array contents between firstLength and firstCapacity.
 350                 // (That might be uninitialized memory, as far as we know.)
 351                 if(first!=NULL) { /* don't dereference NULL */
 352                   safeMiddle.extract(0, 0x7fffffff, first+firstLength-safeMiddle.length());
 353                   if(firstLength<firstCapacity) {
 354                     first[firstLength]=0;  // NUL-terminate in case it was originally.
 355                   }
 356                 }
 357             }
 358         } else {
 359             UnicodeString secondString(secondLength<0, second, secondLength);
 360             if(doNormalize) {
 361                 n2->normalizeSecondAndAppend(firstString, secondString, *pErrorCode);
 362             } else {
 363                 n2->append(firstString, secondString, *pErrorCode);
 364             }
 365         }
 366     }
 367     return firstString.extract(first, firstCapacity, *pErrorCode);
 368 }
 369
 370 U_CAPI int32_t U_EXPORT2
 371 unorm2_normalizeSecondAndAppend(const UNormalizer2 *norm2,
 372                                 UChar *first, int32_t firstLength, int32_t firstCapacity,
 373                                 const UChar *second, int32_t secondLength,
 374                                 UErrorCode *pErrorCode) {
 375     return normalizeSecondAndAppend(norm2,
 376                                     first, firstLength, firstCapacity,
 377                                     second, secondLength,
 378                                     TRUE, pErrorCode);
 379 }
 380
 381 U_CAPI int32_t U_EXPORT2
 382 unorm2_append(const UNormalizer2 *norm2,
 383               UChar *first, int32_t firstLength, int32_t firstCapacity,
 384               const UChar *second, int32_t secondLength,
 385               UErrorCode *pErrorCode) {
 386     return normalizeSecondAndAppend(norm2,
 387                                     first, firstLength, firstCapacity,
 388                                     second, secondLength,
 389                                     FALSE, pErrorCode);
 390 }
 391
 392 U_CAPI int32_t U_EXPORT2
 393 unorm2_getDecomposition(const UNormalizer2 *norm2,
 394                         UChar32 c, UChar *decomposition, int32_t capacity,
 395                         UErrorCode *pErrorCode) {
 396     if(U_FAILURE(*pErrorCode)) {
 397         return 0;
 398     }
 399     if(decomposition==NULL ? capacity!=0 : capacity<0) {
 400         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 401         return 0;
 402     }
 403     UnicodeString destString(decomposition, 0, capacity);
 404     if(reinterpret_cast<const Normalizer2 *>(norm2)->getDecomposition(c, destString)) {
 405         return destString.extract(decomposition, capacity, *pErrorCode);
 406     } else {
 407         return -1;
 408     }
 409 }
 410
 411 U_CAPI int32_t U_EXPORT2
 412 unorm2_getRawDecomposition(const UNormalizer2 *norm2,
 413                            UChar32 c, UChar *decomposition, int32_t capacity,
 414                            UErrorCode *pErrorCode) {
 415     if(U_FAILURE(*pErrorCode)) {
 416         return 0;
 417     }
 418     if(decomposition==NULL ? capacity!=0 : capacity<0) {
 419         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 420         return 0;
 421     }
 422     UnicodeString destString(decomposition, 0, capacity);
 423     if(reinterpret_cast<const Normalizer2 *>(norm2)->getRawDecomposition(c, destString)) {
 424         return destString.extract(decomposition, capacity, *pErrorCode);
 425     } else {
 426         return -1;
 427     }
 428 }
 429
 430 U_CAPI UChar32 U_EXPORT2
 431 unorm2_composePair(const UNormalizer2 *norm2, UChar32 a, UChar32 b) {
 432     return reinterpret_cast<const Normalizer2 *>(norm2)->composePair(a, b);
 433 }
 434
 435 U_CAPI uint8_t U_EXPORT2
 436 unorm2_getCombiningClass(const UNormalizer2 *norm2, UChar32 c) {
 437     return reinterpret_cast<const Normalizer2 *>(norm2)->getCombiningClass(c);
 438 }
 439
 440 U_CAPI UBool U_EXPORT2
 441 unorm2_isNormalized(const UNormalizer2 *norm2,
 442                     const UChar *s, int32_t length,
 443                     UErrorCode *pErrorCode) {
 444     if(U_FAILURE(*pErrorCode)) {
 445         return 0;
 446     }
 447     if((s==NULL && length!=0) || length<-1) {
 448         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 449         return 0;
 450     }
 451     UnicodeString sString(length<0, s, length);
 452     return ((const Normalizer2 *)norm2)->isNormalized(sString, *pErrorCode);
 453 }
 454
 455 U_CAPI UNormalizationCheckResult U_EXPORT2
 456 unorm2_quickCheck(const UNormalizer2 *norm2,
 457                   const UChar *s, int32_t length,
 458                   UErrorCode *pErrorCode) {
 459     if(U_FAILURE(*pErrorCode)) {
 460         return UNORM_NO;
 461     }
 462     if((s==NULL && length!=0) || length<-1) {
 463         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 464         return UNORM_NO;
 465     }
 466     UnicodeString sString(length<0, s, length);
 467     return ((const Normalizer2 *)norm2)->quickCheck(sString, *pErrorCode);
 468 }
 469
 470 U_CAPI int32_t U_EXPORT2
 471 unorm2_spanQuickCheckYes(const UNormalizer2 *norm2,
 472                          const UChar *s, int32_t length,
 473                          UErrorCode *pErrorCode) {
 474     if(U_FAILURE(*pErrorCode)) {
 475         return 0;
 476     }
 477     if((s==NULL && length!=0) || length<-1) {
 478         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
 479         return 0;
 480     }
 481     UnicodeString sString(length<0, s, length);
 482     return ((const Normalizer2 *)norm2)->spanQuickCheckYes(sString, *pErrorCode);
 483 }
 484
 485 U_CAPI UBool U_EXPORT2
 486 unorm2_hasBoundaryBefore(const UNormalizer2 *norm2, UChar32 c) {
 487     return ((const Normalizer2 *)norm2)->hasBoundaryBefore(c);
 488 }
 489
 490 U_CAPI UBool U_EXPORT2
 491 unorm2_hasBoundaryAfter(const UNormalizer2 *norm2, UChar32 c) {
 492     return ((const Normalizer2 *)norm2)->hasBoundaryAfter(c);
 493 }
 494
 495 U_CAPI UBool U_EXPORT2
 496 unorm2_isInert(const UNormalizer2 *norm2, UChar32 c) {
 497     return ((const Normalizer2 *)norm2)->isInert(c);
 498 }
 499
 500 // Some properties APIs ---------------------------------------------------- ***
 501
 502 U_CAPI uint8_t U_EXPORT2
 503 u_getCombiningClass(UChar32 c) {
 504     UErrorCode errorCode=U_ZERO_ERROR;
 505     const Normalizer2 *nfd=Normalizer2::getNFDInstance(errorCode);
 506     if(U_SUCCESS(errorCode)) {
 507         return nfd->getCombiningClass(c);
 508     } else {
 509         return 0;
 510     }
 511 }
 512
 513 U_CFUNC uint16_t
 514 unorm_getFCD16(UChar32 c) {
 515     UErrorCode errorCode=U_ZERO_ERROR;
 516     const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode);
 517     if(U_SUCCESS(errorCode)) {
 518         return impl->getFCD16(c);
 519     } else {
 520         return 0;
 521     }
 522 }
 523
 524 #endif  // !UCONFIG_NO_NORMALIZATION