Update ICU to 54.1 step 1

source/common/normalizer2impl.h

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2009-2013, International Business Machines
+*   Copyright (C) 2009-2014, 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 {
+class U_COMMON_API Hangul {
 public:
     /* Korean Hangul and Jamo constants */
     enum {
         JAMO_L_BASE=0x1100,     /* "lead" jamo */
+        JAMO_L_END=0x1112,
         JAMO_V_BASE=0x1161,     /* "vowel" jamo */
+        JAMO_V_END=0x1175,
         JAMO_T_BASE=0x11a7,     /* "trail" jamo */
+        JAMO_T_END=0x11c2,
 
         HANGUL_BASE=0xac00,
+        HANGUL_END=0xd7a3,
 
         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
     };
@@ skipping 47 matching lines @@
             buffer[0]=orig-c2;  // LV syllable
             buffer[1]=(UChar)(JAMO_T_BASE+c2);
         }
     }
 private:
     Hangul();  // no instantiation
 };
 
 class Normalizer2Impl;
 
-class ReorderingBuffer : public UMemory {
+class U_COMMON_API 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));
         }
     }
@@ skipping 82 matching lines @@
     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 {
+class U_COMMON_API Normalizer2Impl : public UObject {
 public:
-    Normalizer2Impl() : memory(NULL), normTrie(NULL), fCanonIterData(NULL) {
+    Normalizer2Impl() : normTrie(NULL), fCanonIterData(NULL) {
         fCanonIterDataInitOnce.reset();
     }
-    ~Normalizer2Impl();
+    virtual ~Normalizer2Impl();
 
-    void load(const char *packageName, const char *name, UErrorCode &errorCode);
+    void init(const int32_t *inIndexes, const UTrie2 *inTrie,
+              const uint16_t *inExtraData, const uint8_t *inSmallFCD);
 
+    void addLcccChars(UnicodeSet &set) const;
     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 isAlgorithmicNoNo(uint16_t norm16) const { return limitNoNo<=norm16 && norm16<minMaybeYes; }
     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;
         }
@@ skipping 154 matching lines @@
         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 ------------------------------------------ ***
 
+    // NFD without an NFD Normalizer2 instance.
+    UnicodeString &decompose(const UnicodeString &src, UnicodeString &dest,
+                             UErrorCode &errorCode) const;
+    /**
+     * Decomposes [src, limit[ and writes the result to dest.
+     * limit can be NULL if src is NUL-terminated.
+     * destLengthEstimate is the initial dest buffer capacity and can be -1.
+     */
+    void decompose(const UChar *src, const UChar *limit,
+                   UnicodeString &dest, int32_t destLengthEstimate,
+                   UErrorCode &errorCode) const;
+
     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,
@@ skipping 24 matching lines @@
     }
     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;
     // }
@@ skipping 83 matching lines @@
     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;
+    // 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 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.
+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.
@@ skipping 148 matching lines @@
  * - 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__ */