1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 2002-2006, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: uiter.cpp 9 * encoding: US-ASCII 10 * tab size: 8 (not used) 11 * indentation:4 12 * 13 * created on: 2002jan18 14 * created by: Markus W. Scherer 15 */ 16 17 #include "unicode/utypes.h" 18 #include "unicode/ustring.h" 19 #include "unicode/chariter.h" 20 #include "unicode/rep.h" 21 #include "unicode/uiter.h" 22 #include "cstring.h" 23 24 U_NAMESPACE_USE 25 26 #define IS_EVEN(n) (((n)&1)==0) 27 #define IS_POINTER_EVEN(p) IS_EVEN((size_t)p) 28 29 U_CDECL_BEGIN 30 31 /* No-Op UCharIterator implementation for illegal input --------------------- */ 32 33 static int32_t U_CALLCONV 34 noopGetIndex(UCharIterator * /*iter*/, UCharIteratorOrigin /*origin*/) { 35 return 0; 36 } 37 38 static int32_t U_CALLCONV 39 noopMove(UCharIterator * /*iter*/, int32_t /*delta*/, UCharIteratorOrigin /*origin*/) { 40 return 0; 41 } 42 43 static UBool U_CALLCONV 44 noopHasNext(UCharIterator * /*iter*/) { 45 return FALSE; 46 } 47 48 static UChar32 U_CALLCONV 49 noopCurrent(UCharIterator * /*iter*/) { 50 return U_SENTINEL; 51 } 52 53 static uint32_t U_CALLCONV 54 noopGetState(const UCharIterator * /*iter*/) { 55 return UITER_NO_STATE; 56 } 57 58 static void U_CALLCONV 59 noopSetState(UCharIterator * /*iter*/, uint32_t /*state*/, UErrorCode *pErrorCode) { 60 *pErrorCode=U_UNSUPPORTED_ERROR; 61 } 62 63 static const UCharIterator noopIterator={ 64 0, 0, 0, 0, 0, 0, 65 noopGetIndex, 66 noopMove, 67 noopHasNext, 68 noopHasNext, 69 noopCurrent, 70 noopCurrent, 71 noopCurrent, 72 NULL, 73 noopGetState, 74 noopSetState 75 }; 76 77 /* UCharIterator implementation for simple strings -------------------------- */ 78 79 /* 80 * This is an implementation of a code unit (UChar) iterator 81 * for UChar * strings. 82 * 83 * The UCharIterator.context field holds a pointer to the string. 84 */ 85 86 static int32_t U_CALLCONV 87 stringIteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) { 88 switch(origin) { 89 case UITER_ZERO: 90 return 0; 91 case UITER_START: 92 return iter->start; 93 case UITER_CURRENT: 94 return iter->index; 95 case UITER_LIMIT: 96 return iter->limit; 97 case UITER_LENGTH: 98 return iter->length; 99 default: 100 /* not a valid origin */ 101 /* Should never get here! */ 102 return -1; 103 } 104 } 105 106 static int32_t U_CALLCONV 107 stringIteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) { 108 int32_t pos; 109 110 switch(origin) { 111 case UITER_ZERO: 112 pos=delta; 113 break; 114 case UITER_START: 115 pos=iter->start+delta; 116 break; 117 case UITER_CURRENT: 118 pos=iter->index+delta; 119 break; 120 case UITER_LIMIT: 121 pos=iter->limit+delta; 122 break; 123 case UITER_LENGTH: 124 pos=iter->length+delta; 125 break; 126 default: 127 return -1; /* Error */ 128 } 129 130 if(pos<iter->start) { 131 pos=iter->start; 132 } else if(pos>iter->limit) { 133 pos=iter->limit; 134 } 135 136 return iter->index=pos; 137 } 138 139 static UBool U_CALLCONV 140 stringIteratorHasNext(UCharIterator *iter) { 141 return iter->index<iter->limit; 142 } 143 144 static UBool U_CALLCONV 145 stringIteratorHasPrevious(UCharIterator *iter) { 146 return iter->index>iter->start; 147 } 148 149 static UChar32 U_CALLCONV 150 stringIteratorCurrent(UCharIterator *iter) { 151 if(iter->index<iter->limit) { 152 return ((const UChar *)(iter->context))[iter->index]; 153 } else { 154 return U_SENTINEL; 155 } 156 } 157 158 static UChar32 U_CALLCONV 159 stringIteratorNext(UCharIterator *iter) { 160 if(iter->index<iter->limit) { 161 return ((const UChar *)(iter->context))[iter->index++]; 162 } else { 163 return U_SENTINEL; 164 } 165 } 166 167 static UChar32 U_CALLCONV 168 stringIteratorPrevious(UCharIterator *iter) { 169 if(iter->index>iter->start) { 170 return ((const UChar *)(iter->context))[--iter->index]; 171 } else { 172 return U_SENTINEL; 173 } 174 } 175 176 static uint32_t U_CALLCONV 177 stringIteratorGetState(const UCharIterator *iter) { 178 return (uint32_t)iter->index; 179 } 180 181 static void U_CALLCONV 182 stringIteratorSetState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) { 183 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 184 /* do nothing */ 185 } else if(iter==NULL) { 186 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 187 } else if((int32_t)state<iter->start || iter->limit<(int32_t)state) { 188 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 189 } else { 190 iter->index=(int32_t)state; 191 } 192 } 193 194 static const UCharIterator stringIterator={ 195 0, 0, 0, 0, 0, 0, 196 stringIteratorGetIndex, 197 stringIteratorMove, 198 stringIteratorHasNext, 199 stringIteratorHasPrevious, 200 stringIteratorCurrent, 201 stringIteratorNext, 202 stringIteratorPrevious, 203 NULL, 204 stringIteratorGetState, 205 stringIteratorSetState 206 }; 207 208 U_CAPI void U_EXPORT2 209 uiter_setString(UCharIterator *iter, const UChar *s, int32_t length) { 210 if(iter!=0) { 211 if(s!=0 && length>=-1) { 212 *iter=stringIterator; 213 iter->context=s; 214 if(length>=0) { 215 iter->length=length; 216 } else { 217 iter->length=u_strlen(s); 218 } 219 iter->limit=iter->length; 220 } else { 221 *iter=noopIterator; 222 } 223 } 224 } 225 226 /* UCharIterator implementation for UTF-16BE strings ------------------------ */ 227 228 /* 229 * This is an implementation of a code unit (UChar) iterator 230 * for UTF-16BE strings, i.e., strings in byte-vectors where 231 * each UChar is stored as a big-endian pair of bytes. 232 * 233 * The UCharIterator.context field holds a pointer to the string. 234 * Everything works just like with a normal UChar iterator (uiter_setString), 235 * except that UChars are assembled from byte pairs. 236 */ 237 238 /* internal helper function */ 239 static inline UChar32 240 utf16BEIteratorGet(UCharIterator *iter, int32_t index) { 241 const uint8_t *p=(const uint8_t *)iter->context; 242 return ((UChar)p[2*index]<<8)|(UChar)p[2*index+1]; 243 } 244 245 static UChar32 U_CALLCONV 246 utf16BEIteratorCurrent(UCharIterator *iter) { 247 int32_t index; 248 249 if((index=iter->index)<iter->limit) { 250 return utf16BEIteratorGet(iter, index); 251 } else { 252 return U_SENTINEL; 253 } 254 } 255 256 static UChar32 U_CALLCONV 257 utf16BEIteratorNext(UCharIterator *iter) { 258 int32_t index; 259 260 if((index=iter->index)<iter->limit) { 261 iter->index=index+1; 262 return utf16BEIteratorGet(iter, index); 263 } else { 264 return U_SENTINEL; 265 } 266 } 267 268 static UChar32 U_CALLCONV 269 utf16BEIteratorPrevious(UCharIterator *iter) { 270 int32_t index; 271 272 if((index=iter->index)>iter->start) { 273 iter->index=--index; 274 return utf16BEIteratorGet(iter, index); 275 } else { 276 return U_SENTINEL; 277 } 278 } 279 280 static const UCharIterator utf16BEIterator={ 281 0, 0, 0, 0, 0, 0, 282 stringIteratorGetIndex, 283 stringIteratorMove, 284 stringIteratorHasNext, 285 stringIteratorHasPrevious, 286 utf16BEIteratorCurrent, 287 utf16BEIteratorNext, 288 utf16BEIteratorPrevious, 289 NULL, 290 stringIteratorGetState, 291 stringIteratorSetState 292 }; 293 294 /* 295 * Count the number of UChars in a UTF-16BE string before a terminating UChar NUL, 296 * i.e., before a pair of 0 bytes where the first 0 byte is at an even 297 * offset from s. 298 */ 299 static int32_t 300 utf16BE_strlen(const char *s) { 301 if(IS_POINTER_EVEN(s)) { 302 /* 303 * even-aligned, call u_strlen(s) 304 * we are probably on a little-endian machine, but searching for UChar NUL 305 * does not care about endianness 306 */ 307 return u_strlen((const UChar *)s); 308 } else { 309 /* odd-aligned, search for pair of 0 bytes */ 310 const char *p=s; 311 312 while(!(*p==0 && p[1]==0)) { 313 p+=2; 314 } 315 return (int32_t)((p-s)/2); 316 } 317 } 318 319 U_CAPI void U_EXPORT2 320 uiter_setUTF16BE(UCharIterator *iter, const char *s, int32_t length) { 321 if(iter!=NULL) { 322 /* allow only even-length strings (the input length counts bytes) */ 323 if(s!=NULL && (length==-1 || (length>=0 && IS_EVEN(length)))) { 324 /* length/=2, except that >>=1 also works for -1 (-1/2==0, -1>>1==-1) */ 325 length>>=1; 326 327 if(U_IS_BIG_ENDIAN && IS_POINTER_EVEN(s)) { 328 /* big-endian machine and 2-aligned UTF-16BE string: use normal UChar iterator */ 329 uiter_setString(iter, (const UChar *)s, length); 330 return; 331 } 332 333 *iter=utf16BEIterator; 334 iter->context=s; 335 if(length>=0) { 336 iter->length=length; 337 } else { 338 iter->length=utf16BE_strlen(s); 339 } 340 iter->limit=iter->length; 341 } else { 342 *iter=noopIterator; 343 } 344 } 345 } 346 347 /* UCharIterator wrapper around CharacterIterator --------------------------- */ 348 349 /* 350 * This is wrapper code around a C++ CharacterIterator to 351 * look like a C UCharIterator. 352 * 353 * The UCharIterator.context field holds a pointer to the CharacterIterator. 354 */ 355 356 static int32_t U_CALLCONV 357 characterIteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) { 358 switch(origin) { 359 case UITER_ZERO: 360 return 0; 361 case UITER_START: 362 return ((CharacterIterator *)(iter->context))->startIndex(); 363 case UITER_CURRENT: 364 return ((CharacterIterator *)(iter->context))->getIndex(); 365 case UITER_LIMIT: 366 return ((CharacterIterator *)(iter->context))->endIndex(); 367 case UITER_LENGTH: 368 return ((CharacterIterator *)(iter->context))->getLength(); 369 default: 370 /* not a valid origin */ 371 /* Should never get here! */ 372 return -1; 373 } 374 } 375 376 static int32_t U_CALLCONV 377 characterIteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) { 378 switch(origin) { 379 case UITER_ZERO: 380 ((CharacterIterator *)(iter->context))->setIndex(delta); 381 return ((CharacterIterator *)(iter->context))->getIndex(); 382 case UITER_START: 383 case UITER_CURRENT: 384 case UITER_LIMIT: 385 return ((CharacterIterator *)(iter->context))->move(delta, (CharacterIterator::EOrigin)origin); 386 case UITER_LENGTH: 387 ((CharacterIterator *)(iter->context))->setIndex(((CharacterIterator *)(iter->context))->getLength()+delta); 388 return ((CharacterIterator *)(iter->context))->getIndex(); 389 default: 390 /* not a valid origin */ 391 /* Should never get here! */ 392 return -1; 393 } 394 } 395 396 static UBool U_CALLCONV 397 characterIteratorHasNext(UCharIterator *iter) { 398 return ((CharacterIterator *)(iter->context))->hasNext(); 399 } 400 401 static UBool U_CALLCONV 402 characterIteratorHasPrevious(UCharIterator *iter) { 403 return ((CharacterIterator *)(iter->context))->hasPrevious(); 404 } 405 406 static UChar32 U_CALLCONV 407 characterIteratorCurrent(UCharIterator *iter) { 408 UChar32 c; 409 410 c=((CharacterIterator *)(iter->context))->current(); 411 if(c!=0xffff || ((CharacterIterator *)(iter->context))->hasNext()) { 412 return c; 413 } else { 414 return U_SENTINEL; 415 } 416 } 417 418 static UChar32 U_CALLCONV 419 characterIteratorNext(UCharIterator *iter) { 420 if(((CharacterIterator *)(iter->context))->hasNext()) { 421 return ((CharacterIterator *)(iter->context))->nextPostInc(); 422 } else { 423 return U_SENTINEL; 424 } 425 } 426 427 static UChar32 U_CALLCONV 428 characterIteratorPrevious(UCharIterator *iter) { 429 if(((CharacterIterator *)(iter->context))->hasPrevious()) { 430 return ((CharacterIterator *)(iter->context))->previous(); 431 } else { 432 return U_SENTINEL; 433 } 434 } 435 436 static uint32_t U_CALLCONV 437 characterIteratorGetState(const UCharIterator *iter) { 438 return ((CharacterIterator *)(iter->context))->getIndex(); 439 } 440 441 static void U_CALLCONV 442 characterIteratorSetState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) { 443 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 444 /* do nothing */ 445 } else if(iter==NULL || iter->context==NULL) { 446 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 447 } else if((int32_t)state<((CharacterIterator *)(iter->context))->startIndex() || ((CharacterIterator *)(iter->context))->endIndex()<(int32_t)state) { 448 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 449 } else { 450 ((CharacterIterator *)(iter->context))->setIndex((int32_t)state); 451 } 452 } 453 454 static const UCharIterator characterIteratorWrapper={ 455 0, 0, 0, 0, 0, 0, 456 characterIteratorGetIndex, 457 characterIteratorMove, 458 characterIteratorHasNext, 459 characterIteratorHasPrevious, 460 characterIteratorCurrent, 461 characterIteratorNext, 462 characterIteratorPrevious, 463 NULL, 464 characterIteratorGetState, 465 characterIteratorSetState 466 }; 467 468 U_CAPI void U_EXPORT2 469 uiter_setCharacterIterator(UCharIterator *iter, CharacterIterator *charIter) { 470 if(iter!=0) { 471 if(charIter!=0) { 472 *iter=characterIteratorWrapper; 473 iter->context=charIter; 474 } else { 475 *iter=noopIterator; 476 } 477 } 478 } 479 480 /* UCharIterator wrapper around Replaceable --------------------------------- */ 481 482 /* 483 * This is an implementation of a code unit (UChar) iterator 484 * based on a Replaceable object. 485 * 486 * The UCharIterator.context field holds a pointer to the Replaceable. 487 * UCharIterator.length and UCharIterator.index hold Replaceable.length() 488 * and the iteration index. 489 */ 490 491 static UChar32 U_CALLCONV 492 replaceableIteratorCurrent(UCharIterator *iter) { 493 if(iter->index<iter->limit) { 494 return ((Replaceable *)(iter->context))->charAt(iter->index); 495 } else { 496 return U_SENTINEL; 497 } 498 } 499 500 static UChar32 U_CALLCONV 501 replaceableIteratorNext(UCharIterator *iter) { 502 if(iter->index<iter->limit) { 503 return ((Replaceable *)(iter->context))->charAt(iter->index++); 504 } else { 505 return U_SENTINEL; 506 } 507 } 508 509 static UChar32 U_CALLCONV 510 replaceableIteratorPrevious(UCharIterator *iter) { 511 if(iter->index>iter->start) { 512 return ((Replaceable *)(iter->context))->charAt(--iter->index); 513 } else { 514 return U_SENTINEL; 515 } 516 } 517 518 static const UCharIterator replaceableIterator={ 519 0, 0, 0, 0, 0, 0, 520 stringIteratorGetIndex, 521 stringIteratorMove, 522 stringIteratorHasNext, 523 stringIteratorHasPrevious, 524 replaceableIteratorCurrent, 525 replaceableIteratorNext, 526 replaceableIteratorPrevious, 527 NULL, 528 stringIteratorGetState, 529 stringIteratorSetState 530 }; 531 532 U_CAPI void U_EXPORT2 533 uiter_setReplaceable(UCharIterator *iter, const Replaceable *rep) { 534 if(iter!=0) { 535 if(rep!=0) { 536 *iter=replaceableIterator; 537 iter->context=rep; 538 iter->limit=iter->length=rep->length(); 539 } else { 540 *iter=noopIterator; 541 } 542 } 543 } 544 545 /* UCharIterator implementation for UTF-8 strings --------------------------- */ 546 547 /* 548 * Possible, probably necessary only for an implementation for arbitrary 549 * converters: 550 * Maintain a buffer (ring buffer?) for a piece of converted 16-bit text. 551 * This would require to turn reservedFn into a close function and 552 * to introduce a uiter_close(iter). 553 */ 554 555 #define UITER_CNV_CAPACITY 16 556 557 /* 558 * Minimal implementation: 559 * Maintain a single-UChar buffer for an additional surrogate. 560 * The caller must not modify start and limit because they are used internally. 561 * 562 * Use UCharIterator fields as follows: 563 * context pointer to UTF-8 string 564 * length UTF-16 length of the string; -1 until lazy evaluation 565 * start current UTF-8 index 566 * index current UTF-16 index; may be -1="unknown" after setState() 567 * limit UTF-8 length of the string 568 * reservedField supplementary code point 569 * 570 * Since UCharIterator delivers 16-bit code units, the iteration can be 571 * currently in the middle of the byte sequence for a supplementary code point. 572 * In this case, reservedField will contain that code point and start will 573 * point to after the corresponding byte sequence. The UTF-16 index will be 574 * one less than what it would otherwise be corresponding to the UTF-8 index. 575 * Otherwise, reservedField will be 0. 576 */ 577 578 /* 579 * Possible optimization for NUL-terminated UTF-8 and UTF-16 strings: 580 * Add implementations that do not call strlen() for iteration but check for NUL. 581 */ 582 583 static int32_t U_CALLCONV 584 utf8IteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) { 585 switch(origin) { 586 case UITER_ZERO: 587 case UITER_START: 588 return 0; 589 case UITER_CURRENT: 590 if(iter->index<0) { 591 /* the current UTF-16 index is unknown after setState(), count from the beginning */ 592 const uint8_t *s; 593 UChar32 c; 594 int32_t i, limit, index; 595 596 s=(const uint8_t *)iter->context; 597 i=index=0; 598 limit=iter->start; /* count up to the UTF-8 index */ 599 while(i<limit) { 600 U8_NEXT(s, i, limit, c); 601 if(c<=0xffff) { 602 ++index; 603 } else { 604 index+=2; 605 } 606 } 607 608 iter->start=i; /* just in case setState() did not get us to a code point boundary */ 609 if(i==iter->limit) { 610 iter->length=index; /* in case it was <0 or wrong */ 611 } 612 if(iter->reservedField!=0) { 613 --index; /* we are in the middle of a supplementary code point */ 614 } 615 iter->index=index; 616 } 617 return iter->index; 618 case UITER_LIMIT: 619 case UITER_LENGTH: 620 if(iter->length<0) { 621 const uint8_t *s; 622 UChar32 c; 623 int32_t i, limit, length; 624 625 s=(const uint8_t *)iter->context; 626 if(iter->index<0) { 627 /* 628 * the current UTF-16 index is unknown after setState(), 629 * we must first count from the beginning to here 630 */ 631 i=length=0; 632 limit=iter->start; 633 634 /* count from the beginning to the current index */ 635 while(i<limit) { 636 U8_NEXT(s, i, limit, c); 637 if(c<=0xffff) { 638 ++length; 639 } else { 640 length+=2; 641 } 642 } 643 644 /* assume i==limit==iter->start, set the UTF-16 index */ 645 iter->start=i; /* just in case setState() did not get us to a code point boundary */ 646 iter->index= iter->reservedField!=0 ? length-1 : length; 647 } else { 648 i=iter->start; 649 length=iter->index; 650 if(iter->reservedField!=0) { 651 ++length; 652 } 653 } 654 655 /* count from the current index to the end */ 656 limit=iter->limit; 657 while(i<limit) { 658 U8_NEXT(s, i, limit, c); 659 if(c<=0xffff) { 660 ++length; 661 } else { 662 length+=2; 663 } 664 } 665 iter->length=length; 666 } 667 return iter->length; 668 default: 669 /* not a valid origin */ 670 /* Should never get here! */ 671 return -1; 672 } 673 } 674 675 static int32_t U_CALLCONV 676 utf8IteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) { 677 const uint8_t *s; 678 UChar32 c; 679 int32_t pos; /* requested UTF-16 index */ 680 int32_t i; /* UTF-8 index */ 681 UBool havePos; 682 683 /* calculate the requested UTF-16 index */ 684 switch(origin) { 685 case UITER_ZERO: 686 case UITER_START: 687 pos=delta; 688 havePos=TRUE; 689 /* iter->index<0 (unknown) is possible */ 690 break; 691 case UITER_CURRENT: 692 if(iter->index>=0) { 693 pos=iter->index+delta; 694 havePos=TRUE; 695 } else { 696 /* the current UTF-16 index is unknown after setState(), use only delta */ 697 pos=0; 698 havePos=FALSE; 699 } 700 break; 701 case UITER_LIMIT: 702 case UITER_LENGTH: 703 if(iter->length>=0) { 704 pos=iter->length+delta; 705 havePos=TRUE; 706 } else { 707 /* pin to the end, avoid counting the length */ 708 iter->index=-1; 709 iter->start=iter->limit; 710 iter->reservedField=0; 711 if(delta>=0) { 712 return UITER_UNKNOWN_INDEX; 713 } else { 714 /* the current UTF-16 index is unknown, use only delta */ 715 pos=0; 716 havePos=FALSE; 717 } 718 } 719 break; 720 default: 721 return -1; /* Error */ 722 } 723 724 if(havePos) { 725 /* shortcuts: pinning to the edges of the string */ 726 if(pos<=0) { 727 iter->index=iter->start=iter->reservedField=0; 728 return 0; 729 } else if(iter->length>=0 && pos>=iter->length) { 730 iter->index=iter->length; 731 iter->start=iter->limit; 732 iter->reservedField=0; 733 return iter->index; 734 } 735 736 /* minimize the number of U8_NEXT/PREV operations */ 737 if(iter->index<0 || pos<iter->index/2) { 738 /* go forward from the start instead of backward from the current index */ 739 iter->index=iter->start=iter->reservedField=0; 740 } else if(iter->length>=0 && (iter->length-pos)<(pos-iter->index)) { 741 /* 742 * if we have the UTF-16 index and length and the new position is 743 * closer to the end than the current index, 744 * then go backward from the end instead of forward from the current index 745 */ 746 iter->index=iter->length; 747 iter->start=iter->limit; 748 iter->reservedField=0; 749 } 750 751 delta=pos-iter->index; 752 if(delta==0) { 753 return iter->index; /* nothing to do */ 754 } 755 } else { 756 /* move relative to unknown UTF-16 index */ 757 if(delta==0) { 758 return UITER_UNKNOWN_INDEX; /* nothing to do */ 759 } else if(-delta>=iter->start) { 760 /* moving backwards by more UChars than there are UTF-8 bytes, pin to 0 */ 761 iter->index=iter->start=iter->reservedField=0; 762 return 0; 763 } else if(delta>=(iter->limit-iter->start)) { 764 /* moving forward by more UChars than the remaining UTF-8 bytes, pin to the end */ 765 iter->index=iter->length; /* may or may not be <0 (unknown) */ 766 iter->start=iter->limit; 767 iter->reservedField=0; 768 return iter->index>=0 ? iter->index : (int32_t)UITER_UNKNOWN_INDEX; 769 } 770 } 771 772 /* delta!=0 */ 773 774 /* move towards the requested position, pin to the edges of the string */ 775 s=(const uint8_t *)iter->context; 776 pos=iter->index; /* could be <0 (unknown) */ 777 i=iter->start; 778 if(delta>0) { 779 /* go forward */ 780 int32_t limit=iter->limit; 781 if(iter->reservedField!=0) { 782 iter->reservedField=0; 783 ++pos; 784 --delta; 785 } 786 while(delta>0 && i<limit) { 787 U8_NEXT(s, i, limit, c); 788 if(c<0xffff) { 789 ++pos; 790 --delta; 791 } else if(delta>=2) { 792 pos+=2; 793 delta-=2; 794 } else /* delta==1 */ { 795 /* stop in the middle of a supplementary code point */ 796 iter->reservedField=c; 797 ++pos; 798 break; /* delta=0; */ 799 } 800 } 801 if(i==limit) { 802 if(iter->length<0 && iter->index>=0) { 803 iter->length= iter->reservedField==0 ? pos : pos+1; 804 } else if(iter->index<0 && iter->length>=0) { 805 iter->index= iter->reservedField==0 ? iter->length : iter->length-1; 806 } 807 } 808 } else /* delta<0 */ { 809 /* go backward */ 810 if(iter->reservedField!=0) { 811 iter->reservedField=0; 812 i-=4; /* we stayed behind the supplementary code point; go before it now */ 813 --pos; 814 ++delta; 815 } 816 while(delta<0 && i>0) { 817 U8_PREV(s, 0, i, c); 818 if(c<0xffff) { 819 --pos; 820 ++delta; 821 } else if(delta<=-2) { 822 pos-=2; 823 delta+=2; 824 } else /* delta==-1 */ { 825 /* stop in the middle of a supplementary code point */ 826 i+=4; /* back to behind this supplementary code point for consistent state */ 827 iter->reservedField=c; 828 --pos; 829 break; /* delta=0; */ 830 } 831 } 832 } 833 834 iter->start=i; 835 if(iter->index>=0) { 836 return iter->index=pos; 837 } else { 838 /* we started with index<0 (unknown) so pos is bogus */ 839 if(i<=1) { 840 return iter->index=i; /* reached the beginning */ 841 } else { 842 /* we still don't know the UTF-16 index */ 843 return UITER_UNKNOWN_INDEX; 844 } 845 } 846 } 847 848 static UBool U_CALLCONV 849 utf8IteratorHasNext(UCharIterator *iter) { 850 return iter->start<iter->limit || iter->reservedField!=0; 851 } 852 853 static UBool U_CALLCONV 854 utf8IteratorHasPrevious(UCharIterator *iter) { 855 return iter->start>0; 856 } 857 858 static UChar32 U_CALLCONV 859 utf8IteratorCurrent(UCharIterator *iter) { 860 if(iter->reservedField!=0) { 861 return U16_TRAIL(iter->reservedField); 862 } else if(iter->start<iter->limit) { 863 const uint8_t *s=(const uint8_t *)iter->context; 864 UChar32 c; 865 int32_t i=iter->start; 866 867 U8_NEXT(s, i, iter->limit, c); 868 if(c<0) { 869 return 0xfffd; 870 } else if(c<=0xffff) { 871 return c; 872 } else { 873 return U16_LEAD(c); 874 } 875 } else { 876 return U_SENTINEL; 877 } 878 } 879 880 static UChar32 U_CALLCONV 881 utf8IteratorNext(UCharIterator *iter) { 882 int32_t index; 883 884 if(iter->reservedField!=0) { 885 UChar trail=U16_TRAIL(iter->reservedField); 886 iter->reservedField=0; 887 if((index=iter->index)>=0) { 888 iter->index=index+1; 889 } 890 return trail; 891 } else if(iter->start<iter->limit) { 892 const uint8_t *s=(const uint8_t *)iter->context; 893 UChar32 c; 894 895 U8_NEXT(s, iter->start, iter->limit, c); 896 if((index=iter->index)>=0) { 897 iter->index=++index; 898 if(iter->length<0 && iter->start==iter->limit) { 899 iter->length= c<=0xffff ? index : index+1; 900 } 901 } else if(iter->start==iter->limit && iter->length>=0) { 902 iter->index= c<=0xffff ? iter->length : iter->length-1; 903 } 904 if(c<0) { 905 return 0xfffd; 906 } else if(c<=0xffff) { 907 return c; 908 } else { 909 iter->reservedField=c; 910 return U16_LEAD(c); 911 } 912 } else { 913 return U_SENTINEL; 914 } 915 } 916 917 static UChar32 U_CALLCONV 918 utf8IteratorPrevious(UCharIterator *iter) { 919 int32_t index; 920 921 if(iter->reservedField!=0) { 922 UChar lead=U16_LEAD(iter->reservedField); 923 iter->reservedField=0; 924 iter->start-=4; /* we stayed behind the supplementary code point; go before it now */ 925 if((index=iter->index)>0) { 926 iter->index=index-1; 927 } 928 return lead; 929 } else if(iter->start>0) { 930 const uint8_t *s=(const uint8_t *)iter->context; 931 UChar32 c; 932 933 U8_PREV(s, 0, iter->start, c); 934 if((index=iter->index)>0) { 935 iter->index=index-1; 936 } else if(iter->start<=1) { 937 iter->index= c<=0xffff ? iter->start : iter->start+1; 938 } 939 if(c<0) { 940 return 0xfffd; 941 } else if(c<=0xffff) { 942 return c; 943 } else { 944 iter->start+=4; /* back to behind this supplementary code point for consistent state */ 945 iter->reservedField=c; 946 return U16_TRAIL(c); 947 } 948 } else { 949 return U_SENTINEL; 950 } 951 } 952 953 static uint32_t U_CALLCONV 954 utf8IteratorGetState(const UCharIterator *iter) { 955 uint32_t state=(uint32_t)(iter->start<<1); 956 if(iter->reservedField!=0) { 957 state|=1; 958 } 959 return state; 960 } 961 962 static void U_CALLCONV 963 utf8IteratorSetState(UCharIterator *iter, 964 uint32_t state, 965 UErrorCode *pErrorCode) 966 { 967 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 968 /* do nothing */ 969 } else if(iter==NULL) { 970 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 971 } else if(state==utf8IteratorGetState(iter)) { 972 /* setting to the current state: no-op */ 973 } else { 974 int32_t index=(int32_t)(state>>1); /* UTF-8 index */ 975 state&=1; /* 1 if in surrogate pair, must be index>=4 */ 976 977 if((state==0 ? index<0 : index<4) || iter->limit<index) { 978 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 979 } else { 980 iter->start=index; /* restore UTF-8 byte index */ 981 if(index<=1) { 982 iter->index=index; 983 } else { 984 iter->index=-1; /* unknown UTF-16 index */ 985 } 986 if(state==0) { 987 iter->reservedField=0; 988 } else { 989 /* verified index>=4 above */ 990 UChar32 c; 991 U8_PREV((const uint8_t *)iter->context, 0, index, c); 992 if(c<=0xffff) { 993 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 994 } else { 995 iter->reservedField=c; 996 } 997 } 998 } 999 } 1000 } 1001 1002 static const UCharIterator utf8Iterator={ 1003 0, 0, 0, 0, 0, 0, 1004 utf8IteratorGetIndex, 1005 utf8IteratorMove, 1006 utf8IteratorHasNext, 1007 utf8IteratorHasPrevious, 1008 utf8IteratorCurrent, 1009 utf8IteratorNext, 1010 utf8IteratorPrevious, 1011 NULL, 1012 utf8IteratorGetState, 1013 utf8IteratorSetState 1014 }; 1015 1016 U_CAPI void U_EXPORT2 1017 uiter_setUTF8(UCharIterator *iter, const char *s, int32_t length) { 1018 if(iter!=0) { 1019 if(s!=0 && length>=-1) { 1020 *iter=utf8Iterator; 1021 iter->context=s; 1022 if(length>=0) { 1023 iter->limit=length; 1024 } else { 1025 iter->limit=(int32_t)uprv_strlen(s); 1026 } 1027 iter->length= iter->limit<=1 ? iter->limit : -1; 1028 } else { 1029 *iter=noopIterator; 1030 } 1031 } 1032 } 1033 1034 /* Helper functions --------------------------------------------------------- */ 1035 1036 U_CAPI UChar32 U_EXPORT2 1037 uiter_current32(UCharIterator *iter) { 1038 UChar32 c, c2; 1039 1040 c=iter->current(iter); 1041 if(UTF_IS_SURROGATE(c)) { 1042 if(UTF_IS_SURROGATE_FIRST(c)) { 1043 /* 1044 * go to the next code unit 1045 * we know that we are not at the limit because c!=U_SENTINEL 1046 */ 1047 iter->move(iter, 1, UITER_CURRENT); 1048 if(UTF_IS_SECOND_SURROGATE(c2=iter->current(iter))) { 1049 c=UTF16_GET_PAIR_VALUE(c, c2); 1050 } 1051 1052 /* undo index movement */ 1053 iter->move(iter, -1, UITER_CURRENT); 1054 } else { 1055 if(UTF_IS_FIRST_SURROGATE(c2=iter->previous(iter))) { 1056 c=UTF16_GET_PAIR_VALUE(c2, c); 1057 } 1058 if(c2>=0) { 1059 /* undo index movement */ 1060 iter->move(iter, 1, UITER_CURRENT); 1061 } 1062 } 1063 } 1064 return c; 1065 } 1066 1067 U_CAPI UChar32 U_EXPORT2 1068 uiter_next32(UCharIterator *iter) { 1069 UChar32 c, c2; 1070 1071 c=iter->next(iter); 1072 if(UTF_IS_FIRST_SURROGATE(c)) { 1073 if(UTF_IS_SECOND_SURROGATE(c2=iter->next(iter))) { 1074 c=UTF16_GET_PAIR_VALUE(c, c2); 1075 } else if(c2>=0) { 1076 /* unmatched first surrogate, undo index movement */ 1077 iter->move(iter, -1, UITER_CURRENT); 1078 } 1079 } 1080 return c; 1081 } 1082 1083 U_CAPI UChar32 U_EXPORT2 1084 uiter_previous32(UCharIterator *iter) { 1085 UChar32 c, c2; 1086 1087 c=iter->previous(iter); 1088 if(UTF_IS_SECOND_SURROGATE(c)) { 1089 if(UTF_IS_FIRST_SURROGATE(c2=iter->previous(iter))) { 1090 c=UTF16_GET_PAIR_VALUE(c2, c); 1091 } else if(c2>=0) { 1092 /* unmatched second surrogate, undo index movement */ 1093 iter->move(iter, 1, UITER_CURRENT); 1094 } 1095 } 1096 return c; 1097 } 1098 1099 U_CAPI uint32_t U_EXPORT2 1100 uiter_getState(const UCharIterator *iter) { 1101 if(iter==NULL || iter->getState==NULL) { 1102 return UITER_NO_STATE; 1103 } else { 1104 return iter->getState(iter); 1105 } 1106 } 1107 1108 U_CAPI void U_EXPORT2 1109 uiter_setState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) { 1110 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 1111 /* do nothing */ 1112 } else if(iter==NULL) { 1113 *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; 1114 } else if(iter->setState==NULL) { 1115 *pErrorCode=U_UNSUPPORTED_ERROR; 1116 } else { 1117 iter->setState(iter, state, pErrorCode); 1118 } 1119 } 1120 1121 U_CDECL_END 1122
