diff options
Diffstat (limited to 'Build/source/libs/icu/icu-4.4/common/uprops.cpp')
-rw-r--r-- | Build/source/libs/icu/icu-4.4/common/uprops.cpp | 753 |
1 files changed, 0 insertions, 753 deletions
diff --git a/Build/source/libs/icu/icu-4.4/common/uprops.cpp b/Build/source/libs/icu/icu-4.4/common/uprops.cpp deleted file mode 100644 index 37409cec9cc..00000000000 --- a/Build/source/libs/icu/icu-4.4/common/uprops.cpp +++ /dev/null @@ -1,753 +0,0 @@ -/* -******************************************************************************* -* -* Copyright (C) 2002-2010, 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/uscript.h" -#include "unicode/ustring.h" -#include "cstring.h" -#include "normalizer2impl.h" -#include "ucln_cmn.h" -#include "umutex.h" -#include "unormimp.h" -#include "ubidi_props.h" -#include "uprops.h" -#include "ucase.h" - -#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) - -U_NAMESPACE_USE - -/* cleanup ------------------------------------------------------------------ */ - -static const UBiDiProps *gBdp=NULL; - -static UBool U_CALLCONV uprops_cleanup(void) { - gBdp=NULL; - return TRUE; -} - -/* bidi/shaping properties API ---------------------------------------------- */ - -/* get the UBiDiProps singleton, or else its dummy, once and for all */ -static const UBiDiProps * -getBiDiProps() { - /* - * This lazy intialization with double-checked locking (without mutex protection for - * the initial check) is transiently unsafe under certain circumstances. - * Check the readme and use u_init() if necessary. - */ - - /* the initial check is performed by the GET_BIDI_PROPS() macro */ - const UBiDiProps *bdp; - UErrorCode errorCode=U_ZERO_ERROR; - - bdp=ubidi_getSingleton(&errorCode); -#if !UBIDI_HARDCODE_DATA - if(U_FAILURE(errorCode)) { - errorCode=U_ZERO_ERROR; - bdp=ubidi_getDummy(&errorCode); - if(U_FAILURE(errorCode)) { - return NULL; - } - } -#endif - - umtx_lock(NULL); - if(gBdp==NULL) { - gBdp=bdp; - ucln_common_registerCleanup(UCLN_COMMON_UPROPS, uprops_cleanup); - } - umtx_unlock(NULL); - - return gBdp; -} - -/* see comment for GET_CASE_PROPS() */ -#define GET_BIDI_PROPS() (gBdp!=NULL ? gBdp : getBiDiProps()) - -/* general properties API functions ----------------------------------------- */ - -static const struct { - int32_t column; - uint32_t mask; -} binProps[UCHAR_BINARY_LIMIT]={ - /* - * column and mask values for binary properties from u_getUnicodeProperties(). - * Must be in order of corresponding UProperty, - * and there must be exactly one entry per binary UProperty. - * - * Properties with mask 0 are handled in code. - * For them, column is the UPropertySource value. - */ - { 1, U_MASK(UPROPS_ALPHABETIC) }, - { 1, U_MASK(UPROPS_ASCII_HEX_DIGIT) }, - { UPROPS_SRC_BIDI, 0 }, /* UCHAR_BIDI_CONTROL */ - { UPROPS_SRC_BIDI, 0 }, /* UCHAR_BIDI_MIRRORED */ - { 1, U_MASK(UPROPS_DASH) }, - { 1, U_MASK(UPROPS_DEFAULT_IGNORABLE_CODE_POINT) }, - { 1, U_MASK(UPROPS_DEPRECATED) }, - { 1, U_MASK(UPROPS_DIACRITIC) }, - { 1, U_MASK(UPROPS_EXTENDER) }, - { UPROPS_SRC_NFC, 0 }, /* UCHAR_FULL_COMPOSITION_EXCLUSION */ - { 1, U_MASK(UPROPS_GRAPHEME_BASE) }, - { 1, U_MASK(UPROPS_GRAPHEME_EXTEND) }, - { 1, U_MASK(UPROPS_GRAPHEME_LINK) }, - { 1, U_MASK(UPROPS_HEX_DIGIT) }, - { 1, U_MASK(UPROPS_HYPHEN) }, - { 1, U_MASK(UPROPS_ID_CONTINUE) }, - { 1, U_MASK(UPROPS_ID_START) }, - { 1, U_MASK(UPROPS_IDEOGRAPHIC) }, - { 1, U_MASK(UPROPS_IDS_BINARY_OPERATOR) }, - { 1, U_MASK(UPROPS_IDS_TRINARY_OPERATOR) }, - { UPROPS_SRC_BIDI, 0 }, /* UCHAR_JOIN_CONTROL */ - { 1, U_MASK(UPROPS_LOGICAL_ORDER_EXCEPTION) }, - { UPROPS_SRC_CASE, 0 }, /* UCHAR_LOWERCASE */ - { 1, U_MASK(UPROPS_MATH) }, - { 1, U_MASK(UPROPS_NONCHARACTER_CODE_POINT) }, - { 1, U_MASK(UPROPS_QUOTATION_MARK) }, - { 1, U_MASK(UPROPS_RADICAL) }, - { UPROPS_SRC_CASE, 0 }, /* UCHAR_SOFT_DOTTED */ - { 1, U_MASK(UPROPS_TERMINAL_PUNCTUATION) }, - { 1, U_MASK(UPROPS_UNIFIED_IDEOGRAPH) }, - { UPROPS_SRC_CASE, 0 }, /* UCHAR_UPPERCASE */ - { 1, U_MASK(UPROPS_WHITE_SPACE) }, - { 1, U_MASK(UPROPS_XID_CONTINUE) }, - { 1, U_MASK(UPROPS_XID_START) }, - { UPROPS_SRC_CASE, 0 }, /* UCHAR_CASE_SENSITIVE */ - { 1, U_MASK(UPROPS_S_TERM) }, - { 1, U_MASK(UPROPS_VARIATION_SELECTOR) }, - { UPROPS_SRC_NFC, 0 }, /* UCHAR_NFD_INERT */ - { UPROPS_SRC_NFKC, 0 }, /* UCHAR_NFKD_INERT */ - { UPROPS_SRC_NFC, 0 }, /* UCHAR_NFC_INERT */ - { UPROPS_SRC_NFKC, 0 }, /* UCHAR_NFKC_INERT */ - { UPROPS_SRC_NORM, 0 }, /* UCHAR_SEGMENT_STARTER */ - { 1, U_MASK(UPROPS_PATTERN_SYNTAX) }, - { 1, U_MASK(UPROPS_PATTERN_WHITE_SPACE) }, - { UPROPS_SRC_CHAR_AND_PROPSVEC, 0 }, /* UCHAR_POSIX_ALNUM */ - { UPROPS_SRC_CHAR, 0 }, /* UCHAR_POSIX_BLANK */ - { UPROPS_SRC_CHAR, 0 }, /* UCHAR_POSIX_GRAPH */ - { UPROPS_SRC_CHAR, 0 }, /* UCHAR_POSIX_PRINT */ - { UPROPS_SRC_CHAR, 0 }, /* UCHAR_POSIX_XDIGIT */ - { UPROPS_SRC_CASE, 0 }, /* UCHAR_CASED */ - { UPROPS_SRC_CASE, 0 }, /* UCHAR_CASE_IGNORABLE */ - { UPROPS_SRC_CASE, 0 }, /* UCHAR_CHANGES_WHEN_LOWERCASED */ - { UPROPS_SRC_CASE, 0 }, /* UCHAR_CHANGES_WHEN_UPPERCASED */ - { UPROPS_SRC_CASE, 0 }, /* UCHAR_CHANGES_WHEN_TITLECASED */ - { UPROPS_SRC_CASE_AND_NORM, 0 }, /* UCHAR_CHANGES_WHEN_CASEFOLDED */ - { UPROPS_SRC_CASE, 0 }, /* UCHAR_CHANGES_WHEN_CASEMAPPED */ - { UPROPS_SRC_NFKC_CF, 0 } /* UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED */ -}; - -U_CAPI UBool U_EXPORT2 -u_hasBinaryProperty(UChar32 c, UProperty which) { - /* c is range-checked in the functions that are called from here */ - if(which<UCHAR_BINARY_START || UCHAR_BINARY_LIMIT<=which) { - /* not a known binary property */ - } else { - uint32_t mask=binProps[which].mask; - int32_t column=binProps[which].column; - if(mask!=0) { - /* systematic, directly stored properties */ - return (u_getUnicodeProperties(c, column)&mask)!=0; - } else { - if(column==UPROPS_SRC_CASE) { - return ucase_hasBinaryProperty(c, which); - } else if(column==UPROPS_SRC_NORM) { -#if !UCONFIG_NO_NORMALIZATION - /* normalization properties from unorm.icu */ - switch(which) { - case UCHAR_SEGMENT_STARTER: - return unorm_isCanonSafeStart(c); - default: - break; - } -#endif - } else if(column==UPROPS_SRC_NFC) { -#if !UCONFIG_NO_NORMALIZATION - UErrorCode errorCode=U_ZERO_ERROR; - switch(which) { - case UCHAR_FULL_COMPOSITION_EXCLUSION: { - // By definition, Full_Composition_Exclusion is the same as NFC_QC=No. - const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); - return U_SUCCESS(errorCode) && impl->isCompNo(impl->getNorm16(c)); - break; - } - default: { - // UCHAR_NF[CD]_INERT properties - const Normalizer2 *norm2=Normalizer2Factory::getInstance( - (UNormalizationMode)(which-UCHAR_NFD_INERT+UNORM_NFD), errorCode); - return U_SUCCESS(errorCode) && norm2->isInert(c); - } - } -#endif - } else if(column==UPROPS_SRC_NFKC) { -#if !UCONFIG_NO_NORMALIZATION - // UCHAR_NFK[CD]_INERT properties - UErrorCode errorCode=U_ZERO_ERROR; - const Normalizer2 *norm2=Normalizer2Factory::getInstance( - (UNormalizationMode)(which-UCHAR_NFD_INERT+UNORM_NFD), errorCode); - return U_SUCCESS(errorCode) && norm2->isInert(c); -#endif - } else if(column==UPROPS_SRC_NFKC_CF) { - // currently only for UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED -#if !UCONFIG_NO_NORMALIZATION - UErrorCode errorCode=U_ZERO_ERROR; - const Normalizer2Impl *kcf=Normalizer2Factory::getNFKC_CFImpl(errorCode); - if(U_SUCCESS(errorCode)) { - UnicodeString src(c); - UnicodeString dest; - { - // The ReorderingBuffer must be in a block because its destructor - // needs to release dest's buffer before we look at its contents. - ReorderingBuffer buffer(*kcf, dest); - // Small destCapacity for NFKC_CF(c). - if(buffer.init(5, errorCode)) { - const UChar *srcArray=src.getBuffer(); - kcf->compose(srcArray, srcArray+src.length(), FALSE, - TRUE, buffer, errorCode); - } - } - return U_SUCCESS(errorCode) && dest!=src; - } -#endif - } else if(column==UPROPS_SRC_BIDI) { - /* bidi/shaping properties */ - const UBiDiProps *bdp=GET_BIDI_PROPS(); - if(bdp!=NULL) { - switch(which) { - case UCHAR_BIDI_MIRRORED: - return ubidi_isMirrored(bdp, c); - case UCHAR_BIDI_CONTROL: - return ubidi_isBidiControl(bdp, c); - case UCHAR_JOIN_CONTROL: - return ubidi_isJoinControl(bdp, c); - default: - break; - } - } - /* else return FALSE below */ - } else if(column==UPROPS_SRC_CHAR) { - switch(which) { - case UCHAR_POSIX_BLANK: - return u_isblank(c); - case UCHAR_POSIX_GRAPH: - return u_isgraphPOSIX(c); - case UCHAR_POSIX_PRINT: - return u_isprintPOSIX(c); - case UCHAR_POSIX_XDIGIT: - return u_isxdigit(c); - default: - break; - } - } else if(column==UPROPS_SRC_CHAR_AND_PROPSVEC) { - switch(which) { - case UCHAR_POSIX_ALNUM: - return u_isalnumPOSIX(c); - default: - break; - } - } else if(column==UPROPS_SRC_CASE_AND_NORM) { -#if !UCONFIG_NO_NORMALIZATION - UChar nfdBuffer[4]; - const UChar *nfd; - int32_t nfdLength; - UErrorCode errorCode=U_ZERO_ERROR; - const Normalizer2Impl *nfcImpl=Normalizer2Factory::getNFCImpl(errorCode); - if(U_FAILURE(errorCode)) { - return FALSE; - } - switch(which) { - case UCHAR_CHANGES_WHEN_CASEFOLDED: - nfd=nfcImpl->getDecomposition(c, nfdBuffer, nfdLength); - if(nfd!=NULL) { - /* c has a decomposition */ - if(nfdLength==1) { - c=nfd[0]; /* single BMP code point */ - } else if(nfdLength<=U16_MAX_LENGTH) { - int32_t i=0; - U16_NEXT(nfd, i, nfdLength, c); - if(i==nfdLength) { - /* single supplementary code point */ - } else { - c=U_SENTINEL; - } - } else { - c=U_SENTINEL; - } - } else if(c<0) { - return FALSE; /* protect against bad input */ - } - errorCode=U_ZERO_ERROR; - if(c>=0) { - /* single code point */ - const UCaseProps *csp=ucase_getSingleton(&errorCode); - 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), nfd, nfdLength, U_FOLD_CASE_DEFAULT, &errorCode); - return (UBool)(U_SUCCESS(errorCode) && 0!=u_strCompare(nfd, nfdLength, dest, destLength, FALSE)); - } - default: - break; - } -#endif - } - } - } - return FALSE; -} - -#if !UCONFIG_NO_NORMALIZATION - -U_CAPI uint8_t U_EXPORT2 -u_getCombiningClass(UChar32 c) { - UErrorCode errorCode=U_ZERO_ERROR; - const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); - if(U_SUCCESS(errorCode)) { - return impl->getCC(impl->getNorm16(c)); - } else { - return 0; - } -} - -static uint16_t -getFCD16(UChar32 c) { - UErrorCode errorCode=U_ZERO_ERROR; - const UTrie2 *trie=Normalizer2Factory::getFCDTrie(errorCode); - if(U_SUCCESS(errorCode)) { - return UTRIE2_GET16(trie, c); - } else { - return 0; - } -} - -#endif - -/* - * Map some of the Grapheme Cluster Break values to Hangul Syllable Types. - * Hangul_Syllable_Type is fully redundant with a subset of Grapheme_Cluster_Break. - */ -static const UHangulSyllableType gcbToHst[]={ - U_HST_NOT_APPLICABLE, /* U_GCB_OTHER */ - U_HST_NOT_APPLICABLE, /* U_GCB_CONTROL */ - U_HST_NOT_APPLICABLE, /* U_GCB_CR */ - U_HST_NOT_APPLICABLE, /* U_GCB_EXTEND */ - U_HST_LEADING_JAMO, /* U_GCB_L */ - U_HST_NOT_APPLICABLE, /* U_GCB_LF */ - U_HST_LV_SYLLABLE, /* U_GCB_LV */ - U_HST_LVT_SYLLABLE, /* U_GCB_LVT */ - U_HST_TRAILING_JAMO, /* U_GCB_T */ - U_HST_VOWEL_JAMO /* U_GCB_V */ - /* - * Omit GCB values beyond what we need for hst. - * The code below checks for the array length. - */ -}; - -U_CAPI int32_t U_EXPORT2 -u_getIntPropertyValue(UChar32 c, UProperty which) { - UErrorCode errorCode; - - if(which<UCHAR_BINARY_START) { - return 0; /* undefined */ - } else if(which<UCHAR_BINARY_LIMIT) { - return (int32_t)u_hasBinaryProperty(c, which); - } else if(which<UCHAR_INT_START) { - return 0; /* undefined */ - } else if(which<UCHAR_INT_LIMIT) { - switch(which) { - case UCHAR_BIDI_CLASS: - return (int32_t)u_charDirection(c); - case UCHAR_BLOCK: - return (int32_t)ublock_getCode(c); -#if !UCONFIG_NO_NORMALIZATION - case UCHAR_CANONICAL_COMBINING_CLASS: - return u_getCombiningClass(c); -#endif - case UCHAR_DECOMPOSITION_TYPE: - return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_DT_MASK); - case UCHAR_EAST_ASIAN_WIDTH: - return (int32_t)(u_getUnicodeProperties(c, 0)&UPROPS_EA_MASK)>>UPROPS_EA_SHIFT; - case UCHAR_GENERAL_CATEGORY: - return (int32_t)u_charType(c); - case UCHAR_JOINING_GROUP: - return ubidi_getJoiningGroup(GET_BIDI_PROPS(), c); - case UCHAR_JOINING_TYPE: - return ubidi_getJoiningType(GET_BIDI_PROPS(), c); - case UCHAR_LINE_BREAK: - return (int32_t)(u_getUnicodeProperties(c, UPROPS_LB_VWORD)&UPROPS_LB_MASK)>>UPROPS_LB_SHIFT; - case UCHAR_NUMERIC_TYPE: { - int32_t ntv=(int32_t)GET_NUMERIC_TYPE_VALUE(u_getUnicodeProperties(c, -1)); - return UPROPS_NTV_GET_TYPE(ntv); - } - case UCHAR_SCRIPT: - errorCode=U_ZERO_ERROR; - return (int32_t)uscript_getScript(c, &errorCode); - case UCHAR_HANGUL_SYLLABLE_TYPE: { - /* see comments on gcbToHst[] above */ - int32_t gcb=(int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT; - if(gcb<LENGTHOF(gcbToHst)) { - return gcbToHst[gcb]; - } else { - return U_HST_NOT_APPLICABLE; - } - } -#if !UCONFIG_NO_NORMALIZATION - case UCHAR_NFD_QUICK_CHECK: - case UCHAR_NFKD_QUICK_CHECK: - case UCHAR_NFC_QUICK_CHECK: - case UCHAR_NFKC_QUICK_CHECK: - return (int32_t)unorm_getQuickCheck(c, (UNormalizationMode)(which-UCHAR_NFD_QUICK_CHECK+UNORM_NFD)); - case UCHAR_LEAD_CANONICAL_COMBINING_CLASS: - return getFCD16(c)>>8; - case UCHAR_TRAIL_CANONICAL_COMBINING_CLASS: - return getFCD16(c)&0xff; -#endif - case UCHAR_GRAPHEME_CLUSTER_BREAK: - return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT; - case UCHAR_SENTENCE_BREAK: - return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_SB_MASK)>>UPROPS_SB_SHIFT; - case UCHAR_WORD_BREAK: - return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_WB_MASK)>>UPROPS_WB_SHIFT; - default: - return 0; /* undefined */ - } - } else if(which==UCHAR_GENERAL_CATEGORY_MASK) { - return U_MASK(u_charType(c)); - } else { - return 0; /* undefined */ - } -} - -U_CAPI int32_t U_EXPORT2 -u_getIntPropertyMinValue(UProperty which) { - return 0; /* all binary/enum/int properties have a minimum value of 0 */ -} - -U_CAPI int32_t U_EXPORT2 -u_getIntPropertyMaxValue(UProperty which) { - if(which<UCHAR_BINARY_START) { - return -1; /* undefined */ - } else if(which<UCHAR_BINARY_LIMIT) { - return 1; /* maximum TRUE for all binary properties */ - } else if(which<UCHAR_INT_START) { - return -1; /* undefined */ - } else if(which<UCHAR_INT_LIMIT) { - switch(which) { - case UCHAR_BIDI_CLASS: - case UCHAR_JOINING_GROUP: - case UCHAR_JOINING_TYPE: - return ubidi_getMaxValue(GET_BIDI_PROPS(), which); - case UCHAR_BLOCK: - return (uprv_getMaxValues(0)&UPROPS_BLOCK_MASK)>>UPROPS_BLOCK_SHIFT; - case UCHAR_CANONICAL_COMBINING_CLASS: - case UCHAR_LEAD_CANONICAL_COMBINING_CLASS: - case UCHAR_TRAIL_CANONICAL_COMBINING_CLASS: - return 0xff; /* TODO do we need to be more precise, getting the actual maximum? */ - case UCHAR_DECOMPOSITION_TYPE: - return uprv_getMaxValues(2)&UPROPS_DT_MASK; - case UCHAR_EAST_ASIAN_WIDTH: - return (uprv_getMaxValues(0)&UPROPS_EA_MASK)>>UPROPS_EA_SHIFT; - case UCHAR_GENERAL_CATEGORY: - return (int32_t)U_CHAR_CATEGORY_COUNT-1; - case UCHAR_LINE_BREAK: - return (uprv_getMaxValues(UPROPS_LB_VWORD)&UPROPS_LB_MASK)>>UPROPS_LB_SHIFT; - case UCHAR_NUMERIC_TYPE: - return (int32_t)U_NT_COUNT-1; - case UCHAR_SCRIPT: - return uprv_getMaxValues(0)&UPROPS_SCRIPT_MASK; - case UCHAR_HANGUL_SYLLABLE_TYPE: - return (int32_t)U_HST_COUNT-1; -#if !UCONFIG_NO_NORMALIZATION - case UCHAR_NFD_QUICK_CHECK: - case UCHAR_NFKD_QUICK_CHECK: - return (int32_t)UNORM_YES; /* these are never "maybe", only "no" or "yes" */ - case UCHAR_NFC_QUICK_CHECK: - case UCHAR_NFKC_QUICK_CHECK: - return (int32_t)UNORM_MAYBE; -#endif - case UCHAR_GRAPHEME_CLUSTER_BREAK: - return (uprv_getMaxValues(2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT; - case UCHAR_SENTENCE_BREAK: - return (uprv_getMaxValues(2)&UPROPS_SB_MASK)>>UPROPS_SB_SHIFT; - case UCHAR_WORD_BREAK: - return (uprv_getMaxValues(2)&UPROPS_WB_MASK)>>UPROPS_WB_SHIFT; - default: - return -1; /* undefined */ - } - } else { - return -1; /* undefined */ - } -} - -/* - * TODO: Simplify, similar to binProps[]. - * Use an array of column/source, mask, shift values to drive returning simple - * properties and their sources. - * - * TODO: Split the single propsvec into one per column, and have - * upropsvec_addPropertyStarts() pass a trie value function that gets the - * desired column's values. - */ -U_CFUNC UPropertySource U_EXPORT2 -uprops_getSource(UProperty which) { - if(which<UCHAR_BINARY_START) { - return UPROPS_SRC_NONE; /* undefined */ - } else if(which<UCHAR_BINARY_LIMIT) { - if(binProps[which].mask!=0) { - return UPROPS_SRC_PROPSVEC; - } else { - return (UPropertySource)binProps[which].column; - } - } else if(which<UCHAR_INT_START) { - return UPROPS_SRC_NONE; /* undefined */ - } else if(which<UCHAR_INT_LIMIT) { - switch(which) { - case UCHAR_GENERAL_CATEGORY: - case UCHAR_NUMERIC_TYPE: - return UPROPS_SRC_CHAR; - - case UCHAR_CANONICAL_COMBINING_CLASS: - case UCHAR_NFD_QUICK_CHECK: - case UCHAR_NFC_QUICK_CHECK: - case UCHAR_LEAD_CANONICAL_COMBINING_CLASS: - case UCHAR_TRAIL_CANONICAL_COMBINING_CLASS: - return UPROPS_SRC_NFC; - case UCHAR_NFKD_QUICK_CHECK: - case UCHAR_NFKC_QUICK_CHECK: - return UPROPS_SRC_NFKC; - - case UCHAR_BIDI_CLASS: - case UCHAR_JOINING_GROUP: - case UCHAR_JOINING_TYPE: - return UPROPS_SRC_BIDI; - - default: - return UPROPS_SRC_PROPSVEC; - } - } else if(which<UCHAR_STRING_START) { - switch(which) { - case UCHAR_GENERAL_CATEGORY_MASK: - case UCHAR_NUMERIC_VALUE: - return UPROPS_SRC_CHAR; - - default: - return UPROPS_SRC_NONE; - } - } else if(which<UCHAR_STRING_LIMIT) { - switch(which) { - case UCHAR_AGE: - return UPROPS_SRC_PROPSVEC; - - case UCHAR_BIDI_MIRRORING_GLYPH: - return UPROPS_SRC_BIDI; - - case UCHAR_CASE_FOLDING: - case UCHAR_LOWERCASE_MAPPING: - case UCHAR_SIMPLE_CASE_FOLDING: - case UCHAR_SIMPLE_LOWERCASE_MAPPING: - case UCHAR_SIMPLE_TITLECASE_MAPPING: - case UCHAR_SIMPLE_UPPERCASE_MAPPING: - case UCHAR_TITLECASE_MAPPING: - case UCHAR_UPPERCASE_MAPPING: - return UPROPS_SRC_CASE; - - case UCHAR_ISO_COMMENT: - case UCHAR_NAME: - case UCHAR_UNICODE_1_NAME: - return UPROPS_SRC_NAMES; - - default: - return UPROPS_SRC_NONE; - } - } else { - return UPROPS_SRC_NONE; /* undefined */ - } -} - -#if !UCONFIG_NO_NORMALIZATION - -U_CAPI int32_t U_EXPORT2 -u_getFC_NFKC_Closure(UChar32 c, UChar *dest, int32_t destCapacity, UErrorCode *pErrorCode) { - if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { - return 0; - } - 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 UCaseProps *csp=ucase_getSingleton(pErrorCode); - 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); - if(nfkcImpl->getCompQuickCheck(nfkcImpl->getNorm16(c))!=UNORM_NO) { - return u_terminateUChars(dest, destCapacity, 0, pErrorCode); // c does not change at all under CaseFolding+NFKC - } - folded1String.setTo(c); - } else { - if(folded1Length>UCASE_MAX_STRING_LENGTH) { - folded1String.setTo(folded1Length); - } else { - folded1String.setTo(FALSE, folded1, folded1Length); - } - } - UnicodeString kc1=nfkc->normalize(folded1String, *pErrorCode); - // second: c = NFKC(Fold(b)) - UnicodeString folded2String(kc1); - 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 - -/*---------------------------------------------------------------- - * Inclusions list - *----------------------------------------------------------------*/ - -/* - * Return a set of characters for property enumeration. - * The set implicitly contains 0x110000 as well, which is one more than the highest - * Unicode code point. - * - * This set is used as an ordered list - its code points are ordered, and - * consecutive code points (in Unicode code point order) in the set define a range. - * For each two consecutive characters (start, limit) in the set, - * all of the UCD/normalization and related properties for - * all code points start..limit-1 are all the same, - * except for character names and ISO comments. - * - * All Unicode code points U+0000..U+10ffff are covered by these ranges. - * The ranges define a partition of the Unicode code space. - * ICU uses the inclusions set to enumerate properties for generating - * UnicodeSets containing all code points that have a certain property value. - * - * The Inclusion List is generated from the UCD. It is generated - * by enumerating the data tries, and code points for hardcoded properties - * are added as well. - * - * -------------------------------------------------------------------------- - * - * The following are ideas for getting properties-unique code point ranges, - * with possible optimizations beyond the current implementation. - * These optimizations would require more code and be more fragile. - * The current implementation generates one single list (set) for all properties. - * - * To enumerate properties efficiently, one needs to know ranges of - * repetitive values, so that the value of only each start code point - * can be applied to the whole range. - * This information is in principle available in the uprops.icu/unorm.icu data. - * - * There are two obstacles: - * - * 1. Some properties are computed from multiple data structures, - * making it necessary to get repetitive ranges by intersecting - * ranges from multiple tries. - * - * 2. It is not economical to write code for getting repetitive ranges - * that are precise for each of some 50 properties. - * - * Compromise ideas: - * - * - Get ranges per trie, not per individual property. - * Each range contains the same values for a whole group of properties. - * This would generate currently five range sets, two for uprops.icu tries - * and three for unorm.icu tries. - * - * - Combine sets of ranges for multiple tries to get sufficient sets - * for properties, e.g., the uprops.icu main and auxiliary tries - * for all non-normalization properties. - * - * Ideas for representing ranges and combining them: - * - * - A UnicodeSet could hold just the start code points of ranges. - * Multiple sets are easily combined by or-ing them together. - * - * - Alternatively, a UnicodeSet could hold each even-numbered range. - * All ranges could be enumerated by using each start code point - * (for the even-numbered ranges) as well as each limit (end+1) code point - * (for the odd-numbered ranges). - * It should be possible to combine two such sets by xor-ing them, - * but no more than two. - * - * The second way to represent ranges may(?!) yield smaller UnicodeSet arrays, - * but the first one is certainly simpler and applicable for combining more than - * two range sets. - * - * It is possible to combine all range sets for all uprops/unorm tries into one - * set that can be used for all properties. - * As an optimization, there could be less-combined range sets for certain - * groups of properties. - * The relationship of which less-combined range set to use for which property - * depends on the implementation of the properties and must be hardcoded - * - somewhat error-prone and higher maintenance but can be tested easily - * by building property sets "the simple way" in test code. - * - * --- - * - * Do not use a UnicodeSet pattern because that causes infinite recursion; - * UnicodeSet depends on the inclusions set. - * - * --- - * - * uprv_getInclusions() is commented out starting 2004-sep-13 because - * uniset_props.cpp now calls the uxyz_addPropertyStarts() directly, - * and only for the relevant property source. - */ -#if 0 - -U_CAPI void U_EXPORT2 -uprv_getInclusions(const USetAdder *sa, UErrorCode *pErrorCode) { - if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { - return; - } - -#if !UCONFIG_NO_NORMALIZATION - unorm_addPropertyStarts(sa, pErrorCode); -#endif - uchar_addPropertyStarts(sa, pErrorCode); - ucase_addPropertyStarts(ucase_getSingleton(pErrorCode), sa, pErrorCode); - ubidi_addPropertyStarts(ubidi_getSingleton(pErrorCode), sa, pErrorCode); -} - -#endif |