util/X86MAC64/include/unicode/ucptrie.h

   1 // © 2017 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3
   4 // ucptrie.h (modified from utrie2.h)
   5 // created: 2017dec29 Markus W. Scherer
   6
   7 #ifndef __UCPTRIE_H__
   8 #define __UCPTRIE_H__
   9
  10 #include "unicode/utypes.h"
  11 #include "unicode/ucpmap.h"
  12 #include "unicode/utf8.h"
  13
  14 #if U_SHOW_CPLUSPLUS_API
  15 #include "unicode/localpointer.h"
  16 #endif   // U_SHOW_CPLUSPLUS_API
  17
  18 U_CDECL_BEGIN
  19
  20 /**
  21  * \file
  22  *
  23  * This file defines an immutable Unicode code point trie.
  24  *
  25  * @see UCPTrie
  26  * @see UMutableCPTrie
  27  */
  28
  29 #ifndef U_IN_DOXYGEN
  30 /** @internal */
  31 typedef union UCPTrieData {
  32     /** @internal */
  33     const void *ptr0;
  34     /** @internal */
  35     const uint16_t *ptr16;
  36     /** @internal */
  37     const uint32_t *ptr32;
  38     /** @internal */
  39     const uint8_t *ptr8;
  40 } UCPTrieData;
  41 #endif
  42
  43 /**
  44  * Immutable Unicode code point trie structure.
  45  * Fast, reasonably compact, map from Unicode code points (U+0000..U+10FFFF) to integer values.
  46  * For details see https://icu.unicode.org/design/struct/utrie
  47  *
  48  * Do not access UCPTrie fields directly; use public functions and macros.
  49  * Functions are easy to use: They support all trie types and value widths.
  50  *
  51  * When performance is really important, macros provide faster access.
  52  * Most macros are specific to either "fast" or "small" tries, see UCPTrieType.
  53  * There are "fast" macros for special optimized use cases.
  54  *
  55  * The macros will return bogus values, or may crash, if used on the wrong type or value width.
  56  *
  57  * @see UMutableCPTrie
  58  * @stable ICU 63
  59  */
  60 struct UCPTrie {
  61 #ifndef U_IN_DOXYGEN
  62     /** @internal */
  63     const uint16_t *index;
  64     /** @internal */
  65     UCPTrieData data;
  66
  67     /** @internal */
  68     int32_t indexLength;
  69     /** @internal */
  70     int32_t dataLength;
  71     /** Start of the last range which ends at U+10FFFF. @internal */
  72     UChar32 highStart;
  73     /** highStart>>12 @internal */
  74     uint16_t shifted12HighStart;
  75
  76     /** @internal */
  77     int8_t type;  // UCPTrieType
  78     /** @internal */
  79     int8_t valueWidth;  // UCPTrieValueWidth
  80
  81     /** padding/reserved @internal */
  82     uint32_t reserved32;
  83     /** padding/reserved @internal */
  84     uint16_t reserved16;
  85
  86     /**
  87      * Internal index-3 null block offset.
  88      * Set to an impossibly high value (e.g., 0xffff) if there is no dedicated index-3 null block.
  89      * @internal
  90      */
  91     uint16_t index3NullOffset;
  92     /**
  93      * Internal data null block offset, not shifted.
  94      * Set to an impossibly high value (e.g., 0xfffff) if there is no dedicated data null block.
  95      * @internal
  96      */
  97     int32_t dataNullOffset;
  98     /** @internal */
  99     uint32_t nullValue;
 100
 101 #ifdef UCPTRIE_DEBUG
 102     /** @internal */
 103     const char *name;
 104 #endif
 105 #endif
 106 };
 107 #ifndef U_IN_DOXYGEN
 108 typedef struct UCPTrie UCPTrie;
 109 #endif
 110
 111 /**
 112  * Selectors for the type of a UCPTrie.
 113  * Different trade-offs for size vs. speed.
 114  *
 115  * @see umutablecptrie_buildImmutable
 116  * @see ucptrie_openFromBinary
 117  * @see ucptrie_getType
 118  * @stable ICU 63
 119  */
 120 enum UCPTrieType {
 121     /**
 122      * For ucptrie_openFromBinary() to accept any type.
 123      * ucptrie_getType() will return the actual type.
 124      * @stable ICU 63
 125      */
 126     UCPTRIE_TYPE_ANY = -1,
 127     /**
 128      * Fast/simple/larger BMP data structure. Use functions and "fast" macros.
 129      * @stable ICU 63
 130      */
 131     UCPTRIE_TYPE_FAST,
 132     /**
 133      * Small/slower BMP data structure. Use functions and "small" macros.
 134      * @stable ICU 63
 135      */
 136     UCPTRIE_TYPE_SMALL
 137 };
 138 #ifndef U_IN_DOXYGEN
 139 typedef enum UCPTrieType UCPTrieType;
 140 #endif
 141
 142 /**
 143  * Selectors for the number of bits in a UCPTrie data value.
 144  *
 145  * @see umutablecptrie_buildImmutable
 146  * @see ucptrie_openFromBinary
 147  * @see ucptrie_getValueWidth
 148  * @stable ICU 63
 149  */
 150 enum UCPTrieValueWidth {
 151     /**
 152      * For ucptrie_openFromBinary() to accept any data value width.
 153      * ucptrie_getValueWidth() will return the actual data value width.
 154      * @stable ICU 63
 155      */
 156     UCPTRIE_VALUE_BITS_ANY = -1,
 157     /**
 158      * The trie stores 16 bits per data value.
 159      * It returns them as unsigned values 0..0xffff=65535.
 160      * @stable ICU 63
 161      */
 162     UCPTRIE_VALUE_BITS_16,
 163     /**
 164      * The trie stores 32 bits per data value.
 165      * @stable ICU 63
 166      */
 167     UCPTRIE_VALUE_BITS_32,
 168     /**
 169      * The trie stores 8 bits per data value.
 170      * It returns them as unsigned values 0..0xff=255.
 171      * @stable ICU 63
 172      */
 173     UCPTRIE_VALUE_BITS_8
 174 };
 175 #ifndef U_IN_DOXYGEN
 176 typedef enum UCPTrieValueWidth UCPTrieValueWidth;
 177 #endif
 178
 179 /**
 180  * Opens a trie from its binary form, stored in 32-bit-aligned memory.
 181  * Inverse of ucptrie_toBinary().
 182  *
 183  * The memory must remain valid and unchanged as long as the trie is used.
 184  * You must ucptrie_close() the trie once you are done using it.
 185  *
 186  * @param type selects the trie type; results in an
 187  *             U_INVALID_FORMAT_ERROR if it does not match the binary data;
 188  *             use UCPTRIE_TYPE_ANY to accept any type
 189  * @param valueWidth selects the number of bits in a data value; results in an
 190  *                  U_INVALID_FORMAT_ERROR if it does not match the binary data;
 191  *                  use UCPTRIE_VALUE_BITS_ANY to accept any data value width
 192  * @param data a pointer to 32-bit-aligned memory containing the binary data of a UCPTrie
 193  * @param length the number of bytes available at data;
 194  *               can be more than necessary
 195  * @param pActualLength receives the actual number of bytes at data taken up by the trie data;
 196  *                      can be NULL
 197  * @param pErrorCode an in/out ICU UErrorCode
 198  * @return the trie
 199  *
 200  * @see umutablecptrie_open
 201  * @see umutablecptrie_buildImmutable
 202  * @see ucptrie_toBinary
 203  * @stable ICU 63
 204  */
 205 U_CAPI UCPTrie * U_EXPORT2
 206 ucptrie_openFromBinary(UCPTrieType type, UCPTrieValueWidth valueWidth,
 207                        const void *data, int32_t length, int32_t *pActualLength,
 208                        UErrorCode *pErrorCode);
 209
 210 /**
 211  * Closes a trie and releases associated memory.
 212  *
 213  * @param trie the trie
 214  * @stable ICU 63
 215  */
 216 U_CAPI void U_EXPORT2
 217 ucptrie_close(UCPTrie *trie);
 218
 219 /**
 220  * Returns the trie type.
 221  *
 222  * @param trie the trie
 223  * @return the trie type
 224  * @see ucptrie_openFromBinary
 225  * @see UCPTRIE_TYPE_ANY
 226  * @stable ICU 63
 227  */
 228 U_CAPI UCPTrieType U_EXPORT2
 229 ucptrie_getType(const UCPTrie *trie);
 230
 231 /**
 232  * Returns the number of bits in a trie data value.
 233  *
 234  * @param trie the trie
 235  * @return the number of bits in a trie data value
 236  * @see ucptrie_openFromBinary
 237  * @see UCPTRIE_VALUE_BITS_ANY
 238  * @stable ICU 63
 239  */
 240 U_CAPI UCPTrieValueWidth U_EXPORT2
 241 ucptrie_getValueWidth(const UCPTrie *trie);
 242
 243 /**
 244  * Returns the value for a code point as stored in the trie, with range checking.
 245  * Returns the trie error value if c is not in the range 0..U+10FFFF.
 246  *
 247  * Easier to use than UCPTRIE_FAST_GET() and similar macros but slower.
 248  * Easier to use because, unlike the macros, this function works on all UCPTrie
 249  * objects, for all types and value widths.
 250  *
 251  * @param trie the trie
 252  * @param c the code point
 253  * @return the trie value,
 254  *         or the trie error value if the code point is not in the range 0..U+10FFFF
 255  * @stable ICU 63
 256  */
 257 U_CAPI uint32_t U_EXPORT2
 258 ucptrie_get(const UCPTrie *trie, UChar32 c);
 259
 260 /**
 261  * Returns the last code point such that all those from start to there have the same value.
 262  * Can be used to efficiently iterate over all same-value ranges in a trie.
 263  * (This is normally faster than iterating over code points and get()ting each value,
 264  * but much slower than a data structure that stores ranges directly.)
 265  *
 266  * If the UCPMapValueFilter function pointer is not NULL, then
 267  * the value to be delivered is passed through that function, and the return value is the end
 268  * of the range where all values are modified to the same actual value.
 269  * The value is unchanged if that function pointer is NULL.
 270  *
 271  * Example:
 272  * \code
 273  * UChar32 start = 0, end;
 274  * uint32_t value;
 275  * while ((end = ucptrie_getRange(trie, start, UCPMAP_RANGE_NORMAL, 0,
 276  *                                NULL, NULL, &value)) >= 0) {
 277  *     // Work with the range start..end and its value.
 278  *     start = end + 1;
 279  * }
 280  * \endcode
 281  *
 282  * @param trie the trie
 283  * @param start range start
 284  * @param option defines whether surrogates are treated normally,
 285  *               or as having the surrogateValue; usually UCPMAP_RANGE_NORMAL
 286  * @param surrogateValue value for surrogates; ignored if option==UCPMAP_RANGE_NORMAL
 287  * @param filter a pointer to a function that may modify the trie data value,
 288  *     or NULL if the values from the trie are to be used unmodified
 289  * @param context an opaque pointer that is passed on to the filter function
 290  * @param pValue if not NULL, receives the value that every code point start..end has;
 291  *     may have been modified by filter(context, trie value)
 292  *     if that function pointer is not NULL
 293  * @return the range end code point, or -1 if start is not a valid code point
 294  * @stable ICU 63
 295  */
 296 U_CAPI UChar32 U_EXPORT2
 297 ucptrie_getRange(const UCPTrie *trie, UChar32 start,
 298                  UCPMapRangeOption option, uint32_t surrogateValue,
 299                  UCPMapValueFilter *filter, const void *context, uint32_t *pValue);
 300
 301 /**
 302  * Writes a memory-mappable form of the trie into 32-bit aligned memory.
 303  * Inverse of ucptrie_openFromBinary().
 304  *
 305  * @param trie the trie
 306  * @param data a pointer to 32-bit-aligned memory to be filled with the trie data;
 307  *             can be NULL if capacity==0
 308  * @param capacity the number of bytes available at data, or 0 for pure preflighting
 309  * @param pErrorCode an in/out ICU UErrorCode;
 310  *                   U_BUFFER_OVERFLOW_ERROR if the capacity is too small
 311  * @return the number of bytes written or (if buffer overflow) needed for the trie
 312  *
 313  * @see ucptrie_openFromBinary()
 314  * @stable ICU 63
 315  */
 316 U_CAPI int32_t U_EXPORT2
 317 ucptrie_toBinary(const UCPTrie *trie, void *data, int32_t capacity, UErrorCode *pErrorCode);
 318
 319 /**
 320  * Macro parameter value for a trie with 16-bit data values.
 321  * Use the name of this macro as a "dataAccess" parameter in other macros.
 322  * Do not use this macro in any other way.
 323  *
 324  * @see UCPTRIE_VALUE_BITS_16
 325  * @stable ICU 63
 326  */
 327 #define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i])
 328
 329 /**
 330  * Macro parameter value for a trie with 32-bit data values.
 331  * Use the name of this macro as a "dataAccess" parameter in other macros.
 332  * Do not use this macro in any other way.
 333  *
 334  * @see UCPTRIE_VALUE_BITS_32
 335  * @stable ICU 63
 336  */
 337 #define UCPTRIE_32(trie, i) ((trie)->data.ptr32[i])
 338
 339 /**
 340  * Macro parameter value for a trie with 8-bit data values.
 341  * Use the name of this macro as a "dataAccess" parameter in other macros.
 342  * Do not use this macro in any other way.
 343  *
 344  * @see UCPTRIE_VALUE_BITS_8
 345  * @stable ICU 63
 346  */
 347 #define UCPTRIE_8(trie, i) ((trie)->data.ptr8[i])
 348
 349 /**
 350  * Returns a trie value for a code point, with range checking.
 351  * Returns the trie error value if c is not in the range 0..U+10FFFF.
 352  *
 353  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_FAST
 354  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 355  * @param c (UChar32, in) the input code point
 356  * @return The code point's trie value.
 357  * @stable ICU 63
 358  */
 359 #define UCPTRIE_FAST_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_CP_INDEX(trie, 0xffff, c))
 360
 361 /**
 362  * Returns a 16-bit trie value for a code point, with range checking.
 363  * Returns the trie error value if c is not in the range U+0000..U+10FFFF.
 364  *
 365  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_SMALL
 366  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 367  * @param c (UChar32, in) the input code point
 368  * @return The code point's trie value.
 369  * @stable ICU 63
 370  */
 371 #define UCPTRIE_SMALL_GET(trie, dataAccess, c) \
 372     dataAccess(trie, _UCPTRIE_CP_INDEX(trie, UCPTRIE_SMALL_MAX, c))
 373
 374 /**
 375  * UTF-16: Reads the next code point (UChar32 c, out), post-increments src,
 376  * and gets a value from the trie.
 377  * Sets the trie error value if c is an unpaired surrogate.
 378  *
 379  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_FAST
 380  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 381  * @param src (const UChar *, in/out) the source text pointer
 382  * @param limit (const UChar *, in) the limit pointer for the text, or NULL if NUL-terminated
 383  * @param c (UChar32, out) variable for the code point
 384  * @param result (out) variable for the trie lookup result
 385  * @stable ICU 63
 386  */
 387 #define UCPTRIE_FAST_U16_NEXT(trie, dataAccess, src, limit, c, result) UPRV_BLOCK_MACRO_BEGIN { \
 388     (c) = *(src)++; \
 389     int32_t __index; \
 390     if (!U16_IS_SURROGATE(c)) { \
 391         __index = _UCPTRIE_FAST_INDEX(trie, c); \
 392     } else { \
 393         uint16_t __c2; \
 394         if (U16_IS_SURROGATE_LEAD(c) && (src) != (limit) && U16_IS_TRAIL(__c2 = *(src))) { \
 395             ++(src); \
 396             (c) = U16_GET_SUPPLEMENTARY((c), __c2); \
 397             __index = _UCPTRIE_SMALL_INDEX(trie, c); \
 398         } else { \
 399             __index = (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET; \
 400         } \
 401     } \
 402     (result) = dataAccess(trie, __index); \
 403 } UPRV_BLOCK_MACRO_END
 404
 405 /**
 406  * UTF-16: Reads the previous code point (UChar32 c, out), pre-decrements src,
 407  * and gets a value from the trie.
 408  * Sets the trie error value if c is an unpaired surrogate.
 409  *
 410  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_FAST
 411  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 412  * @param start (const UChar *, in) the start pointer for the text
 413  * @param src (const UChar *, in/out) the source text pointer
 414  * @param c (UChar32, out) variable for the code point
 415  * @param result (out) variable for the trie lookup result
 416  * @stable ICU 63
 417  */
 418 #define UCPTRIE_FAST_U16_PREV(trie, dataAccess, start, src, c, result) UPRV_BLOCK_MACRO_BEGIN { \
 419     (c) = *--(src); \
 420     int32_t __index; \
 421     if (!U16_IS_SURROGATE(c)) { \
 422         __index = _UCPTRIE_FAST_INDEX(trie, c); \
 423     } else { \
 424         uint16_t __c2; \
 425         if (U16_IS_SURROGATE_TRAIL(c) && (src) != (start) && U16_IS_LEAD(__c2 = *((src) - 1))) { \
 426             --(src); \
 427             (c) = U16_GET_SUPPLEMENTARY(__c2, (c)); \
 428             __index = _UCPTRIE_SMALL_INDEX(trie, c); \
 429         } else { \
 430             __index = (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET; \
 431         } \
 432     } \
 433     (result) = dataAccess(trie, __index); \
 434 } UPRV_BLOCK_MACRO_END
 435
 436 /**
 437  * UTF-8: Post-increments src and gets a value from the trie.
 438  * Sets the trie error value for an ill-formed byte sequence.
 439  *
 440  * Unlike UCPTRIE_FAST_U16_NEXT() this UTF-8 macro does not provide the code point
 441  * because it would be more work to do so and is often not needed.
 442  * If the trie value differs from the error value, then the byte sequence is well-formed,
 443  * and the code point can be assembled without revalidation.
 444  *
 445  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_FAST
 446  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 447  * @param src (const char *, in/out) the source text pointer
 448  * @param limit (const char *, in) the limit pointer for the text (must not be NULL)
 449  * @param result (out) variable for the trie lookup result
 450  * @stable ICU 63
 451  */
 452 #define UCPTRIE_FAST_U8_NEXT(trie, dataAccess, src, limit, result) UPRV_BLOCK_MACRO_BEGIN { \
 453     int32_t __lead = (uint8_t)*(src)++; \
 454     if (!U8_IS_SINGLE(__lead)) { \
 455         uint8_t __t1, __t2, __t3; \
 456         if ((src) != (limit) && \
 457             (__lead >= 0xe0 ? \
 458                 __lead < 0xf0 ?  /* U+0800..U+FFFF except surrogates */ \
 459                     U8_LEAD3_T1_BITS[__lead &= 0xf] & (1 << ((__t1 = *(src)) >> 5)) && \
 460                     ++(src) != (limit) && (__t2 = *(src) - 0x80) <= 0x3f && \
 461                     (__lead = ((int32_t)(trie)->index[(__lead << 6) + (__t1 & 0x3f)]) + __t2, 1) \
 462                 :  /* U+10000..U+10FFFF */ \
 463                     (__lead -= 0xf0) <= 4 && \
 464                     U8_LEAD4_T1_BITS[(__t1 = *(src)) >> 4] & (1 << __lead) && \
 465                     (__lead = (__lead << 6) | (__t1 & 0x3f), ++(src) != (limit)) && \
 466                     (__t2 = *(src) - 0x80) <= 0x3f && \
 467                     ++(src) != (limit) && (__t3 = *(src) - 0x80) <= 0x3f && \
 468                     (__lead = __lead >= (trie)->shifted12HighStart ? \
 469                         (trie)->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET : \
 470                         ucptrie_internalSmallU8Index((trie), __lead, __t2, __t3), 1) \
 471             :  /* U+0080..U+07FF */ \
 472                 __lead >= 0xc2 && (__t1 = *(src) - 0x80) <= 0x3f && \
 473                 (__lead = (int32_t)(trie)->index[__lead & 0x1f] + __t1, 1))) { \
 474             ++(src); \
 475         } else { \
 476             __lead = (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET;  /* ill-formed*/ \
 477         } \
 478     } \
 479     (result) = dataAccess(trie, __lead); \
 480 } UPRV_BLOCK_MACRO_END
 481
 482 /**
 483  * UTF-8: Pre-decrements src and gets a value from the trie.
 484  * Sets the trie error value for an ill-formed byte sequence.
 485  *
 486  * Unlike UCPTRIE_FAST_U16_PREV() this UTF-8 macro does not provide the code point
 487  * because it would be more work to do so and is often not needed.
 488  * If the trie value differs from the error value, then the byte sequence is well-formed,
 489  * and the code point can be assembled without revalidation.
 490  *
 491  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_FAST
 492  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 493  * @param start (const char *, in) the start pointer for the text
 494  * @param src (const char *, in/out) the source text pointer
 495  * @param result (out) variable for the trie lookup result
 496  * @stable ICU 63
 497  */
 498 #define UCPTRIE_FAST_U8_PREV(trie, dataAccess, start, src, result) UPRV_BLOCK_MACRO_BEGIN { \
 499     int32_t __index = (uint8_t)*--(src); \
 500     if (!U8_IS_SINGLE(__index)) { \
 501         __index = ucptrie_internalU8PrevIndex((trie), __index, (const uint8_t *)(start), \
 502                                               (const uint8_t *)(src)); \
 503         (src) -= __index & 7; \
 504         __index >>= 3; \
 505     } \
 506     (result) = dataAccess(trie, __index); \
 507 } UPRV_BLOCK_MACRO_END
 508
 509 /**
 510  * Returns a trie value for an ASCII code point, without range checking.
 511  *
 512  * @param trie (const UCPTrie *, in) the trie (of either fast or small type)
 513  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 514  * @param c (UChar32, in) the input code point; must be U+0000..U+007F
 515  * @return The ASCII code point's trie value.
 516  * @stable ICU 63
 517  */
 518 #define UCPTRIE_ASCII_GET(trie, dataAccess, c) dataAccess(trie, c)
 519
 520 /**
 521  * Returns a trie value for a BMP code point (U+0000..U+FFFF), without range checking.
 522  * Can be used to look up a value for a UTF-16 code unit if other parts of
 523  * the string processing check for surrogates.
 524  *
 525  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_FAST
 526  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 527  * @param c (UChar32, in) the input code point, must be U+0000..U+FFFF
 528  * @return The BMP code point's trie value.
 529  * @stable ICU 63
 530  */
 531 #define UCPTRIE_FAST_BMP_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_FAST_INDEX(trie, c))
 532
 533 /**
 534  * Returns a trie value for a supplementary code point (U+10000..U+10FFFF),
 535  * without range checking.
 536  *
 537  * @param trie (const UCPTrie *, in) the trie; must have type UCPTRIE_TYPE_FAST
 538  * @param dataAccess UCPTRIE_16, UCPTRIE_32, or UCPTRIE_8 according to the trie’s value width
 539  * @param c (UChar32, in) the input code point, must be U+10000..U+10FFFF
 540  * @return The supplementary code point's trie value.
 541  * @stable ICU 63
 542  */
 543 #define UCPTRIE_FAST_SUPP_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_SMALL_INDEX(trie, c))
 544
 545 /* Internal definitions ----------------------------------------------------- */
 546
 547 #ifndef U_IN_DOXYGEN
 548
 549 /**
 550  * Internal implementation constants.
 551  * These are needed for the API macros, but users should not use these directly.
 552  * @internal
 553  */
 554 enum {
 555     /** @internal */
 556     UCPTRIE_FAST_SHIFT = 6,
 557
 558     /** Number of entries in a data block for code points below the fast limit. 64=0x40 @internal */
 559     UCPTRIE_FAST_DATA_BLOCK_LENGTH = 1 << UCPTRIE_FAST_SHIFT,
 560
 561     /** Mask for getting the lower bits for the in-fast-data-block offset. @internal */
 562     UCPTRIE_FAST_DATA_MASK = UCPTRIE_FAST_DATA_BLOCK_LENGTH - 1,
 563
 564     /** @internal */
 565     UCPTRIE_SMALL_MAX = 0xfff,
 566
 567     /**
 568      * Offset from dataLength (to be subtracted) for fetching the
 569      * value returned for out-of-range code points and ill-formed UTF-8/16.
 570      * @internal
 571      */
 572     UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET = 1,
 573     /**
 574      * Offset from dataLength (to be subtracted) for fetching the
 575      * value returned for code points highStart..U+10FFFF.
 576      * @internal
 577      */
 578     UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET = 2
 579 };
 580
 581 /* Internal functions and macros -------------------------------------------- */
 582 // Do not conditionalize with #ifndef U_HIDE_INTERNAL_API, needed for public API
 583
 584 /** @internal */
 585 U_CAPI int32_t U_EXPORT2
 586 ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c);
 587
 588 /** @internal */
 589 U_CAPI int32_t U_EXPORT2
 590 ucptrie_internalSmallU8Index(const UCPTrie *trie, int32_t lt1, uint8_t t2, uint8_t t3);
 591
 592 /**
 593  * Internal function for part of the UCPTRIE_FAST_U8_PREVxx() macro implementations.
 594  * Do not call directly.
 595  * @internal
 596  */
 597 U_CAPI int32_t U_EXPORT2
 598 ucptrie_internalU8PrevIndex(const UCPTrie *trie, UChar32 c,
 599                             const uint8_t *start, const uint8_t *src);
 600
 601 /** Internal trie getter for a code point below the fast limit. Returns the data index. @internal */
 602 #define _UCPTRIE_FAST_INDEX(trie, c) \
 603     ((int32_t)(trie)->index[(c) >> UCPTRIE_FAST_SHIFT] + ((c) & UCPTRIE_FAST_DATA_MASK))
 604
 605 /** Internal trie getter for a code point at or above the fast limit. Returns the data index. @internal */
 606 #define _UCPTRIE_SMALL_INDEX(trie, c) \
 607     ((c) >= (trie)->highStart ? \
 608         (trie)->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET : \
 609         ucptrie_internalSmallIndex(trie, c))
 610
 611 /**
 612  * Internal trie getter for a code point, with checking that c is in U+0000..10FFFF.
 613  * Returns the data index.
 614  * @internal
 615  */
 616 #define _UCPTRIE_CP_INDEX(trie, fastMax, c) \
 617     ((uint32_t)(c) <= (uint32_t)(fastMax) ? \
 618         _UCPTRIE_FAST_INDEX(trie, c) : \
 619         (uint32_t)(c) <= 0x10ffff ? \
 620             _UCPTRIE_SMALL_INDEX(trie, c) : \
 621             (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET)
 622
 623 U_CDECL_END
 624
 625 #endif  // U_IN_DOXYGEN
 626
 627 #if U_SHOW_CPLUSPLUS_API
 628
 629 U_NAMESPACE_BEGIN
 630
 631 /**
 632  * \class LocalUCPTriePointer
 633  * "Smart pointer" class, closes a UCPTrie via ucptrie_close().
 634  * For most methods see the LocalPointerBase base class.
 635  *
 636  * @see LocalPointerBase
 637  * @see LocalPointer
 638  * @stable ICU 63
 639  */
 640 U_DEFINE_LOCAL_OPEN_POINTER(LocalUCPTriePointer, UCPTrie, ucptrie_close);
 641
 642 U_NAMESPACE_END
 643
 644 #endif  // U_SHOW_CPLUSPLUS_API
 645
 646 #endif