icuSources/common/uiter.cpp

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