icuSources/common/uprops.cpp

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