diff options
author | Peter Breitenlohner <peb@mppmu.mpg.de> | 2009-04-20 18:13:48 +0000 |
---|---|---|
committer | Peter Breitenlohner <peb@mppmu.mpg.de> | 2009-04-20 18:13:48 +0000 |
commit | e5786f530f9555469c01435f86039b06aa53feba (patch) | |
tree | c868e8d32282422d7d445b729db95c3fcdafb6d0 /Build/source/libs/icu-xetex/samples/uciter8/uit_len8.c | |
parent | ebaa1768b43c8606d923d2e861b5286b74207b3e (diff) |
new build system: build icu libs and xetex plus misc updates
git-svn-id: svn://tug.org/texlive/trunk@12759 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/icu-xetex/samples/uciter8/uit_len8.c')
-rw-r--r-- | Build/source/libs/icu-xetex/samples/uciter8/uit_len8.c | 556 |
1 files changed, 0 insertions, 556 deletions
diff --git a/Build/source/libs/icu-xetex/samples/uciter8/uit_len8.c b/Build/source/libs/icu-xetex/samples/uciter8/uit_len8.c deleted file mode 100644 index 16fa487c642..00000000000 --- a/Build/source/libs/icu-xetex/samples/uciter8/uit_len8.c +++ /dev/null @@ -1,556 +0,0 @@ -/* -******************************************************************************* -* -* Copyright (C) 2003-2006, International Business Machines -* Corporation and others. All Rights Reserved. -* -******************************************************************************* -* file name: uit_len8.c -* encoding: US-ASCII -* tab size: 8 (not used) -* indentation:4 -* -* created on: 2003feb10 -* created by: Markus W. Scherer -* -* This file contains the implementation of the "lenient UTF-8" UCharIterator -* as used in the uciter8 sample code. -* UTF-8-style macros are defined as well as the UCharIterator. -* The macros are incomplete (do not assemble code points from pairs of -* surrogates, see comment below) -* but sufficient for the iterator. -*/ - -#include <string.h> -#include "unicode/utypes.h" -#include "unicode/uiter.h" - -/* lenient UTF-8/CESU-8 macros ---------------------------------------------- */ - -/* - * This code leniently reads 8-bit Unicode strings, - * which could contain a mix of UTF-8 and CESU-8. - * More precisely: - * - supplementary code points may be encoded with dedicated 4-byte sequences - * (UTF-8 style) - * - supplementary code points may be encoded with - * pairs of 3-byte sequences, one for each surrogate of the UTF-16 form - * (CESU-8 style) - * - single surrogates are allowed, encoded with their "natural" 3-byte sequences - * - * Limitation: - * Right now, the macros do not attempt to assemble code points from pairs of - * separately encoded surrogates. - * This would not be sufficient for processing based on these macros, - * but it is sufficient for a UCharIterator that returns only UChars anyway. - * - * The code is copied and modified from utf_impl.c and utf8.h. - * - * Change 2006feb08: Much of the implementation code is replaced by calling - * the utf_impl.c functions which accept a new "strict" parameter value - * of -2 implementing exactly this leniency. - */ - -#define L8_NEXT(s, i, length, c) { \ - (c)=(uint8_t)(s)[(i)++]; \ - if((c)>=0x80) { \ - if(U8_IS_LEAD(c)) { \ - (c)=utf8_nextCharSafeBody((const uint8_t *)s, &(i), (int32_t)(length), c, -2); \ - } else { \ - (c)=U_SENTINEL; \ - } \ - } \ -} - -#define L8_PREV(s, start, i, c) { \ - (c)=(uint8_t)(s)[--(i)]; \ - if((c)>=0x80) { \ - if((c)<=0xbf) { \ - (c)=utf8_prevCharSafeBody((const uint8_t *)s, start, &(i), c, -2); \ - } else { \ - (c)=U_SENTINEL; \ - } \ - } \ -} - -/* lenient-8 UCharIterator -------------------------------------------------- */ - -/* - * This is a copy of the UTF-8 UCharIterator in uiter.cpp, - * except that it uses the lenient-8-bit-Unicode macros above. - */ - -/* - * 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 -lenient8IteratorGetIndex(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) { - L8_NEXT(s, i, limit, c); - if(c<=0xffff) { - ++index; - } else { - index+=2; - } - } - - 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) { - L8_NEXT(s, i, limit, c); - if(c<=0xffff) { - ++length; - } else { - length+=2; - } - } - - /* 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) { - L8_NEXT(s, i, limit, c); - if(c<=0xffff) { - ++length; - } else { - length+=2; - } - } - iter->length=length; - } - return iter->length; - default: - /* not a valid origin */ - /* Should never get here! */ - return -1; - } -} - -static int32_t U_CALLCONV -lenient8IteratorMove(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 L8_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 : 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) { - L8_NEXT(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) { - L8_PREV(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 -lenient8IteratorHasNext(UCharIterator *iter) { - return iter->reservedField!=0 || iter->start<iter->limit; -} - -static UBool U_CALLCONV -lenient8IteratorHasPrevious(UCharIterator *iter) { - return iter->start>0; -} - -static UChar32 U_CALLCONV -lenient8IteratorCurrent(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; - - L8_NEXT(s, i, iter->limit, c); - if(c<0) { - return 0xfffd; - } else if(c<=0xffff) { - return c; - } else { - return U16_LEAD(c); - } - } else { - return U_SENTINEL; - } -} - -static UChar32 U_CALLCONV -lenient8IteratorNext(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; - - L8_NEXT(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<0) { - return 0xfffd; - } else if(c<=0xffff) { - return c; - } else { - iter->reservedField=c; - return U16_LEAD(c); - } - } else { - return U_SENTINEL; - } -} - -static UChar32 U_CALLCONV -lenient8IteratorPrevious(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; - - L8_PREV(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<0) { - return 0xfffd; - } else 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 -lenient8IteratorGetState(const UCharIterator *iter) { - uint32_t state=(uint32_t)(iter->start<<1); - if(iter->reservedField!=0) { - state|=1; - } - return state; -} - -static void U_CALLCONV -lenient8IteratorSetState(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==lenient8IteratorGetState(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; - L8_PREV((const uint8_t *)iter->context, 0, index, c); - if(c<=0xffff) { - *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; - } else { - iter->reservedField=c; - } - } - } - } -} - -static const UCharIterator lenient8Iterator={ - 0, 0, 0, 0, 0, 0, - lenient8IteratorGetIndex, - lenient8IteratorMove, - lenient8IteratorHasNext, - lenient8IteratorHasPrevious, - lenient8IteratorCurrent, - lenient8IteratorNext, - lenient8IteratorPrevious, - NULL, - lenient8IteratorGetState, - lenient8IteratorSetState -}; - -U_CAPI void U_EXPORT2 -uiter_setLenient8(UCharIterator *iter, const char *s, int32_t length) { - if(iter!=0) { - if(s!=0 && length>=-1) { - *iter=lenient8Iterator; - iter->context=s; - if(length>=0) { - iter->limit=length; - } else { - iter->limit=strlen(s); - } - iter->length= iter->limit<=1 ? iter->limit : -1; - } else { - /* set no-op iterator */ - uiter_setString(iter, NULL, 0); - } - } -} |