icuSources/common/uprops.c

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 2002-2008, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  uprops.h
   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/uscript.h"
  27 #include "cstring.h"
  28 #include "ucln_cmn.h"
  29 #include "umutex.h"
  30 #include "unormimp.h"
  31 #include "ubidi_props.h"
  32 #include "uprops.h"
  33 #include "ucase.h"
  34
  35 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  36
  37 /* cleanup ------------------------------------------------------------------ */
  38
  39 static const UBiDiProps *gBdp=NULL;
  40
  41 static UBool U_CALLCONV uprops_cleanup(void) {
  42     gBdp=NULL;
  43     return TRUE;
  44 }
  45
  46 /* bidi/shaping properties API ---------------------------------------------- */
  47
  48 /* get the UBiDiProps singleton, or else its dummy, once and for all */
  49 static const UBiDiProps *
  50 getBiDiProps() {
  51     /*
  52      * This lazy intialization with double-checked locking (without mutex protection for
  53      * the initial check) is transiently unsafe under certain circumstances.
  54      * Check the readme and use u_init() if necessary.
  55      */
  56
  57     /* the initial check is performed by the GET_BIDI_PROPS() macro */
  58     const UBiDiProps *bdp;
  59     UErrorCode errorCode=U_ZERO_ERROR;
  60
  61     bdp=ubidi_getSingleton(&errorCode);
  62 #if !UBIDI_HARDCODE_DATA
  63     if(U_FAILURE(errorCode)) {
  64         errorCode=U_ZERO_ERROR;
  65         bdp=ubidi_getDummy(&errorCode);
  66         if(U_FAILURE(errorCode)) {
  67             return NULL;
  68         }
  69     }
  70 #endif
  71
  72     umtx_lock(NULL);
  73     if(gBdp==NULL) {
  74         gBdp=bdp;
  75         ucln_common_registerCleanup(UCLN_COMMON_UPROPS, uprops_cleanup);
  76     }
  77     umtx_unlock(NULL);
  78
  79     return gBdp;
  80 }
  81
  82 /* see comment for GET_CASE_PROPS() */
  83 #define GET_BIDI_PROPS() (gBdp!=NULL ? gBdp : getBiDiProps())
  84
  85 /* general properties API functions ----------------------------------------- */
  86
  87 static const struct {
  88     int32_t column;
  89     uint32_t mask;
  90 } binProps[UCHAR_BINARY_LIMIT]={
  91     /*
  92      * column and mask values for binary properties from u_getUnicodeProperties().
  93      * Must be in order of corresponding UProperty,
  94      * and there must be exacly one entry per binary UProperty.
  95      *
  96      * Properties with mask 0 are handled in code.
  97      * For them, column is the UPropertySource value.
  98      */
  99     {  1,               U_MASK(UPROPS_ALPHABETIC) },
 100     {  1,               U_MASK(UPROPS_ASCII_HEX_DIGIT) },
 101     { UPROPS_SRC_BIDI,  0 },                                    /* UCHAR_BIDI_CONTROL */
 102     { UPROPS_SRC_BIDI,  0 },                                    /* UCHAR_BIDI_MIRRORED */
 103     {  1,               U_MASK(UPROPS_DASH) },
 104     {  1,               U_MASK(UPROPS_DEFAULT_IGNORABLE_CODE_POINT) },
 105     {  1,               U_MASK(UPROPS_DEPRECATED) },
 106     {  1,               U_MASK(UPROPS_DIACRITIC) },
 107     {  1,               U_MASK(UPROPS_EXTENDER) },
 108     { UPROPS_SRC_NORM,  0 },                                    /* UCHAR_FULL_COMPOSITION_EXCLUSION */
 109     {  1,               U_MASK(UPROPS_GRAPHEME_BASE) },
 110     {  1,               U_MASK(UPROPS_GRAPHEME_EXTEND) },
 111     {  1,               U_MASK(UPROPS_GRAPHEME_LINK) },
 112     {  1,               U_MASK(UPROPS_HEX_DIGIT) },
 113     {  1,               U_MASK(UPROPS_HYPHEN) },
 114     {  1,               U_MASK(UPROPS_ID_CONTINUE) },
 115     {  1,               U_MASK(UPROPS_ID_START) },
 116     {  1,               U_MASK(UPROPS_IDEOGRAPHIC) },
 117     {  1,               U_MASK(UPROPS_IDS_BINARY_OPERATOR) },
 118     {  1,               U_MASK(UPROPS_IDS_TRINARY_OPERATOR) },
 119     { UPROPS_SRC_BIDI,  0 },                                    /* UCHAR_JOIN_CONTROL */
 120     {  1,               U_MASK(UPROPS_LOGICAL_ORDER_EXCEPTION) },
 121     { UPROPS_SRC_CASE,  0 },                                    /* UCHAR_LOWERCASE */
 122     {  1,               U_MASK(UPROPS_MATH) },
 123     {  1,               U_MASK(UPROPS_NONCHARACTER_CODE_POINT) },
 124     {  1,               U_MASK(UPROPS_QUOTATION_MARK) },
 125     {  1,               U_MASK(UPROPS_RADICAL) },
 126     { UPROPS_SRC_CASE,  0 },                                    /* UCHAR_SOFT_DOTTED */
 127     {  1,               U_MASK(UPROPS_TERMINAL_PUNCTUATION) },
 128     {  1,               U_MASK(UPROPS_UNIFIED_IDEOGRAPH) },
 129     { UPROPS_SRC_CASE,  0 },                                    /* UCHAR_UPPERCASE */
 130     {  1,               U_MASK(UPROPS_WHITE_SPACE) },
 131     {  1,               U_MASK(UPROPS_XID_CONTINUE) },
 132     {  1,               U_MASK(UPROPS_XID_START) },
 133     { UPROPS_SRC_CASE,  0 },                                    /* UCHAR_CASE_SENSITIVE */
 134     {  1,               U_MASK(UPROPS_S_TERM) },
 135     {  1,               U_MASK(UPROPS_VARIATION_SELECTOR) },
 136     { UPROPS_SRC_NORM,  0 },                                    /* UCHAR_NFD_INERT */
 137     { UPROPS_SRC_NORM,  0 },                                    /* UCHAR_NFKD_INERT */
 138     { UPROPS_SRC_NORM,  0 },                                    /* UCHAR_NFC_INERT */
 139     { UPROPS_SRC_NORM,  0 },                                    /* UCHAR_NFKC_INERT */
 140     { UPROPS_SRC_NORM,  0 },                                    /* UCHAR_SEGMENT_STARTER */
 141     {  1,               U_MASK(UPROPS_PATTERN_SYNTAX) },
 142     {  1,               U_MASK(UPROPS_PATTERN_WHITE_SPACE) },
 143     { UPROPS_SRC_CHAR_AND_PROPSVEC,  0 },                       /* UCHAR_POSIX_ALNUM */
 144     { UPROPS_SRC_CHAR,  0 },                                    /* UCHAR_POSIX_BLANK */
 145     { UPROPS_SRC_CHAR,  0 },                                    /* UCHAR_POSIX_GRAPH */
 146     { UPROPS_SRC_CHAR,  0 },                                    /* UCHAR_POSIX_PRINT */
 147     { UPROPS_SRC_CHAR,  0 }                                     /* UCHAR_POSIX_XDIGIT */
 148 };
 149
 150 U_CAPI UBool U_EXPORT2
 151 u_hasBinaryProperty(UChar32 c, UProperty which) {
 152     /* c is range-checked in the functions that are called from here */
 153     if(which<UCHAR_BINARY_START || UCHAR_BINARY_LIMIT<=which) {
 154         /* not a known binary property */
 155     } else {
 156         uint32_t mask=binProps[which].mask;
 157         int32_t column=binProps[which].column;
 158         if(mask!=0) {
 159             /* systematic, directly stored properties */
 160             return (u_getUnicodeProperties(c, column)&mask)!=0;
 161         } else {
 162             if(column==UPROPS_SRC_CASE) {
 163                 return ucase_hasBinaryProperty(c, which);
 164             } else if(column==UPROPS_SRC_NORM) {
 165 #if !UCONFIG_NO_NORMALIZATION
 166                 /* normalization properties from unorm.icu */
 167                 switch(which) {
 168                 case UCHAR_FULL_COMPOSITION_EXCLUSION:
 169                     return unorm_internalIsFullCompositionExclusion(c);
 170                 case UCHAR_NFD_INERT:
 171                 case UCHAR_NFKD_INERT:
 172                 case UCHAR_NFC_INERT:
 173                 case UCHAR_NFKC_INERT:
 174                     return unorm_isNFSkippable(c, (UNormalizationMode)(which-UCHAR_NFD_INERT+UNORM_NFD));
 175                 case UCHAR_SEGMENT_STARTER:
 176                     return unorm_isCanonSafeStart(c);
 177                 default:
 178                     break;
 179                 }
 180 #endif
 181             } else if(column==UPROPS_SRC_BIDI) {
 182                 /* bidi/shaping properties */
 183                 const UBiDiProps *bdp=GET_BIDI_PROPS();
 184                 if(bdp!=NULL) {
 185                     switch(which) {
 186                     case UCHAR_BIDI_MIRRORED:
 187                         return ubidi_isMirrored(bdp, c);
 188                     case UCHAR_BIDI_CONTROL:
 189                         return ubidi_isBidiControl(bdp, c);
 190                     case UCHAR_JOIN_CONTROL:
 191                         return ubidi_isJoinControl(bdp, c);
 192                     default:
 193                         break;
 194                     }
 195                 }
 196                 /* else return FALSE below */
 197             } else if(column==UPROPS_SRC_CHAR) {
 198                 switch(which) {
 199                 case UCHAR_POSIX_BLANK:
 200                     return u_isblank(c);
 201                 case UCHAR_POSIX_GRAPH:
 202                     return u_isgraphPOSIX(c);
 203                 case UCHAR_POSIX_PRINT:
 204                     return u_isprintPOSIX(c);
 205                 case UCHAR_POSIX_XDIGIT:
 206                     return u_isxdigit(c);
 207                 default:
 208                     break;
 209                 }
 210             } else if(column==UPROPS_SRC_CHAR_AND_PROPSVEC) {
 211                 switch(which) {
 212                 case UCHAR_POSIX_ALNUM:
 213                     return u_isalnumPOSIX(c);
 214                 default:
 215                     break;
 216                 }
 217             }
 218         }
 219     }
 220     return FALSE;
 221 }
 222
 223 U_CAPI int32_t U_EXPORT2
 224 u_getIntPropertyValue(UChar32 c, UProperty which) {
 225     UErrorCode errorCode;
 226     int32_t type;
 227
 228     if(which<UCHAR_BINARY_START) {
 229         return 0; /* undefined */
 230     } else if(which<UCHAR_BINARY_LIMIT) {
 231         return (int32_t)u_hasBinaryProperty(c, which);
 232     } else if(which<UCHAR_INT_START) {
 233         return 0; /* undefined */
 234     } else if(which<UCHAR_INT_LIMIT) {
 235         switch(which) {
 236         case UCHAR_BIDI_CLASS:
 237             return (int32_t)u_charDirection(c);
 238         case UCHAR_BLOCK:
 239             return (int32_t)ublock_getCode(c);
 240         case UCHAR_CANONICAL_COMBINING_CLASS:
 241 #if !UCONFIG_NO_NORMALIZATION
 242             return u_getCombiningClass(c);
 243 #else
 244             return 0;
 245 #endif
 246         case UCHAR_DECOMPOSITION_TYPE:
 247             return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_DT_MASK);
 248         case UCHAR_EAST_ASIAN_WIDTH:
 249             return (int32_t)(u_getUnicodeProperties(c, 0)&UPROPS_EA_MASK)>>UPROPS_EA_SHIFT;
 250         case UCHAR_GENERAL_CATEGORY:
 251             return (int32_t)u_charType(c);
 252         case UCHAR_JOINING_GROUP:
 253             return ubidi_getJoiningGroup(GET_BIDI_PROPS(), c);
 254         case UCHAR_JOINING_TYPE:
 255             return ubidi_getJoiningType(GET_BIDI_PROPS(), c);
 256         case UCHAR_LINE_BREAK:
 257             return (int32_t)(u_getUnicodeProperties(c, UPROPS_LB_VWORD)&UPROPS_LB_MASK)>>UPROPS_LB_SHIFT;
 258         case UCHAR_NUMERIC_TYPE:
 259             type=(int32_t)GET_NUMERIC_TYPE(u_getUnicodeProperties(c, -1));
 260             if(type>U_NT_NUMERIC) {
 261                 /* keep internal variants of U_NT_NUMERIC from becoming visible */
 262                 type=U_NT_NUMERIC;
 263             }
 264             return type;
 265         case UCHAR_SCRIPT:
 266             errorCode=U_ZERO_ERROR;
 267             return (int32_t)uscript_getScript(c, &errorCode);
 268         case UCHAR_HANGUL_SYLLABLE_TYPE:
 269             return uchar_getHST(c);
 270 #if !UCONFIG_NO_NORMALIZATION
 271         case UCHAR_NFD_QUICK_CHECK:
 272         case UCHAR_NFKD_QUICK_CHECK:
 273         case UCHAR_NFC_QUICK_CHECK:
 274         case UCHAR_NFKC_QUICK_CHECK:
 275             return (int32_t)unorm_getQuickCheck(c, (UNormalizationMode)(which-UCHAR_NFD_QUICK_CHECK+UNORM_NFD));
 276         case UCHAR_LEAD_CANONICAL_COMBINING_CLASS:
 277             return unorm_getFCD16FromCodePoint(c)>>8;
 278         case UCHAR_TRAIL_CANONICAL_COMBINING_CLASS:
 279             return unorm_getFCD16FromCodePoint(c)&0xff;
 280 #endif
 281         case UCHAR_GRAPHEME_CLUSTER_BREAK:
 282             return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT;
 283         case UCHAR_SENTENCE_BREAK:
 284             return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_SB_MASK)>>UPROPS_SB_SHIFT;
 285         case UCHAR_WORD_BREAK:
 286             return (int32_t)(u_getUnicodeProperties(c, 2)&UPROPS_WB_MASK)>>UPROPS_WB_SHIFT;
 287         default:
 288             return 0; /* undefined */
 289         }
 290     } else if(which==UCHAR_GENERAL_CATEGORY_MASK) {
 291         return U_MASK(u_charType(c));
 292     } else {
 293         return 0; /* undefined */
 294     }
 295 }
 296
 297 U_CAPI int32_t U_EXPORT2
 298 u_getIntPropertyMinValue(UProperty which) {
 299     return 0; /* all binary/enum/int properties have a minimum value of 0 */
 300 }
 301
 302 U_CAPI int32_t U_EXPORT2
 303 u_getIntPropertyMaxValue(UProperty which) {
 304     if(which<UCHAR_BINARY_START) {
 305         return -1; /* undefined */
 306     } else if(which<UCHAR_BINARY_LIMIT) {
 307         return 1; /* maximum TRUE for all binary properties */
 308     } else if(which<UCHAR_INT_START) {
 309         return -1; /* undefined */
 310     } else if(which<UCHAR_INT_LIMIT) {
 311         switch(which) {
 312         case UCHAR_BIDI_CLASS:
 313         case UCHAR_JOINING_GROUP:
 314         case UCHAR_JOINING_TYPE:
 315             return ubidi_getMaxValue(GET_BIDI_PROPS(), which);
 316         case UCHAR_BLOCK:
 317             return (uprv_getMaxValues(0)&UPROPS_BLOCK_MASK)>>UPROPS_BLOCK_SHIFT;
 318         case UCHAR_CANONICAL_COMBINING_CLASS:
 319         case UCHAR_LEAD_CANONICAL_COMBINING_CLASS:
 320         case UCHAR_TRAIL_CANONICAL_COMBINING_CLASS:
 321             return 0xff; /* TODO do we need to be more precise, getting the actual maximum? */
 322         case UCHAR_DECOMPOSITION_TYPE:
 323             return uprv_getMaxValues(2)&UPROPS_DT_MASK;
 324         case UCHAR_EAST_ASIAN_WIDTH:
 325             return (uprv_getMaxValues(0)&UPROPS_EA_MASK)>>UPROPS_EA_SHIFT;
 326         case UCHAR_GENERAL_CATEGORY:
 327             return (int32_t)U_CHAR_CATEGORY_COUNT-1;
 328         case UCHAR_LINE_BREAK:
 329             return (uprv_getMaxValues(UPROPS_LB_VWORD)&UPROPS_LB_MASK)>>UPROPS_LB_SHIFT;
 330         case UCHAR_NUMERIC_TYPE:
 331             return (int32_t)U_NT_COUNT-1;
 332         case UCHAR_SCRIPT:
 333             return uprv_getMaxValues(0)&UPROPS_SCRIPT_MASK;
 334         case UCHAR_HANGUL_SYLLABLE_TYPE:
 335             return (int32_t)U_HST_COUNT-1;
 336 #if !UCONFIG_NO_NORMALIZATION
 337         case UCHAR_NFD_QUICK_CHECK:
 338         case UCHAR_NFKD_QUICK_CHECK:
 339             return (int32_t)UNORM_YES; /* these are never "maybe", only "no" or "yes" */
 340         case UCHAR_NFC_QUICK_CHECK:
 341         case UCHAR_NFKC_QUICK_CHECK:
 342             return (int32_t)UNORM_MAYBE;
 343 #endif
 344         case UCHAR_GRAPHEME_CLUSTER_BREAK:
 345             return (uprv_getMaxValues(2)&UPROPS_GCB_MASK)>>UPROPS_GCB_SHIFT;
 346         case UCHAR_SENTENCE_BREAK:
 347             return (uprv_getMaxValues(2)&UPROPS_SB_MASK)>>UPROPS_SB_SHIFT;
 348         case UCHAR_WORD_BREAK:
 349             return (uprv_getMaxValues(2)&UPROPS_WB_MASK)>>UPROPS_WB_SHIFT;
 350         default:
 351             return -1; /* undefined */
 352         }
 353     } else {
 354         return -1; /* undefined */
 355     }
 356 }
 357
 358 U_CFUNC UPropertySource U_EXPORT2
 359 uprops_getSource(UProperty which) {
 360     if(which<UCHAR_BINARY_START) {
 361         return UPROPS_SRC_NONE; /* undefined */
 362     } else if(which<UCHAR_BINARY_LIMIT) {
 363         if(binProps[which].mask!=0) {
 364             return UPROPS_SRC_PROPSVEC;
 365         } else {
 366             return (UPropertySource)binProps[which].column;
 367         }
 368     } else if(which<UCHAR_INT_START) {
 369         return UPROPS_SRC_NONE; /* undefined */
 370     } else if(which<UCHAR_INT_LIMIT) {
 371         switch(which) {
 372         case UCHAR_GENERAL_CATEGORY:
 373         case UCHAR_NUMERIC_TYPE:
 374             return UPROPS_SRC_CHAR;
 375
 376         case UCHAR_HANGUL_SYLLABLE_TYPE:
 377             return UPROPS_SRC_HST;
 378
 379         case UCHAR_CANONICAL_COMBINING_CLASS:
 380         case UCHAR_NFD_QUICK_CHECK:
 381         case UCHAR_NFKD_QUICK_CHECK:
 382         case UCHAR_NFC_QUICK_CHECK:
 383         case UCHAR_NFKC_QUICK_CHECK:
 384         case UCHAR_LEAD_CANONICAL_COMBINING_CLASS:
 385         case UCHAR_TRAIL_CANONICAL_COMBINING_CLASS:
 386             return UPROPS_SRC_NORM;
 387
 388         case UCHAR_BIDI_CLASS:
 389         case UCHAR_JOINING_GROUP:
 390         case UCHAR_JOINING_TYPE:
 391             return UPROPS_SRC_BIDI;
 392
 393         default:
 394             return UPROPS_SRC_PROPSVEC;
 395         }
 396     } else if(which<UCHAR_STRING_START) {
 397         switch(which) {
 398         case UCHAR_GENERAL_CATEGORY_MASK:
 399         case UCHAR_NUMERIC_VALUE:
 400             return UPROPS_SRC_CHAR;
 401
 402         default:
 403             return UPROPS_SRC_NONE;
 404         }
 405     } else if(which<UCHAR_STRING_LIMIT) {
 406         switch(which) {
 407         case UCHAR_AGE:
 408             return UPROPS_SRC_PROPSVEC;
 409
 410         case UCHAR_BIDI_MIRRORING_GLYPH:
 411             return UPROPS_SRC_BIDI;
 412
 413         case UCHAR_CASE_FOLDING:
 414         case UCHAR_LOWERCASE_MAPPING:
 415         case UCHAR_SIMPLE_CASE_FOLDING:
 416         case UCHAR_SIMPLE_LOWERCASE_MAPPING:
 417         case UCHAR_SIMPLE_TITLECASE_MAPPING:
 418         case UCHAR_SIMPLE_UPPERCASE_MAPPING:
 419         case UCHAR_TITLECASE_MAPPING:
 420         case UCHAR_UPPERCASE_MAPPING:
 421             return UPROPS_SRC_CASE;
 422
 423         case UCHAR_ISO_COMMENT:
 424         case UCHAR_NAME:
 425         case UCHAR_UNICODE_1_NAME:
 426             return UPROPS_SRC_NAMES;
 427
 428         default:
 429             return UPROPS_SRC_NONE;
 430         }
 431     } else {
 432         return UPROPS_SRC_NONE; /* undefined */
 433     }
 434 }
 435
 436 /*----------------------------------------------------------------
 437  * Inclusions list
 438  *----------------------------------------------------------------*/
 439
 440 /*
 441  * Return a set of characters for property enumeration.
 442  * The set implicitly contains 0x110000 as well, which is one more than the highest
 443  * Unicode code point.
 444  *
 445  * This set is used as an ordered list - its code points are ordered, and
 446  * consecutive code points (in Unicode code point order) in the set define a range.
 447  * For each two consecutive characters (start, limit) in the set,
 448  * all of the UCD/normalization and related properties for
 449  * all code points start..limit-1 are all the same,
 450  * except for character names and ISO comments.
 451  *
 452  * All Unicode code points U+0000..U+10ffff are covered by these ranges.
 453  * The ranges define a partition of the Unicode code space.
 454  * ICU uses the inclusions set to enumerate properties for generating
 455  * UnicodeSets containing all code points that have a certain property value.
 456  *
 457  * The Inclusion List is generated from the UCD. It is generated
 458  * by enumerating the data tries, and code points for hardcoded properties
 459  * are added as well.
 460  *
 461  * --------------------------------------------------------------------------
 462  *
 463  * The following are ideas for getting properties-unique code point ranges,
 464  * with possible optimizations beyond the current implementation.
 465  * These optimizations would require more code and be more fragile.
 466  * The current implementation generates one single list (set) for all properties.
 467  *
 468  * To enumerate properties efficiently, one needs to know ranges of
 469  * repetitive values, so that the value of only each start code point
 470  * can be applied to the whole range.
 471  * This information is in principle available in the uprops.icu/unorm.icu data.
 472  *
 473  * There are two obstacles:
 474  *
 475  * 1. Some properties are computed from multiple data structures,
 476  *    making it necessary to get repetitive ranges by intersecting
 477  *    ranges from multiple tries.
 478  *
 479  * 2. It is not economical to write code for getting repetitive ranges
 480  *    that are precise for each of some 50 properties.
 481  *
 482  * Compromise ideas:
 483  *
 484  * - Get ranges per trie, not per individual property.
 485  *   Each range contains the same values for a whole group of properties.
 486  *   This would generate currently five range sets, two for uprops.icu tries
 487  *   and three for unorm.icu tries.
 488  *
 489  * - Combine sets of ranges for multiple tries to get sufficient sets
 490  *   for properties, e.g., the uprops.icu main and auxiliary tries
 491  *   for all non-normalization properties.
 492  *
 493  * Ideas for representing ranges and combining them:
 494  *
 495  * - A UnicodeSet could hold just the start code points of ranges.
 496  *   Multiple sets are easily combined by or-ing them together.
 497  *
 498  * - Alternatively, a UnicodeSet could hold each even-numbered range.
 499  *   All ranges could be enumerated by using each start code point
 500  *   (for the even-numbered ranges) as well as each limit (end+1) code point
 501  *   (for the odd-numbered ranges).
 502  *   It should be possible to combine two such sets by xor-ing them,
 503  *   but no more than two.
 504  *
 505  * The second way to represent ranges may(?!) yield smaller UnicodeSet arrays,
 506  * but the first one is certainly simpler and applicable for combining more than
 507  * two range sets.
 508  *
 509  * It is possible to combine all range sets for all uprops/unorm tries into one
 510  * set that can be used for all properties.
 511  * As an optimization, there could be less-combined range sets for certain
 512  * groups of properties.
 513  * The relationship of which less-combined range set to use for which property
 514  * depends on the implementation of the properties and must be hardcoded
 515  * - somewhat error-prone and higher maintenance but can be tested easily
 516  * by building property sets "the simple way" in test code.
 517  *
 518  * ---
 519  *
 520  * Do not use a UnicodeSet pattern because that causes infinite recursion;
 521  * UnicodeSet depends on the inclusions set.
 522  *
 523  * ---
 524  *
 525  * uprv_getInclusions() is commented out starting 2004-sep-13 because
 526  * uniset_props.cpp now calls the uxyz_addPropertyStarts() directly,
 527  * and only for the relevant property source.
 528  */
 529 #if 0
 530
 531 U_CAPI void U_EXPORT2
 532 uprv_getInclusions(const USetAdder *sa, UErrorCode *pErrorCode) {
 533     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
 534         return;
 535     }
 536
 537 #if !UCONFIG_NO_NORMALIZATION
 538     unorm_addPropertyStarts(sa, pErrorCode);
 539 #endif
 540     uchar_addPropertyStarts(sa, pErrorCode);
 541     uhst_addPropertyStarts(sa, pErrorCode);
 542     ucase_addPropertyStarts(ucase_getSingleton(pErrorCode), sa, pErrorCode);
 543     ubidi_addPropertyStarts(ubidi_getSingleton(pErrorCode), sa, pErrorCode);
 544 }
 545
 546 #endif