Update ICU to 54.1 step 1

source/common/uprops.cpp

 /*
 *******************************************************************************
 *
-*   Copyright (C) 2002-2013, International Business Machines
+*   Copyright (C) 2002-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  uprops.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2002feb24
 *   created by: Markus W. Scherer
 *
 *   Implementations for mostly non-core Unicode character properties
 *   stored in uprops.icu.
 *
 *   With the APIs implemented here, almost all properties files and
 *   their associated implementation files are used from this file,
 *   including those for normalization and case mappings.
 */
 
 #include "unicode/utypes.h"
 #include "unicode/uchar.h"
 #include "unicode/unorm2.h"
 #include "unicode/uscript.h"
 #include "unicode/ustring.h"
 #include "cstring.h"
 #include "normalizer2impl.h"
-#include "ucln_cmn.h"
 #include "umutex.h"
 #include "ubidi_props.h"
 #include "uprops.h"
 #include "ucase.h"
 #include "ustr_imp.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 U_NAMESPACE_USE
 
 #define GET_BIDI_PROPS() ubidi_getSingleton()
 
 /* general properties API functions ----------------------------------------- */
 
 struct BinaryProperty;
 
 typedef UBool BinaryPropertyContains(const BinaryProperty &prop, UChar32 c, UProperty which);
 
@@ skipping 52 matching lines @@
 #endif
 
 #if UCONFIG_NO_NORMALIZATION
 static UBool changesWhenCasefolded(const BinaryProperty &, UChar32, UProperty) {
     return FALSE;
 }
 #else
 static UBool changesWhenCasefolded(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
     UnicodeString nfd;
     UErrorCode errorCode=U_ZERO_ERROR;
-    const Normalizer2 *nfcNorm2=Normalizer2Factory::getNFCInstance(errorCode);
+    const Normalizer2 *nfcNorm2=Normalizer2::getNFCInstance(errorCode);
     if(U_FAILURE(errorCode)) {
         return FALSE;
     }
     if(nfcNorm2->getDecomposition(c, nfd)) {
         /* c has a decomposition */
         if(nfd.length()==1) {
             c=nfd[0];  /* single BMP code point */
         } else if(nfd.length()<=U16_MAX_LENGTH &&
                   nfd.length()==U16_LENGTH(c=nfd.char32At(0))
         ) {
             /* single supplementary code point */
         } else {
             c=U_SENTINEL;
         }
     } else if(c<0) {
         return FALSE;  /* protect against bad input */
     }
     if(c>=0) {
         /* single code point */
         const UCaseProps *csp=ucase_getSingleton();
         const UChar *resultString;
         return (UBool)(ucase_toFullFolding(csp, c, &resultString, U_FOLD_CASE_DEFAULT)>=0);
     } else {
         /* guess some large but stack-friendly capacity */
         UChar dest[2*UCASE_MAX_STRING_LENGTH];
         int32_t destLength;
-        destLength=u_strFoldCase(dest, LENGTHOF(dest),
+        destLength=u_strFoldCase(dest, UPRV_LENGTHOF(dest),
                                   nfd.getBuffer(), nfd.length(),
                                   U_FOLD_CASE_DEFAULT, &errorCode);
         return (UBool)(U_SUCCESS(errorCode) &&
                        0!=u_strCompare(nfd.getBuffer(), nfd.length(),
                                        dest, destLength, FALSE));
     }
 }
 #endif
 
 #if UCONFIG_NO_NORMALIZATION
@@ skipping 225 matching lines @@
     U_HST_VOWEL_JAMO        /* U_GCB_V */
     /*
      * Omit GCB values beyond what we need for hst.
      * The code below checks for the array length.
      */
 };
 
 static int32_t getHangulSyllableType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) {
     /* see comments on gcbToHst[] above */
     int32_t gcb=(int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT;
-    if(gcb<LENGTHOF(gcbToHst)) {
+    if(gcb<UPRV_LENGTHOF(gcbToHst)) {
         return gcbToHst[gcb];
     } else {
         return U_HST_NOT_APPLICABLE;
     }
 }
 
 #if UCONFIG_NO_NORMALIZATION
 static int32_t getNormQuickCheck(const IntProperty &, UChar32, UProperty) {
     return 0;
 }
@@ skipping 169 matching lines @@
     if(destCapacity<0 || (dest==NULL && destCapacity>0)) {
         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
     // Compute the FC_NFKC_Closure on the fly:
     // We have the API for complete coverage of Unicode properties, although
     // this value by itself is not useful via API.
     // (What could be useful is a custom normalization table that combines
     // case folding and NFKC.)
     // For the derivation, see Unicode's DerivedNormalizationProps.txt.
-    const Normalizer2 *nfkc=Normalizer2Factory::getNFKCInstance(*pErrorCode);
+    const Normalizer2 *nfkc=Normalizer2::getNFKCInstance(*pErrorCode);
     const UCaseProps *csp=ucase_getSingleton();
     if(U_FAILURE(*pErrorCode)) {
         return 0;
     }
     // first: b = NFKC(Fold(a))
     UnicodeString folded1String;
     const UChar *folded1;
     int32_t folded1Length=ucase_toFullFolding(csp, c, &folded1, U_FOLD_CASE_DEFAULT);
     if(folded1Length<0) {
         const Normalizer2Impl *nfkcImpl=Normalizer2Factory::getImpl(nfkc);
@@ skipping 14 matching lines @@
     UnicodeString kc2=nfkc->normalize(folded2String.foldCase(), *pErrorCode);
     // if (c != b) add the mapping from a to c
     if(U_FAILURE(*pErrorCode) || kc1==kc2) {
         return u_terminateUChars(dest, destCapacity, 0, pErrorCode);
     } else {
         return kc2.extract(dest, destCapacity, *pErrorCode);
     }
 }
 
 #endif