The Tor Browser / file revision

 /*

 *******************************************************************************

 *

 *   Copyright (C) 2009-2013, International Business Machines

 *   Corporation and others.  All Rights Reserved.

 *

 *******************************************************************************

 *   file name:  normalizer2impl.h

 *   encoding:   US-ASCII

 *   tab size:   8 (not used)

 *   indentation:4

 *

 *   created on: 2009nov22

 *   created by: Markus W. Scherer

 */

 #ifndef __NORMALIZER2IMPL_H__

 #define __NORMALIZER2IMPL_H__

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_NORMALIZATION

 #include "unicode/normalizer2.h"

 #include "unicode/udata.h"

 #include "unicode/unistr.h"

 #include "unicode/unorm.h"

 #include "unicode/utf16.h"

 #include "mutex.h"

 #include "uset_imp.h"

 #include "utrie2.h"

 U_NAMESPACE_BEGIN

 struct CanonIterData;

 class Hangul {

 public:

     /* Korean Hangul and Jamo constants */

     enum {

         JAMO_L_BASE=0x1100,     /* "lead" jamo */

         JAMO_V_BASE=0x1161,     /* "vowel" jamo */

         JAMO_T_BASE=0x11a7,     /* "trail" jamo */

         HANGUL_BASE=0xac00,

         JAMO_L_COUNT=19,

         JAMO_V_COUNT=21,

         JAMO_T_COUNT=28,

         JAMO_VT_COUNT=JAMO_V_COUNT*JAMO_T_COUNT,

         HANGUL_COUNT=JAMO_L_COUNT*JAMO_V_COUNT*JAMO_T_COUNT,

         HANGUL_LIMIT=HANGUL_BASE+HANGUL_COUNT

     };

     static inline UBool isHangul(UChar32 c) {

         return HANGUL_BASE<=c && c<HANGUL_LIMIT;

     }

     static inline UBool

     isHangulWithoutJamoT(UChar c) {

         c-=HANGUL_BASE;

         return c<HANGUL_COUNT && c%JAMO_T_COUNT==0;

     }

     static inline UBool isJamoL(UChar32 c) {

         return (uint32_t)(c-JAMO_L_BASE)<JAMO_L_COUNT;

     }

     static inline UBool isJamoV(UChar32 c) {

         return (uint32_t)(c-JAMO_V_BASE)<JAMO_V_COUNT;

     }

     /**

      * Decomposes c, which must be a Hangul syllable, into buffer

      * and returns the length of the decomposition (2 or 3).

      */

     static inline int32_t decompose(UChar32 c, UChar buffer[3]) {

         c-=HANGUL_BASE;

         UChar32 c2=c%JAMO_T_COUNT;

         c/=JAMO_T_COUNT;

         buffer[0]=(UChar)(JAMO_L_BASE+c/JAMO_V_COUNT);

         buffer[1]=(UChar)(JAMO_V_BASE+c%JAMO_V_COUNT);

         if(c2==0) {

             return 2;

         } else {

             buffer[2]=(UChar)(JAMO_T_BASE+c2);

             return 3;

         }

     }

     /**

      * Decomposes c, which must be a Hangul syllable, into buffer.

      * This is the raw, not recursive, decomposition. Its length is always 2.

      */

     static inline void getRawDecomposition(UChar32 c, UChar buffer[2]) {

         UChar32 orig=c;

         c-=HANGUL_BASE;

         UChar32 c2=c%JAMO_T_COUNT;

         if(c2==0) {

             c/=JAMO_T_COUNT;

             buffer[0]=(UChar)(JAMO_L_BASE+c/JAMO_V_COUNT);

             buffer[1]=(UChar)(JAMO_V_BASE+c%JAMO_V_COUNT);

         } else {

             buffer[0]=orig-c2;  // LV syllable

             buffer[1]=(UChar)(JAMO_T_BASE+c2);

         }

     }

 private:

     Hangul();  // no instantiation

 };

 class Normalizer2Impl;

 class ReorderingBuffer : public UMemory {

 public:

     ReorderingBuffer(const Normalizer2Impl &ni, UnicodeString &dest) :

         impl(ni), str(dest),

         start(NULL), reorderStart(NULL), limit(NULL),

         remainingCapacity(0), lastCC(0) {}

     ~ReorderingBuffer() {

         if(start!=NULL) {

             str.releaseBuffer((int32_t)(limit-start));

         }

     }

     UBool init(int32_t destCapacity, UErrorCode &errorCode);

     UBool isEmpty() const { return start==limit; }

     int32_t length() const { return (int32_t)(limit-start); }

     UChar *getStart() { return start; }

     UChar *getLimit() { return limit; }

     uint8_t getLastCC() const { return lastCC; }

     UBool equals(const UChar *start, const UChar *limit) const;

     // For Hangul composition, replacing the Leading consonant Jamo with the syllable.

     void setLastChar(UChar c) {

         *(limit-1)=c;

     }

     UBool append(UChar32 c, uint8_t cc, UErrorCode &errorCode) {

         return (c<=0xffff) ?

             appendBMP((UChar)c, cc, errorCode) :

             appendSupplementary(c, cc, errorCode);

     }

     // s must be in NFD, otherwise change the implementation.

     UBool append(const UChar *s, int32_t length,

                  uint8_t leadCC, uint8_t trailCC,

                  UErrorCode &errorCode);

     UBool appendBMP(UChar c, uint8_t cc, UErrorCode &errorCode) {

         if(remainingCapacity==0 && !resize(1, errorCode)) {

             return FALSE;

         }

         if(lastCC<=cc || cc==0) {

             *limit++=c;

             lastCC=cc;

             if(cc<=1) {

                 reorderStart=limit;

             }

         } else {

             insert(c, cc);

         }

         --remainingCapacity;

         return TRUE;

     }

     UBool appendZeroCC(UChar32 c, UErrorCode &errorCode);

     UBool appendZeroCC(const UChar *s, const UChar *sLimit, UErrorCode &errorCode);

     void remove();

     void removeSuffix(int32_t suffixLength);

     void setReorderingLimit(UChar *newLimit) {

         remainingCapacity+=(int32_t)(limit-newLimit);

         reorderStart=limit=newLimit;

         lastCC=0;

     }

     void copyReorderableSuffixTo(UnicodeString &s) const {

         s.setTo(reorderStart, (int32_t)(limit-reorderStart));

     }

 private:

     /*

      * TODO: Revisit whether it makes sense to track reorderStart.

      * It is set to after the last known character with cc<=1,

      * which stops previousCC() before it reads that character and looks up its cc.

      * previousCC() is normally only called from insert().

      * In other words, reorderStart speeds up the insertion of a combining mark

      * into a multi-combining mark sequence where it does not belong at the end.

      * This might not be worth the trouble.

      * On the other hand, it's not a huge amount of trouble.

      *

      * We probably need it for UNORM_SIMPLE_APPEND.

      */

     UBool appendSupplementary(UChar32 c, uint8_t cc, UErrorCode &errorCode);

     void insert(UChar32 c, uint8_t cc);

     static void writeCodePoint(UChar *p, UChar32 c) {

         if(c<=0xffff) {

             *p=(UChar)c;

         } else {

             p[0]=U16_LEAD(c);

             p[1]=U16_TRAIL(c);

         }

     }

     UBool resize(int32_t appendLength, UErrorCode &errorCode);

     const Normalizer2Impl &impl;

     UnicodeString &str;

     UChar *start, *reorderStart, *limit;

     int32_t remainingCapacity;

     uint8_t lastCC;

     // private backward iterator

     void setIterator() { codePointStart=limit; }

     void skipPrevious();  // Requires start<codePointStart.

     uint8_t previousCC();  // Returns 0 if there is no previous character.

     UChar *codePointStart, *codePointLimit;

 };

 class U_COMMON_API Normalizer2Impl : public UMemory {

 public:

     Normalizer2Impl() : memory(NULL), normTrie(NULL), fCanonIterData(NULL) {

         fCanonIterDataInitOnce.reset();

     }

     ~Normalizer2Impl();

     void load(const char *packageName, const char *name, UErrorCode &errorCode);

     void addPropertyStarts(const USetAdder *sa, UErrorCode &errorCode) const;

     void addCanonIterPropertyStarts(const USetAdder *sa, UErrorCode &errorCode) const;

     // low-level properties ------------------------------------------------ ***

     const UTrie2 *getNormTrie() const { return normTrie; }

     UBool ensureCanonIterData(UErrorCode &errorCode) const;

     uint16_t getNorm16(UChar32 c) const { return UTRIE2_GET16(normTrie, c); }

     UNormalizationCheckResult getCompQuickCheck(uint16_t norm16) const {

         if(norm16<minNoNo || MIN_YES_YES_WITH_CC<=norm16) {

             return UNORM_YES;

         } else if(minMaybeYes<=norm16) {

             return UNORM_MAYBE;

         } else {

             return UNORM_NO;

         }

     }

     UBool isCompNo(uint16_t norm16) const { return minNoNo<=norm16 && norm16<minMaybeYes; }

     UBool isDecompYes(uint16_t norm16) const { return norm16<minYesNo || minMaybeYes<=norm16; }

     uint8_t getCC(uint16_t norm16) const {

         if(norm16>=MIN_NORMAL_MAYBE_YES) {

             return (uint8_t)norm16;

         }

         if(norm16<minNoNo || limitNoNo<=norm16) {

             return 0;

         }

         return getCCFromNoNo(norm16);

     }

     static uint8_t getCCFromYesOrMaybe(uint16_t norm16) {

         return norm16>=MIN_NORMAL_MAYBE_YES ? (uint8_t)norm16 : 0;

     }

     /**

      * Returns the FCD data for code point c.

      * @param c A Unicode code point.

      * @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.

      */

     uint16_t getFCD16(UChar32 c) const {

         if(c<0) {

             return 0;

         } else if(c<0x180) {

             return tccc180[c];

         } else if(c<=0xffff) {

             if(!singleLeadMightHaveNonZeroFCD16(c)) { return 0; }

         }

         return getFCD16FromNormData(c);

     }

     /**

      * Returns the FCD data for the next code point (post-increment).

      * Might skip only a lead surrogate rather than the whole surrogate pair if none of

      * the supplementary code points associated with the lead surrogate have non-zero FCD data.

      * @param s A valid pointer into a string. Requires s!=limit.

      * @param limit The end of the string, or NULL.

      * @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.

      */

     uint16_t nextFCD16(const UChar *&s, const UChar *limit) const {

         UChar32 c=*s++;

         if(c<0x180) {

             return tccc180[c];

         } else if(!singleLeadMightHaveNonZeroFCD16(c)) {

             return 0;

         }

         UChar c2;

         if(U16_IS_LEAD(c) && s!=limit && U16_IS_TRAIL(c2=*s)) {

             c=U16_GET_SUPPLEMENTARY(c, c2);

             ++s;

         }

         return getFCD16FromNormData(c);

     }

     /**

      * Returns the FCD data for the previous code point (pre-decrement).

      * @param start The start of the string.

      * @param s A valid pointer into a string. Requires start<s.

      * @return The lccc(c) in bits 15..8 and tccc(c) in bits 7..0.

      */

     uint16_t previousFCD16(const UChar *start, const UChar *&s) const {

         UChar32 c=*--s;

         if(c<0x180) {

             return tccc180[c];

         }

         if(!U16_IS_TRAIL(c)) {

             if(!singleLeadMightHaveNonZeroFCD16(c)) {

                 return 0;

             }

         } else {

             UChar c2;

             if(start<s && U16_IS_LEAD(c2=*(s-1))) {

                 c=U16_GET_SUPPLEMENTARY(c2, c);

                 --s;

             }

         }

         return getFCD16FromNormData(c);

     }

     /** Returns the FCD data for U+0000<=c<U+0180. */

     uint16_t getFCD16FromBelow180(UChar32 c) const { return tccc180[c]; }

     /** Returns TRUE if the single-or-lead code unit c might have non-zero FCD data. */

     UBool singleLeadMightHaveNonZeroFCD16(UChar32 lead) const {

         // 0<=lead<=0xffff

         uint8_t bits=smallFCD[lead>>8];

         if(bits==0) { return false; }

         return (UBool)((bits>>((lead>>5)&7))&1);

     }

     /** Returns the FCD value from the regular normalization data. */

     uint16_t getFCD16FromNormData(UChar32 c) const;

     void makeCanonIterDataFromNorm16(UChar32 start, UChar32 end, uint16_t norm16,

                                      CanonIterData &newData, UErrorCode &errorCode) const;

     /**

      * Gets the decomposition for one code point.

      * @param c code point

      * @param buffer out-only buffer for algorithmic decompositions

      * @param length out-only, takes the length of the decomposition, if any

      * @return pointer to the decomposition, or NULL if none

      */

     const UChar *getDecomposition(UChar32 c, UChar buffer[4], int32_t &length) const;

     /**

      * Gets the raw decomposition for one code point.

      * @param c code point

      * @param buffer out-only buffer for algorithmic decompositions

      * @param length out-only, takes the length of the decomposition, if any

      * @return pointer to the decomposition, or NULL if none

      */

     const UChar *getRawDecomposition(UChar32 c, UChar buffer[30], int32_t &length) const;

     UChar32 composePair(UChar32 a, UChar32 b) const;

     UBool isCanonSegmentStarter(UChar32 c) const;

     UBool getCanonStartSet(UChar32 c, UnicodeSet &set) const;

     enum {

         MIN_CCC_LCCC_CP=0x300

     };

     enum {

         MIN_YES_YES_WITH_CC=0xff01,

         JAMO_VT=0xff00,

         MIN_NORMAL_MAYBE_YES=0xfe00,

         JAMO_L=1,

         MAX_DELTA=0x40

     };

     enum {

         // Byte offsets from the start of the data, after the generic header.

         IX_NORM_TRIE_OFFSET,

         IX_EXTRA_DATA_OFFSET,

         IX_SMALL_FCD_OFFSET,

         IX_RESERVED3_OFFSET,

         IX_RESERVED4_OFFSET,

         IX_RESERVED5_OFFSET,

         IX_RESERVED6_OFFSET,

         IX_TOTAL_SIZE,

         // Code point thresholds for quick check codes.

         IX_MIN_DECOMP_NO_CP,

         IX_MIN_COMP_NO_MAYBE_CP,

         // Norm16 value thresholds for quick check combinations and types of extra data.

         IX_MIN_YES_NO,  // Mappings & compositions in [minYesNo..minYesNoMappingsOnly[.

         IX_MIN_NO_NO,

         IX_LIMIT_NO_NO,

         IX_MIN_MAYBE_YES,

         IX_MIN_YES_NO_MAPPINGS_ONLY,  // Mappings only in [minYesNoMappingsOnly..minNoNo[.

         IX_RESERVED15,

         IX_COUNT

     };

     enum {

         MAPPING_HAS_CCC_LCCC_WORD=0x80,

         MAPPING_HAS_RAW_MAPPING=0x40,

         MAPPING_NO_COMP_BOUNDARY_AFTER=0x20,

         MAPPING_LENGTH_MASK=0x1f

     };

     enum {

         COMP_1_LAST_TUPLE=0x8000,

         COMP_1_TRIPLE=1,

         COMP_1_TRAIL_LIMIT=0x3400,

         COMP_1_TRAIL_MASK=0x7ffe,

         COMP_1_TRAIL_SHIFT=9,  // 10-1 for the "triple" bit

         COMP_2_TRAIL_SHIFT=6,

         COMP_2_TRAIL_MASK=0xffc0

     };

     // higher-level functionality ------------------------------------------ ***

     const UChar *decompose(const UChar *src, const UChar *limit,

                            ReorderingBuffer *buffer, UErrorCode &errorCode) const;

     void decomposeAndAppend(const UChar *src, const UChar *limit,

                             UBool doDecompose,

                             UnicodeString &safeMiddle,

                             ReorderingBuffer &buffer,

                             UErrorCode &errorCode) const;

     UBool compose(const UChar *src, const UChar *limit,

                   UBool onlyContiguous,

                   UBool doCompose,

                   ReorderingBuffer &buffer,

                   UErrorCode &errorCode) const;

     const UChar *composeQuickCheck(const UChar *src, const UChar *limit,

                                    UBool onlyContiguous,

                                    UNormalizationCheckResult *pQCResult) const;

     void composeAndAppend(const UChar *src, const UChar *limit,

                           UBool doCompose,

                           UBool onlyContiguous,

                           UnicodeString &safeMiddle,

                           ReorderingBuffer &buffer,

                           UErrorCode &errorCode) const;

     const UChar *makeFCD(const UChar *src, const UChar *limit,

                          ReorderingBuffer *buffer, UErrorCode &errorCode) const;

     void makeFCDAndAppend(const UChar *src, const UChar *limit,

                           UBool doMakeFCD,

                           UnicodeString &safeMiddle,

                           ReorderingBuffer &buffer,

                           UErrorCode &errorCode) const;

     UBool hasDecompBoundary(UChar32 c, UBool before) const;

     UBool isDecompInert(UChar32 c) const { return isDecompYesAndZeroCC(getNorm16(c)); }

     UBool hasCompBoundaryBefore(UChar32 c) const {

         return c<minCompNoMaybeCP || hasCompBoundaryBefore(c, getNorm16(c));

     }

     UBool hasCompBoundaryAfter(UChar32 c, UBool onlyContiguous, UBool testInert) const;

     UBool hasFCDBoundaryBefore(UChar32 c) const { return c<MIN_CCC_LCCC_CP || getFCD16(c)<=0xff; }

     UBool hasFCDBoundaryAfter(UChar32 c) const {

         uint16_t fcd16=getFCD16(c);

         return fcd16<=1 || (fcd16&0xff)==0;

     }

     UBool isFCDInert(UChar32 c) const { return getFCD16(c)<=1; }

 private:

     static UBool U_CALLCONV

     isAcceptable(void *context, const char *type, const char *name, const UDataInfo *pInfo);

     UBool isMaybe(uint16_t norm16) const { return minMaybeYes<=norm16 && norm16<=JAMO_VT; }

     UBool isMaybeOrNonZeroCC(uint16_t norm16) const { return norm16>=minMaybeYes; }

     static UBool isInert(uint16_t norm16) { return norm16==0; }

     static UBool isJamoL(uint16_t norm16) { return norm16==1; }

     static UBool isJamoVT(uint16_t norm16) { return norm16==JAMO_VT; }

     UBool isHangul(uint16_t norm16) const { return norm16==minYesNo; }

     UBool isCompYesAndZeroCC(uint16_t norm16) const { return norm16<minNoNo; }

     // UBool isCompYes(uint16_t norm16) const {

     //     return norm16>=MIN_YES_YES_WITH_CC || norm16<minNoNo;

     // }

     // UBool isCompYesOrMaybe(uint16_t norm16) const {

     //     return norm16<minNoNo || minMaybeYes<=norm16;

     // }

     // UBool hasZeroCCFromDecompYes(uint16_t norm16) const {

     //     return norm16<=MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;

     // }

     UBool isDecompYesAndZeroCC(uint16_t norm16) const {

         return norm16<minYesNo ||

                norm16==JAMO_VT ||

                (minMaybeYes<=norm16 && norm16<=MIN_NORMAL_MAYBE_YES);

     }

     /**

      * A little faster and simpler than isDecompYesAndZeroCC() but does not include

      * the MaybeYes which combine-forward and have ccc=0.

      * (Standard Unicode 5.2 normalization does not have such characters.)

      */

     UBool isMostDecompYesAndZeroCC(uint16_t norm16) const {

         return norm16<minYesNo || norm16==MIN_NORMAL_MAYBE_YES || norm16==JAMO_VT;

     }

     UBool isDecompNoAlgorithmic(uint16_t norm16) const { return norm16>=limitNoNo; }

     // For use with isCompYes().

     // Perhaps the compiler can combine the two tests for MIN_YES_YES_WITH_CC.

     // static uint8_t getCCFromYes(uint16_t norm16) {

     //     return norm16>=MIN_YES_YES_WITH_CC ? (uint8_t)norm16 : 0;

     // }

     uint8_t getCCFromNoNo(uint16_t norm16) const {

         const uint16_t *mapping=getMapping(norm16);

         if(*mapping&MAPPING_HAS_CCC_LCCC_WORD) {

             return (uint8_t)*(mapping-1);

         } else {

             return 0;

         }

     }

     // requires that the [cpStart..cpLimit[ character passes isCompYesAndZeroCC()

     uint8_t getTrailCCFromCompYesAndZeroCC(const UChar *cpStart, const UChar *cpLimit) const;

     // Requires algorithmic-NoNo.

     UChar32 mapAlgorithmic(UChar32 c, uint16_t norm16) const {

         return c+norm16-(minMaybeYes-MAX_DELTA-1);

     }

     // Requires minYesNo<norm16<limitNoNo.

     const uint16_t *getMapping(uint16_t norm16) const { return extraData+norm16; }

     const uint16_t *getCompositionsListForDecompYes(uint16_t norm16) const {

         if(norm16==0 || MIN_NORMAL_MAYBE_YES<=norm16) {

             return NULL;

         } else if(norm16<minMaybeYes) {

             return extraData+norm16;  // for yesYes; if Jamo L: harmless empty list

         } else {

             return maybeYesCompositions+norm16-minMaybeYes;

         }

     }

     const uint16_t *getCompositionsListForComposite(uint16_t norm16) const {

         const uint16_t *list=extraData+norm16;  // composite has both mapping & compositions list

         return list+  // mapping pointer

             1+  // +1 to skip the first unit with the mapping lenth

             (*list&MAPPING_LENGTH_MASK);  // + mapping length

     }

     /**

      * @param c code point must have compositions

      * @return compositions list pointer

      */

     const uint16_t *getCompositionsList(uint16_t norm16) const {

         return isDecompYes(norm16) ?

                 getCompositionsListForDecompYes(norm16) :

                 getCompositionsListForComposite(norm16);

     }

     const UChar *copyLowPrefixFromNulTerminated(const UChar *src,

                                                 UChar32 minNeedDataCP,

                                                 ReorderingBuffer *buffer,

                                                 UErrorCode &errorCode) const;

     UBool decomposeShort(const UChar *src, const UChar *limit,

                          ReorderingBuffer &buffer, UErrorCode &errorCode) const;

     UBool decompose(UChar32 c, uint16_t norm16,

                     ReorderingBuffer &buffer, UErrorCode &errorCode) const;

     static int32_t combine(const uint16_t *list, UChar32 trail);

     void addComposites(const uint16_t *list, UnicodeSet &set) const;

     void recompose(ReorderingBuffer &buffer, int32_t recomposeStartIndex,

                    UBool onlyContiguous) const;

     UBool hasCompBoundaryBefore(UChar32 c, uint16_t norm16) const;

     const UChar *findPreviousCompBoundary(const UChar *start, const UChar *p) const;

     const UChar *findNextCompBoundary(const UChar *p, const UChar *limit) const;

     const UChar *findPreviousFCDBoundary(const UChar *start, const UChar *p) const;

     const UChar *findNextFCDBoundary(const UChar *p, const UChar *limit) const;

     int32_t getCanonValue(UChar32 c) const;

     const UnicodeSet &getCanonStartSet(int32_t n) const;

     UDataMemory *memory;

     UVersionInfo dataVersion;

     // Code point thresholds for quick check codes.

     UChar32 minDecompNoCP;

     UChar32 minCompNoMaybeCP;

     // Norm16 value thresholds for quick check combinations and types of extra data.

     uint16_t minYesNo;

     uint16_t minYesNoMappingsOnly;

     uint16_t minNoNo;

     uint16_t limitNoNo;

     uint16_t minMaybeYes;

     UTrie2 *normTrie;

     const uint16_t *maybeYesCompositions;

     const uint16_t *extraData;  // mappings and/or compositions for yesYes, yesNo & noNo characters

     const uint8_t *smallFCD;  // [0x100] one bit per 32 BMP code points, set if any FCD!=0

     uint8_t tccc180[0x180];  // tccc values for U+0000..U+017F

   public:           // CanonIterData is public to allow access from C callback functions.

     UInitOnce       fCanonIterDataInitOnce;

     CanonIterData  *fCanonIterData;

 };

 // bits in canonIterData

 #define CANON_NOT_SEGMENT_STARTER 0x80000000

 #define CANON_HAS_COMPOSITIONS 0x40000000

 #define CANON_HAS_SET 0x200000

 #define CANON_VALUE_MASK 0x1fffff

 /**

  * ICU-internal shortcut for quick access to standard Unicode normalization.

  */

 class U_COMMON_API Normalizer2Factory {

 public:

     static const Normalizer2 *getNFCInstance(UErrorCode &errorCode);

     static const Normalizer2 *getNFDInstance(UErrorCode &errorCode);

     static const Normalizer2 *getFCDInstance(UErrorCode &errorCode);

     static const Normalizer2 *getFCCInstance(UErrorCode &errorCode);

     static const Normalizer2 *getNFKCInstance(UErrorCode &errorCode);

     static const Normalizer2 *getNFKDInstance(UErrorCode &errorCode);

     static const Normalizer2 *getNFKC_CFInstance(UErrorCode &errorCode);

     static const Normalizer2 *getNoopInstance(UErrorCode &errorCode);

     static const Normalizer2 *getInstance(UNormalizationMode mode, UErrorCode &errorCode);

     static const Normalizer2Impl *getNFCImpl(UErrorCode &errorCode);

     static const Normalizer2Impl *getNFKCImpl(UErrorCode &errorCode);

     static const Normalizer2Impl *getNFKC_CFImpl(UErrorCode &errorCode);

     // Get the Impl instance of the Normalizer2.

     // Must be used only when it is known that norm2 is a Normalizer2WithImpl instance.

     static const Normalizer2Impl *getImpl(const Normalizer2 *norm2);

 private:

     Normalizer2Factory();  // No instantiation.

 };

 U_NAMESPACE_END

 U_CAPI int32_t U_EXPORT2

 unorm2_swap(const UDataSwapper *ds,

             const void *inData, int32_t length, void *outData,

             UErrorCode *pErrorCode);

 /**

  * Get the NF*_QC property for a code point, for u_getIntPropertyValue().

  * @internal

  */

 U_CFUNC UNormalizationCheckResult

 unorm_getQuickCheck(UChar32 c, UNormalizationMode mode);

 /**

  * Gets the 16-bit FCD value (lead & trail CCs) for a code point, for u_getIntPropertyValue().

  * @internal

  */

 U_CFUNC uint16_t

 unorm_getFCD16(UChar32 c);

 /**

  * Format of Normalizer2 .nrm data files.

  * Format version 2.0.

  *

  * Normalizer2 .nrm data files provide data for the Unicode Normalization algorithms.

  * ICU ships with data files for standard Unicode Normalization Forms

  * NFC and NFD (nfc.nrm), NFKC and NFKD (nfkc.nrm) and NFKC_Casefold (nfkc_cf.nrm).

  * Custom (application-specific) data can be built into additional .nrm files

  * with the gennorm2 build tool.

  *

  * Normalizer2.getInstance() causes a .nrm file to be loaded, unless it has been

  * cached already. Internally, Normalizer2Impl.load() reads the .nrm file.

  *

  * A .nrm file begins with a standard ICU data file header

  * (DataHeader, see ucmndata.h and unicode/udata.h).

  * The UDataInfo.dataVersion field usually contains the Unicode version

  * for which the data was generated.

  *

  * After the header, the file contains the following parts.

  * Constants are defined as enum values of the Normalizer2Impl class.

  *

  * Many details of the data structures are described in the design doc

  * which is at http://site.icu-project.org/design/normalization/custom

  *

  * int32_t indexes[indexesLength]; -- indexesLength=indexes[IX_NORM_TRIE_OFFSET]/4;

  *

  *      The first eight indexes are byte offsets in ascending order.

  *      Each byte offset marks the start of the next part in the data file,

  *      and the end of the previous one.

  *      When two consecutive byte offsets are the same, then the corresponding part is empty.

  *      Byte offsets are offsets from after the header,

  *      that is, from the beginning of the indexes[].

  *      Each part starts at an offset with proper alignment for its data.

  *      If necessary, the previous part may include padding bytes to achieve this alignment.

  *

  *      minDecompNoCP=indexes[IX_MIN_DECOMP_NO_CP] is the lowest code point

  *      with a decomposition mapping, that is, with NF*D_QC=No.

  *      minCompNoMaybeCP=indexes[IX_MIN_COMP_NO_MAYBE_CP] is the lowest code point

  *      with NF*C_QC=No (has a one-way mapping) or Maybe (combines backward).

  *

  *      The next five indexes are thresholds of 16-bit trie values for ranges of

  *      values indicating multiple normalization properties.

  *          minYesNo=indexes[IX_MIN_YES_NO];

  *          minNoNo=indexes[IX_MIN_NO_NO];

  *          limitNoNo=indexes[IX_LIMIT_NO_NO];

  *          minMaybeYes=indexes[IX_MIN_MAYBE_YES];

  *          minYesNoMappingsOnly=indexes[IX_MIN_YES_NO_MAPPINGS_ONLY];

  *      See the normTrie description below and the design doc for details.

  *

  * UTrie2 normTrie; -- see utrie2_impl.h and utrie2.h

  *

  *      The trie holds the main normalization data. Each code point is mapped to a 16-bit value.

  *      Rather than using independent bits in the value (which would require more than 16 bits),

  *      information is extracted primarily via range checks.

  *      For example, a 16-bit value norm16 in the range minYesNo<=norm16<minNoNo

  *      means that the character has NF*C_QC=Yes and NF*D_QC=No properties,

  *      which means it has a two-way (round-trip) decomposition mapping.

  *      Values in the range 2<=norm16<limitNoNo are also directly indexes into the extraData

  *      pointing to mappings, compositions lists, or both.

  *      Value norm16==0 means that the character is normalization-inert, that is,

  *      it does not have a mapping, does not participate in composition, has a zero

  *      canonical combining class, and forms a boundary where text before it and after it

  *      can be normalized independently.

  *      For details about how multiple properties are encoded in 16-bit values

  *      see the design doc.

  *      Note that the encoding cannot express all combinations of the properties involved;

  *      it only supports those combinations that are allowed by

  *      the Unicode Normalization algorithms. Details are in the design doc as well.

  *      The gennorm2 tool only builds .nrm files for data that conforms to the limitations.

  *

  *      The trie has a value for each lead surrogate code unit representing the "worst case"

  *      properties of the 1024 supplementary characters whose UTF-16 form starts with

  *      the lead surrogate. If all of the 1024 supplementary characters are normalization-inert,

  *      then their lead surrogate code unit has the trie value 0.

  *      When the lead surrogate unit's value exceeds the quick check minimum during processing,

  *      the properties for the full supplementary code point need to be looked up.

  *

  * uint16_t maybeYesCompositions[MIN_NORMAL_MAYBE_YES-minMaybeYes];

  * uint16_t extraData[];

  *

  *      There is only one byte offset for the end of these two arrays.

  *      The split between them is given by the constant and variable mentioned above.

  *

  *      The maybeYesCompositions array contains compositions lists for characters that

  *      combine both forward (as starters in composition pairs)

  *      and backward (as trailing characters in composition pairs).

  *      Such characters do not occur in Unicode 5.2 but are allowed by

  *      the Unicode Normalization algorithms.

  *      If there are no such characters, then minMaybeYes==MIN_NORMAL_MAYBE_YES

  *      and the maybeYesCompositions array is empty.

  *      If there are such characters, then minMaybeYes is subtracted from their norm16 values

  *      to get the index into this array.

  *

  *      The extraData array contains compositions lists for "YesYes" characters,

  *      followed by mappings and optional compositions lists for "YesNo" characters,

  *      followed by only mappings for "NoNo" characters.

  *      (Referring to pairs of NFC/NFD quick check values.)

  *      The norm16 values of those characters are directly indexes into the extraData array.

  *

  *      The data structures for compositions lists and mappings are described in the design doc.

  *

  * uint8_t smallFCD[0x100]; -- new in format version 2

  *

  *      This is a bit set to help speed up FCD value lookups in the absence of a full

  *      UTrie2 or other large data structure with the full FCD value mapping.

  *

  *      Each smallFCD bit is set if any of the corresponding 32 BMP code points

  *      has a non-zero FCD value (lccc!=0 or tccc!=0).

  *      Bit 0 of smallFCD[0] is for U+0000..U+001F. Bit 7 of smallFCD[0xff] is for U+FFE0..U+FFFF.

  *      A bit for 32 lead surrogates is set if any of the 32k corresponding

  *      _supplementary_ code points has a non-zero FCD value.

  *

  *      This bit set is most useful for the large blocks of CJK characters with FCD=0.

  *

  * Changes from format version 1 to format version 2 ---------------------------

  *

  * - Addition of data for raw (not recursively decomposed) mappings.

  *   + The MAPPING_NO_COMP_BOUNDARY_AFTER bit in the extraData is now also set when

  *     the mapping is to an empty string or when the character combines-forward.

  *     This subsumes the one actual use of the MAPPING_PLUS_COMPOSITION_LIST bit which

  *     is then repurposed for the MAPPING_HAS_RAW_MAPPING bit.

  *   + For details see the design doc.

  * - Addition of indexes[IX_MIN_YES_NO_MAPPINGS_ONLY] and separation of the yesNo extraData into

  *   distinct ranges (combines-forward vs. not)

  *   so that a range check can be used to find out if there is a compositions list.

  *   This is fully equivalent with formatVersion 1's MAPPING_PLUS_COMPOSITION_LIST flag.

  *   It is needed for the new (in ICU 49) composePair(), not for other normalization.

  * - Addition of the smallFCD[] bit set.

  */

 #endif  /* !UCONFIG_NO_NORMALIZATION */

 #endif  /* __NORMALIZER2IMPL_H__ */