1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ****************************************************************************** 5 * 6 * Copyright (C) 2001-2014, International Business Machines 7 * Corporation and others. All Rights Reserved. 8 * 9 ****************************************************************************** 10 * file name: utrie2.cpp 11 * encoding: UTF-8 12 * tab size: 8 (not used) 13 * indentation:4 14 * 15 * created on: 2008aug16 (starting from a copy of utrie.c) 16 * created by: Markus W. Scherer 17 * 18 * This is a common implementation of a Unicode trie. 19 * It is a kind of compressed, serializable table of 16- or 32-bit values associated with 20 * Unicode code points (0..0x10ffff). 21 * This is the second common version of a Unicode trie (hence the name UTrie2). 22 * See utrie2.h for a comparison. 23 * 24 * This file contains only the runtime and enumeration code, for read-only access. 25 * See utrie2_builder.c for the builder code. 26 */ 27 #ifdef UTRIE2_DEBUG 28 # include <stdio.h> 29 #endif 30 31 #include "unicode/utypes.h" 32 #include "unicode/utf.h" 33 #include "unicode/utf8.h" 34 #include "unicode/utf16.h" 35 #include "cmemory.h" 36 #include "utrie2.h" 37 #include "utrie2_impl.h" 38 #include "uassert.h" 39 40 /* Public UTrie2 API implementation ----------------------------------------- */ 41 42 static uint32_t 43 get32(const UNewTrie2 *trie, UChar32 c, UBool fromLSCP) { 44 int32_t i2, block; 45 46 if(c>=trie->highStart && (!U_IS_LEAD(c) || fromLSCP)) { 47 return trie->data[trie->dataLength-UTRIE2_DATA_GRANULARITY]; 48 } 49 50 if(U_IS_LEAD(c) && fromLSCP) { 51 i2=(UTRIE2_LSCP_INDEX_2_OFFSET-(0xd800>>UTRIE2_SHIFT_2))+ 52 (c>>UTRIE2_SHIFT_2); 53 } else { 54 i2=trie->index1[c>>UTRIE2_SHIFT_1]+ 55 ((c>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK); 56 } 57 block=trie->index2[i2]; 58 return trie->data[block+(c&UTRIE2_DATA_MASK)]; 59 } 60 61 U_CAPI uint32_t U_EXPORT2 62 utrie2_get32(const UTrie2 *trie, UChar32 c) { 63 if(trie->data16!=NULL) { 64 return UTRIE2_GET16(trie, c); 65 } else if(trie->data32!=NULL) { 66 return UTRIE2_GET32(trie, c); 67 } else if((uint32_t)c>0x10ffff) { 68 return trie->errorValue; 69 } else { 70 return get32(trie->newTrie, c, TRUE); 71 } 72 } 73 74 U_CAPI uint32_t U_EXPORT2 75 utrie2_get32FromLeadSurrogateCodeUnit(const UTrie2 *trie, UChar32 c) { 76 if(!U_IS_LEAD(c)) { 77 return trie->errorValue; 78 } 79 if(trie->data16!=NULL) { 80 return UTRIE2_GET16_FROM_U16_SINGLE_LEAD(trie, c); 81 } else if(trie->data32!=NULL) { 82 return UTRIE2_GET32_FROM_U16_SINGLE_LEAD(trie, c); 83 } else { 84 return get32(trie->newTrie, c, FALSE); 85 } 86 } 87 88 static inline int32_t 89 u8Index(const UTrie2 *trie, UChar32 c, int32_t i) { 90 int32_t idx= 91 _UTRIE2_INDEX_FROM_CP( 92 trie, 93 trie->data32==NULL ? trie->indexLength : 0, 94 c); 95 return (idx<<3)|i; 96 } 97 98 U_CAPI int32_t U_EXPORT2 99 utrie2_internalU8NextIndex(const UTrie2 *trie, UChar32 c, 100 const uint8_t *src, const uint8_t *limit) { 101 int32_t i, length; 102 i=0; 103 /* support 64-bit pointers by avoiding cast of arbitrary difference */ 104 if((limit-src)<=7) { 105 length=(int32_t)(limit-src); 106 } else { 107 length=7; 108 } 109 c=utf8_nextCharSafeBody(src, &i, length, c, -1); 110 return u8Index(trie, c, i); 111 } 112 113 U_CAPI int32_t U_EXPORT2 114 utrie2_internalU8PrevIndex(const UTrie2 *trie, UChar32 c, 115 const uint8_t *start, const uint8_t *src) { 116 int32_t i, length; 117 /* support 64-bit pointers by avoiding cast of arbitrary difference */ 118 if((src-start)<=7) { 119 i=length=(int32_t)(src-start); 120 } else { 121 i=length=7; 122 start=src-7; 123 } 124 c=utf8_prevCharSafeBody(start, 0, &i, c, -1); 125 i=length-i; /* number of bytes read backward from src */ 126 return u8Index(trie, c, i); 127 } 128 129 U_CAPI UTrie2 * U_EXPORT2 130 utrie2_openFromSerialized(UTrie2ValueBits valueBits, 131 const void *data, int32_t length, int32_t *pActualLength, 132 UErrorCode *pErrorCode) { 133 const UTrie2Header *header; 134 const uint16_t *p16; 135 int32_t actualLength; 136 137 UTrie2 tempTrie; 138 UTrie2 *trie; 139 140 if(U_FAILURE(*pErrorCode)) { 141 return 0; 142 } 143 144 if( length<=0 || (U_POINTER_MASK_LSB(data, 3)!=0) || 145 valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits 146 ) { 147 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 148 return 0; 149 } 150 151 /* enough data for a trie header? */ 152 if(length<(int32_t)sizeof(UTrie2Header)) { 153 *pErrorCode=U_INVALID_FORMAT_ERROR; 154 return 0; 155 } 156 157 /* check the signature */ 158 header=(const UTrie2Header *)data; 159 if(header->signature!=UTRIE2_SIG) { 160 *pErrorCode=U_INVALID_FORMAT_ERROR; 161 return 0; 162 } 163 164 /* get the options */ 165 if(valueBits!=(UTrie2ValueBits)(header->options&UTRIE2_OPTIONS_VALUE_BITS_MASK)) { 166 *pErrorCode=U_INVALID_FORMAT_ERROR; 167 return 0; 168 } 169 170 /* get the length values and offsets */ 171 uprv_memset(&tempTrie, 0, sizeof(tempTrie)); 172 tempTrie.indexLength=header->indexLength; 173 tempTrie.dataLength=header->shiftedDataLength<<UTRIE2_INDEX_SHIFT; 174 tempTrie.index2NullOffset=header->index2NullOffset; 175 tempTrie.dataNullOffset=header->dataNullOffset; 176 177 tempTrie.highStart=header->shiftedHighStart<<UTRIE2_SHIFT_1; 178 tempTrie.highValueIndex=tempTrie.dataLength-UTRIE2_DATA_GRANULARITY; 179 if(valueBits==UTRIE2_16_VALUE_BITS) { 180 tempTrie.highValueIndex+=tempTrie.indexLength; 181 } 182 183 /* calculate the actual length */ 184 actualLength=(int32_t)sizeof(UTrie2Header)+tempTrie.indexLength*2; 185 if(valueBits==UTRIE2_16_VALUE_BITS) { 186 actualLength+=tempTrie.dataLength*2; 187 } else { 188 actualLength+=tempTrie.dataLength*4; 189 } 190 if(length<actualLength) { 191 *pErrorCode=U_INVALID_FORMAT_ERROR; /* not enough bytes */ 192 return 0; 193 } 194 195 /* allocate the trie */ 196 trie=(UTrie2 *)uprv_malloc(sizeof(UTrie2)); 197 if(trie==NULL) { 198 *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 199 return 0; 200 } 201 uprv_memcpy(trie, &tempTrie, sizeof(tempTrie)); 202 trie->memory=(uint32_t *)data; 203 trie->length=actualLength; 204 trie->isMemoryOwned=FALSE; 205 206 /* set the pointers to its index and data arrays */ 207 p16=(const uint16_t *)(header+1); 208 trie->index=p16; 209 p16+=trie->indexLength; 210 211 /* get the data */ 212 switch(valueBits) { 213 case UTRIE2_16_VALUE_BITS: 214 trie->data16=p16; 215 trie->data32=NULL; 216 trie->initialValue=trie->index[trie->dataNullOffset]; 217 trie->errorValue=trie->data16[UTRIE2_BAD_UTF8_DATA_OFFSET]; 218 break; 219 case UTRIE2_32_VALUE_BITS: 220 trie->data16=NULL; 221 trie->data32=(const uint32_t *)p16; 222 trie->initialValue=trie->data32[trie->dataNullOffset]; 223 trie->errorValue=trie->data32[UTRIE2_BAD_UTF8_DATA_OFFSET]; 224 break; 225 default: 226 *pErrorCode=U_INVALID_FORMAT_ERROR; 227 return 0; 228 } 229 230 if(pActualLength!=NULL) { 231 *pActualLength=actualLength; 232 } 233 return trie; 234 } 235 236 U_CAPI UTrie2 * U_EXPORT2 237 utrie2_openDummy(UTrie2ValueBits valueBits, 238 uint32_t initialValue, uint32_t errorValue, 239 UErrorCode *pErrorCode) { 240 UTrie2 *trie; 241 UTrie2Header *header; 242 uint32_t *p; 243 uint16_t *dest16; 244 int32_t indexLength, dataLength, length, i; 245 int32_t dataMove; /* >0 if the data is moved to the end of the index array */ 246 247 if(U_FAILURE(*pErrorCode)) { 248 return 0; 249 } 250 251 if(valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits) { 252 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 253 return 0; 254 } 255 256 /* calculate the total length of the dummy trie data */ 257 indexLength=UTRIE2_INDEX_1_OFFSET; 258 dataLength=UTRIE2_DATA_START_OFFSET+UTRIE2_DATA_GRANULARITY; 259 length=(int32_t)sizeof(UTrie2Header)+indexLength*2; 260 if(valueBits==UTRIE2_16_VALUE_BITS) { 261 length+=dataLength*2; 262 } else { 263 length+=dataLength*4; 264 } 265 266 /* allocate the trie */ 267 trie=(UTrie2 *)uprv_malloc(sizeof(UTrie2)); 268 if(trie==NULL) { 269 *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 270 return 0; 271 } 272 uprv_memset(trie, 0, sizeof(UTrie2)); 273 trie->memory=uprv_malloc(length); 274 if(trie->memory==NULL) { 275 uprv_free(trie); 276 *pErrorCode=U_MEMORY_ALLOCATION_ERROR; 277 return 0; 278 } 279 trie->length=length; 280 trie->isMemoryOwned=TRUE; 281 282 /* set the UTrie2 fields */ 283 if(valueBits==UTRIE2_16_VALUE_BITS) { 284 dataMove=indexLength; 285 } else { 286 dataMove=0; 287 } 288 289 trie->indexLength=indexLength; 290 trie->dataLength=dataLength; 291 trie->index2NullOffset=UTRIE2_INDEX_2_OFFSET; 292 trie->dataNullOffset=(uint16_t)dataMove; 293 trie->initialValue=initialValue; 294 trie->errorValue=errorValue; 295 trie->highStart=0; 296 trie->highValueIndex=dataMove+UTRIE2_DATA_START_OFFSET; 297 298 /* set the header fields */ 299 header=(UTrie2Header *)trie->memory; 300 301 header->signature=UTRIE2_SIG; /* "Tri2" */ 302 header->options=(uint16_t)valueBits; 303 304 header->indexLength=(uint16_t)indexLength; 305 header->shiftedDataLength=(uint16_t)(dataLength>>UTRIE2_INDEX_SHIFT); 306 header->index2NullOffset=(uint16_t)UTRIE2_INDEX_2_OFFSET; 307 header->dataNullOffset=(uint16_t)dataMove; 308 header->shiftedHighStart=0; 309 310 /* fill the index and data arrays */ 311 dest16=(uint16_t *)(header+1); 312 trie->index=dest16; 313 314 /* write the index-2 array values shifted right by UTRIE2_INDEX_SHIFT */ 315 for(i=0; i<UTRIE2_INDEX_2_BMP_LENGTH; ++i) { 316 *dest16++=(uint16_t)(dataMove>>UTRIE2_INDEX_SHIFT); /* null data block */ 317 } 318 319 /* write UTF-8 2-byte index-2 values, not right-shifted */ 320 for(i=0; i<(0xc2-0xc0); ++i) { /* C0..C1 */ 321 *dest16++=(uint16_t)(dataMove+UTRIE2_BAD_UTF8_DATA_OFFSET); 322 } 323 for(; i<(0xe0-0xc0); ++i) { /* C2..DF */ 324 *dest16++=(uint16_t)dataMove; 325 } 326 327 /* write the 16/32-bit data array */ 328 switch(valueBits) { 329 case UTRIE2_16_VALUE_BITS: 330 /* write 16-bit data values */ 331 trie->data16=dest16; 332 trie->data32=NULL; 333 for(i=0; i<0x80; ++i) { 334 *dest16++=(uint16_t)initialValue; 335 } 336 for(; i<0xc0; ++i) { 337 *dest16++=(uint16_t)errorValue; 338 } 339 /* highValue and reserved values */ 340 for(i=0; i<UTRIE2_DATA_GRANULARITY; ++i) { 341 *dest16++=(uint16_t)initialValue; 342 } 343 break; 344 case UTRIE2_32_VALUE_BITS: 345 /* write 32-bit data values */ 346 p=(uint32_t *)dest16; 347 trie->data16=NULL; 348 trie->data32=p; 349 for(i=0; i<0x80; ++i) { 350 *p++=initialValue; 351 } 352 for(; i<0xc0; ++i) { 353 *p++=errorValue; 354 } 355 /* highValue and reserved values */ 356 for(i=0; i<UTRIE2_DATA_GRANULARITY; ++i) { 357 *p++=initialValue; 358 } 359 break; 360 default: 361 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 362 return 0; 363 } 364 365 return trie; 366 } 367 368 U_CAPI void U_EXPORT2 369 utrie2_close(UTrie2 *trie) { 370 if(trie!=NULL) { 371 if(trie->isMemoryOwned) { 372 uprv_free(trie->memory); 373 } 374 if(trie->newTrie!=NULL) { 375 uprv_free(trie->newTrie->data); 376 uprv_free(trie->newTrie); 377 } 378 uprv_free(trie); 379 } 380 } 381 382 U_CAPI int32_t U_EXPORT2 383 utrie2_getVersion(const void *data, int32_t length, UBool anyEndianOk) { 384 uint32_t signature; 385 if(length<16 || data==NULL || (U_POINTER_MASK_LSB(data, 3)!=0)) { 386 return 0; 387 } 388 signature=*(const uint32_t *)data; 389 if(signature==UTRIE2_SIG) { 390 return 2; 391 } 392 if(anyEndianOk && signature==UTRIE2_OE_SIG) { 393 return 2; 394 } 395 if(signature==UTRIE_SIG) { 396 return 1; 397 } 398 if(anyEndianOk && signature==UTRIE_OE_SIG) { 399 return 1; 400 } 401 return 0; 402 } 403 404 U_CAPI UBool U_EXPORT2 405 utrie2_isFrozen(const UTrie2 *trie) { 406 return (UBool)(trie->newTrie==NULL); 407 } 408 409 U_CAPI int32_t U_EXPORT2 410 utrie2_serialize(const UTrie2 *trie, 411 void *data, int32_t capacity, 412 UErrorCode *pErrorCode) { 413 /* argument check */ 414 if(U_FAILURE(*pErrorCode)) { 415 return 0; 416 } 417 418 if( trie==NULL || trie->memory==NULL || trie->newTrie!=NULL || 419 capacity<0 || (capacity>0 && (data==NULL || (U_POINTER_MASK_LSB(data, 3)!=0))) 420 ) { 421 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 422 return 0; 423 } 424 425 if(capacity>=trie->length) { 426 uprv_memcpy(data, trie->memory, trie->length); 427 } else { 428 *pErrorCode=U_BUFFER_OVERFLOW_ERROR; 429 } 430 return trie->length; 431 } 432 433 U_CAPI int32_t U_EXPORT2 434 utrie2_swap(const UDataSwapper *ds, 435 const void *inData, int32_t length, void *outData, 436 UErrorCode *pErrorCode) { 437 const UTrie2Header *inTrie; 438 UTrie2Header trie; 439 int32_t dataLength, size; 440 UTrie2ValueBits valueBits; 441 442 if(U_FAILURE(*pErrorCode)) { 443 return 0; 444 } 445 if(ds==NULL || inData==NULL || (length>=0 && outData==NULL)) { 446 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 447 return 0; 448 } 449 450 /* setup and swapping */ 451 if(length>=0 && length<(int32_t)sizeof(UTrie2Header)) { 452 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 453 return 0; 454 } 455 456 inTrie=(const UTrie2Header *)inData; 457 trie.signature=ds->readUInt32(inTrie->signature); 458 trie.options=ds->readUInt16(inTrie->options); 459 trie.indexLength=ds->readUInt16(inTrie->indexLength); 460 trie.shiftedDataLength=ds->readUInt16(inTrie->shiftedDataLength); 461 462 valueBits=(UTrie2ValueBits)(trie.options&UTRIE2_OPTIONS_VALUE_BITS_MASK); 463 dataLength=(int32_t)trie.shiftedDataLength<<UTRIE2_INDEX_SHIFT; 464 465 if( trie.signature!=UTRIE2_SIG || 466 valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits || 467 trie.indexLength<UTRIE2_INDEX_1_OFFSET || 468 dataLength<UTRIE2_DATA_START_OFFSET 469 ) { 470 *pErrorCode=U_INVALID_FORMAT_ERROR; /* not a UTrie */ 471 return 0; 472 } 473 474 size=sizeof(UTrie2Header)+trie.indexLength*2; 475 switch(valueBits) { 476 case UTRIE2_16_VALUE_BITS: 477 size+=dataLength*2; 478 break; 479 case UTRIE2_32_VALUE_BITS: 480 size+=dataLength*4; 481 break; 482 default: 483 *pErrorCode=U_INVALID_FORMAT_ERROR; 484 return 0; 485 } 486 487 if(length>=0) { 488 UTrie2Header *outTrie; 489 490 if(length<size) { 491 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 492 return 0; 493 } 494 495 outTrie=(UTrie2Header *)outData; 496 497 /* swap the header */ 498 ds->swapArray32(ds, &inTrie->signature, 4, &outTrie->signature, pErrorCode); 499 ds->swapArray16(ds, &inTrie->options, 12, &outTrie->options, pErrorCode); 500 501 /* swap the index and the data */ 502 switch(valueBits) { 503 case UTRIE2_16_VALUE_BITS: 504 ds->swapArray16(ds, inTrie+1, (trie.indexLength+dataLength)*2, outTrie+1, pErrorCode); 505 break; 506 case UTRIE2_32_VALUE_BITS: 507 ds->swapArray16(ds, inTrie+1, trie.indexLength*2, outTrie+1, pErrorCode); 508 ds->swapArray32(ds, (const uint16_t *)(inTrie+1)+trie.indexLength, dataLength*4, 509 (uint16_t *)(outTrie+1)+trie.indexLength, pErrorCode); 510 break; 511 default: 512 *pErrorCode=U_INVALID_FORMAT_ERROR; 513 return 0; 514 } 515 } 516 517 return size; 518 } 519 520 // utrie2_swapAnyVersion() should be defined here but lives in utrie2_builder.c 521 // to avoid a dependency from utrie2.cpp on utrie.c. 522 523 /* enumeration -------------------------------------------------------------- */ 524 525 #define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b)) 526 527 /* default UTrie2EnumValue() returns the input value itself */ 528 static uint32_t U_CALLCONV 529 enumSameValue(const void * /*context*/, uint32_t value) { 530 return value; 531 } 532 533 /** 534 * Enumerate all ranges of code points with the same relevant values. 535 * The values are transformed from the raw trie entries by the enumValue function. 536 * 537 * Currently requires start<limit and both start and limit must be multiples 538 * of UTRIE2_DATA_BLOCK_LENGTH. 539 * 540 * Optimizations: 541 * - Skip a whole block if we know that it is filled with a single value, 542 * and it is the same as we visited just before. 543 * - Handle the null block specially because we know a priori that it is filled 544 * with a single value. 545 */ 546 static void 547 enumEitherTrie(const UTrie2 *trie, 548 UChar32 start, UChar32 limit, 549 UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 550 const uint32_t *data32; 551 const uint16_t *idx; 552 553 uint32_t value, prevValue, initialValue; 554 UChar32 c, prev, highStart; 555 int32_t j, i2Block, prevI2Block, index2NullOffset, block, prevBlock, nullBlock; 556 557 if(enumRange==NULL) { 558 return; 559 } 560 if(enumValue==NULL) { 561 enumValue=enumSameValue; 562 } 563 564 if(trie->newTrie==NULL) { 565 /* frozen trie */ 566 idx=trie->index; 567 U_ASSERT(idx!=NULL); /* the following code assumes trie->newTrie is not NULL when idx is NULL */ 568 data32=trie->data32; 569 570 index2NullOffset=trie->index2NullOffset; 571 nullBlock=trie->dataNullOffset; 572 } else { 573 /* unfrozen, mutable trie */ 574 idx=NULL; 575 data32=trie->newTrie->data; 576 U_ASSERT(data32!=NULL); /* the following code assumes idx is not NULL when data32 is NULL */ 577 578 index2NullOffset=trie->newTrie->index2NullOffset; 579 nullBlock=trie->newTrie->dataNullOffset; 580 } 581 582 highStart=trie->highStart; 583 584 /* get the enumeration value that corresponds to an initial-value trie data entry */ 585 initialValue=enumValue(context, trie->initialValue); 586 587 /* set variables for previous range */ 588 prevI2Block=-1; 589 prevBlock=-1; 590 prev=start; 591 prevValue=0; 592 593 /* enumerate index-2 blocks */ 594 for(c=start; c<limit && c<highStart;) { 595 /* Code point limit for iterating inside this i2Block. */ 596 UChar32 tempLimit=c+UTRIE2_CP_PER_INDEX_1_ENTRY; 597 if(limit<tempLimit) { 598 tempLimit=limit; 599 } 600 if(c<=0xffff) { 601 if(!U_IS_SURROGATE(c)) { 602 i2Block=c>>UTRIE2_SHIFT_2; 603 } else if(U_IS_SURROGATE_LEAD(c)) { 604 /* 605 * Enumerate values for lead surrogate code points, not code units: 606 * This special block has half the normal length. 607 */ 608 i2Block=UTRIE2_LSCP_INDEX_2_OFFSET; 609 tempLimit=MIN_VALUE(0xdc00, limit); 610 } else { 611 /* 612 * Switch back to the normal part of the index-2 table. 613 * Enumerate the second half of the surrogates block. 614 */ 615 i2Block=0xd800>>UTRIE2_SHIFT_2; 616 tempLimit=MIN_VALUE(0xe000, limit); 617 } 618 } else { 619 /* supplementary code points */ 620 if(idx!=NULL) { 621 i2Block=idx[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+ 622 (c>>UTRIE2_SHIFT_1)]; 623 } else { 624 i2Block=trie->newTrie->index1[c>>UTRIE2_SHIFT_1]; 625 } 626 if(i2Block==prevI2Block && (c-prev)>=UTRIE2_CP_PER_INDEX_1_ENTRY) { 627 /* 628 * The index-2 block is the same as the previous one, and filled with prevValue. 629 * Only possible for supplementary code points because the linear-BMP index-2 630 * table creates unique i2Block values. 631 */ 632 c+=UTRIE2_CP_PER_INDEX_1_ENTRY; 633 continue; 634 } 635 } 636 prevI2Block=i2Block; 637 if(i2Block==index2NullOffset) { 638 /* this is the null index-2 block */ 639 if(prevValue!=initialValue) { 640 if(prev<c && !enumRange(context, prev, c-1, prevValue)) { 641 return; 642 } 643 prevBlock=nullBlock; 644 prev=c; 645 prevValue=initialValue; 646 } 647 c+=UTRIE2_CP_PER_INDEX_1_ENTRY; 648 } else { 649 /* enumerate data blocks for one index-2 block */ 650 int32_t i2, i2Limit; 651 i2=(c>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 652 if((c>>UTRIE2_SHIFT_1)==(tempLimit>>UTRIE2_SHIFT_1)) { 653 i2Limit=(tempLimit>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK; 654 } else { 655 i2Limit=UTRIE2_INDEX_2_BLOCK_LENGTH; 656 } 657 for(; i2<i2Limit; ++i2) { 658 if(idx!=NULL) { 659 block=(int32_t)idx[i2Block+i2]<<UTRIE2_INDEX_SHIFT; 660 } else { 661 block=trie->newTrie->index2[i2Block+i2]; 662 } 663 if(block==prevBlock && (c-prev)>=UTRIE2_DATA_BLOCK_LENGTH) { 664 /* the block is the same as the previous one, and filled with prevValue */ 665 c+=UTRIE2_DATA_BLOCK_LENGTH; 666 continue; 667 } 668 prevBlock=block; 669 if(block==nullBlock) { 670 /* this is the null data block */ 671 if(prevValue!=initialValue) { 672 if(prev<c && !enumRange(context, prev, c-1, prevValue)) { 673 return; 674 } 675 prev=c; 676 prevValue=initialValue; 677 } 678 c+=UTRIE2_DATA_BLOCK_LENGTH; 679 } else { 680 for(j=0; j<UTRIE2_DATA_BLOCK_LENGTH; ++j) { 681 value=enumValue(context, data32!=NULL ? data32[block+j] : idx[block+j]); 682 if(value!=prevValue) { 683 if(prev<c && !enumRange(context, prev, c-1, prevValue)) { 684 return; 685 } 686 prev=c; 687 prevValue=value; 688 } 689 ++c; 690 } 691 } 692 } 693 } 694 } 695 696 if(c>limit) { 697 c=limit; /* could be higher if in the index2NullOffset */ 698 } else if(c<limit) { 699 /* c==highStart<limit */ 700 uint32_t highValue; 701 if(idx!=NULL) { 702 highValue= 703 data32!=NULL ? 704 data32[trie->highValueIndex] : 705 idx[trie->highValueIndex]; 706 } else { 707 highValue=trie->newTrie->data[trie->newTrie->dataLength-UTRIE2_DATA_GRANULARITY]; 708 } 709 value=enumValue(context, highValue); 710 if(value!=prevValue) { 711 if(prev<c && !enumRange(context, prev, c-1, prevValue)) { 712 return; 713 } 714 prev=c; 715 prevValue=value; 716 } 717 c=limit; 718 } 719 720 /* deliver last range */ 721 enumRange(context, prev, c-1, prevValue); 722 } 723 724 U_CAPI void U_EXPORT2 725 utrie2_enum(const UTrie2 *trie, 726 UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) { 727 enumEitherTrie(trie, 0, 0x110000, enumValue, enumRange, context); 728 } 729 730 U_CAPI void U_EXPORT2 731 utrie2_enumForLeadSurrogate(const UTrie2 *trie, UChar32 lead, 732 UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, 733 const void *context) { 734 if(!U16_IS_LEAD(lead)) { 735 return; 736 } 737 lead=(lead-0xd7c0)<<10; /* start code point */ 738 enumEitherTrie(trie, lead, lead+0x400, enumValue, enumRange, context); 739 } 740 741 /* C++ convenience wrappers ------------------------------------------------- */ 742 743 U_NAMESPACE_BEGIN 744 745 uint16_t BackwardUTrie2StringIterator::previous16() { 746 codePointLimit=codePointStart; 747 if(start>=codePointStart) { 748 codePoint=U_SENTINEL; 749 return trie->errorValue; 750 } 751 uint16_t result; 752 UTRIE2_U16_PREV16(trie, start, codePointStart, codePoint, result); 753 return result; 754 } 755 756 uint16_t ForwardUTrie2StringIterator::next16() { 757 codePointStart=codePointLimit; 758 if(codePointLimit==limit) { 759 codePoint=U_SENTINEL; 760 return trie->errorValue; 761 } 762 uint16_t result; 763 UTRIE2_U16_NEXT16(trie, codePointLimit, limit, codePoint, result); 764 return result; 765 } 766 767 U_NAMESPACE_END 768
