| // © 2016 and later: Unicode, Inc. and others. | |
| // License & terms of use: http://www.unicode.org/copyright.html | |
| /* | |
| ******************************************************************************* | |
| * | |
| * Copyright (C) 2002-2012, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ******************************************************************************* | |
| * file name: uiter.cpp | |
| * encoding: UTF-8 | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * created on: 2002jan18 | |
| * created by: Markus W. Scherer | |
| */ | |
| #include "unicode/utypes.h" | |
| #include "unicode/ustring.h" | |
| #include "unicode/chariter.h" | |
| #include "unicode/rep.h" | |
| #include "unicode/uiter.h" | |
| #include "unicode/utf.h" | |
| #include "unicode/utf8.h" | |
| #include "unicode/utf16.h" | |
| #include "cstring.h" | |
| U_NAMESPACE_USE | |
| #define IS_EVEN(n) (((n)&1)==0) | |
| #define IS_POINTER_EVEN(p) IS_EVEN((size_t)p) | |
| U_CDECL_BEGIN | |
| /* No-Op UCharIterator implementation for illegal input --------------------- */ | |
| static int32_t U_CALLCONV | |
| noopGetIndex(UCharIterator * /*iter*/, UCharIteratorOrigin /*origin*/) { | |
| return 0; | |
| } | |
| static int32_t U_CALLCONV | |
| noopMove(UCharIterator * /*iter*/, int32_t /*delta*/, UCharIteratorOrigin /*origin*/) { | |
| return 0; | |
| } | |
| static UBool U_CALLCONV | |
| noopHasNext(UCharIterator * /*iter*/) { | |
| return FALSE; | |
| } | |
| static UChar32 U_CALLCONV | |
| noopCurrent(UCharIterator * /*iter*/) { | |
| return U_SENTINEL; | |
| } | |
| static uint32_t U_CALLCONV | |
| noopGetState(const UCharIterator * /*iter*/) { | |
| return UITER_NO_STATE; | |
| } | |
| static void U_CALLCONV | |
| noopSetState(UCharIterator * /*iter*/, uint32_t /*state*/, UErrorCode *pErrorCode) { | |
| *pErrorCode=U_UNSUPPORTED_ERROR; | |
| } | |
| static const UCharIterator noopIterator={ | |
| 0, 0, 0, 0, 0, 0, | |
| noopGetIndex, | |
| noopMove, | |
| noopHasNext, | |
| noopHasNext, | |
| noopCurrent, | |
| noopCurrent, | |
| noopCurrent, | |
| NULL, | |
| noopGetState, | |
| noopSetState | |
| }; | |
| /* UCharIterator implementation for simple strings -------------------------- */ | |
| /* | |
| * This is an implementation of a code unit (UChar) iterator | |
| * for UChar * strings. | |
| * | |
| * The UCharIterator.context field holds a pointer to the string. | |
| */ | |
| static int32_t U_CALLCONV | |
| stringIteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) { | |
| switch(origin) { | |
| case UITER_ZERO: | |
| return 0; | |
| case UITER_START: | |
| return iter->start; | |
| case UITER_CURRENT: | |
| return iter->index; | |
| case UITER_LIMIT: | |
| return iter->limit; | |
| case UITER_LENGTH: | |
| return iter->length; | |
| default: | |
| /* not a valid origin */ | |
| /* Should never get here! */ | |
| return -1; | |
| } | |
| } | |
| static int32_t U_CALLCONV | |
| stringIteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) { | |
| int32_t pos; | |
| switch(origin) { | |
| case UITER_ZERO: | |
| pos=delta; | |
| break; | |
| case UITER_START: | |
| pos=iter->start+delta; | |
| break; | |
| case UITER_CURRENT: | |
| pos=iter->index+delta; | |
| break; | |
| case UITER_LIMIT: | |
| pos=iter->limit+delta; | |
| break; | |
| case UITER_LENGTH: | |
| pos=iter->length+delta; | |
| break; | |
| default: | |
| return -1; /* Error */ | |
| } | |
| if(pos<iter->start) { | |
| pos=iter->start; | |
| } else if(pos>iter->limit) { | |
| pos=iter->limit; | |
| } | |
| return iter->index=pos; | |
| } | |
| static UBool U_CALLCONV | |
| stringIteratorHasNext(UCharIterator *iter) { | |
| return iter->index<iter->limit; | |
| } | |
| static UBool U_CALLCONV | |
| stringIteratorHasPrevious(UCharIterator *iter) { | |
| return iter->index>iter->start; | |
| } | |
| static UChar32 U_CALLCONV | |
| stringIteratorCurrent(UCharIterator *iter) { | |
| if(iter->index<iter->limit) { | |
| return ((const UChar *)(iter->context))[iter->index]; | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| stringIteratorNext(UCharIterator *iter) { | |
| if(iter->index<iter->limit) { | |
| return ((const UChar *)(iter->context))[iter->index++]; | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| stringIteratorPrevious(UCharIterator *iter) { | |
| if(iter->index>iter->start) { | |
| return ((const UChar *)(iter->context))[--iter->index]; | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static uint32_t U_CALLCONV | |
| stringIteratorGetState(const UCharIterator *iter) { | |
| return (uint32_t)iter->index; | |
| } | |
| static void U_CALLCONV | |
| stringIteratorSetState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) { | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { | |
| /* do nothing */ | |
| } else if(iter==NULL) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| } else if((int32_t)state<iter->start || iter->limit<(int32_t)state) { | |
| *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| } else { | |
| iter->index=(int32_t)state; | |
| } | |
| } | |
| static const UCharIterator stringIterator={ | |
| 0, 0, 0, 0, 0, 0, | |
| stringIteratorGetIndex, | |
| stringIteratorMove, | |
| stringIteratorHasNext, | |
| stringIteratorHasPrevious, | |
| stringIteratorCurrent, | |
| stringIteratorNext, | |
| stringIteratorPrevious, | |
| NULL, | |
| stringIteratorGetState, | |
| stringIteratorSetState | |
| }; | |
| U_CAPI void U_EXPORT2 | |
| uiter_setString(UCharIterator *iter, const UChar *s, int32_t length) { | |
| if(iter!=0) { | |
| if(s!=0 && length>=-1) { | |
| *iter=stringIterator; | |
| iter->context=s; | |
| if(length>=0) { | |
| iter->length=length; | |
| } else { | |
| iter->length=u_strlen(s); | |
| } | |
| iter->limit=iter->length; | |
| } else { | |
| *iter=noopIterator; | |
| } | |
| } | |
| } | |
| /* UCharIterator implementation for UTF-16BE strings ------------------------ */ | |
| /* | |
| * This is an implementation of a code unit (UChar) iterator | |
| * for UTF-16BE strings, i.e., strings in byte-vectors where | |
| * each UChar is stored as a big-endian pair of bytes. | |
| * | |
| * The UCharIterator.context field holds a pointer to the string. | |
| * Everything works just like with a normal UChar iterator (uiter_setString), | |
| * except that UChars are assembled from byte pairs. | |
| */ | |
| /* internal helper function */ | |
| static inline UChar32 | |
| utf16BEIteratorGet(UCharIterator *iter, int32_t index) { | |
| const uint8_t *p=(const uint8_t *)iter->context; | |
| return ((UChar)p[2*index]<<8)|(UChar)p[2*index+1]; | |
| } | |
| static UChar32 U_CALLCONV | |
| utf16BEIteratorCurrent(UCharIterator *iter) { | |
| int32_t index; | |
| if((index=iter->index)<iter->limit) { | |
| return utf16BEIteratorGet(iter, index); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| utf16BEIteratorNext(UCharIterator *iter) { | |
| int32_t index; | |
| if((index=iter->index)<iter->limit) { | |
| iter->index=index+1; | |
| return utf16BEIteratorGet(iter, index); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| utf16BEIteratorPrevious(UCharIterator *iter) { | |
| int32_t index; | |
| if((index=iter->index)>iter->start) { | |
| iter->index=--index; | |
| return utf16BEIteratorGet(iter, index); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static const UCharIterator utf16BEIterator={ | |
| 0, 0, 0, 0, 0, 0, | |
| stringIteratorGetIndex, | |
| stringIteratorMove, | |
| stringIteratorHasNext, | |
| stringIteratorHasPrevious, | |
| utf16BEIteratorCurrent, | |
| utf16BEIteratorNext, | |
| utf16BEIteratorPrevious, | |
| NULL, | |
| stringIteratorGetState, | |
| stringIteratorSetState | |
| }; | |
| /* | |
| * Count the number of UChars in a UTF-16BE string before a terminating UChar NUL, | |
| * i.e., before a pair of 0 bytes where the first 0 byte is at an even | |
| * offset from s. | |
| */ | |
| static int32_t | |
| utf16BE_strlen(const char *s) { | |
| if(IS_POINTER_EVEN(s)) { | |
| /* | |
| * even-aligned, call u_strlen(s) | |
| * we are probably on a little-endian machine, but searching for UChar NUL | |
| * does not care about endianness | |
| */ | |
| return u_strlen((const UChar *)s); | |
| } else { | |
| /* odd-aligned, search for pair of 0 bytes */ | |
| const char *p=s; | |
| while(!(*p==0 && p[1]==0)) { | |
| p+=2; | |
| } | |
| return (int32_t)((p-s)/2); | |
| } | |
| } | |
| U_CAPI void U_EXPORT2 | |
| uiter_setUTF16BE(UCharIterator *iter, const char *s, int32_t length) { | |
| if(iter!=NULL) { | |
| /* allow only even-length strings (the input length counts bytes) */ | |
| if(s!=NULL && (length==-1 || (length>=0 && IS_EVEN(length)))) { | |
| /* length/=2, except that >>=1 also works for -1 (-1/2==0, -1>>1==-1) */ | |
| length>>=1; | |
| if(U_IS_BIG_ENDIAN && IS_POINTER_EVEN(s)) { | |
| /* big-endian machine and 2-aligned UTF-16BE string: use normal UChar iterator */ | |
| uiter_setString(iter, (const UChar *)s, length); | |
| return; | |
| } | |
| *iter=utf16BEIterator; | |
| iter->context=s; | |
| if(length>=0) { | |
| iter->length=length; | |
| } else { | |
| iter->length=utf16BE_strlen(s); | |
| } | |
| iter->limit=iter->length; | |
| } else { | |
| *iter=noopIterator; | |
| } | |
| } | |
| } | |
| /* UCharIterator wrapper around CharacterIterator --------------------------- */ | |
| /* | |
| * This is wrapper code around a C++ CharacterIterator to | |
| * look like a C UCharIterator. | |
| * | |
| * The UCharIterator.context field holds a pointer to the CharacterIterator. | |
| */ | |
| static int32_t U_CALLCONV | |
| characterIteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) { | |
| switch(origin) { | |
| case UITER_ZERO: | |
| return 0; | |
| case UITER_START: | |
| return ((CharacterIterator *)(iter->context))->startIndex(); | |
| case UITER_CURRENT: | |
| return ((CharacterIterator *)(iter->context))->getIndex(); | |
| case UITER_LIMIT: | |
| return ((CharacterIterator *)(iter->context))->endIndex(); | |
| case UITER_LENGTH: | |
| return ((CharacterIterator *)(iter->context))->getLength(); | |
| default: | |
| /* not a valid origin */ | |
| /* Should never get here! */ | |
| return -1; | |
| } | |
| } | |
| static int32_t U_CALLCONV | |
| characterIteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) { | |
| switch(origin) { | |
| case UITER_ZERO: | |
| ((CharacterIterator *)(iter->context))->setIndex(delta); | |
| return ((CharacterIterator *)(iter->context))->getIndex(); | |
| case UITER_START: | |
| case UITER_CURRENT: | |
| case UITER_LIMIT: | |
| return ((CharacterIterator *)(iter->context))->move(delta, (CharacterIterator::EOrigin)origin); | |
| case UITER_LENGTH: | |
| ((CharacterIterator *)(iter->context))->setIndex(((CharacterIterator *)(iter->context))->getLength()+delta); | |
| return ((CharacterIterator *)(iter->context))->getIndex(); | |
| default: | |
| /* not a valid origin */ | |
| /* Should never get here! */ | |
| return -1; | |
| } | |
| } | |
| static UBool U_CALLCONV | |
| characterIteratorHasNext(UCharIterator *iter) { | |
| return ((CharacterIterator *)(iter->context))->hasNext(); | |
| } | |
| static UBool U_CALLCONV | |
| characterIteratorHasPrevious(UCharIterator *iter) { | |
| return ((CharacterIterator *)(iter->context))->hasPrevious(); | |
| } | |
| static UChar32 U_CALLCONV | |
| characterIteratorCurrent(UCharIterator *iter) { | |
| UChar32 c; | |
| c=((CharacterIterator *)(iter->context))->current(); | |
| if(c!=0xffff || ((CharacterIterator *)(iter->context))->hasNext()) { | |
| return c; | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| characterIteratorNext(UCharIterator *iter) { | |
| if(((CharacterIterator *)(iter->context))->hasNext()) { | |
| return ((CharacterIterator *)(iter->context))->nextPostInc(); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| characterIteratorPrevious(UCharIterator *iter) { | |
| if(((CharacterIterator *)(iter->context))->hasPrevious()) { | |
| return ((CharacterIterator *)(iter->context))->previous(); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static uint32_t U_CALLCONV | |
| characterIteratorGetState(const UCharIterator *iter) { | |
| return ((CharacterIterator *)(iter->context))->getIndex(); | |
| } | |
| static void U_CALLCONV | |
| characterIteratorSetState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) { | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { | |
| /* do nothing */ | |
| } else if(iter==NULL || iter->context==NULL) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| } else if((int32_t)state<((CharacterIterator *)(iter->context))->startIndex() || ((CharacterIterator *)(iter->context))->endIndex()<(int32_t)state) { | |
| *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| } else { | |
| ((CharacterIterator *)(iter->context))->setIndex((int32_t)state); | |
| } | |
| } | |
| static const UCharIterator characterIteratorWrapper={ | |
| 0, 0, 0, 0, 0, 0, | |
| characterIteratorGetIndex, | |
| characterIteratorMove, | |
| characterIteratorHasNext, | |
| characterIteratorHasPrevious, | |
| characterIteratorCurrent, | |
| characterIteratorNext, | |
| characterIteratorPrevious, | |
| NULL, | |
| characterIteratorGetState, | |
| characterIteratorSetState | |
| }; | |
| U_CAPI void U_EXPORT2 | |
| uiter_setCharacterIterator(UCharIterator *iter, CharacterIterator *charIter) { | |
| if(iter!=0) { | |
| if(charIter!=0) { | |
| *iter=characterIteratorWrapper; | |
| iter->context=charIter; | |
| } else { | |
| *iter=noopIterator; | |
| } | |
| } | |
| } | |
| /* UCharIterator wrapper around Replaceable --------------------------------- */ | |
| /* | |
| * This is an implementation of a code unit (UChar) iterator | |
| * based on a Replaceable object. | |
| * | |
| * The UCharIterator.context field holds a pointer to the Replaceable. | |
| * UCharIterator.length and UCharIterator.index hold Replaceable.length() | |
| * and the iteration index. | |
| */ | |
| static UChar32 U_CALLCONV | |
| replaceableIteratorCurrent(UCharIterator *iter) { | |
| if(iter->index<iter->limit) { | |
| return ((Replaceable *)(iter->context))->charAt(iter->index); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| replaceableIteratorNext(UCharIterator *iter) { | |
| if(iter->index<iter->limit) { | |
| return ((Replaceable *)(iter->context))->charAt(iter->index++); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| replaceableIteratorPrevious(UCharIterator *iter) { | |
| if(iter->index>iter->start) { | |
| return ((Replaceable *)(iter->context))->charAt(--iter->index); | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static const UCharIterator replaceableIterator={ | |
| 0, 0, 0, 0, 0, 0, | |
| stringIteratorGetIndex, | |
| stringIteratorMove, | |
| stringIteratorHasNext, | |
| stringIteratorHasPrevious, | |
| replaceableIteratorCurrent, | |
| replaceableIteratorNext, | |
| replaceableIteratorPrevious, | |
| NULL, | |
| stringIteratorGetState, | |
| stringIteratorSetState | |
| }; | |
| U_CAPI void U_EXPORT2 | |
| uiter_setReplaceable(UCharIterator *iter, const Replaceable *rep) { | |
| if(iter!=0) { | |
| if(rep!=0) { | |
| *iter=replaceableIterator; | |
| iter->context=rep; | |
| iter->limit=iter->length=rep->length(); | |
| } else { | |
| *iter=noopIterator; | |
| } | |
| } | |
| } | |
| /* UCharIterator implementation for UTF-8 strings --------------------------- */ | |
| /* | |
| * Possible, probably necessary only for an implementation for arbitrary | |
| * converters: | |
| * Maintain a buffer (ring buffer?) for a piece of converted 16-bit text. | |
| * This would require to turn reservedFn into a close function and | |
| * to introduce a uiter_close(iter). | |
| */ | |
| #define UITER_CNV_CAPACITY 16 | |
| /* | |
| * Minimal implementation: | |
| * Maintain a single-UChar buffer for an additional surrogate. | |
| * The caller must not modify start and limit because they are used internally. | |
| * | |
| * Use UCharIterator fields as follows: | |
| * context pointer to UTF-8 string | |
| * length UTF-16 length of the string; -1 until lazy evaluation | |
| * start current UTF-8 index | |
| * index current UTF-16 index; may be -1="unknown" after setState() | |
| * limit UTF-8 length of the string | |
| * reservedField supplementary code point | |
| * | |
| * Since UCharIterator delivers 16-bit code units, the iteration can be | |
| * currently in the middle of the byte sequence for a supplementary code point. | |
| * In this case, reservedField will contain that code point and start will | |
| * point to after the corresponding byte sequence. The UTF-16 index will be | |
| * one less than what it would otherwise be corresponding to the UTF-8 index. | |
| * Otherwise, reservedField will be 0. | |
| */ | |
| /* | |
| * Possible optimization for NUL-terminated UTF-8 and UTF-16 strings: | |
| * Add implementations that do not call strlen() for iteration but check for NUL. | |
| */ | |
| static int32_t U_CALLCONV | |
| utf8IteratorGetIndex(UCharIterator *iter, UCharIteratorOrigin origin) { | |
| switch(origin) { | |
| case UITER_ZERO: | |
| case UITER_START: | |
| return 0; | |
| case UITER_CURRENT: | |
| if(iter->index<0) { | |
| /* the current UTF-16 index is unknown after setState(), count from the beginning */ | |
| const uint8_t *s; | |
| UChar32 c; | |
| int32_t i, limit, index; | |
| s=(const uint8_t *)iter->context; | |
| i=index=0; | |
| limit=iter->start; /* count up to the UTF-8 index */ | |
| while(i<limit) { | |
| U8_NEXT_OR_FFFD(s, i, limit, c); | |
| index+=U16_LENGTH(c); | |
| } | |
| iter->start=i; /* just in case setState() did not get us to a code point boundary */ | |
| if(i==iter->limit) { | |
| iter->length=index; /* in case it was <0 or wrong */ | |
| } | |
| if(iter->reservedField!=0) { | |
| --index; /* we are in the middle of a supplementary code point */ | |
| } | |
| iter->index=index; | |
| } | |
| return iter->index; | |
| case UITER_LIMIT: | |
| case UITER_LENGTH: | |
| if(iter->length<0) { | |
| const uint8_t *s; | |
| UChar32 c; | |
| int32_t i, limit, length; | |
| s=(const uint8_t *)iter->context; | |
| if(iter->index<0) { | |
| /* | |
| * the current UTF-16 index is unknown after setState(), | |
| * we must first count from the beginning to here | |
| */ | |
| i=length=0; | |
| limit=iter->start; | |
| /* count from the beginning to the current index */ | |
| while(i<limit) { | |
| U8_NEXT_OR_FFFD(s, i, limit, c); | |
| length+=U16_LENGTH(c); | |
| } | |
| /* assume i==limit==iter->start, set the UTF-16 index */ | |
| iter->start=i; /* just in case setState() did not get us to a code point boundary */ | |
| iter->index= iter->reservedField!=0 ? length-1 : length; | |
| } else { | |
| i=iter->start; | |
| length=iter->index; | |
| if(iter->reservedField!=0) { | |
| ++length; | |
| } | |
| } | |
| /* count from the current index to the end */ | |
| limit=iter->limit; | |
| while(i<limit) { | |
| U8_NEXT_OR_FFFD(s, i, limit, c); | |
| length+=U16_LENGTH(c); | |
| } | |
| iter->length=length; | |
| } | |
| return iter->length; | |
| default: | |
| /* not a valid origin */ | |
| /* Should never get here! */ | |
| return -1; | |
| } | |
| } | |
| static int32_t U_CALLCONV | |
| utf8IteratorMove(UCharIterator *iter, int32_t delta, UCharIteratorOrigin origin) { | |
| const uint8_t *s; | |
| UChar32 c; | |
| int32_t pos; /* requested UTF-16 index */ | |
| int32_t i; /* UTF-8 index */ | |
| UBool havePos; | |
| /* calculate the requested UTF-16 index */ | |
| switch(origin) { | |
| case UITER_ZERO: | |
| case UITER_START: | |
| pos=delta; | |
| havePos=TRUE; | |
| /* iter->index<0 (unknown) is possible */ | |
| break; | |
| case UITER_CURRENT: | |
| if(iter->index>=0) { | |
| pos=iter->index+delta; | |
| havePos=TRUE; | |
| } else { | |
| /* the current UTF-16 index is unknown after setState(), use only delta */ | |
| pos=0; | |
| havePos=FALSE; | |
| } | |
| break; | |
| case UITER_LIMIT: | |
| case UITER_LENGTH: | |
| if(iter->length>=0) { | |
| pos=iter->length+delta; | |
| havePos=TRUE; | |
| } else { | |
| /* pin to the end, avoid counting the length */ | |
| iter->index=-1; | |
| iter->start=iter->limit; | |
| iter->reservedField=0; | |
| if(delta>=0) { | |
| return UITER_UNKNOWN_INDEX; | |
| } else { | |
| /* the current UTF-16 index is unknown, use only delta */ | |
| pos=0; | |
| havePos=FALSE; | |
| } | |
| } | |
| break; | |
| default: | |
| return -1; /* Error */ | |
| } | |
| if(havePos) { | |
| /* shortcuts: pinning to the edges of the string */ | |
| if(pos<=0) { | |
| iter->index=iter->start=iter->reservedField=0; | |
| return 0; | |
| } else if(iter->length>=0 && pos>=iter->length) { | |
| iter->index=iter->length; | |
| iter->start=iter->limit; | |
| iter->reservedField=0; | |
| return iter->index; | |
| } | |
| /* minimize the number of U8_NEXT/PREV operations */ | |
| if(iter->index<0 || pos<iter->index/2) { | |
| /* go forward from the start instead of backward from the current index */ | |
| iter->index=iter->start=iter->reservedField=0; | |
| } else if(iter->length>=0 && (iter->length-pos)<(pos-iter->index)) { | |
| /* | |
| * if we have the UTF-16 index and length and the new position is | |
| * closer to the end than the current index, | |
| * then go backward from the end instead of forward from the current index | |
| */ | |
| iter->index=iter->length; | |
| iter->start=iter->limit; | |
| iter->reservedField=0; | |
| } | |
| delta=pos-iter->index; | |
| if(delta==0) { | |
| return iter->index; /* nothing to do */ | |
| } | |
| } else { | |
| /* move relative to unknown UTF-16 index */ | |
| if(delta==0) { | |
| return UITER_UNKNOWN_INDEX; /* nothing to do */ | |
| } else if(-delta>=iter->start) { | |
| /* moving backwards by more UChars than there are UTF-8 bytes, pin to 0 */ | |
| iter->index=iter->start=iter->reservedField=0; | |
| return 0; | |
| } else if(delta>=(iter->limit-iter->start)) { | |
| /* moving forward by more UChars than the remaining UTF-8 bytes, pin to the end */ | |
| iter->index=iter->length; /* may or may not be <0 (unknown) */ | |
| iter->start=iter->limit; | |
| iter->reservedField=0; | |
| return iter->index>=0 ? iter->index : (int32_t)UITER_UNKNOWN_INDEX; | |
| } | |
| } | |
| /* delta!=0 */ | |
| /* move towards the requested position, pin to the edges of the string */ | |
| s=(const uint8_t *)iter->context; | |
| pos=iter->index; /* could be <0 (unknown) */ | |
| i=iter->start; | |
| if(delta>0) { | |
| /* go forward */ | |
| int32_t limit=iter->limit; | |
| if(iter->reservedField!=0) { | |
| iter->reservedField=0; | |
| ++pos; | |
| --delta; | |
| } | |
| while(delta>0 && i<limit) { | |
| U8_NEXT_OR_FFFD(s, i, limit, c); | |
| if(c<=0xffff) { | |
| ++pos; | |
| --delta; | |
| } else if(delta>=2) { | |
| pos+=2; | |
| delta-=2; | |
| } else /* delta==1 */ { | |
| /* stop in the middle of a supplementary code point */ | |
| iter->reservedField=c; | |
| ++pos; | |
| break; /* delta=0; */ | |
| } | |
| } | |
| if(i==limit) { | |
| if(iter->length<0 && iter->index>=0) { | |
| iter->length= iter->reservedField==0 ? pos : pos+1; | |
| } else if(iter->index<0 && iter->length>=0) { | |
| iter->index= iter->reservedField==0 ? iter->length : iter->length-1; | |
| } | |
| } | |
| } else /* delta<0 */ { | |
| /* go backward */ | |
| if(iter->reservedField!=0) { | |
| iter->reservedField=0; | |
| i-=4; /* we stayed behind the supplementary code point; go before it now */ | |
| --pos; | |
| ++delta; | |
| } | |
| while(delta<0 && i>0) { | |
| U8_PREV_OR_FFFD(s, 0, i, c); | |
| if(c<=0xffff) { | |
| --pos; | |
| ++delta; | |
| } else if(delta<=-2) { | |
| pos-=2; | |
| delta+=2; | |
| } else /* delta==-1 */ { | |
| /* stop in the middle of a supplementary code point */ | |
| i+=4; /* back to behind this supplementary code point for consistent state */ | |
| iter->reservedField=c; | |
| --pos; | |
| break; /* delta=0; */ | |
| } | |
| } | |
| } | |
| iter->start=i; | |
| if(iter->index>=0) { | |
| return iter->index=pos; | |
| } else { | |
| /* we started with index<0 (unknown) so pos is bogus */ | |
| if(i<=1) { | |
| return iter->index=i; /* reached the beginning */ | |
| } else { | |
| /* we still don't know the UTF-16 index */ | |
| return UITER_UNKNOWN_INDEX; | |
| } | |
| } | |
| } | |
| static UBool U_CALLCONV | |
| utf8IteratorHasNext(UCharIterator *iter) { | |
| return iter->start<iter->limit || iter->reservedField!=0; | |
| } | |
| static UBool U_CALLCONV | |
| utf8IteratorHasPrevious(UCharIterator *iter) { | |
| return iter->start>0; | |
| } | |
| static UChar32 U_CALLCONV | |
| utf8IteratorCurrent(UCharIterator *iter) { | |
| if(iter->reservedField!=0) { | |
| return U16_TRAIL(iter->reservedField); | |
| } else if(iter->start<iter->limit) { | |
| const uint8_t *s=(const uint8_t *)iter->context; | |
| UChar32 c; | |
| int32_t i=iter->start; | |
| U8_NEXT_OR_FFFD(s, i, iter->limit, c); | |
| if(c<=0xffff) { | |
| return c; | |
| } else { | |
| return U16_LEAD(c); | |
| } | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| utf8IteratorNext(UCharIterator *iter) { | |
| int32_t index; | |
| if(iter->reservedField!=0) { | |
| UChar trail=U16_TRAIL(iter->reservedField); | |
| iter->reservedField=0; | |
| if((index=iter->index)>=0) { | |
| iter->index=index+1; | |
| } | |
| return trail; | |
| } else if(iter->start<iter->limit) { | |
| const uint8_t *s=(const uint8_t *)iter->context; | |
| UChar32 c; | |
| U8_NEXT_OR_FFFD(s, iter->start, iter->limit, c); | |
| if((index=iter->index)>=0) { | |
| iter->index=++index; | |
| if(iter->length<0 && iter->start==iter->limit) { | |
| iter->length= c<=0xffff ? index : index+1; | |
| } | |
| } else if(iter->start==iter->limit && iter->length>=0) { | |
| iter->index= c<=0xffff ? iter->length : iter->length-1; | |
| } | |
| if(c<=0xffff) { | |
| return c; | |
| } else { | |
| iter->reservedField=c; | |
| return U16_LEAD(c); | |
| } | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static UChar32 U_CALLCONV | |
| utf8IteratorPrevious(UCharIterator *iter) { | |
| int32_t index; | |
| if(iter->reservedField!=0) { | |
| UChar lead=U16_LEAD(iter->reservedField); | |
| iter->reservedField=0; | |
| iter->start-=4; /* we stayed behind the supplementary code point; go before it now */ | |
| if((index=iter->index)>0) { | |
| iter->index=index-1; | |
| } | |
| return lead; | |
| } else if(iter->start>0) { | |
| const uint8_t *s=(const uint8_t *)iter->context; | |
| UChar32 c; | |
| U8_PREV_OR_FFFD(s, 0, iter->start, c); | |
| if((index=iter->index)>0) { | |
| iter->index=index-1; | |
| } else if(iter->start<=1) { | |
| iter->index= c<=0xffff ? iter->start : iter->start+1; | |
| } | |
| if(c<=0xffff) { | |
| return c; | |
| } else { | |
| iter->start+=4; /* back to behind this supplementary code point for consistent state */ | |
| iter->reservedField=c; | |
| return U16_TRAIL(c); | |
| } | |
| } else { | |
| return U_SENTINEL; | |
| } | |
| } | |
| static uint32_t U_CALLCONV | |
| utf8IteratorGetState(const UCharIterator *iter) { | |
| uint32_t state=(uint32_t)(iter->start<<1); | |
| if(iter->reservedField!=0) { | |
| state|=1; | |
| } | |
| return state; | |
| } | |
| static void U_CALLCONV | |
| utf8IteratorSetState(UCharIterator *iter, | |
| uint32_t state, | |
| UErrorCode *pErrorCode) | |
| { | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { | |
| /* do nothing */ | |
| } else if(iter==NULL) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| } else if(state==utf8IteratorGetState(iter)) { | |
| /* setting to the current state: no-op */ | |
| } else { | |
| int32_t index=(int32_t)(state>>1); /* UTF-8 index */ | |
| state&=1; /* 1 if in surrogate pair, must be index>=4 */ | |
| if((state==0 ? index<0 : index<4) || iter->limit<index) { | |
| *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| } else { | |
| iter->start=index; /* restore UTF-8 byte index */ | |
| if(index<=1) { | |
| iter->index=index; | |
| } else { | |
| iter->index=-1; /* unknown UTF-16 index */ | |
| } | |
| if(state==0) { | |
| iter->reservedField=0; | |
| } else { | |
| /* verified index>=4 above */ | |
| UChar32 c; | |
| U8_PREV_OR_FFFD((const uint8_t *)iter->context, 0, index, c); | |
| if(c<=0xffff) { | |
| *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; | |
| } else { | |
| iter->reservedField=c; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| static const UCharIterator utf8Iterator={ | |
| 0, 0, 0, 0, 0, 0, | |
| utf8IteratorGetIndex, | |
| utf8IteratorMove, | |
| utf8IteratorHasNext, | |
| utf8IteratorHasPrevious, | |
| utf8IteratorCurrent, | |
| utf8IteratorNext, | |
| utf8IteratorPrevious, | |
| NULL, | |
| utf8IteratorGetState, | |
| utf8IteratorSetState | |
| }; | |
| U_CAPI void U_EXPORT2 | |
| uiter_setUTF8(UCharIterator *iter, const char *s, int32_t length) { | |
| if(iter!=0) { | |
| if(s!=0 && length>=-1) { | |
| *iter=utf8Iterator; | |
| iter->context=s; | |
| if(length>=0) { | |
| iter->limit=length; | |
| } else { | |
| iter->limit=(int32_t)uprv_strlen(s); | |
| } | |
| iter->length= iter->limit<=1 ? iter->limit : -1; | |
| } else { | |
| *iter=noopIterator; | |
| } | |
| } | |
| } | |
| /* Helper functions --------------------------------------------------------- */ | |
| U_CAPI UChar32 U_EXPORT2 | |
| uiter_current32(UCharIterator *iter) { | |
| UChar32 c, c2; | |
| c=iter->current(iter); | |
| if(U16_IS_SURROGATE(c)) { | |
| if(U16_IS_SURROGATE_LEAD(c)) { | |
| /* | |
| * go to the next code unit | |
| * we know that we are not at the limit because c!=U_SENTINEL | |
| */ | |
| iter->move(iter, 1, UITER_CURRENT); | |
| if(U16_IS_TRAIL(c2=iter->current(iter))) { | |
| c=U16_GET_SUPPLEMENTARY(c, c2); | |
| } | |
| /* undo index movement */ | |
| iter->move(iter, -1, UITER_CURRENT); | |
| } else { | |
| if(U16_IS_LEAD(c2=iter->previous(iter))) { | |
| c=U16_GET_SUPPLEMENTARY(c2, c); | |
| } | |
| if(c2>=0) { | |
| /* undo index movement */ | |
| iter->move(iter, 1, UITER_CURRENT); | |
| } | |
| } | |
| } | |
| return c; | |
| } | |
| U_CAPI UChar32 U_EXPORT2 | |
| uiter_next32(UCharIterator *iter) { | |
| UChar32 c, c2; | |
| c=iter->next(iter); | |
| if(U16_IS_LEAD(c)) { | |
| if(U16_IS_TRAIL(c2=iter->next(iter))) { | |
| c=U16_GET_SUPPLEMENTARY(c, c2); | |
| } else if(c2>=0) { | |
| /* unmatched first surrogate, undo index movement */ | |
| iter->move(iter, -1, UITER_CURRENT); | |
| } | |
| } | |
| return c; | |
| } | |
| U_CAPI UChar32 U_EXPORT2 | |
| uiter_previous32(UCharIterator *iter) { | |
| UChar32 c, c2; | |
| c=iter->previous(iter); | |
| if(U16_IS_TRAIL(c)) { | |
| if(U16_IS_LEAD(c2=iter->previous(iter))) { | |
| c=U16_GET_SUPPLEMENTARY(c2, c); | |
| } else if(c2>=0) { | |
| /* unmatched second surrogate, undo index movement */ | |
| iter->move(iter, 1, UITER_CURRENT); | |
| } | |
| } | |
| return c; | |
| } | |
| U_CAPI uint32_t U_EXPORT2 | |
| uiter_getState(const UCharIterator *iter) { | |
| if(iter==NULL || iter->getState==NULL) { | |
| return UITER_NO_STATE; | |
| } else { | |
| return iter->getState(iter); | |
| } | |
| } | |
| U_CAPI void U_EXPORT2 | |
| uiter_setState(UCharIterator *iter, uint32_t state, UErrorCode *pErrorCode) { | |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { | |
| /* do nothing */ | |
| } else if(iter==NULL) { | |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; | |
| } else if(iter->setState==NULL) { | |
| *pErrorCode=U_UNSUPPORTED_ERROR; | |
| } else { | |
| iter->setState(iter, state, pErrorCode); | |
| } | |
| } | |
| U_CDECL_END |