ICU 63.1 63.1

ucptrie.h
Go to the documentation of this file.
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
12 #ifndef U_HIDE_DRAFT_API
13
14 #include "unicode/localpointer.h"
15 #include "unicode/ucpmap.h"
16 #include "unicode/utf8.h"
17
18 U_CDECL_BEGIN
19
29 #ifndef U_IN_DOXYGEN
30
31 typedef union UCPTrieData {
33 const void *ptr0;
35 const uint16_t *ptr16;
37 const uint32_t *ptr32;
39 const uint8_t *ptr8;
40 } UCPTrieData;
41 #endif
42
60 struct UCPTrie {
61 #ifndef U_IN_DOXYGEN
62
63 const uint16_t *index;
65 UCPTrieData data;
66
68 int32_t indexLength;
70 int32_t dataLength;
72 UChar32 highStart;
74 uint16_t shifted12HighStart;
75
77 int8_t type; // UCPTrieType
79 int8_t valueWidth; // UCPTrieValueWidth
80
82 uint32_t reserved32;
84 uint16_t reserved16;
85
91 uint16_t index3NullOffset;
97 int32_t dataNullOffset;
99 uint32_t nullValue;
100
101 #ifdef UCPTRIE_DEBUG
102
103 const char *name;
104 #endif
105 #endif
106 };
107 #ifndef U_IN_DOXYGEN
108 typedef struct UCPTrie UCPTrie;
109 #endif
110
120 enum UCPTrieType {
126 UCPTRIE_TYPE_ANY = -1,
131 UCPTRIE_TYPE_FAST,
136 UCPTRIE_TYPE_SMALL
137 };
138 #ifndef U_IN_DOXYGEN
139 typedef enum UCPTrieType UCPTrieType;
140 #endif
141
150 enum UCPTrieValueWidth {
156 UCPTRIE_VALUE_BITS_ANY = -1,
162 UCPTRIE_VALUE_BITS_16,
167 UCPTRIE_VALUE_BITS_32,
173 UCPTRIE_VALUE_BITS_8
174 };
175 #ifndef U_IN_DOXYGEN
176 typedef enum UCPTrieValueWidth UCPTrieValueWidth;
177 #endif
178
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
216 U_CAPI void U_EXPORT2
217 ucptrie_close(UCPTrie *trie);
218
219 #if U_SHOW_CPLUSPLUS_API
220
221 U_NAMESPACE_BEGIN
222
232 U_DEFINE_LOCAL_OPEN_POINTER(LocalUCPTriePointer, UCPTrie, ucptrie_close);
233
234 U_NAMESPACE_END
235
236 #endif
237
247 U_CAPI UCPTrieType U_EXPORT2
248 ucptrie_getType(const UCPTrie *trie);
249
259 U_CAPI UCPTrieValueWidth U_EXPORT2
260 ucptrie_getValueWidth(const UCPTrie *trie);
261
276 U_CAPI uint32_t U_EXPORT2
277 ucptrie_get(const UCPTrie *trie, UChar32 c);
278
315 U_CAPI UChar32 U_EXPORT2
316 ucptrie_getRange(const UCPTrie *trie, UChar32 start,
317 UCPMapRangeOption option, uint32_t surrogateValue,
318 UCPMapValueFilter *filter, const void *context, uint32_t *pValue);
319
335 U_CAPI int32_t U_EXPORT2
336 ucptrie_toBinary(const UCPTrie *trie, void *data, int32_t capacity, UErrorCode *pErrorCode);
337
346 #define UCPTRIE_16(trie, i) ((trie)->data.ptr16[i])
347
356 #define UCPTRIE_32(trie, i) ((trie)->data.ptr32[i])
357
366 #define UCPTRIE_8(trie, i) ((trie)->data.ptr8[i])
367
378 #define UCPTRIE_FAST_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_CP_INDEX(trie, 0xffff, c))
379
390 #define UCPTRIE_SMALL_GET(trie, dataAccess, c) \
391 dataAccess(trie, _UCPTRIE_CP_INDEX(trie, UCPTRIE_SMALL_MAX, c))
392
406 #define UCPTRIE_FAST_U16_NEXT(trie, dataAccess, src, limit, c, result) { \
407 (c) = *(src)++; \
408 int32_t __index; \
409 if (!U16_IS_SURROGATE(c)) { \
410 __index = _UCPTRIE_FAST_INDEX(trie, c); \
411 } else { \
412 uint16_t __c2; \
413 if (U16_IS_SURROGATE_LEAD(c) && (src) != (limit) && U16_IS_TRAIL(__c2 = *(src))) { \
414 ++(src); \
415 (c) = U16_GET_SUPPLEMENTARY((c), __c2); \
416 __index = _UCPTRIE_SMALL_INDEX(trie, c); \
417 } else { \
418 __index = (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET; \
419 } \
420 } \
421 (result) = dataAccess(trie, __index); \
422 }
423
437 #define UCPTRIE_FAST_U16_PREV(trie, dataAccess, start, src, c, result) { \
438 (c) = *--(src); \
439 int32_t __index; \
440 if (!U16_IS_SURROGATE(c)) { \
441 __index = _UCPTRIE_FAST_INDEX(trie, c); \
442 } else { \
443 uint16_t __c2; \
444 if (U16_IS_SURROGATE_TRAIL(c) && (src) != (start) && U16_IS_LEAD(__c2 = *((src) - 1))) { \
445 --(src); \
446 (c) = U16_GET_SUPPLEMENTARY(__c2, (c)); \
447 __index = _UCPTRIE_SMALL_INDEX(trie, c); \
448 } else { \
449 __index = (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET; \
450 } \
451 } \
452 (result) = dataAccess(trie, __index); \
453 }
454
471 #define UCPTRIE_FAST_U8_NEXT(trie, dataAccess, src, limit, result) { \
472 int32_t __lead = (uint8_t)*(src)++; \
473 if (!U8_IS_SINGLE(__lead)) { \
474 uint8_t __t1, __t2, __t3; \
475 if ((src) != (limit) && \
476 (__lead >= 0xe0 ? \
477 __lead < 0xf0 ? /* U+0800..U+FFFF except surrogates */ \
478 U8_LEAD3_T1_BITS[__lead &= 0xf] & (1 << ((__t1 = *(src)) >> 5)) && \
479 ++(src) != (limit) && (__t2 = *(src) - 0x80) <= 0x3f && \
480 (__lead = ((int32_t)(trie)->index[(__lead << 6) + (__t1 & 0x3f)]) + __t2, 1) \
481 : /* U+10000..U+10FFFF */ \
482 (__lead -= 0xf0) <= 4 && \
483 U8_LEAD4_T1_BITS[(__t1 = *(src)) >> 4] & (1 << __lead) && \
484 (__lead = (__lead << 6) | (__t1 & 0x3f), ++(src) != (limit)) && \
485 (__t2 = *(src) - 0x80) <= 0x3f && \
486 ++(src) != (limit) && (__t3 = *(src) - 0x80) <= 0x3f && \
487 (__lead = __lead >= (trie)->shifted12HighStart ? \
488 (trie)->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET : \
489 ucptrie_internalSmallU8Index((trie), __lead, __t2, __t3), 1) \
490 : /* U+0080..U+07FF */ \
491 __lead >= 0xc2 && (__t1 = *(src) - 0x80) <= 0x3f && \
492 (__lead = (int32_t)(trie)->index[__lead & 0x1f] + __t1, 1))) { \
493 ++(src); \
494 } else { \
495 __lead = (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET; /* ill-formed*/ \
496 } \
497 } \
498 (result) = dataAccess(trie, __lead); \
499 }
500
517 #define UCPTRIE_FAST_U8_PREV(trie, dataAccess, start, src, result) { \
518 int32_t __index = (uint8_t)*--(src); \
519 if (!U8_IS_SINGLE(__index)) { \
520 __index = ucptrie_internalU8PrevIndex((trie), __index, (const uint8_t *)(start), \
521 (const uint8_t *)(src)); \
522 (src) -= __index & 7; \
523 __index >>= 3; \
524 } \
525 (result) = dataAccess(trie, __index); \
526 }
527
537 #define UCPTRIE_ASCII_GET(trie, dataAccess, c) dataAccess(trie, c)
538
550 #define UCPTRIE_FAST_BMP_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_FAST_INDEX(trie, c))
551
562 #define UCPTRIE_FAST_SUPP_GET(trie, dataAccess, c) dataAccess(trie, _UCPTRIE_SMALL_INDEX(trie, c))
563
564 /* Internal definitions ----------------------------------------------------- */
565
566 #ifndef U_IN_DOXYGEN
567
573 enum {
575 UCPTRIE_FAST_SHIFT = 6,
576
578 UCPTRIE_FAST_DATA_BLOCK_LENGTH = 1 << UCPTRIE_FAST_SHIFT,
579
581 UCPTRIE_FAST_DATA_MASK = UCPTRIE_FAST_DATA_BLOCK_LENGTH - 1,
582
584 UCPTRIE_SMALL_MAX = 0xfff,
585
591 UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET = 1,
597 UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET = 2
598 };
599
600 /* Internal functions and macros -------------------------------------------- */
601 // Do not conditionalize with #ifndef U_HIDE_INTERNAL_API, needed for public API
602
604 U_INTERNAL int32_t U_EXPORT2
605 ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c);
606
608 U_INTERNAL int32_t U_EXPORT2
609 ucptrie_internalSmallU8Index(const UCPTrie *trie, int32_t lt1, uint8_t t2, uint8_t t3);
610
616 U_INTERNAL int32_t U_EXPORT2
617 ucptrie_internalU8PrevIndex(const UCPTrie *trie, UChar32 c,
618 const uint8_t *start, const uint8_t *src);
619
621 #define _UCPTRIE_FAST_INDEX(trie, c) \
622 ((int32_t)(trie)->index[(c) >> UCPTRIE_FAST_SHIFT] + ((c) & UCPTRIE_FAST_DATA_MASK))
623
625 #define _UCPTRIE_SMALL_INDEX(trie, c) \
626 ((c) >= (trie)->highStart ? \
627 (trie)->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET : \
628 ucptrie_internalSmallIndex(trie, c))
629
635 #define _UCPTRIE_CP_INDEX(trie, fastMax, c) \
636 ((uint32_t)(c) <= (uint32_t)(fastMax) ? \
637 _UCPTRIE_FAST_INDEX(trie, c) : \
638 (uint32_t)(c) <= 0x10ffff ? \
639 _UCPTRIE_SMALL_INDEX(trie, c) : \
640 (trie)->dataLength - UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET)
641
642 U_CDECL_END
643
644 #endif // U_IN_DOXYGEN
645 #endif // U_HIDE_DRAFT_API
646 #endif
UCPMapRangeOption
UCPMapRangeOption
Selectors for how ucpmap_getRange() etc.
Definition: ucpmap.h:44
ucptrie_getType
U_CAPI UCPTrieType ucptrie_getType(const UCPTrie *trie)
Returns the trie type.
ucptrie_openFromBinary
U_CAPI UCPTrie * ucptrie_openFromBinary(UCPTrieType type, UCPTrieValueWidth valueWidth, const void *data, int32_t length, int32_t *pActualLength, UErrorCode *pErrorCode)
Opens a trie from its binary form, stored in 32-bit-aligned memory.
U_CAPI
#define U_CAPI
This is used to declare a function as a public ICU C API.
Definition: umachine.h:109
UCPTrieValueWidth
UCPTrieValueWidth
Selectors for the number of bits in a UCPTrie data value.
Definition: ucptrie.h:150
UCPTrie
Immutable Unicode code point trie structure.
Definition: ucptrie.h:60
ucpmap.h
This file defines an abstract map from Unicode code points to integer values.
U_INTERNAL
#define U_INTERNAL
This is used to declare a function as an internal ICU C API.
Definition: umachine.h:119
UCPTRIE_VALUE_BITS_8
The trie stores 8 bits per data value.
Definition: ucptrie.h:173
utf8.h
C API: 8-bit Unicode handling macros.
U_CDECL_BEGIN
#define U_CDECL_BEGIN
This is used to begin a declaration of a library private ICU C API.
Definition: umachine.h:84
LocalUCPTriePointer
"Smart pointer" class, closes a UCPTrie via ucptrie_close().
U_NAMESPACE_BEGIN
#define U_NAMESPACE_BEGIN
This is used to begin a declaration of a public ICU C++ API.
Definition: uversion.h:137
ucptrie_get
U_CAPI uint32_t ucptrie_get(const UCPTrie *trie, UChar32 c)
Returns the value for a code point as stored in the trie, with range checking.
UCPTRIE_TYPE_FAST
Fast/simple/larger BMP data structure.
Definition: ucptrie.h:131
U_DEFINE_LOCAL_OPEN_POINTER
#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction)
"Smart pointer" definition macro, deletes objects via the closeFunction.
Definition: localpointer.h:487
localpointer.h
C++ API: "Smart pointers" for use with and in ICU4C C++ code.
ucptrie_toBinary
U_CAPI int32_t ucptrie_toBinary(const UCPTrie *trie, void *data, int32_t capacity, UErrorCode *pErrorCode)
Writes a memory-mappable form of the trie into 32-bit aligned memory.
UCPMapValueFilter
uint32_t UCPMapValueFilter(const void *context, uint32_t value)
Callback function type: Modifies a map value.
Definition: ucpmap.h:116
UCPTRIE_VALUE_BITS_32
The trie stores 32 bits per data value.
Definition: ucptrie.h:167
UChar32
int32_t UChar32
Define UChar32 as a type for single Unicode code points.
Definition: umachine.h:389
UCPTRIE_VALUE_BITS_16
The trie stores 16 bits per data value.
Definition: ucptrie.h:162
ucptrie_getValueWidth
U_CAPI UCPTrieValueWidth ucptrie_getValueWidth(const UCPTrie *trie)
Returns the number of bits in a trie data value.
UCPTRIE_VALUE_BITS_ANY
For ucptrie_openFromBinary() to accept any data value width.
Definition: ucptrie.h:156
ucptrie_close
U_CAPI void ucptrie_close(UCPTrie *trie)
Closes a trie and releases associated memory.
U_CDECL_END
#define U_CDECL_END
This is used to end a declaration of a library private ICU C API.
Definition: umachine.h:85
U_NAMESPACE_END
#define U_NAMESPACE_END
This is used to end a declaration of a public ICU C++ API.
Definition: uversion.h:138
UErrorCode
UErrorCode
Error code to replace exception handling, so that the code is compatible with all C++ compilers...
Definition: utypes.h:401
UCPTRIE_TYPE_ANY
For ucptrie_openFromBinary() to accept any type.
Definition: ucptrie.h:126
utypes.h
Basic definitions for ICU, for both C and C++ APIs.
ucptrie_getRange
U_CAPI UChar32 ucptrie_getRange(const UCPTrie *trie, UChar32 start, UCPMapRangeOption option, uint32_t surrogateValue, UCPMapValueFilter *filter, const void *context, uint32_t *pValue)
Returns the last code point such that all those from start to there have the same value...
UCPTrieType
UCPTrieType
Selectors for the type of a UCPTrie.
Definition: ucptrie.h:120
UCPTRIE_TYPE_SMALL
Small/slower BMP data structure.
Definition: ucptrie.h:136