summaryrefslogtreecommitdiff
path: root/Build/source/libs/icu/icu-4.4/common/uprops.cpp
diff options
context:
space:
mode:
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.cpp753
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