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