--- /dev/null
+/*
+******************************************************************************
+*
+* Copyright (C) 2001-2010, International Business Machines
+* Corporation and others. All Rights Reserved.
+*
+******************************************************************************
+* file name: utrie2.cpp
+* encoding: US-ASCII
+* tab size: 8 (not used)
+* indentation:4
+*
+* created on: 2008aug16 (starting from a copy of utrie.c)
+* created by: Markus W. Scherer
+*
+* This is a common implementation of a Unicode trie.
+* It is a kind of compressed, serializable table of 16- or 32-bit values associated with
+* Unicode code points (0..0x10ffff).
+* This is the second common version of a Unicode trie (hence the name UTrie2).
+* See utrie2.h for a comparison.
+*
+* This file contains only the runtime and enumeration code, for read-only access.
+* See utrie2_builder.c for the builder code.
+*/
+#ifdef UTRIE2_DEBUG
+# include <stdio.h>
+#endif
+
+#include "unicode/utypes.h"
+#include "cmemory.h"
+#include "utrie2.h"
+#include "utrie2_impl.h"
+
+/* Public UTrie2 API implementation ----------------------------------------- */
+
+static uint32_t
+get32(const UNewTrie2 *trie, UChar32 c, UBool fromLSCP) {
+ int32_t i2, block;
+
+ if(c>=trie->highStart && (!U_IS_LEAD(c) || fromLSCP)) {
+ return trie->data[trie->dataLength-UTRIE2_DATA_GRANULARITY];
+ }
+
+ if(U_IS_LEAD(c) && fromLSCP) {
+ i2=(UTRIE2_LSCP_INDEX_2_OFFSET-(0xd800>>UTRIE2_SHIFT_2))+
+ (c>>UTRIE2_SHIFT_2);
+ } else {
+ i2=trie->index1[c>>UTRIE2_SHIFT_1]+
+ ((c>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK);
+ }
+ block=trie->index2[i2];
+ return trie->data[block+(c&UTRIE2_DATA_MASK)];
+}
+
+U_CAPI uint32_t U_EXPORT2
+utrie2_get32(const UTrie2 *trie, UChar32 c) {
+ if(trie->data16!=NULL) {
+ return UTRIE2_GET16(trie, c);
+ } else if(trie->data32!=NULL) {
+ return UTRIE2_GET32(trie, c);
+ } else if((uint32_t)c>0x10ffff) {
+ return trie->errorValue;
+ } else {
+ return get32(trie->newTrie, c, TRUE);
+ }
+}
+
+U_CAPI uint32_t U_EXPORT2
+utrie2_get32FromLeadSurrogateCodeUnit(const UTrie2 *trie, UChar32 c) {
+ if(!U_IS_LEAD(c)) {
+ return trie->errorValue;
+ }
+ if(trie->data16!=NULL) {
+ return UTRIE2_GET16_FROM_U16_SINGLE_LEAD(trie, c);
+ } else if(trie->data32!=NULL) {
+ return UTRIE2_GET32_FROM_U16_SINGLE_LEAD(trie, c);
+ } else {
+ return get32(trie->newTrie, c, FALSE);
+ }
+}
+
+static U_INLINE int32_t
+u8Index(const UTrie2 *trie, UChar32 c, int32_t i) {
+ int32_t idx=
+ _UTRIE2_INDEX_FROM_CP(
+ trie,
+ trie->data32==NULL ? trie->indexLength : 0,
+ c);
+ return (idx<<3)|i;
+}
+
+U_CAPI int32_t U_EXPORT2
+utrie2_internalU8NextIndex(const UTrie2 *trie, UChar32 c,
+ const uint8_t *src, const uint8_t *limit) {
+ int32_t i, length;
+ i=0;
+ /* support 64-bit pointers by avoiding cast of arbitrary difference */
+ if((limit-src)<=7) {
+ length=(int32_t)(limit-src);
+ } else {
+ length=7;
+ }
+ c=utf8_nextCharSafeBody(src, &i, length, c, -1);
+ return u8Index(trie, c, i);
+}
+
+U_CAPI int32_t U_EXPORT2
+utrie2_internalU8PrevIndex(const UTrie2 *trie, UChar32 c,
+ const uint8_t *start, const uint8_t *src) {
+ int32_t i, length;
+ /* support 64-bit pointers by avoiding cast of arbitrary difference */
+ if((src-start)<=7) {
+ i=length=(int32_t)(src-start);
+ } else {
+ i=length=7;
+ start=src-7;
+ }
+ c=utf8_prevCharSafeBody(start, 0, &i, c, -1);
+ i=length-i; /* number of bytes read backward from src */
+ return u8Index(trie, c, i);
+}
+
+U_CAPI UTrie2 * U_EXPORT2
+utrie2_openFromSerialized(UTrie2ValueBits valueBits,
+ const void *data, int32_t length, int32_t *pActualLength,
+ UErrorCode *pErrorCode) {
+ const UTrie2Header *header;
+ const uint16_t *p16;
+ int32_t actualLength;
+
+ UTrie2 tempTrie;
+ UTrie2 *trie;
+
+ if(U_FAILURE(*pErrorCode)) {
+ return 0;
+ }
+
+ if( length<=0 || (U_POINTER_MASK_LSB(data, 3)!=0) ||
+ valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits
+ ) {
+ *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ /* enough data for a trie header? */
+ if(length<(int32_t)sizeof(UTrie2Header)) {
+ *pErrorCode=U_INVALID_FORMAT_ERROR;
+ return 0;
+ }
+
+ /* check the signature */
+ header=(const UTrie2Header *)data;
+ if(header->signature!=UTRIE2_SIG) {
+ *pErrorCode=U_INVALID_FORMAT_ERROR;
+ return 0;
+ }
+
+ /* get the options */
+ if(valueBits!=(UTrie2ValueBits)(header->options&UTRIE2_OPTIONS_VALUE_BITS_MASK)) {
+ *pErrorCode=U_INVALID_FORMAT_ERROR;
+ return 0;
+ }
+
+ /* get the length values and offsets */
+ uprv_memset(&tempTrie, 0, sizeof(tempTrie));
+ tempTrie.indexLength=header->indexLength;
+ tempTrie.dataLength=header->shiftedDataLength<<UTRIE2_INDEX_SHIFT;
+ tempTrie.index2NullOffset=header->index2NullOffset;
+ tempTrie.dataNullOffset=header->dataNullOffset;
+
+ tempTrie.highStart=header->shiftedHighStart<<UTRIE2_SHIFT_1;
+ tempTrie.highValueIndex=tempTrie.dataLength-UTRIE2_DATA_GRANULARITY;
+ if(valueBits==UTRIE2_16_VALUE_BITS) {
+ tempTrie.highValueIndex+=tempTrie.indexLength;
+ }
+
+ /* calculate the actual length */
+ actualLength=(int32_t)sizeof(UTrie2Header)+tempTrie.indexLength*2;
+ if(valueBits==UTRIE2_16_VALUE_BITS) {
+ actualLength+=tempTrie.dataLength*2;
+ } else {
+ actualLength+=tempTrie.dataLength*4;
+ }
+ if(length<actualLength) {
+ *pErrorCode=U_INVALID_FORMAT_ERROR; /* not enough bytes */
+ return 0;
+ }
+
+ /* allocate the trie */
+ trie=(UTrie2 *)uprv_malloc(sizeof(UTrie2));
+ if(trie==NULL) {
+ *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
+ return 0;
+ }
+ uprv_memcpy(trie, &tempTrie, sizeof(tempTrie));
+ trie->memory=(uint32_t *)data;
+ trie->length=actualLength;
+ trie->isMemoryOwned=FALSE;
+
+ /* set the pointers to its index and data arrays */
+ p16=(const uint16_t *)(header+1);
+ trie->index=p16;
+ p16+=trie->indexLength;
+
+ /* get the data */
+ switch(valueBits) {
+ case UTRIE2_16_VALUE_BITS:
+ trie->data16=p16;
+ trie->data32=NULL;
+ trie->initialValue=trie->index[trie->dataNullOffset];
+ trie->errorValue=trie->data16[UTRIE2_BAD_UTF8_DATA_OFFSET];
+ break;
+ case UTRIE2_32_VALUE_BITS:
+ trie->data16=NULL;
+ trie->data32=(const uint32_t *)p16;
+ trie->initialValue=trie->data32[trie->dataNullOffset];
+ trie->errorValue=trie->data32[UTRIE2_BAD_UTF8_DATA_OFFSET];
+ break;
+ default:
+ *pErrorCode=U_INVALID_FORMAT_ERROR;
+ return 0;
+ }
+
+ if(pActualLength!=NULL) {
+ *pActualLength=actualLength;
+ }
+ return trie;
+}
+
+U_CAPI UTrie2 * U_EXPORT2
+utrie2_openDummy(UTrie2ValueBits valueBits,
+ uint32_t initialValue, uint32_t errorValue,
+ UErrorCode *pErrorCode) {
+ UTrie2 *trie;
+ UTrie2Header *header;
+ uint32_t *p;
+ uint16_t *dest16;
+ int32_t indexLength, dataLength, length, i;
+ int32_t dataMove; /* >0 if the data is moved to the end of the index array */
+
+ if(U_FAILURE(*pErrorCode)) {
+ return 0;
+ }
+
+ if(valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits) {
+ *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ /* calculate the total length of the dummy trie data */
+ indexLength=UTRIE2_INDEX_1_OFFSET;
+ dataLength=UTRIE2_DATA_START_OFFSET+UTRIE2_DATA_GRANULARITY;
+ length=(int32_t)sizeof(UTrie2Header)+indexLength*2;
+ if(valueBits==UTRIE2_16_VALUE_BITS) {
+ length+=dataLength*2;
+ } else {
+ length+=dataLength*4;
+ }
+
+ /* allocate the trie */
+ trie=(UTrie2 *)uprv_malloc(sizeof(UTrie2));
+ if(trie==NULL) {
+ *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
+ return 0;
+ }
+ uprv_memset(trie, 0, sizeof(UTrie2));
+ trie->memory=uprv_malloc(length);
+ if(trie->memory==NULL) {
+ uprv_free(trie);
+ *pErrorCode=U_MEMORY_ALLOCATION_ERROR;
+ return 0;
+ }
+ trie->length=length;
+ trie->isMemoryOwned=TRUE;
+
+ /* set the UTrie2 fields */
+ if(valueBits==UTRIE2_16_VALUE_BITS) {
+ dataMove=indexLength;
+ } else {
+ dataMove=0;
+ }
+
+ trie->indexLength=indexLength;
+ trie->dataLength=dataLength;
+ trie->index2NullOffset=UTRIE2_INDEX_2_OFFSET;
+ trie->dataNullOffset=(uint16_t)dataMove;
+ trie->initialValue=initialValue;
+ trie->errorValue=errorValue;
+ trie->highStart=0;
+ trie->highValueIndex=dataMove+UTRIE2_DATA_START_OFFSET;
+
+ /* set the header fields */
+ header=(UTrie2Header *)trie->memory;
+
+ header->signature=UTRIE2_SIG; /* "Tri2" */
+ header->options=(uint16_t)valueBits;
+
+ header->indexLength=(uint16_t)indexLength;
+ header->shiftedDataLength=(uint16_t)(dataLength>>UTRIE2_INDEX_SHIFT);
+ header->index2NullOffset=(uint16_t)UTRIE2_INDEX_2_OFFSET;
+ header->dataNullOffset=(uint16_t)dataMove;
+ header->shiftedHighStart=0;
+
+ /* fill the index and data arrays */
+ dest16=(uint16_t *)(header+1);
+ trie->index=dest16;
+
+ /* write the index-2 array values shifted right by UTRIE2_INDEX_SHIFT */
+ for(i=0; i<UTRIE2_INDEX_2_BMP_LENGTH; ++i) {
+ *dest16++=(uint16_t)(dataMove>>UTRIE2_INDEX_SHIFT); /* null data block */
+ }
+
+ /* write UTF-8 2-byte index-2 values, not right-shifted */
+ for(i=0; i<(0xc2-0xc0); ++i) { /* C0..C1 */
+ *dest16++=(uint16_t)(dataMove+UTRIE2_BAD_UTF8_DATA_OFFSET);
+ }
+ for(; i<(0xe0-0xc0); ++i) { /* C2..DF */
+ *dest16++=(uint16_t)dataMove;
+ }
+
+ /* write the 16/32-bit data array */
+ switch(valueBits) {
+ case UTRIE2_16_VALUE_BITS:
+ /* write 16-bit data values */
+ trie->data16=dest16;
+ trie->data32=NULL;
+ for(i=0; i<0x80; ++i) {
+ *dest16++=(uint16_t)initialValue;
+ }
+ for(; i<0xc0; ++i) {
+ *dest16++=(uint16_t)errorValue;
+ }
+ /* highValue and reserved values */
+ for(i=0; i<UTRIE2_DATA_GRANULARITY; ++i) {
+ *dest16++=(uint16_t)initialValue;
+ }
+ break;
+ case UTRIE2_32_VALUE_BITS:
+ /* write 32-bit data values */
+ p=(uint32_t *)dest16;
+ trie->data16=NULL;
+ trie->data32=p;
+ for(i=0; i<0x80; ++i) {
+ *p++=initialValue;
+ }
+ for(; i<0xc0; ++i) {
+ *p++=errorValue;
+ }
+ /* highValue and reserved values */
+ for(i=0; i<UTRIE2_DATA_GRANULARITY; ++i) {
+ *p++=initialValue;
+ }
+ break;
+ default:
+ *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ return trie;
+}
+
+U_CAPI void U_EXPORT2
+utrie2_close(UTrie2 *trie) {
+ if(trie!=NULL) {
+ if(trie->isMemoryOwned) {
+ uprv_free(trie->memory);
+ }
+ if(trie->newTrie!=NULL) {
+ uprv_free(trie->newTrie->data);
+ uprv_free(trie->newTrie);
+ }
+ uprv_free(trie);
+ }
+}
+
+U_CAPI int32_t U_EXPORT2
+utrie2_getVersion(const void *data, int32_t length, UBool anyEndianOk) {
+ uint32_t signature;
+ if(length<16 || data==NULL || (U_POINTER_MASK_LSB(data, 3)!=0)) {
+ return 0;
+ }
+ signature=*(const uint32_t *)data;
+ if(signature==UTRIE2_SIG) {
+ return 2;
+ }
+ if(anyEndianOk && signature==UTRIE2_OE_SIG) {
+ return 2;
+ }
+ if(signature==UTRIE_SIG) {
+ return 1;
+ }
+ if(anyEndianOk && signature==UTRIE_OE_SIG) {
+ return 1;
+ }
+ return 0;
+}
+
+U_CAPI int32_t U_EXPORT2
+utrie2_swap(const UDataSwapper *ds,
+ const void *inData, int32_t length, void *outData,
+ UErrorCode *pErrorCode) {
+ const UTrie2Header *inTrie;
+ UTrie2Header trie;
+ int32_t dataLength, size;
+ UTrie2ValueBits valueBits;
+
+ if(U_FAILURE(*pErrorCode)) {
+ return 0;
+ }
+ if(ds==NULL || inData==NULL || (length>=0 && outData==NULL)) {
+ *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ /* setup and swapping */
+ if(length>=0 && length<(int32_t)sizeof(UTrie2Header)) {
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+ return 0;
+ }
+
+ inTrie=(const UTrie2Header *)inData;
+ trie.signature=ds->readUInt32(inTrie->signature);
+ trie.options=ds->readUInt16(inTrie->options);
+ trie.indexLength=ds->readUInt16(inTrie->indexLength);
+ trie.shiftedDataLength=ds->readUInt16(inTrie->shiftedDataLength);
+
+ valueBits=(UTrie2ValueBits)(trie.options&UTRIE2_OPTIONS_VALUE_BITS_MASK);
+ dataLength=(int32_t)trie.shiftedDataLength<<UTRIE2_INDEX_SHIFT;
+
+ if( trie.signature!=UTRIE2_SIG ||
+ valueBits<0 || UTRIE2_COUNT_VALUE_BITS<=valueBits ||
+ trie.indexLength<UTRIE2_INDEX_1_OFFSET ||
+ dataLength<UTRIE2_DATA_START_OFFSET
+ ) {
+ *pErrorCode=U_INVALID_FORMAT_ERROR; /* not a UTrie */
+ return 0;
+ }
+
+ size=sizeof(UTrie2Header)+trie.indexLength*2;
+ switch(valueBits) {
+ case UTRIE2_16_VALUE_BITS:
+ size+=dataLength*2;
+ break;
+ case UTRIE2_32_VALUE_BITS:
+ size+=dataLength*4;
+ break;
+ default:
+ *pErrorCode=U_INVALID_FORMAT_ERROR;
+ return 0;
+ }
+
+ if(length>=0) {
+ UTrie2Header *outTrie;
+
+ if(length<size) {
+ *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
+ return 0;
+ }
+
+ outTrie=(UTrie2Header *)outData;
+
+ /* swap the header */
+ ds->swapArray32(ds, &inTrie->signature, 4, &outTrie->signature, pErrorCode);
+ ds->swapArray16(ds, &inTrie->options, 12, &outTrie->options, pErrorCode);
+
+ /* swap the index and the data */
+ switch(valueBits) {
+ case UTRIE2_16_VALUE_BITS:
+ ds->swapArray16(ds, inTrie+1, (trie.indexLength+dataLength)*2, outTrie+1, pErrorCode);
+ break;
+ case UTRIE2_32_VALUE_BITS:
+ ds->swapArray16(ds, inTrie+1, trie.indexLength*2, outTrie+1, pErrorCode);
+ ds->swapArray32(ds, (const uint16_t *)(inTrie+1)+trie.indexLength, dataLength*4,
+ (uint16_t *)(outTrie+1)+trie.indexLength, pErrorCode);
+ break;
+ default:
+ *pErrorCode=U_INVALID_FORMAT_ERROR;
+ return 0;
+ }
+ }
+
+ return size;
+}
+
+// utrie2_swapAnyVersion() should be defined here but lives in utrie2_builder.c
+// to avoid a dependency from utrie2.cpp on utrie.c.
+
+/* enumeration -------------------------------------------------------------- */
+
+#define MIN_VALUE(a, b) ((a)<(b) ? (a) : (b))
+
+/* default UTrie2EnumValue() returns the input value itself */
+static uint32_t U_CALLCONV
+enumSameValue(const void * /*context*/, uint32_t value) {
+ return value;
+}
+
+/**
+ * Enumerate all ranges of code points with the same relevant values.
+ * The values are transformed from the raw trie entries by the enumValue function.
+ *
+ * Currently requires start<limit and both start and limit must be multiples
+ * of UTRIE2_DATA_BLOCK_LENGTH.
+ *
+ * Optimizations:
+ * - Skip a whole block if we know that it is filled with a single value,
+ * and it is the same as we visited just before.
+ * - Handle the null block specially because we know a priori that it is filled
+ * with a single value.
+ */
+static void
+enumEitherTrie(const UTrie2 *trie,
+ UChar32 start, UChar32 limit,
+ UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) {
+ const uint32_t *data32;
+ const uint16_t *idx;
+
+ uint32_t value, prevValue, initialValue;
+ UChar32 c, prev, highStart;
+ int32_t j, i2Block, prevI2Block, index2NullOffset, block, prevBlock, nullBlock;
+
+ if(enumRange==NULL) {
+ return;
+ }
+ if(enumValue==NULL) {
+ enumValue=enumSameValue;
+ }
+
+ if(trie->newTrie==NULL) {
+ /* frozen trie */
+ idx=trie->index;
+ data32=trie->data32;
+
+ index2NullOffset=trie->index2NullOffset;
+ nullBlock=trie->dataNullOffset;
+ } else {
+ /* unfrozen, mutable trie */
+ idx=NULL;
+ data32=trie->newTrie->data;
+
+ index2NullOffset=trie->newTrie->index2NullOffset;
+ nullBlock=trie->newTrie->dataNullOffset;
+ }
+
+ highStart=trie->highStart;
+
+ /* get the enumeration value that corresponds to an initial-value trie data entry */
+ initialValue=enumValue(context, trie->initialValue);
+
+ /* set variables for previous range */
+ prevI2Block=-1;
+ prevBlock=-1;
+ prev=start;
+ prevValue=0;
+
+ /* enumerate index-2 blocks */
+ for(c=start; c<limit && c<highStart;) {
+ /* Code point limit for iterating inside this i2Block. */
+ UChar32 tempLimit=c+UTRIE2_CP_PER_INDEX_1_ENTRY;
+ if(limit<tempLimit) {
+ tempLimit=limit;
+ }
+ if(c<=0xffff) {
+ if(!U_IS_SURROGATE(c)) {
+ i2Block=c>>UTRIE2_SHIFT_2;
+ } else if(U_IS_SURROGATE_LEAD(c)) {
+ /*
+ * Enumerate values for lead surrogate code points, not code units:
+ * This special block has half the normal length.
+ */
+ i2Block=UTRIE2_LSCP_INDEX_2_OFFSET;
+ tempLimit=MIN_VALUE(0xdc00, limit);
+ } else {
+ /*
+ * Switch back to the normal part of the index-2 table.
+ * Enumerate the second half of the surrogates block.
+ */
+ i2Block=0xd800>>UTRIE2_SHIFT_2;
+ tempLimit=MIN_VALUE(0xe000, limit);
+ }
+ } else {
+ /* supplementary code points */
+ if(idx!=NULL) {
+ i2Block=idx[(UTRIE2_INDEX_1_OFFSET-UTRIE2_OMITTED_BMP_INDEX_1_LENGTH)+
+ (c>>UTRIE2_SHIFT_1)];
+ } else {
+ i2Block=trie->newTrie->index1[c>>UTRIE2_SHIFT_1];
+ }
+ if(i2Block==prevI2Block && (c-prev)>=UTRIE2_CP_PER_INDEX_1_ENTRY) {
+ /*
+ * The index-2 block is the same as the previous one, and filled with prevValue.
+ * Only possible for supplementary code points because the linear-BMP index-2
+ * table creates unique i2Block values.
+ */
+ c+=UTRIE2_CP_PER_INDEX_1_ENTRY;
+ continue;
+ }
+ }
+ prevI2Block=i2Block;
+ if(i2Block==index2NullOffset) {
+ /* this is the null index-2 block */
+ if(prevValue!=initialValue) {
+ if(prev<c && !enumRange(context, prev, c-1, prevValue)) {
+ return;
+ }
+ prevBlock=nullBlock;
+ prev=c;
+ prevValue=initialValue;
+ }
+ c+=UTRIE2_CP_PER_INDEX_1_ENTRY;
+ } else {
+ /* enumerate data blocks for one index-2 block */
+ int32_t i2, i2Limit;
+ i2=(c>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK;
+ if((c>>UTRIE2_SHIFT_1)==(tempLimit>>UTRIE2_SHIFT_1)) {
+ i2Limit=(tempLimit>>UTRIE2_SHIFT_2)&UTRIE2_INDEX_2_MASK;
+ } else {
+ i2Limit=UTRIE2_INDEX_2_BLOCK_LENGTH;
+ }
+ for(; i2<i2Limit; ++i2) {
+ if(idx!=NULL) {
+ block=(int32_t)idx[i2Block+i2]<<UTRIE2_INDEX_SHIFT;
+ } else {
+ block=trie->newTrie->index2[i2Block+i2];
+ }
+ if(block==prevBlock && (c-prev)>=UTRIE2_DATA_BLOCK_LENGTH) {
+ /* the block is the same as the previous one, and filled with prevValue */
+ c+=UTRIE2_DATA_BLOCK_LENGTH;
+ continue;
+ }
+ prevBlock=block;
+ if(block==nullBlock) {
+ /* this is the null data block */
+ if(prevValue!=initialValue) {
+ if(prev<c && !enumRange(context, prev, c-1, prevValue)) {
+ return;
+ }
+ prev=c;
+ prevValue=initialValue;
+ }
+ c+=UTRIE2_DATA_BLOCK_LENGTH;
+ } else {
+ for(j=0; j<UTRIE2_DATA_BLOCK_LENGTH; ++j) {
+ value=enumValue(context, data32!=NULL ? data32[block+j] : idx[block+j]);
+ if(value!=prevValue) {
+ if(prev<c && !enumRange(context, prev, c-1, prevValue)) {
+ return;
+ }
+ prev=c;
+ prevValue=value;
+ }
+ ++c;
+ }
+ }
+ }
+ }
+ }
+
+ if(c>limit) {
+ c=limit; /* could be higher if in the index2NullOffset */
+ } else if(c<limit) {
+ /* c==highStart<limit */
+ uint32_t highValue;
+ if(idx!=NULL) {
+ highValue=
+ data32!=NULL ?
+ data32[trie->highValueIndex] :
+ idx[trie->highValueIndex];
+ } else {
+ highValue=trie->newTrie->data[trie->newTrie->dataLength-UTRIE2_DATA_GRANULARITY];
+ }
+ value=enumValue(context, highValue);
+ if(value!=prevValue) {
+ if(prev<c && !enumRange(context, prev, c-1, prevValue)) {
+ return;
+ }
+ prev=c;
+ prevValue=value;
+ }
+ c=limit;
+ }
+
+ /* deliver last range */
+ enumRange(context, prev, c-1, prevValue);
+}
+
+U_CAPI void U_EXPORT2
+utrie2_enum(const UTrie2 *trie,
+ UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange, const void *context) {
+ enumEitherTrie(trie, 0, 0x110000, enumValue, enumRange, context);
+}
+
+U_CAPI void U_EXPORT2
+utrie2_enumForLeadSurrogate(const UTrie2 *trie, UChar32 lead,
+ UTrie2EnumValue *enumValue, UTrie2EnumRange *enumRange,
+ const void *context) {
+ if(!U16_IS_LEAD(lead)) {
+ return;
+ }
+ lead=(lead-0xd7c0)<<10; /* start code point */
+ enumEitherTrie(trie, lead, lead+0x400, enumValue, enumRange, context);
+}
+
+/* C++ convenience wrappers ------------------------------------------------- */
+
+U_NAMESPACE_BEGIN
+
+uint16_t BackwardUTrie2StringIterator::previous16() {
+ codePointLimit=codePointStart;
+ if(start>=codePointStart) {
+ codePoint=U_SENTINEL;
+ return 0;
+ }
+ uint16_t result;
+ UTRIE2_U16_PREV16(trie, start, codePointStart, codePoint, result);
+ return result;
+}
+
+uint16_t ForwardUTrie2StringIterator::next16() {
+ codePointStart=codePointLimit;
+ if(codePointLimit==limit) {
+ codePoint=U_SENTINEL;
+ return 0;
+ }
+ uint16_t result;
+ UTRIE2_U16_NEXT16(trie, codePointLimit, limit, codePoint, result);
+ return result;
+}
+
+UTrie2 *UTrie2Singleton::getInstance(InstantiatorFn *instantiator, const void *context,
+ UErrorCode &errorCode) {
+ void *duplicate;
+ UTrie2 *instance=(UTrie2 *)singleton.getInstance(instantiator, context, duplicate, errorCode);
+ utrie2_close((UTrie2 *)duplicate);
+ return instance;
+}
+
+U_NAMESPACE_END
projects / apple / icu.git / blobdiff