1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 2002-2014, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: uprops.cpp 9 * encoding: US-ASCII 10 * tab size: 8 (not used) 11 * indentation:4 12 * 13 * created on: 2002feb24 14 * created by: Markus W. Scherer 15 * 16 * Implementations for mostly non-core Unicode character properties 17 * stored in uprops.icu. 18 * 19 * With the APIs implemented here, almost all properties files and 20 * their associated implementation files are used from this file, 21 * including those for normalization and case mappings. 22 */ 23 24 #include "unicode/utypes.h" 25 #include "unicode/uchar.h" 26 #include "unicode/unorm2.h" 27 #include "unicode/uscript.h" 28 #include "unicode/ustring.h" 29 #include "cstring.h" 30 #include "normalizer2impl.h" 31 #include "umutex.h" 32 #include "ubidi_props.h" 33 #include "uprops.h" 34 #include "ucase.h" 35 #include "ustr_imp.h" 36 37 U_NAMESPACE_USE 38 39 #define GET_BIDI_PROPS() ubidi_getSingleton() 40 41 /* general properties API functions ----------------------------------------- */ 42 43 struct BinaryProperty; 44 45 typedef UBool BinaryPropertyContains(const BinaryProperty &prop, UChar32 c, UProperty which); 46 47 struct BinaryProperty { 48 int32_t column; // SRC_PROPSVEC column, or "source" if mask==0 49 uint32_t mask; 50 BinaryPropertyContains *contains; 51 }; 52 53 static UBool defaultContains(const BinaryProperty &prop, UChar32 c, UProperty /*which*/) { 54 /* systematic, directly stored properties */ 55 return (u_getUnicodeProperties(c, prop.column)&prop.mask)!=0; 56 } 57 58 static UBool caseBinaryPropertyContains(const BinaryProperty &/*prop*/, UChar32 c, UProperty which) { 59 return ucase_hasBinaryProperty(c, which); 60 } 61 62 static UBool isBidiControl(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 63 return ubidi_isBidiControl(GET_BIDI_PROPS(), c); 64 } 65 66 static UBool isMirrored(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 67 return ubidi_isMirrored(GET_BIDI_PROPS(), c); 68 } 69 70 static UBool isJoinControl(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 71 return ubidi_isJoinControl(GET_BIDI_PROPS(), c); 72 } 73 74 #if UCONFIG_NO_NORMALIZATION 75 static UBool hasFullCompositionExclusion(const BinaryProperty &, UChar32, UProperty) { 76 return FALSE; 77 } 78 #else 79 static UBool hasFullCompositionExclusion(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 80 // By definition, Full_Composition_Exclusion is the same as NFC_QC=No. 81 UErrorCode errorCode=U_ZERO_ERROR; 82 const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 83 return U_SUCCESS(errorCode) && impl->isCompNo(impl->getNorm16(c)); 84 } 85 #endif 86 87 // UCHAR_NF*_INERT properties 88 #if UCONFIG_NO_NORMALIZATION 89 static UBool isNormInert(const BinaryProperty &, UChar32, UProperty) { 90 return FALSE; 91 } 92 #else 93 static UBool isNormInert(const BinaryProperty &/*prop*/, UChar32 c, UProperty which) { 94 UErrorCode errorCode=U_ZERO_ERROR; 95 const Normalizer2 *norm2=Normalizer2Factory::getInstance( 96 (UNormalizationMode)(which-UCHAR_NFD_INERT+UNORM_NFD), errorCode); 97 return U_SUCCESS(errorCode) && norm2->isInert(c); 98 } 99 #endif 100 101 #if UCONFIG_NO_NORMALIZATION 102 static UBool changesWhenCasefolded(const BinaryProperty &, UChar32, UProperty) { 103 return FALSE; 104 } 105 #else 106 static UBool changesWhenCasefolded(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 107 UnicodeString nfd; 108 UErrorCode errorCode=U_ZERO_ERROR; 109 const Normalizer2 *nfcNorm2=Normalizer2::getNFCInstance(errorCode); 110 if(U_FAILURE(errorCode)) { 111 return FALSE; 112 } 113 if(nfcNorm2->getDecomposition(c, nfd)) { 114 /* c has a decomposition */ 115 if(nfd.length()==1) { 116 c=nfd[0]; /* single BMP code point */ 117 } else if(nfd.length()<=U16_MAX_LENGTH && 118 nfd.length()==U16_LENGTH(c=nfd.char32At(0)) 119 ) { 120 /* single supplementary code point */ 121 } else { 122 c=U_SENTINEL; 123 } 124 } else if(c<0) { 125 return FALSE; /* protect against bad input */ 126 } 127 if(c>=0) { 128 /* single code point */ 129 const UCaseProps *csp=ucase_getSingleton(); 130 const UChar *resultString; 131 return (UBool)(ucase_toFullFolding(csp, c, &resultString, U_FOLD_CASE_DEFAULT)>=0); 132 } else { 133 /* guess some large but stack-friendly capacity */ 134 UChar dest[2*UCASE_MAX_STRING_LENGTH]; 135 int32_t destLength; 136 destLength=u_strFoldCase(dest, UPRV_LENGTHOF(dest), 137 nfd.getBuffer(), nfd.length(), 138 U_FOLD_CASE_DEFAULT, &errorCode); 139 return (UBool)(U_SUCCESS(errorCode) && 140 0!=u_strCompare(nfd.getBuffer(), nfd.length(), 141 dest, destLength, FALSE)); 142 } 143 } 144 #endif 145 146 #if UCONFIG_NO_NORMALIZATION 147 static UBool changesWhenNFKC_Casefolded(const BinaryProperty &, UChar32, UProperty) { 148 return FALSE; 149 } 150 #else 151 static UBool changesWhenNFKC_Casefolded(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 152 UErrorCode errorCode=U_ZERO_ERROR; 153 const Normalizer2Impl *kcf=Normalizer2Factory::getNFKC_CFImpl(errorCode); 154 if(U_FAILURE(errorCode)) { 155 return FALSE; 156 } 157 UnicodeString src(c); 158 UnicodeString dest; 159 { 160 // The ReorderingBuffer must be in a block because its destructor 161 // needs to release dest's buffer before we look at its contents. 162 ReorderingBuffer buffer(*kcf, dest); 163 // Small destCapacity for NFKC_CF(c). 164 if(buffer.init(5, errorCode)) { 165 const UChar *srcArray=src.getBuffer(); 166 kcf->compose(srcArray, srcArray+src.length(), FALSE, 167 TRUE, buffer, errorCode); 168 } 169 } 170 return U_SUCCESS(errorCode) && dest!=src; 171 } 172 #endif 173 174 #if UCONFIG_NO_NORMALIZATION 175 static UBool isCanonSegmentStarter(const BinaryProperty &, UChar32, UProperty) { 176 return FALSE; 177 } 178 #else 179 static UBool isCanonSegmentStarter(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 180 UErrorCode errorCode=U_ZERO_ERROR; 181 const Normalizer2Impl *impl=Normalizer2Factory::getNFCImpl(errorCode); 182 return 183 U_SUCCESS(errorCode) && impl->ensureCanonIterData(errorCode) && 184 impl->isCanonSegmentStarter(c); 185 } 186 #endif 187 188 static UBool isPOSIX_alnum(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 189 return u_isalnumPOSIX(c); 190 } 191 192 static UBool isPOSIX_blank(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 193 return u_isblank(c); 194 } 195 196 static UBool isPOSIX_graph(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 197 return u_isgraphPOSIX(c); 198 } 199 200 static UBool isPOSIX_print(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 201 return u_isprintPOSIX(c); 202 } 203 204 static UBool isPOSIX_xdigit(const BinaryProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 205 return u_isxdigit(c); 206 } 207 208 static const BinaryProperty binProps[UCHAR_BINARY_LIMIT]={ 209 /* 210 * column and mask values for binary properties from u_getUnicodeProperties(). 211 * Must be in order of corresponding UProperty, 212 * and there must be exactly one entry per binary UProperty. 213 * 214 * Properties with mask==0 are handled in code. 215 * For them, column is the UPropertySource value. 216 */ 217 { 1, U_MASK(UPROPS_ALPHABETIC), defaultContains }, 218 { 1, U_MASK(UPROPS_ASCII_HEX_DIGIT), defaultContains }, 219 { UPROPS_SRC_BIDI, 0, isBidiControl }, 220 { UPROPS_SRC_BIDI, 0, isMirrored }, 221 { 1, U_MASK(UPROPS_DASH), defaultContains }, 222 { 1, U_MASK(UPROPS_DEFAULT_IGNORABLE_CODE_POINT), defaultContains }, 223 { 1, U_MASK(UPROPS_DEPRECATED), defaultContains }, 224 { 1, U_MASK(UPROPS_DIACRITIC), defaultContains }, 225 { 1, U_MASK(UPROPS_EXTENDER), defaultContains }, 226 { UPROPS_SRC_NFC, 0, hasFullCompositionExclusion }, 227 { 1, U_MASK(UPROPS_GRAPHEME_BASE), defaultContains }, 228 { 1, U_MASK(UPROPS_GRAPHEME_EXTEND), defaultContains }, 229 { 1, U_MASK(UPROPS_GRAPHEME_LINK), defaultContains }, 230 { 1, U_MASK(UPROPS_HEX_DIGIT), defaultContains }, 231 { 1, U_MASK(UPROPS_HYPHEN), defaultContains }, 232 { 1, U_MASK(UPROPS_ID_CONTINUE), defaultContains }, 233 { 1, U_MASK(UPROPS_ID_START), defaultContains }, 234 { 1, U_MASK(UPROPS_IDEOGRAPHIC), defaultContains }, 235 { 1, U_MASK(UPROPS_IDS_BINARY_OPERATOR), defaultContains }, 236 { 1, U_MASK(UPROPS_IDS_TRINARY_OPERATOR), defaultContains }, 237 { UPROPS_SRC_BIDI, 0, isJoinControl }, 238 { 1, U_MASK(UPROPS_LOGICAL_ORDER_EXCEPTION), defaultContains }, 239 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_LOWERCASE 240 { 1, U_MASK(UPROPS_MATH), defaultContains }, 241 { 1, U_MASK(UPROPS_NONCHARACTER_CODE_POINT), defaultContains }, 242 { 1, U_MASK(UPROPS_QUOTATION_MARK), defaultContains }, 243 { 1, U_MASK(UPROPS_RADICAL), defaultContains }, 244 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_SOFT_DOTTED 245 { 1, U_MASK(UPROPS_TERMINAL_PUNCTUATION), defaultContains }, 246 { 1, U_MASK(UPROPS_UNIFIED_IDEOGRAPH), defaultContains }, 247 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_UPPERCASE 248 { 1, U_MASK(UPROPS_WHITE_SPACE), defaultContains }, 249 { 1, U_MASK(UPROPS_XID_CONTINUE), defaultContains }, 250 { 1, U_MASK(UPROPS_XID_START), defaultContains }, 251 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CASE_SENSITIVE 252 { 1, U_MASK(UPROPS_S_TERM), defaultContains }, 253 { 1, U_MASK(UPROPS_VARIATION_SELECTOR), defaultContains }, 254 { UPROPS_SRC_NFC, 0, isNormInert }, // UCHAR_NFD_INERT 255 { UPROPS_SRC_NFKC, 0, isNormInert }, // UCHAR_NFKD_INERT 256 { UPROPS_SRC_NFC, 0, isNormInert }, // UCHAR_NFC_INERT 257 { UPROPS_SRC_NFKC, 0, isNormInert }, // UCHAR_NFKC_INERT 258 { UPROPS_SRC_NFC_CANON_ITER, 0, isCanonSegmentStarter }, 259 { 1, U_MASK(UPROPS_PATTERN_SYNTAX), defaultContains }, 260 { 1, U_MASK(UPROPS_PATTERN_WHITE_SPACE), defaultContains }, 261 { UPROPS_SRC_CHAR_AND_PROPSVEC, 0, isPOSIX_alnum }, 262 { UPROPS_SRC_CHAR, 0, isPOSIX_blank }, 263 { UPROPS_SRC_CHAR, 0, isPOSIX_graph }, 264 { UPROPS_SRC_CHAR, 0, isPOSIX_print }, 265 { UPROPS_SRC_CHAR, 0, isPOSIX_xdigit }, 266 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CASED 267 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CASE_IGNORABLE 268 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_LOWERCASED 269 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_UPPERCASED 270 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_TITLECASED 271 { UPROPS_SRC_CASE_AND_NORM, 0, changesWhenCasefolded }, 272 { UPROPS_SRC_CASE, 0, caseBinaryPropertyContains }, // UCHAR_CHANGES_WHEN_CASEMAPPED 273 { UPROPS_SRC_NFKC_CF, 0, changesWhenNFKC_Casefolded } 274 }; 275 276 U_CAPI UBool U_EXPORT2 277 u_hasBinaryProperty(UChar32 c, UProperty which) { 278 /* c is range-checked in the functions that are called from here */ 279 if(which<UCHAR_BINARY_START || UCHAR_BINARY_LIMIT<=which) { 280 /* not a known binary property */ 281 return FALSE; 282 } else { 283 const BinaryProperty &prop=binProps[which]; 284 return prop.contains(prop, c, which); 285 } 286 } 287 288 struct IntProperty; 289 290 typedef int32_t IntPropertyGetValue(const IntProperty &prop, UChar32 c, UProperty which); 291 typedef int32_t IntPropertyGetMaxValue(const IntProperty &prop, UProperty which); 292 293 struct IntProperty { 294 int32_t column; // SRC_PROPSVEC column, or "source" if mask==0 295 uint32_t mask; 296 int32_t shift; // =maxValue if getMaxValueFromShift() is used 297 IntPropertyGetValue *getValue; 298 IntPropertyGetMaxValue *getMaxValue; 299 }; 300 301 static int32_t defaultGetValue(const IntProperty &prop, UChar32 c, UProperty /*which*/) { 302 /* systematic, directly stored properties */ 303 return (int32_t)(u_getUnicodeProperties(c, prop.column)&prop.mask)>>prop.shift; 304 } 305 306 static int32_t defaultGetMaxValue(const IntProperty &prop, UProperty /*which*/) { 307 return (uprv_getMaxValues(prop.column)&prop.mask)>>prop.shift; 308 } 309 310 static int32_t getMaxValueFromShift(const IntProperty &prop, UProperty /*which*/) { 311 return prop.shift; 312 } 313 314 static int32_t getBiDiClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 315 return (int32_t)u_charDirection(c); 316 } 317 318 static int32_t getBiDiPairedBracketType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 319 return (int32_t)ubidi_getPairedBracketType(GET_BIDI_PROPS(), c); 320 } 321 322 static int32_t biDiGetMaxValue(const IntProperty &/*prop*/, UProperty which) { 323 return ubidi_getMaxValue(GET_BIDI_PROPS(), which); 324 } 325 326 #if UCONFIG_NO_NORMALIZATION 327 static int32_t getCombiningClass(const IntProperty &, UChar32, UProperty) { 328 return 0; 329 } 330 #else 331 static int32_t getCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 332 return u_getCombiningClass(c); 333 } 334 #endif 335 336 static int32_t getGeneralCategory(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 337 return (int32_t)u_charType(c); 338 } 339 340 static int32_t getJoiningGroup(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 341 return ubidi_getJoiningGroup(GET_BIDI_PROPS(), c); 342 } 343 344 static int32_t getJoiningType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 345 return ubidi_getJoiningType(GET_BIDI_PROPS(), c); 346 } 347 348 static int32_t getNumericType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 349 int32_t ntv=(int32_t)GET_NUMERIC_TYPE_VALUE(u_getMainProperties(c)); 350 return UPROPS_NTV_GET_TYPE(ntv); 351 } 352 353 static int32_t getScript(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 354 UErrorCode errorCode=U_ZERO_ERROR; 355 return (int32_t)uscript_getScript(c, &errorCode); 356 } 357 358 /* 359 * Map some of the Grapheme Cluster Break values to Hangul Syllable Types. 360 * Hangul_Syllable_Type is fully redundant with a subset of Grapheme_Cluster_Break. 361 */ 362 static const UHangulSyllableType gcbToHst[]={ 363 U_HST_NOT_APPLICABLE, /* U_GCB_OTHER */ 364 U_HST_NOT_APPLICABLE, /* U_GCB_CONTROL */ 365 U_HST_NOT_APPLICABLE, /* U_GCB_CR */ 366 U_HST_NOT_APPLICABLE, /* U_GCB_EXTEND */ 367 U_HST_LEADING_JAMO, /* U_GCB_L */ 368 U_HST_NOT_APPLICABLE, /* U_GCB_LF */ 369 U_HST_LV_SYLLABLE, /* U_GCB_LV */ 370 U_HST_LVT_SYLLABLE, /* U_GCB_LVT */ 371 U_HST_TRAILING_JAMO, /* U_GCB_T */ 372 U_HST_VOWEL_JAMO /* U_GCB_V */ 373 /* 374 * Omit GCB values beyond what we need for hst. 375 * The code below checks for the array length. 376 */ 377 }; 378 379 static int32_t getHangulSyllableType(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 380 /* see comments on gcbToHst[] above */ 381 int32_t gcb=(int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT; 382 if(gcb<UPRV_LENGTHOF(gcbToHst)) { 383 return gcbToHst[gcb]; 384 } else { 385 return U_HST_NOT_APPLICABLE; 386 } 387 } 388 389 #if UCONFIG_NO_NORMALIZATION 390 static int32_t getNormQuickCheck(const IntProperty &, UChar32, UProperty) { 391 return 0; 392 } 393 #else 394 static int32_t getNormQuickCheck(const IntProperty &/*prop*/, UChar32 c, UProperty which) { 395 return (int32_t)unorm_getQuickCheck(c, (UNormalizationMode)(which-UCHAR_NFD_QUICK_CHECK+UNORM_NFD)); 396 } 397 #endif 398 399 #if UCONFIG_NO_NORMALIZATION 400 static int32_t getLeadCombiningClass(const IntProperty &, UChar32, UProperty) { 401 return 0; 402 } 403 #else 404 static int32_t getLeadCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 405 return unorm_getFCD16(c)>>8; 406 } 407 #endif 408 409 #if UCONFIG_NO_NORMALIZATION 410 static int32_t getTrailCombiningClass(const IntProperty &, UChar32, UProperty) { 411 return 0; 412 } 413 #else 414 static int32_t getTrailCombiningClass(const IntProperty &/*prop*/, UChar32 c, UProperty /*which*/) { 415 return unorm_getFCD16(c)&0xff; 416 } 417 #endif 418 419 static const IntProperty intProps[UCHAR_INT_LIMIT-UCHAR_INT_START]={ 420 /* 421 * column, mask and shift values for int-value properties from u_getUnicodeProperties(). 422 * Must be in order of corresponding UProperty, 423 * and there must be exactly one entry per int UProperty. 424 * 425 * Properties with mask==0 are handled in code. 426 * For them, column is the UPropertySource value. 427 */ 428 { UPROPS_SRC_BIDI, 0, 0, getBiDiClass, biDiGetMaxValue }, 429 { 0, UPROPS_BLOCK_MASK, UPROPS_BLOCK_SHIFT, defaultGetValue, defaultGetMaxValue }, 430 { UPROPS_SRC_NFC, 0, 0xff, getCombiningClass, getMaxValueFromShift }, 431 { 2, UPROPS_DT_MASK, 0, defaultGetValue, defaultGetMaxValue }, 432 { 0, UPROPS_EA_MASK, UPROPS_EA_SHIFT, defaultGetValue, defaultGetMaxValue }, 433 { UPROPS_SRC_CHAR, 0, (int32_t)U_CHAR_CATEGORY_COUNT-1,getGeneralCategory, getMaxValueFromShift }, 434 { UPROPS_SRC_BIDI, 0, 0, getJoiningGroup, biDiGetMaxValue }, 435 { UPROPS_SRC_BIDI, 0, 0, getJoiningType, biDiGetMaxValue }, 436 { 2, UPROPS_LB_MASK, UPROPS_LB_SHIFT, defaultGetValue, defaultGetMaxValue }, 437 { UPROPS_SRC_CHAR, 0, (int32_t)U_NT_COUNT-1, getNumericType, getMaxValueFromShift }, 438 { 0, UPROPS_SCRIPT_MASK, 0, getScript, defaultGetMaxValue }, 439 { UPROPS_SRC_PROPSVEC, 0, (int32_t)U_HST_COUNT-1, getHangulSyllableType, getMaxValueFromShift }, 440 // UCHAR_NFD_QUICK_CHECK: max=1=YES -- never "maybe", only "no" or "yes" 441 { UPROPS_SRC_NFC, 0, (int32_t)UNORM_YES, getNormQuickCheck, getMaxValueFromShift }, 442 // UCHAR_NFKD_QUICK_CHECK: max=1=YES -- never "maybe", only "no" or "yes" 443 { UPROPS_SRC_NFKC, 0, (int32_t)UNORM_YES, getNormQuickCheck, getMaxValueFromShift }, 444 // UCHAR_NFC_QUICK_CHECK: max=2=MAYBE 445 { UPROPS_SRC_NFC, 0, (int32_t)UNORM_MAYBE, getNormQuickCheck, getMaxValueFromShift }, 446 // UCHAR_NFKC_QUICK_CHECK: max=2=MAYBE 447 { UPROPS_SRC_NFKC, 0, (int32_t)UNORM_MAYBE, getNormQuickCheck, getMaxValueFromShift }, 448 { UPROPS_SRC_NFC, 0, 0xff, getLeadCombiningClass, getMaxValueFromShift }, 449 { UPROPS_SRC_NFC, 0, 0xff, getTrailCombiningClass, getMaxValueFromShift }, 450 { 2, UPROPS_GCB_MASK, UPROPS_GCB_SHIFT, defaultGetValue, defaultGetMaxValue }, 451 { 2, UPROPS_SB_MASK, UPROPS_SB_SHIFT, defaultGetValue, defaultGetMaxValue }, 452 { 2, UPROPS_WB_MASK, UPROPS_WB_SHIFT, defaultGetValue, defaultGetMaxValue }, 453 { UPROPS_SRC_BIDI, 0, 0, getBiDiPairedBracketType, biDiGetMaxValue }, 454 }; 455 456 U_CAPI int32_t U_EXPORT2 457 u_getIntPropertyValue(UChar32 c, UProperty which) { 458 if(which<UCHAR_INT_START) { 459 if(UCHAR_BINARY_START<=which && which<UCHAR_BINARY_LIMIT) { 460 const BinaryProperty &prop=binProps[which]; 461 return prop.contains(prop, c, which); 462 } 463 } else if(which<UCHAR_INT_LIMIT) { 464 const IntProperty &prop=intProps[which-UCHAR_INT_START]; 465 return prop.getValue(prop, c, which); 466 } else if(which==UCHAR_GENERAL_CATEGORY_MASK) { 467 return U_MASK(u_charType(c)); 468 } 469 return 0; // undefined 470 } 471 472 U_CAPI int32_t U_EXPORT2 473 u_getIntPropertyMinValue(UProperty /*which*/) { 474 return 0; /* all binary/enum/int properties have a minimum value of 0 */ 475 } 476 477 U_CAPI int32_t U_EXPORT2 478 u_getIntPropertyMaxValue(UProperty which) { 479 if(which<UCHAR_INT_START) { 480 if(UCHAR_BINARY_START<=which && which<UCHAR_BINARY_LIMIT) { 481 return 1; // maximum TRUE for all binary properties 482 } 483 } else if(which<UCHAR_INT_LIMIT) { 484 const IntProperty &prop=intProps[which-UCHAR_INT_START]; 485 return prop.getMaxValue(prop, which); 486 } 487 return -1; // undefined 488 } 489 490 U_CFUNC UPropertySource U_EXPORT2 491 uprops_getSource(UProperty which) { 492 if(which<UCHAR_BINARY_START) { 493 return UPROPS_SRC_NONE; /* undefined */ 494 } else if(which<UCHAR_BINARY_LIMIT) { 495 const BinaryProperty &prop=binProps[which]; 496 if(prop.mask!=0) { 497 return UPROPS_SRC_PROPSVEC; 498 } else { 499 return (UPropertySource)prop.column; 500 } 501 } else if(which<UCHAR_INT_START) { 502 return UPROPS_SRC_NONE; /* undefined */ 503 } else if(which<UCHAR_INT_LIMIT) { 504 const IntProperty &prop=intProps[which-UCHAR_INT_START]; 505 if(prop.mask!=0) { 506 return UPROPS_SRC_PROPSVEC; 507 } else { 508 return (UPropertySource)prop.column; 509 } 510 } else if(which<UCHAR_STRING_START) { 511 switch(which) { 512 case UCHAR_GENERAL_CATEGORY_MASK: 513 case UCHAR_NUMERIC_VALUE: 514 return UPROPS_SRC_CHAR; 515 516 default: 517 return UPROPS_SRC_NONE; 518 } 519 } else if(which<UCHAR_STRING_LIMIT) { 520 switch(which) { 521 case UCHAR_AGE: 522 return UPROPS_SRC_PROPSVEC; 523 524 case UCHAR_BIDI_MIRRORING_GLYPH: 525 return UPROPS_SRC_BIDI; 526 527 case UCHAR_CASE_FOLDING: 528 case UCHAR_LOWERCASE_MAPPING: 529 case UCHAR_SIMPLE_CASE_FOLDING: 530 case UCHAR_SIMPLE_LOWERCASE_MAPPING: 531 case UCHAR_SIMPLE_TITLECASE_MAPPING: 532 case UCHAR_SIMPLE_UPPERCASE_MAPPING: 533 case UCHAR_TITLECASE_MAPPING: 534 case UCHAR_UPPERCASE_MAPPING: 535 return UPROPS_SRC_CASE; 536 537 case UCHAR_ISO_COMMENT: 538 case UCHAR_NAME: 539 case UCHAR_UNICODE_1_NAME: 540 return UPROPS_SRC_NAMES; 541 542 default: 543 return UPROPS_SRC_NONE; 544 } 545 } else { 546 switch(which) { 547 case UCHAR_SCRIPT_EXTENSIONS: 548 return UPROPS_SRC_PROPSVEC; 549 default: 550 return UPROPS_SRC_NONE; /* undefined */ 551 } 552 } 553 } 554 555 #if !UCONFIG_NO_NORMALIZATION 556 557 U_CAPI int32_t U_EXPORT2 558 u_getFC_NFKC_Closure(UChar32 c, UChar *dest, int32_t destCapacity, UErrorCode *pErrorCode) { 559 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 560 return 0; 561 } 562 if(destCapacity<0 || (dest==NULL && destCapacity>0)) { 563 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 564 return 0; 565 } 566 // Compute the FC_NFKC_Closure on the fly: 567 // We have the API for complete coverage of Unicode properties, although 568 // this value by itself is not useful via API. 569 // (What could be useful is a custom normalization table that combines 570 // case folding and NFKC.) 571 // For the derivation, see Unicode's DerivedNormalizationProps.txt. 572 const Normalizer2 *nfkc=Normalizer2::getNFKCInstance(*pErrorCode); 573 const UCaseProps *csp=ucase_getSingleton(); 574 if(U_FAILURE(*pErrorCode)) { 575 return 0; 576 } 577 // first: b = NFKC(Fold(a)) 578 UnicodeString folded1String; 579 const UChar *folded1; 580 int32_t folded1Length=ucase_toFullFolding(csp, c, &folded1, U_FOLD_CASE_DEFAULT); 581 if(folded1Length<0) { 582 const Normalizer2Impl *nfkcImpl=Normalizer2Factory::getImpl(nfkc); 583 if(nfkcImpl->getCompQuickCheck(nfkcImpl->getNorm16(c))!=UNORM_NO) { 584 return u_terminateUChars(dest, destCapacity, 0, pErrorCode); // c does not change at all under CaseFolding+NFKC 585 } 586 folded1String.setTo(c); 587 } else { 588 if(folded1Length>UCASE_MAX_STRING_LENGTH) { 589 folded1String.setTo(folded1Length); 590 } else { 591 folded1String.setTo(FALSE, folded1, folded1Length); 592 } 593 } 594 UnicodeString kc1=nfkc->normalize(folded1String, *pErrorCode); 595 // second: c = NFKC(Fold(b)) 596 UnicodeString folded2String(kc1); 597 UnicodeString kc2=nfkc->normalize(folded2String.foldCase(), *pErrorCode); 598 // if (c != b) add the mapping from a to c 599 if(U_FAILURE(*pErrorCode) || kc1==kc2) { 600 return u_terminateUChars(dest, destCapacity, 0, pErrorCode); 601 } else { 602 return kc2.extract(dest, destCapacity, *pErrorCode); 603 } 604 } 605 606 #endif 607
