1 // 2017 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 4 // ucptrie.cpp (modified from utrie2.cpp) 5 // created: 2017dec29 Markus W. Scherer 6 7 // #define UCPTRIE_DEBUG 8 #ifdef UCPTRIE_DEBUG 9 # include <stdio.h> 10 #endif 11 12 #include "unicode/utypes.h" 13 #include "unicode/ucptrie.h" 14 #include "unicode/utf.h" 15 #include "unicode/utf8.h" 16 #include "unicode/utf16.h" 17 #include "cmemory.h" 18 #include "uassert.h" 19 #include "ucptrie_impl.h" 20 21 U_CAPI UCPTrie * U_EXPORT2 22 ucptrie_openFromBinary(UCPTrieType type, UCPTrieValueWidth valueWidth, 23 const void *data, int32_t length, int32_t *pActualLength, 24 UErrorCode *pErrorCode) { 25 if (U_FAILURE(*pErrorCode)) { 26 return nullptr; 27 } 28 29 if (length <= 0 || (U_POINTER_MASK_LSB(data, 3) != 0) || 30 type < UCPTRIE_TYPE_ANY || UCPTRIE_TYPE_SMALL < type || 31 valueWidth < UCPTRIE_VALUE_BITS_ANY || UCPTRIE_VALUE_BITS_8 < valueWidth) { 32 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 33 return nullptr; 34 } 35 36 // Enough data for a trie header? 37 if (length < (int32_t)sizeof(UCPTrieHeader)) { 38 *pErrorCode = U_INVALID_FORMAT_ERROR; 39 return nullptr; 40 } 41 42 // Check the signature. 43 const UCPTrieHeader *header = (const UCPTrieHeader *)data; 44 if (header->signature != UCPTRIE_SIG) { 45 *pErrorCode = U_INVALID_FORMAT_ERROR; 46 return nullptr; 47 } 48 49 int32_t options = header->options; 50 int32_t typeInt = (options >> 6) & 3; 51 int32_t valueWidthInt = options & UCPTRIE_OPTIONS_VALUE_BITS_MASK; 52 if (typeInt > UCPTRIE_TYPE_SMALL || valueWidthInt > UCPTRIE_VALUE_BITS_8 || 53 (options & UCPTRIE_OPTIONS_RESERVED_MASK) != 0) { 54 *pErrorCode = U_INVALID_FORMAT_ERROR; 55 return nullptr; 56 } 57 UCPTrieType actualType = (UCPTrieType)typeInt; 58 UCPTrieValueWidth actualValueWidth = (UCPTrieValueWidth)valueWidthInt; 59 if (type < 0) { 60 type = actualType; 61 } 62 if (valueWidth < 0) { 63 valueWidth = actualValueWidth; 64 } 65 if (type != actualType || valueWidth != actualValueWidth) { 66 *pErrorCode = U_INVALID_FORMAT_ERROR; 67 return nullptr; 68 } 69 70 // Get the length values and offsets. 71 UCPTrie tempTrie; 72 uprv_memset(&tempTrie, 0, sizeof(tempTrie)); 73 tempTrie.indexLength = header->indexLength; 74 tempTrie.dataLength = 75 ((options & UCPTRIE_OPTIONS_DATA_LENGTH_MASK) << 4) | header->dataLength; 76 tempTrie.index3NullOffset = header->index3NullOffset; 77 tempTrie.dataNullOffset = 78 ((options & UCPTRIE_OPTIONS_DATA_NULL_OFFSET_MASK) << 8) | header->dataNullOffset; 79 80 tempTrie.highStart = header->shiftedHighStart << UCPTRIE_SHIFT_2; 81 tempTrie.shifted12HighStart = (tempTrie.highStart + 0xfff) >> 12; 82 tempTrie.type = type; 83 tempTrie.valueWidth = valueWidth; 84 85 // Calculate the actual length. 86 int32_t actualLength = (int32_t)sizeof(UCPTrieHeader) + tempTrie.indexLength * 2; 87 if (valueWidth == UCPTRIE_VALUE_BITS_16) { 88 actualLength += tempTrie.dataLength * 2; 89 } else if (valueWidth == UCPTRIE_VALUE_BITS_32) { 90 actualLength += tempTrie.dataLength * 4; 91 } else { 92 actualLength += tempTrie.dataLength; 93 } 94 if (length < actualLength) { 95 *pErrorCode = U_INVALID_FORMAT_ERROR; // Not enough bytes. 96 return nullptr; 97 } 98 99 // Allocate the trie. 100 UCPTrie *trie = (UCPTrie *)uprv_malloc(sizeof(UCPTrie)); 101 if (trie == nullptr) { 102 *pErrorCode = U_MEMORY_ALLOCATION_ERROR; 103 return nullptr; 104 } 105 uprv_memcpy(trie, &tempTrie, sizeof(tempTrie)); 106 #ifdef UCPTRIE_DEBUG 107 trie->name = "fromSerialized"; 108 #endif 109 110 // Set the pointers to its index and data arrays. 111 const uint16_t *p16 = (const uint16_t *)(header + 1); 112 trie->index = p16; 113 p16 += trie->indexLength; 114 115 // Get the data. 116 int32_t nullValueOffset = trie->dataNullOffset; 117 if (nullValueOffset >= trie->dataLength) { 118 nullValueOffset = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 119 } 120 switch (valueWidth) { 121 case UCPTRIE_VALUE_BITS_16: 122 trie->data.ptr16 = p16; 123 trie->nullValue = trie->data.ptr16[nullValueOffset]; 124 break; 125 case UCPTRIE_VALUE_BITS_32: 126 trie->data.ptr32 = (const uint32_t *)p16; 127 trie->nullValue = trie->data.ptr32[nullValueOffset]; 128 break; 129 case UCPTRIE_VALUE_BITS_8: 130 trie->data.ptr8 = (const uint8_t *)p16; 131 trie->nullValue = trie->data.ptr8[nullValueOffset]; 132 break; 133 default: 134 // Unreachable because valueWidth was checked above. 135 *pErrorCode = U_INVALID_FORMAT_ERROR; 136 return nullptr; 137 } 138 139 if (pActualLength != nullptr) { 140 *pActualLength = actualLength; 141 } 142 return trie; 143 } 144 145 U_CAPI void U_EXPORT2 146 ucptrie_close(UCPTrie *trie) { 147 uprv_free(trie); 148 } 149 150 U_CAPI UCPTrieType U_EXPORT2 151 ucptrie_getType(const UCPTrie *trie) { 152 return (UCPTrieType)trie->type; 153 } 154 155 U_CAPI UCPTrieValueWidth U_EXPORT2 156 ucptrie_getValueWidth(const UCPTrie *trie) { 157 return (UCPTrieValueWidth)trie->valueWidth; 158 } 159 160 U_CAPI int32_t U_EXPORT2 161 ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c) { 162 int32_t i1 = c >> UCPTRIE_SHIFT_1; 163 if (trie->type == UCPTRIE_TYPE_FAST) { 164 U_ASSERT(0xffff < c && c < trie->highStart); 165 i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH; 166 } else { 167 U_ASSERT((uint32_t)c < (uint32_t)trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); 168 i1 += UCPTRIE_SMALL_INDEX_LENGTH; 169 } 170 int32_t i3Block = trie->index[ 171 (int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 172 int32_t i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 173 int32_t dataBlock; 174 if ((i3Block & 0x8000) == 0) { 175 // 16-bit indexes 176 dataBlock = trie->index[i3Block + i3]; 177 } else { 178 // 18-bit indexes stored in groups of 9 entries per 8 indexes. 179 i3Block = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3); 180 i3 &= 7; 181 dataBlock = ((int32_t)trie->index[i3Block++] << (2 + (2 * i3))) & 0x30000; 182 dataBlock |= trie->index[i3Block + i3]; 183 } 184 return dataBlock + (c & UCPTRIE_SMALL_DATA_MASK); 185 } 186 187 U_CAPI int32_t U_EXPORT2 188 ucptrie_internalSmallU8Index(const UCPTrie *trie, int32_t lt1, uint8_t t2, uint8_t t3) { 189 UChar32 c = (lt1 << 12) | (t2 << 6) | t3; 190 if (c >= trie->highStart) { 191 // Possible because the UTF-8 macro compares with shifted12HighStart which may be higher. 192 return trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 193 } 194 return ucptrie_internalSmallIndex(trie, c); 195 } 196 197 U_CAPI int32_t U_EXPORT2 198 ucptrie_internalU8PrevIndex(const UCPTrie *trie, UChar32 c, 199 const uint8_t *start, const uint8_t *src) { 200 int32_t i, length; 201 // Support 64-bit pointers by avoiding cast of arbitrary difference. 202 if ((src - start) <= 7) { 203 i = length = (int32_t)(src - start); 204 } else { 205 i = length = 7; 206 start = src - 7; 207 } 208 c = utf8_prevCharSafeBody(start, 0, &i, c, -1); 209 i = length - i; // Number of bytes read backward from src. 210 int32_t idx = _UCPTRIE_CP_INDEX(trie, 0xffff, c); 211 return (idx << 3) | i; 212 } 213 214 namespace { 215 216 inline uint32_t getValue(UCPTrieData data, UCPTrieValueWidth valueWidth, int32_t dataIndex) { 217 switch (valueWidth) { 218 case UCPTRIE_VALUE_BITS_16: 219 return data.ptr16[dataIndex]; 220 case UCPTRIE_VALUE_BITS_32: 221 return data.ptr32[dataIndex]; 222 case UCPTRIE_VALUE_BITS_8: 223 return data.ptr8[dataIndex]; 224 default: 225 // Unreachable if the trie is properly initialized. 226 return 0xffffffff; 227 } 228 } 229 230 } // namespace 231 232 U_CAPI uint32_t U_EXPORT2 233 ucptrie_get(const UCPTrie *trie, UChar32 c) { 234 int32_t dataIndex; 235 if ((uint32_t)c <= 0x7f) { 236 // linear ASCII 237 dataIndex = c; 238 } else { 239 UChar32 fastMax = trie->type == UCPTRIE_TYPE_FAST ? 0xffff : UCPTRIE_SMALL_MAX; 240 dataIndex = _UCPTRIE_CP_INDEX(trie, fastMax, c); 241 } 242 return getValue(trie->data, (UCPTrieValueWidth)trie->valueWidth, dataIndex); 243 } 244 245 namespace { 246 247 constexpr int32_t MAX_UNICODE = 0x10ffff; 248 249 inline uint32_t maybeFilterValue(uint32_t value, uint32_t trieNullValue, uint32_t nullValue, 250 UCPMapValueFilter *filter, const void *context) { 251 if (value == trieNullValue) { 252 value = nullValue; 253 } else if (filter != nullptr) { 254 value = filter(context, value); 255 } 256 return value; 257 } 258 259 UChar32 getRange(const void *t, UChar32 start, 260 UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 261 if ((uint32_t)start > MAX_UNICODE) { 262 return U_SENTINEL; 263 } 264 const UCPTrie *trie = reinterpret_cast<const UCPTrie *>(t); 265 UCPTrieValueWidth valueWidth = (UCPTrieValueWidth)trie->valueWidth; 266 if (start >= trie->highStart) { 267 if (pValue != nullptr) { 268 int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 269 uint32_t value = getValue(trie->data, valueWidth, di); 270 if (filter != nullptr) { value = filter(context, value); } 271 *pValue = value; 272 } 273 return MAX_UNICODE; 274 } 275 276 uint32_t nullValue = trie->nullValue; 277 if (filter != nullptr) { nullValue = filter(context, nullValue); } 278 const uint16_t *index = trie->index; 279 280 int32_t prevI3Block = -1; 281 int32_t prevBlock = -1; 282 UChar32 c = start; 283 uint32_t trieValue, value; 284 bool haveValue = false; 285 do { 286 int32_t i3Block; 287 int32_t i3; 288 int32_t i3BlockLength; 289 int32_t dataBlockLength; 290 if (c <= 0xffff && (trie->type == UCPTRIE_TYPE_FAST || c <= UCPTRIE_SMALL_MAX)) { 291 i3Block = 0; 292 i3 = c >> UCPTRIE_FAST_SHIFT; 293 i3BlockLength = trie->type == UCPTRIE_TYPE_FAST ? 294 UCPTRIE_BMP_INDEX_LENGTH : UCPTRIE_SMALL_INDEX_LENGTH; 295 dataBlockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH; 296 } else { 297 // Use the multi-stage index. 298 int32_t i1 = c >> UCPTRIE_SHIFT_1; 299 if (trie->type == UCPTRIE_TYPE_FAST) { 300 U_ASSERT(0xffff < c && c < trie->highStart); 301 i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH; 302 } else { 303 U_ASSERT(c < trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT); 304 i1 += UCPTRIE_SMALL_INDEX_LENGTH; 305 } 306 i3Block = trie->index[ 307 (int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)]; 308 if (i3Block == prevI3Block && (c - start) >= UCPTRIE_CP_PER_INDEX_2_ENTRY) { 309 // The index-3 block is the same as the previous one, and filled with value. 310 U_ASSERT((c & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0); 311 c += UCPTRIE_CP_PER_INDEX_2_ENTRY; 312 continue; 313 } 314 prevI3Block = i3Block; 315 if (i3Block == trie->index3NullOffset) { 316 // This is the index-3 null block. 317 if (haveValue) { 318 if (nullValue != value) { 319 return c - 1; 320 } 321 } else { 322 trieValue = trie->nullValue; 323 value = nullValue; 324 if (pValue != nullptr) { *pValue = nullValue; } 325 haveValue = true; 326 } 327 prevBlock = trie->dataNullOffset; 328 c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1); 329 continue; 330 } 331 i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK; 332 i3BlockLength = UCPTRIE_INDEX_3_BLOCK_LENGTH; 333 dataBlockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH; 334 } 335 // Enumerate data blocks for one index-3 block. 336 do { 337 int32_t block; 338 if ((i3Block & 0x8000) == 0) { 339 block = index[i3Block + i3]; 340 } else { 341 // 18-bit indexes stored in groups of 9 entries per 8 indexes. 342 int32_t group = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3); 343 int32_t gi = i3 & 7; 344 block = ((int32_t)index[group++] << (2 + (2 * gi))) & 0x30000; 345 block |= index[group + gi]; 346 } 347 if (block == prevBlock && (c - start) >= dataBlockLength) { 348 // The block is the same as the previous one, and filled with value. 349 U_ASSERT((c & (dataBlockLength - 1)) == 0); 350 c += dataBlockLength; 351 } else { 352 int32_t dataMask = dataBlockLength - 1; 353 prevBlock = block; 354 if (block == trie->dataNullOffset) { 355 // This is the data null block. 356 if (haveValue) { 357 if (nullValue != value) { 358 return c - 1; 359 } 360 } else { 361 trieValue = trie->nullValue; 362 value = nullValue; 363 if (pValue != nullptr) { *pValue = nullValue; } 364 haveValue = true; 365 } 366 c = (c + dataBlockLength) & ~dataMask; 367 } else { 368 int32_t di = block + (c & dataMask); 369 uint32_t trieValue2 = getValue(trie->data, valueWidth, di); 370 if (haveValue) { 371 if (trieValue2 != trieValue) { 372 if (filter == nullptr || 373 maybeFilterValue(trieValue2, trie->nullValue, nullValue, 374 filter, context) != value) { 375 return c - 1; 376 } 377 trieValue = trieValue2; // may or may not help 378 } 379 } else { 380 trieValue = trieValue2; 381 value = maybeFilterValue(trieValue2, trie->nullValue, nullValue, 382 filter, context); 383 if (pValue != nullptr) { *pValue = value; } 384 haveValue = true; 385 } 386 while ((++c & dataMask) != 0) { 387 trieValue2 = getValue(trie->data, valueWidth, ++di); 388 if (trieValue2 != trieValue) { 389 if (filter == nullptr || 390 maybeFilterValue(trieValue2, trie->nullValue, nullValue, 391 filter, context) != value) { 392 return c - 1; 393 } 394 trieValue = trieValue2; // may or may not help 395 } 396 } 397 } 398 } 399 } while (++i3 < i3BlockLength); 400 } while (c < trie->highStart); 401 U_ASSERT(haveValue); 402 int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET; 403 uint32_t highValue = getValue(trie->data, valueWidth, di); 404 if (maybeFilterValue(highValue, trie->nullValue, nullValue, 405 filter, context) != value) { 406 return c - 1; 407 } else { 408 return MAX_UNICODE; 409 } 410 } 411 412 } // namespace 413 414 U_CFUNC UChar32 415 ucptrie_internalGetRange(UCPTrieGetRange *getRange, 416 const void *trie, UChar32 start, 417 UCPMapRangeOption option, uint32_t surrogateValue, 418 UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 419 if (option == UCPMAP_RANGE_NORMAL) { 420 return getRange(trie, start, filter, context, pValue); 421 } 422 uint32_t value; 423 if (pValue == nullptr) { 424 // We need to examine the range value even if the caller does not want it. 425 pValue = &value; 426 } 427 UChar32 surrEnd = option == UCPMAP_RANGE_FIXED_ALL_SURROGATES ? 0xdfff : 0xdbff; 428 UChar32 end = getRange(trie, start, filter, context, pValue); 429 if (end < 0xd7ff || start > surrEnd) { 430 return end; 431 } 432 // The range overlaps with surrogates, or ends just before the first one. 433 if (*pValue == surrogateValue) { 434 if (end >= surrEnd) { 435 // Surrogates followed by a non-surrogateValue range, 436 // or surrogates are part of a larger surrogateValue range. 437 return end; 438 } 439 } else { 440 if (start <= 0xd7ff) { 441 return 0xd7ff; // Non-surrogateValue range ends before surrogateValue surrogates. 442 } 443 // Start is a surrogate with a non-surrogateValue code *unit* value. 444 // Return a surrogateValue code *point* range. 445 *pValue = surrogateValue; 446 if (end > surrEnd) { 447 return surrEnd; // Surrogate range ends before non-surrogateValue rest of range. 448 } 449 } 450 // See if the surrogateValue surrogate range can be merged with 451 // an immediately following range. 452 uint32_t value2; 453 UChar32 end2 = getRange(trie, surrEnd + 1, filter, context, &value2); 454 if (value2 == surrogateValue) { 455 return end2; 456 } 457 return surrEnd; 458 } 459 460 U_CAPI UChar32 U_EXPORT2 461 ucptrie_getRange(const UCPTrie *trie, UChar32 start, 462 UCPMapRangeOption option, uint32_t surrogateValue, 463 UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 464 return ucptrie_internalGetRange(getRange, trie, start, 465 option, surrogateValue, 466 filter, context, pValue); 467 } 468 469 U_CAPI int32_t U_EXPORT2 470 ucptrie_toBinary(const UCPTrie *trie, 471 void *data, int32_t capacity, 472 UErrorCode *pErrorCode) { 473 if (U_FAILURE(*pErrorCode)) { 474 return 0; 475 } 476 477 UCPTrieType type = (UCPTrieType)trie->type; 478 UCPTrieValueWidth valueWidth = (UCPTrieValueWidth)trie->valueWidth; 479 if (type < UCPTRIE_TYPE_FAST || UCPTRIE_TYPE_SMALL < type || 480 valueWidth < UCPTRIE_VALUE_BITS_16 || UCPTRIE_VALUE_BITS_8 < valueWidth || 481 capacity < 0 || 482 (capacity > 0 && (data == nullptr || (U_POINTER_MASK_LSB(data, 3) != 0)))) { 483 *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR; 484 return 0; 485 } 486 487 int32_t length = (int32_t)sizeof(UCPTrieHeader) + trie->indexLength * 2; 488 switch (valueWidth) { 489 case UCPTRIE_VALUE_BITS_16: 490 length += trie->dataLength * 2; 491 break; 492 case UCPTRIE_VALUE_BITS_32: 493 length += trie->dataLength * 4; 494 break; 495 case UCPTRIE_VALUE_BITS_8: 496 length += trie->dataLength; 497 break; 498 default: 499 // unreachable 500 break; 501 } 502 if (capacity < length) { 503 *pErrorCode = U_BUFFER_OVERFLOW_ERROR; 504 return length; 505 } 506 507 char *bytes = (char *)data; 508 UCPTrieHeader *header = (UCPTrieHeader *)bytes; 509 header->signature = UCPTRIE_SIG; // "Tri3" 510 header->options = (uint16_t)( 511 ((trie->dataLength & 0xf0000) >> 4) | 512 ((trie->dataNullOffset & 0xf0000) >> 8) | 513 (trie->type << 6) | 514 valueWidth); 515 header->indexLength = (uint16_t)trie->indexLength; 516 header->dataLength = (uint16_t)trie->dataLength; 517 header->index3NullOffset = trie->index3NullOffset; 518 header->dataNullOffset = (uint16_t)trie->dataNullOffset; 519 header->shiftedHighStart = trie->highStart >> UCPTRIE_SHIFT_2; 520 bytes += sizeof(UCPTrieHeader); 521 522 uprv_memcpy(bytes, trie->index, trie->indexLength * 2); 523 bytes += trie->indexLength * 2; 524 525 switch (valueWidth) { 526 case UCPTRIE_VALUE_BITS_16: 527 uprv_memcpy(bytes, trie->data.ptr16, trie->dataLength * 2); 528 break; 529 case UCPTRIE_VALUE_BITS_32: 530 uprv_memcpy(bytes, trie->data.ptr32, trie->dataLength * 4); 531 break; 532 case UCPTRIE_VALUE_BITS_8: 533 uprv_memcpy(bytes, trie->data.ptr8, trie->dataLength); 534 break; 535 default: 536 // unreachable 537 break; 538 } 539 return length; 540 } 541 542 namespace { 543 544 #ifdef UCPTRIE_DEBUG 545 long countNull(const UCPTrie *trie) { 546 uint32_t nullValue=trie->nullValue; 547 int32_t length=trie->dataLength; 548 long count=0; 549 switch (trie->valueWidth) { 550 case UCPTRIE_VALUE_BITS_16: 551 for(int32_t i=0; i<length; ++i) { 552 if(trie->data.ptr16[i]==nullValue) { ++count; } 553 } 554 break; 555 case UCPTRIE_VALUE_BITS_32: 556 for(int32_t i=0; i<length; ++i) { 557 if(trie->data.ptr32[i]==nullValue) { ++count; } 558 } 559 break; 560 case UCPTRIE_VALUE_BITS_8: 561 for(int32_t i=0; i<length; ++i) { 562 if(trie->data.ptr8[i]==nullValue) { ++count; } 563 } 564 break; 565 default: 566 // unreachable 567 break; 568 } 569 return count; 570 } 571 572 U_CFUNC void 573 ucptrie_printLengths(const UCPTrie *trie, const char *which) { 574 long indexLength=trie->indexLength; 575 long dataLength=(long)trie->dataLength; 576 long totalLength=(long)sizeof(UCPTrieHeader)+indexLength*2+ 577 dataLength*(trie->valueWidth==UCPTRIE_VALUE_BITS_16 ? 2 : 578 trie->valueWidth==UCPTRIE_VALUE_BITS_32 ? 4 : 1); 579 printf("**UCPTrieLengths(%s %s)** index:%6ld data:%6ld countNull:%6ld serialized:%6ld\n", 580 which, trie->name, indexLength, dataLength, countNull(trie), totalLength); 581 } 582 #endif 583 584 } // namespace 585 586 // UCPMap ---- 587 // Initially, this is the same as UCPTrie. This may well change. 588 589 U_CAPI uint32_t U_EXPORT2 590 ucpmap_get(const UCPMap *map, UChar32 c) { 591 return ucptrie_get(reinterpret_cast<const UCPTrie *>(map), c); 592 } 593 594 U_CAPI UChar32 U_EXPORT2 595 ucpmap_getRange(const UCPMap *map, UChar32 start, 596 UCPMapRangeOption option, uint32_t surrogateValue, 597 UCPMapValueFilter *filter, const void *context, uint32_t *pValue) { 598 return ucptrie_getRange(reinterpret_cast<const UCPTrie *>(map), start, 599 option, surrogateValue, 600 filter, context, pValue); 601 } 602
