diff options
Diffstat (limited to 'deps/node/deps/icu-small/source/common/utext.cpp')
| -rw-r--r-- | deps/node/deps/icu-small/source/common/utext.cpp | 2875 |
1 files changed, 0 insertions, 2875 deletions
diff --git a/deps/node/deps/icu-small/source/common/utext.cpp b/deps/node/deps/icu-small/source/common/utext.cpp deleted file mode 100644 index 5e3a0056..00000000 --- a/deps/node/deps/icu-small/source/common/utext.cpp +++ /dev/null @@ -1,2875 +0,0 @@ -// © 2016 and later: Unicode, Inc. and others. -// License & terms of use: http://www.unicode.org/copyright.html -/* -******************************************************************************* -* -* Copyright (C) 2005-2016, International Business Machines -* Corporation and others. All Rights Reserved. -* -******************************************************************************* -* file name: utext.cpp -* encoding: UTF-8 -* tab size: 8 (not used) -* indentation:4 -* -* created on: 2005apr12 -* created by: Markus W. Scherer -*/ - -#include "unicode/utypes.h" -#include "unicode/ustring.h" -#include "unicode/unistr.h" -#include "unicode/chariter.h" -#include "unicode/utext.h" -#include "unicode/utf.h" -#include "unicode/utf8.h" -#include "unicode/utf16.h" -#include "ustr_imp.h" -#include "cmemory.h" -#include "cstring.h" -#include "uassert.h" -#include "putilimp.h" - -U_NAMESPACE_USE - -#define I32_FLAG(bitIndex) ((int32_t)1<<(bitIndex)) - - -static UBool -utext_access(UText *ut, int64_t index, UBool forward) { - return ut->pFuncs->access(ut, index, forward); -} - - - -U_CAPI UBool U_EXPORT2 -utext_moveIndex32(UText *ut, int32_t delta) { - UChar32 c; - if (delta > 0) { - do { - if(ut->chunkOffset>=ut->chunkLength && !utext_access(ut, ut->chunkNativeLimit, TRUE)) { - return FALSE; - } - c = ut->chunkContents[ut->chunkOffset]; - if (U16_IS_SURROGATE(c)) { - c = utext_next32(ut); - if (c == U_SENTINEL) { - return FALSE; - } - } else { - ut->chunkOffset++; - } - } while(--delta>0); - - } else if (delta<0) { - do { - if(ut->chunkOffset<=0 && !utext_access(ut, ut->chunkNativeStart, FALSE)) { - return FALSE; - } - c = ut->chunkContents[ut->chunkOffset-1]; - if (U16_IS_SURROGATE(c)) { - c = utext_previous32(ut); - if (c == U_SENTINEL) { - return FALSE; - } - } else { - ut->chunkOffset--; - } - } while(++delta<0); - } - - return TRUE; -} - - -U_CAPI int64_t U_EXPORT2 -utext_nativeLength(UText *ut) { - return ut->pFuncs->nativeLength(ut); -} - - -U_CAPI UBool U_EXPORT2 -utext_isLengthExpensive(const UText *ut) { - UBool r = (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE)) != 0; - return r; -} - - -U_CAPI int64_t U_EXPORT2 -utext_getNativeIndex(const UText *ut) { - if(ut->chunkOffset <= ut->nativeIndexingLimit) { - return ut->chunkNativeStart+ut->chunkOffset; - } else { - return ut->pFuncs->mapOffsetToNative(ut); - } -} - - -U_CAPI void U_EXPORT2 -utext_setNativeIndex(UText *ut, int64_t index) { - if(index<ut->chunkNativeStart || index>=ut->chunkNativeLimit) { - // The desired position is outside of the current chunk. - // Access the new position. Assume a forward iteration from here, - // which will also be optimimum for a single random access. - // Reverse iterations may suffer slightly. - ut->pFuncs->access(ut, index, TRUE); - } else if((int32_t)(index - ut->chunkNativeStart) <= ut->nativeIndexingLimit) { - // utf-16 indexing. - ut->chunkOffset=(int32_t)(index-ut->chunkNativeStart); - } else { - ut->chunkOffset=ut->pFuncs->mapNativeIndexToUTF16(ut, index); - } - // The convention is that the index must always be on a code point boundary. - // Adjust the index position if it is in the middle of a surrogate pair. - if (ut->chunkOffset<ut->chunkLength) { - UChar c= ut->chunkContents[ut->chunkOffset]; - if (U16_IS_TRAIL(c)) { - if (ut->chunkOffset==0) { - ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE); - } - if (ut->chunkOffset>0) { - UChar lead = ut->chunkContents[ut->chunkOffset-1]; - if (U16_IS_LEAD(lead)) { - ut->chunkOffset--; - } - } - } - } -} - - - -U_CAPI int64_t U_EXPORT2 -utext_getPreviousNativeIndex(UText *ut) { - // - // Fast-path the common case. - // Common means current position is not at the beginning of a chunk - // and the preceding character is not supplementary. - // - int32_t i = ut->chunkOffset - 1; - int64_t result; - if (i >= 0) { - UChar c = ut->chunkContents[i]; - if (U16_IS_TRAIL(c) == FALSE) { - if (i <= ut->nativeIndexingLimit) { - result = ut->chunkNativeStart + i; - } else { - ut->chunkOffset = i; - result = ut->pFuncs->mapOffsetToNative(ut); - ut->chunkOffset++; - } - return result; - } - } - - // If at the start of text, simply return 0. - if (ut->chunkOffset==0 && ut->chunkNativeStart==0) { - return 0; - } - - // Harder, less common cases. We are at a chunk boundary, or on a surrogate. - // Keep it simple, use other functions to handle the edges. - // - utext_previous32(ut); - result = UTEXT_GETNATIVEINDEX(ut); - utext_next32(ut); - return result; -} - - -// -// utext_current32. Get the UChar32 at the current position. -// UText iteration position is always on a code point boundary, -// never on the trail half of a surrogate pair. -// -U_CAPI UChar32 U_EXPORT2 -utext_current32(UText *ut) { - UChar32 c; - if (ut->chunkOffset==ut->chunkLength) { - // Current position is just off the end of the chunk. - if (ut->pFuncs->access(ut, ut->chunkNativeLimit, TRUE) == FALSE) { - // Off the end of the text. - return U_SENTINEL; - } - } - - c = ut->chunkContents[ut->chunkOffset]; - if (U16_IS_LEAD(c) == FALSE) { - // Normal, non-supplementary case. - return c; - } - - // - // Possible supplementary char. - // - UChar32 trail = 0; - UChar32 supplementaryC = c; - if ((ut->chunkOffset+1) < ut->chunkLength) { - // The trail surrogate is in the same chunk. - trail = ut->chunkContents[ut->chunkOffset+1]; - } else { - // The trail surrogate is in a different chunk. - // Because we must maintain the iteration position, we need to switch forward - // into the new chunk, get the trail surrogate, then revert the chunk back to the - // original one. - // An edge case to be careful of: the entire text may end with an unpaired - // leading surrogate. The attempt to access the trail will fail, but - // the original position before the unpaired lead still needs to be restored. - int64_t nativePosition = ut->chunkNativeLimit; - int32_t originalOffset = ut->chunkOffset; - if (ut->pFuncs->access(ut, nativePosition, TRUE)) { - trail = ut->chunkContents[ut->chunkOffset]; - } - UBool r = ut->pFuncs->access(ut, nativePosition, FALSE); // reverse iteration flag loads preceding chunk - U_ASSERT(r==TRUE); - ut->chunkOffset = originalOffset; - if(!r) { - return U_SENTINEL; - } - } - - if (U16_IS_TRAIL(trail)) { - supplementaryC = U16_GET_SUPPLEMENTARY(c, trail); - } - return supplementaryC; - -} - - -U_CAPI UChar32 U_EXPORT2 -utext_char32At(UText *ut, int64_t nativeIndex) { - UChar32 c = U_SENTINEL; - - // Fast path the common case. - if (nativeIndex>=ut->chunkNativeStart && nativeIndex < ut->chunkNativeStart + ut->nativeIndexingLimit) { - ut->chunkOffset = (int32_t)(nativeIndex - ut->chunkNativeStart); - c = ut->chunkContents[ut->chunkOffset]; - if (U16_IS_SURROGATE(c) == FALSE) { - return c; - } - } - - - utext_setNativeIndex(ut, nativeIndex); - if (nativeIndex>=ut->chunkNativeStart && ut->chunkOffset<ut->chunkLength) { - c = ut->chunkContents[ut->chunkOffset]; - if (U16_IS_SURROGATE(c)) { - // For surrogates, let current32() deal with the complications - // of supplementaries that may span chunk boundaries. - c = utext_current32(ut); - } - } - return c; -} - - -U_CAPI UChar32 U_EXPORT2 -utext_next32(UText *ut) { - UChar32 c; - - if (ut->chunkOffset >= ut->chunkLength) { - if (ut->pFuncs->access(ut, ut->chunkNativeLimit, TRUE) == FALSE) { - return U_SENTINEL; - } - } - - c = ut->chunkContents[ut->chunkOffset++]; - if (U16_IS_LEAD(c) == FALSE) { - // Normal case, not supplementary. - // (A trail surrogate seen here is just returned as is, as a surrogate value. - // It cannot be part of a pair.) - return c; - } - - if (ut->chunkOffset >= ut->chunkLength) { - if (ut->pFuncs->access(ut, ut->chunkNativeLimit, TRUE) == FALSE) { - // c is an unpaired lead surrogate at the end of the text. - // return it as it is. - return c; - } - } - UChar32 trail = ut->chunkContents[ut->chunkOffset]; - if (U16_IS_TRAIL(trail) == FALSE) { - // c was an unpaired lead surrogate, not at the end of the text. - // return it as it is (unpaired). Iteration position is on the - // following character, possibly in the next chunk, where the - // trail surrogate would have been if it had existed. - return c; - } - - UChar32 supplementary = U16_GET_SUPPLEMENTARY(c, trail); - ut->chunkOffset++; // move iteration position over the trail surrogate. - return supplementary; - } - - -U_CAPI UChar32 U_EXPORT2 -utext_previous32(UText *ut) { - UChar32 c; - - if (ut->chunkOffset <= 0) { - if (ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE) == FALSE) { - return U_SENTINEL; - } - } - ut->chunkOffset--; - c = ut->chunkContents[ut->chunkOffset]; - if (U16_IS_TRAIL(c) == FALSE) { - // Normal case, not supplementary. - // (A lead surrogate seen here is just returned as is, as a surrogate value. - // It cannot be part of a pair.) - return c; - } - - if (ut->chunkOffset <= 0) { - if (ut->pFuncs->access(ut, ut->chunkNativeStart, FALSE) == FALSE) { - // c is an unpaired trail surrogate at the start of the text. - // return it as it is. - return c; - } - } - - UChar32 lead = ut->chunkContents[ut->chunkOffset-1]; - if (U16_IS_LEAD(lead) == FALSE) { - // c was an unpaired trail surrogate, not at the end of the text. - // return it as it is (unpaired). Iteration position is at c - return c; - } - - UChar32 supplementary = U16_GET_SUPPLEMENTARY(lead, c); - ut->chunkOffset--; // move iteration position over the lead surrogate. - return supplementary; -} - - - -U_CAPI UChar32 U_EXPORT2 -utext_next32From(UText *ut, int64_t index) { - UChar32 c = U_SENTINEL; - - if(index<ut->chunkNativeStart || index>=ut->chunkNativeLimit) { - // Desired position is outside of the current chunk. - if(!ut->pFuncs->access(ut, index, TRUE)) { - // no chunk available here - return U_SENTINEL; - } - } else if (index - ut->chunkNativeStart <= (int64_t)ut->nativeIndexingLimit) { - // Desired position is in chunk, with direct 1:1 native to UTF16 indexing - ut->chunkOffset = (int32_t)(index - ut->chunkNativeStart); - } else { - // Desired position is in chunk, with non-UTF16 indexing. - ut->chunkOffset = ut->pFuncs->mapNativeIndexToUTF16(ut, index); - } - - c = ut->chunkContents[ut->chunkOffset++]; - if (U16_IS_SURROGATE(c)) { - // Surrogates. Many edge cases. Use other functions that already - // deal with the problems. - utext_setNativeIndex(ut, index); - c = utext_next32(ut); - } - return c; -} - - -U_CAPI UChar32 U_EXPORT2 -utext_previous32From(UText *ut, int64_t index) { - // - // Return the character preceding the specified index. - // Leave the iteration position at the start of the character that was returned. - // - UChar32 cPrev; // The character preceding cCurr, which is what we will return. - - // Address the chunk containg the position preceding the incoming index - // A tricky edge case: - // We try to test the requested native index against the chunkNativeStart to determine - // whether the character preceding the one at the index is in the current chunk. - // BUT, this test can fail with UTF-8 (or any other multibyte encoding), when the - // requested index is on something other than the first position of the first char. - // - if(index<=ut->chunkNativeStart || index>ut->chunkNativeLimit) { - // Requested native index is outside of the current chunk. - if(!ut->pFuncs->access(ut, index, FALSE)) { - // no chunk available here - return U_SENTINEL; - } - } else if(index - ut->chunkNativeStart <= (int64_t)ut->nativeIndexingLimit) { - // Direct UTF-16 indexing. - ut->chunkOffset = (int32_t)(index - ut->chunkNativeStart); - } else { - ut->chunkOffset=ut->pFuncs->mapNativeIndexToUTF16(ut, index); - if (ut->chunkOffset==0 && !ut->pFuncs->access(ut, index, FALSE)) { - // no chunk available here - return U_SENTINEL; - } - } - - // - // Simple case with no surrogates. - // - ut->chunkOffset--; - cPrev = ut->chunkContents[ut->chunkOffset]; - - if (U16_IS_SURROGATE(cPrev)) { - // Possible supplementary. Many edge cases. - // Let other functions do the heavy lifting. - utext_setNativeIndex(ut, index); - cPrev = utext_previous32(ut); - } - return cPrev; -} - - -U_CAPI int32_t U_EXPORT2 -utext_extract(UText *ut, - int64_t start, int64_t limit, - UChar *dest, int32_t destCapacity, - UErrorCode *status) { - return ut->pFuncs->extract(ut, start, limit, dest, destCapacity, status); - } - - - -U_CAPI UBool U_EXPORT2 -utext_equals(const UText *a, const UText *b) { - if (a==NULL || b==NULL || - a->magic != UTEXT_MAGIC || - b->magic != UTEXT_MAGIC) { - // Null or invalid arguments don't compare equal to anything. - return FALSE; - } - - if (a->pFuncs != b->pFuncs) { - // Different types of text providers. - return FALSE; - } - - if (a->context != b->context) { - // Different sources (different strings) - return FALSE; - } - if (utext_getNativeIndex(a) != utext_getNativeIndex(b)) { - // Different current position in the string. - return FALSE; - } - - return TRUE; -} - -U_CAPI UBool U_EXPORT2 -utext_isWritable(const UText *ut) -{ - UBool b = (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_WRITABLE)) != 0; - return b; -} - - -U_CAPI void U_EXPORT2 -utext_freeze(UText *ut) { - // Zero out the WRITABLE flag. - ut->providerProperties &= ~(I32_FLAG(UTEXT_PROVIDER_WRITABLE)); -} - - -U_CAPI UBool U_EXPORT2 -utext_hasMetaData(const UText *ut) -{ - UBool b = (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_HAS_META_DATA)) != 0; - return b; -} - - - -U_CAPI int32_t U_EXPORT2 -utext_replace(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - const UChar *replacementText, int32_t replacementLength, - UErrorCode *status) -{ - if (U_FAILURE(*status)) { - return 0; - } - if ((ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_WRITABLE)) == 0) { - *status = U_NO_WRITE_PERMISSION; - return 0; - } - int32_t i = ut->pFuncs->replace(ut, nativeStart, nativeLimit, replacementText, replacementLength, status); - return i; -} - -U_CAPI void U_EXPORT2 -utext_copy(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - int64_t destIndex, - UBool move, - UErrorCode *status) -{ - if (U_FAILURE(*status)) { - return; - } - if ((ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_WRITABLE)) == 0) { - *status = U_NO_WRITE_PERMISSION; - return; - } - ut->pFuncs->copy(ut, nativeStart, nativeLimit, destIndex, move, status); -} - - - -U_CAPI UText * U_EXPORT2 -utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status) { - if (U_FAILURE(*status)) { - return dest; - } - UText *result = src->pFuncs->clone(dest, src, deep, status); - if (U_FAILURE(*status)) { - return result; - } - if (result == NULL) { - *status = U_MEMORY_ALLOCATION_ERROR; - return result; - } - if (readOnly) { - utext_freeze(result); - } - return result; -} - - - -//------------------------------------------------------------------------------ -// -// UText common functions implementation -// -//------------------------------------------------------------------------------ - -// -// UText.flags bit definitions -// -enum { - UTEXT_HEAP_ALLOCATED = 1, // 1 if ICU has allocated this UText struct on the heap. - // 0 if caller provided storage for the UText. - - UTEXT_EXTRA_HEAP_ALLOCATED = 2, // 1 if ICU has allocated extra storage as a separate - // heap block. - // 0 if there is no separate allocation. Either no extra - // storage was requested, or it is appended to the end - // of the main UText storage. - - UTEXT_OPEN = 4 // 1 if this UText is currently open - // 0 if this UText is not open. -}; - - -// -// Extended form of a UText. The purpose is to aid in computing the total size required -// when a provider asks for a UText to be allocated with extra storage. - -struct ExtendedUText { - UText ut; - UAlignedMemory extension; -}; - -static const UText emptyText = UTEXT_INITIALIZER; - -U_CAPI UText * U_EXPORT2 -utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status) { - if (U_FAILURE(*status)) { - return ut; - } - - if (ut == NULL) { - // We need to heap-allocate storage for the new UText - int32_t spaceRequired = sizeof(UText); - if (extraSpace > 0) { - spaceRequired = sizeof(ExtendedUText) + extraSpace - sizeof(UAlignedMemory); - } - ut = (UText *)uprv_malloc(spaceRequired); - if (ut == NULL) { - *status = U_MEMORY_ALLOCATION_ERROR; - return NULL; - } else { - *ut = emptyText; - ut->flags |= UTEXT_HEAP_ALLOCATED; - if (spaceRequired>0) { - ut->extraSize = extraSpace; - ut->pExtra = &((ExtendedUText *)ut)->extension; - } - } - } else { - // We have been supplied with an already existing UText. - // Verify that it really appears to be a UText. - if (ut->magic != UTEXT_MAGIC) { - *status = U_ILLEGAL_ARGUMENT_ERROR; - return ut; - } - // If the ut is already open and there's a provider supplied close - // function, call it. - if ((ut->flags & UTEXT_OPEN) && ut->pFuncs->close != NULL) { - ut->pFuncs->close(ut); - } - ut->flags &= ~UTEXT_OPEN; - - // If extra space was requested by our caller, check whether - // sufficient already exists, and allocate new if needed. - if (extraSpace > ut->extraSize) { - // Need more space. If there is existing separately allocated space, - // delete it first, then allocate new space. - if (ut->flags & UTEXT_EXTRA_HEAP_ALLOCATED) { - uprv_free(ut->pExtra); - ut->extraSize = 0; - } - ut->pExtra = uprv_malloc(extraSpace); - if (ut->pExtra == NULL) { - *status = U_MEMORY_ALLOCATION_ERROR; - } else { - ut->extraSize = extraSpace; - ut->flags |= UTEXT_EXTRA_HEAP_ALLOCATED; - } - } - } - if (U_SUCCESS(*status)) { - ut->flags |= UTEXT_OPEN; - - // Initialize all remaining fields of the UText. - // - ut->context = NULL; - ut->chunkContents = NULL; - ut->p = NULL; - ut->q = NULL; - ut->r = NULL; - ut->a = 0; - ut->b = 0; - ut->c = 0; - ut->chunkOffset = 0; - ut->chunkLength = 0; - ut->chunkNativeStart = 0; - ut->chunkNativeLimit = 0; - ut->nativeIndexingLimit = 0; - ut->providerProperties = 0; - ut->privA = 0; - ut->privB = 0; - ut->privC = 0; - ut->privP = NULL; - if (ut->pExtra!=NULL && ut->extraSize>0) - uprv_memset(ut->pExtra, 0, ut->extraSize); - - } - return ut; -} - - -U_CAPI UText * U_EXPORT2 -utext_close(UText *ut) { - if (ut==NULL || - ut->magic != UTEXT_MAGIC || - (ut->flags & UTEXT_OPEN) == 0) - { - // The supplied ut is not an open UText. - // Do nothing. - return ut; - } - - // If the provider gave us a close function, call it now. - // This will clean up anything allocated specifically by the provider. - if (ut->pFuncs->close != NULL) { - ut->pFuncs->close(ut); - } - ut->flags &= ~UTEXT_OPEN; - - // If we (the framework) allocated the UText or subsidiary storage, - // delete it. - if (ut->flags & UTEXT_EXTRA_HEAP_ALLOCATED) { - uprv_free(ut->pExtra); - ut->pExtra = NULL; - ut->flags &= ~UTEXT_EXTRA_HEAP_ALLOCATED; - ut->extraSize = 0; - } - - // Zero out function table of the closed UText. This is a defensive move, - // inteded to cause applications that inadvertantly use a closed - // utext to crash with null pointer errors. - ut->pFuncs = NULL; - - if (ut->flags & UTEXT_HEAP_ALLOCATED) { - // This UText was allocated by UText setup. We need to free it. - // Clear magic, so we can detect if the user messes up and immediately - // tries to reopen another UText using the deleted storage. - ut->magic = 0; - uprv_free(ut); - ut = NULL; - } - return ut; -} - - - - -// -// invalidateChunk Reset a chunk to have no contents, so that the next call -// to access will cause new data to load. -// This is needed when copy/move/replace operate directly on the -// backing text, potentially putting it out of sync with the -// contents in the chunk. -// -static void -invalidateChunk(UText *ut) { - ut->chunkLength = 0; - ut->chunkNativeLimit = 0; - ut->chunkNativeStart = 0; - ut->chunkOffset = 0; - ut->nativeIndexingLimit = 0; -} - -// -// pinIndex Do range pinning on a native index parameter. -// 64 bit pinning is done in place. -// 32 bit truncated result is returned as a convenience for -// use in providers that don't need 64 bits. -static int32_t -pinIndex(int64_t &index, int64_t limit) { - if (index<0) { - index = 0; - } else if (index > limit) { - index = limit; - } - return (int32_t)index; -} - - -U_CDECL_BEGIN - -// -// Pointer relocation function, -// a utility used by shallow clone. -// Adjust a pointer that refers to something within one UText (the source) -// to refer to the same relative offset within a another UText (the target) -// -static void adjustPointer(UText *dest, const void **destPtr, const UText *src) { - // convert all pointers to (char *) so that byte address arithmetic will work. - char *dptr = (char *)*destPtr; - char *dUText = (char *)dest; - char *sUText = (char *)src; - - if (dptr >= (char *)src->pExtra && dptr < ((char*)src->pExtra)+src->extraSize) { - // target ptr was to something within the src UText's pExtra storage. - // relocate it into the target UText's pExtra region. - *destPtr = ((char *)dest->pExtra) + (dptr - (char *)src->pExtra); - } else if (dptr>=sUText && dptr < sUText+src->sizeOfStruct) { - // target ptr was pointing to somewhere within the source UText itself. - // Move it to the same offset within the target UText. - *destPtr = dUText + (dptr-sUText); - } -} - - -// -// Clone. This is a generic copy-the-utext-by-value clone function that can be -// used as-is with some utext types, and as a helper by other clones. -// -static UText * U_CALLCONV -shallowTextClone(UText * dest, const UText * src, UErrorCode * status) { - if (U_FAILURE(*status)) { - return NULL; - } - int32_t srcExtraSize = src->extraSize; - - // - // Use the generic text_setup to allocate storage if required. - // - dest = utext_setup(dest, srcExtraSize, status); - if (U_FAILURE(*status)) { - return dest; - } - - // - // flags (how the UText was allocated) and the pointer to the - // extra storage must retain the values in the cloned utext that - // were set up by utext_setup. Save them separately before - // copying the whole struct. - // - void *destExtra = dest->pExtra; - int32_t flags = dest->flags; - - - // - // Copy the whole UText struct by value. - // Any "Extra" storage is copied also. - // - int sizeToCopy = src->sizeOfStruct; - if (sizeToCopy > dest->sizeOfStruct) { - sizeToCopy = dest->sizeOfStruct; - } - uprv_memcpy(dest, src, sizeToCopy); - dest->pExtra = destExtra; - dest->flags = flags; - if (srcExtraSize > 0) { - uprv_memcpy(dest->pExtra, src->pExtra, srcExtraSize); - } - - // - // Relocate any pointers in the target that refer to the UText itself - // to point to the cloned copy rather than the original source. - // - adjustPointer(dest, &dest->context, src); - adjustPointer(dest, &dest->p, src); - adjustPointer(dest, &dest->q, src); - adjustPointer(dest, &dest->r, src); - adjustPointer(dest, (const void **)&dest->chunkContents, src); - - // The newly shallow-cloned UText does _not_ own the underlying storage for the text. - // (The source for the clone may or may not have owned the text.) - - dest->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT); - - return dest; -} - - -U_CDECL_END - - - -//------------------------------------------------------------------------------ -// -// UText implementation for UTF-8 char * strings (read-only) -// Limitation: string length must be <= 0x7fffffff in length. -// (length must for in an int32_t variable) -// -// Use of UText data members: -// context pointer to UTF-8 string -// utext.b is the input string length (bytes). -// utext.c Length scanned so far in string -// (for optimizing finding length of zero terminated strings.) -// utext.p pointer to the current buffer -// utext.q pointer to the other buffer. -// -//------------------------------------------------------------------------------ - -// Chunk size. -// Must be less than 85 (256/3), because of byte mapping from UChar indexes to native indexes. -// Worst case is three native bytes to one UChar. (Supplemenaries are 4 native bytes -// to two UChars.) -// The longest illegal byte sequence treated as a single error (and converted to U+FFFD) -// is a three-byte sequence (truncated four-byte sequence). -// -enum { UTF8_TEXT_CHUNK_SIZE=32 }; - -// -// UTF8Buf Two of these structs will be set up in the UText's extra allocated space. -// Each contains the UChar chunk buffer, the to and from native maps, and -// header info. -// -// because backwards iteration fills the buffers starting at the end and -// working towards the front, the filled part of the buffers may not begin -// at the start of the available storage for the buffers. -// -// Buffer size is one bigger than the specified UTF8_TEXT_CHUNK_SIZE to allow for -// the last character added being a supplementary, and thus requiring a surrogate -// pair. Doing this is simpler than checking for the edge case. -// - -struct UTF8Buf { - int32_t bufNativeStart; // Native index of first char in UChar buf - int32_t bufNativeLimit; // Native index following last char in buf. - int32_t bufStartIdx; // First filled position in buf. - int32_t bufLimitIdx; // Limit of filled range in buf. - int32_t bufNILimit; // Limit of native indexing part of buf - int32_t toUCharsMapStart; // Native index corresponding to - // mapToUChars[0]. - // Set to bufNativeStart when filling forwards. - // Set to computed value when filling backwards. - - UChar buf[UTF8_TEXT_CHUNK_SIZE+4]; // The UChar buffer. Requires one extra position beyond the - // the chunk size, to allow for surrogate at the end. - // Length must be identical to mapToNative array, below, - // because of the way indexing works when the array is - // filled backwards during a reverse iteration. Thus, - // the additional extra size. - uint8_t mapToNative[UTF8_TEXT_CHUNK_SIZE+4]; // map UChar index in buf to - // native offset from bufNativeStart. - // Requires two extra slots, - // one for a supplementary starting in the last normal position, - // and one for an entry for the buffer limit position. - uint8_t mapToUChars[UTF8_TEXT_CHUNK_SIZE*3+6]; // Map native offset from bufNativeStart to - // correspoding offset in filled part of buf. - int32_t align; -}; - -U_CDECL_BEGIN - -// -// utf8TextLength -// -// Get the length of the string. If we don't already know it, -// we'll need to scan for the trailing nul. -// -static int64_t U_CALLCONV -utf8TextLength(UText *ut) { - if (ut->b < 0) { - // Zero terminated string, and we haven't scanned to the end yet. - // Scan it now. - const char *r = (const char *)ut->context + ut->c; - while (*r != 0) { - r++; - } - if ((r - (const char *)ut->context) < 0x7fffffff) { - ut->b = (int32_t)(r - (const char *)ut->context); - } else { - // Actual string was bigger (more than 2 gig) than we - // can handle. Clip it to 2 GB. - ut->b = 0x7fffffff; - } - ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - } - return ut->b; -} - - - - - - -static UBool U_CALLCONV -utf8TextAccess(UText *ut, int64_t index, UBool forward) { - // - // Apologies to those who are allergic to goto statements. - // Consider each goto to a labelled block to be the equivalent of - // call the named block as if it were a function(); - // return; - // - const uint8_t *s8=(const uint8_t *)ut->context; - UTF8Buf *u8b = NULL; - int32_t length = ut->b; // Length of original utf-8 - int32_t ix= (int32_t)index; // Requested index, trimmed to 32 bits. - int32_t mapIndex = 0; - if (index<0) { - ix=0; - } else if (index > 0x7fffffff) { - // Strings with 64 bit lengths not supported by this UTF-8 provider. - ix = 0x7fffffff; - } - - // Pin requested index to the string length. - if (ix>length) { - if (length>=0) { - ix=length; - } else if (ix>=ut->c) { - // Zero terminated string, and requested index is beyond - // the region that has already been scanned. - // Scan up to either the end of the string or to the - // requested position, whichever comes first. - while (ut->c<ix && s8[ut->c]!=0) { - ut->c++; - } - // TODO: support for null terminated string length > 32 bits. - if (s8[ut->c] == 0) { - // We just found the actual length of the string. - // Trim the requested index back to that. - ix = ut->c; - ut->b = ut->c; - length = ut->c; - ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - } - } - } - - // - // Dispatch to the appropriate action for a forward iteration request. - // - if (forward) { - if (ix==ut->chunkNativeLimit) { - // Check for normal sequential iteration cases first. - if (ix==length) { - // Just reached end of string - // Don't swap buffers, but do set the - // current buffer position. - ut->chunkOffset = ut->chunkLength; - return FALSE; - } else { - // End of current buffer. - // check whether other buffer already has what we need. - UTF8Buf *altB = (UTF8Buf *)ut->q; - if (ix>=altB->bufNativeStart && ix<altB->bufNativeLimit) { - goto swapBuffers; - } - } - } - - // A random access. Desired index could be in either or niether buf. - // For optimizing the order of testing, first check for the index - // being in the other buffer. This will be the case for uses that - // move back and forth over a fairly limited range - { - u8b = (UTF8Buf *)ut->q; // the alternate buffer - if (ix>=u8b->bufNativeStart && ix<u8b->bufNativeLimit) { - // Requested index is in the other buffer. - goto swapBuffers; - } - if (ix == length) { - // Requested index is end-of-string. - // (this is the case of randomly seeking to the end. - // The case of iterating off the end is handled earlier.) - if (ix == ut->chunkNativeLimit) { - // Current buffer extends up to the end of the string. - // Leave it as the current buffer. - ut->chunkOffset = ut->chunkLength; - return FALSE; - } - if (ix == u8b->bufNativeLimit) { - // Alternate buffer extends to the end of string. - // Swap it in as the current buffer. - goto swapBuffersAndFail; - } - - // Neither existing buffer extends to the end of the string. - goto makeStubBuffer; - } - - if (ix<ut->chunkNativeStart || ix>=ut->chunkNativeLimit) { - // Requested index is in neither buffer. - goto fillForward; - } - - // Requested index is in this buffer. - u8b = (UTF8Buf *)ut->p; // the current buffer - mapIndex = ix - u8b->toUCharsMapStart; - U_ASSERT(mapIndex < (int32_t)sizeof(UTF8Buf::mapToUChars)); - ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx; - return TRUE; - - } - } - - - // - // Dispatch to the appropriate action for a - // Backwards Diretion iteration request. - // - if (ix==ut->chunkNativeStart) { - // Check for normal sequential iteration cases first. - if (ix==0) { - // Just reached the start of string - // Don't swap buffers, but do set the - // current buffer position. - ut->chunkOffset = 0; - return FALSE; - } else { - // Start of current buffer. - // check whether other buffer already has what we need. - UTF8Buf *altB = (UTF8Buf *)ut->q; - if (ix>altB->bufNativeStart && ix<=altB->bufNativeLimit) { - goto swapBuffers; - } - } - } - - // A random access. Desired index could be in either or niether buf. - // For optimizing the order of testing, - // Most likely case: in the other buffer. - // Second most likely: in neither buffer. - // Unlikely, but must work: in the current buffer. - u8b = (UTF8Buf *)ut->q; // the alternate buffer - if (ix>u8b->bufNativeStart && ix<=u8b->bufNativeLimit) { - // Requested index is in the other buffer. - goto swapBuffers; - } - // Requested index is start-of-string. - // (this is the case of randomly seeking to the start. - // The case of iterating off the start is handled earlier.) - if (ix==0) { - if (u8b->bufNativeStart==0) { - // Alternate buffer contains the data for the start string. - // Make it be the current buffer. - goto swapBuffersAndFail; - } else { - // Request for data before the start of string, - // neither buffer is usable. - // set up a zero-length buffer. - goto makeStubBuffer; - } - } - - if (ix<=ut->chunkNativeStart || ix>ut->chunkNativeLimit) { - // Requested index is in neither buffer. - goto fillReverse; - } - - // Requested index is in this buffer. - // Set the utf16 buffer index. - u8b = (UTF8Buf *)ut->p; - mapIndex = ix - u8b->toUCharsMapStart; - ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx; - if (ut->chunkOffset==0) { - // This occurs when the first character in the text is - // a multi-byte UTF-8 char, and the requested index is to - // one of the trailing bytes. Because there is no preceding , - // character, this access fails. We can't pick up on the - // situation sooner because the requested index is not zero. - return FALSE; - } else { - return TRUE; - } - - - -swapBuffers: - // The alternate buffer (ut->q) has the string data that was requested. - // Swap the primary and alternate buffers, and set the - // chunk index into the new primary buffer. - { - u8b = (UTF8Buf *)ut->q; - ut->q = ut->p; - ut->p = u8b; - ut->chunkContents = &u8b->buf[u8b->bufStartIdx]; - ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx; - ut->chunkNativeStart = u8b->bufNativeStart; - ut->chunkNativeLimit = u8b->bufNativeLimit; - ut->nativeIndexingLimit = u8b->bufNILimit; - - // Index into the (now current) chunk - // Use the map to set the chunk index. It's more trouble than it's worth - // to check whether native indexing can be used. - U_ASSERT(ix>=u8b->bufNativeStart); - U_ASSERT(ix<=u8b->bufNativeLimit); - mapIndex = ix - u8b->toUCharsMapStart; - U_ASSERT(mapIndex>=0); - U_ASSERT(mapIndex<(int32_t)sizeof(u8b->mapToUChars)); - ut->chunkOffset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx; - - return TRUE; - } - - - swapBuffersAndFail: - // We got a request for either the start or end of the string, - // with iteration continuing in the out-of-bounds direction. - // The alternate buffer already contains the data up to the - // start/end. - // Swap the buffers, then return failure, indicating that we couldn't - // make things correct for continuing the iteration in the requested - // direction. The position & buffer are correct should the - // user decide to iterate in the opposite direction. - u8b = (UTF8Buf *)ut->q; - ut->q = ut->p; - ut->p = u8b; - ut->chunkContents = &u8b->buf[u8b->bufStartIdx]; - ut->chunkLength = u8b->bufLimitIdx - u8b->bufStartIdx; - ut->chunkNativeStart = u8b->bufNativeStart; - ut->chunkNativeLimit = u8b->bufNativeLimit; - ut->nativeIndexingLimit = u8b->bufNILimit; - - // Index into the (now current) chunk - // For this function (swapBuffersAndFail), the requested index - // will always be at either the start or end of the chunk. - if (ix==u8b->bufNativeLimit) { - ut->chunkOffset = ut->chunkLength; - } else { - ut->chunkOffset = 0; - U_ASSERT(ix == u8b->bufNativeStart); - } - return FALSE; - -makeStubBuffer: - // The user has done a seek/access past the start or end - // of the string. Rather than loading data that is likely - // to never be used, just set up a zero-length buffer at - // the position. - u8b = (UTF8Buf *)ut->q; - u8b->bufNativeStart = ix; - u8b->bufNativeLimit = ix; - u8b->bufStartIdx = 0; - u8b->bufLimitIdx = 0; - u8b->bufNILimit = 0; - u8b->toUCharsMapStart = ix; - u8b->mapToNative[0] = 0; - u8b->mapToUChars[0] = 0; - goto swapBuffersAndFail; - - - -fillForward: - { - // Move the incoming index to a code point boundary. - U8_SET_CP_START(s8, 0, ix); - - // Swap the UText buffers. - // We want to fill what was previously the alternate buffer, - // and make what was the current buffer be the new alternate. - UTF8Buf *u8b_swap = (UTF8Buf *)ut->q; - ut->q = ut->p; - ut->p = u8b_swap; - - int32_t strLen = ut->b; - UBool nulTerminated = FALSE; - if (strLen < 0) { - strLen = 0x7fffffff; - nulTerminated = TRUE; - } - - UChar *buf = u8b_swap->buf; - uint8_t *mapToNative = u8b_swap->mapToNative; - uint8_t *mapToUChars = u8b_swap->mapToUChars; - int32_t destIx = 0; - int32_t srcIx = ix; - UBool seenNonAscii = FALSE; - UChar32 c = 0; - - // Fill the chunk buffer and mapping arrays. - while (destIx<UTF8_TEXT_CHUNK_SIZE) { - c = s8[srcIx]; - if (c>0 && c<0x80) { - // Special case ASCII range for speed. - // zero is excluded to simplify bounds checking. - buf[destIx] = (UChar)c; - mapToNative[destIx] = (uint8_t)(srcIx - ix); - mapToUChars[srcIx-ix] = (uint8_t)destIx; - srcIx++; - destIx++; - } else { - // General case, handle everything. - if (seenNonAscii == FALSE) { - seenNonAscii = TRUE; - u8b_swap->bufNILimit = destIx; - } - - int32_t cIx = srcIx; - int32_t dIx = destIx; - int32_t dIxSaved = destIx; - U8_NEXT_OR_FFFD(s8, srcIx, strLen, c); - if (c==0 && nulTerminated) { - srcIx--; - break; - } - - U16_APPEND_UNSAFE(buf, destIx, c); - do { - mapToNative[dIx++] = (uint8_t)(cIx - ix); - } while (dIx < destIx); - - do { - mapToUChars[cIx++ - ix] = (uint8_t)dIxSaved; - } while (cIx < srcIx); - } - if (srcIx>=strLen) { - break; - } - - } - - // store Native <--> Chunk Map entries for the end of the buffer. - // There is no actual character here, but the index position is valid. - mapToNative[destIx] = (uint8_t)(srcIx - ix); - mapToUChars[srcIx - ix] = (uint8_t)destIx; - - // fill in Buffer descriptor - u8b_swap->bufNativeStart = ix; - u8b_swap->bufNativeLimit = srcIx; - u8b_swap->bufStartIdx = 0; - u8b_swap->bufLimitIdx = destIx; - if (seenNonAscii == FALSE) { - u8b_swap->bufNILimit = destIx; - } - u8b_swap->toUCharsMapStart = u8b_swap->bufNativeStart; - - // Set UText chunk to refer to this buffer. - ut->chunkContents = buf; - ut->chunkOffset = 0; - ut->chunkLength = u8b_swap->bufLimitIdx; - ut->chunkNativeStart = u8b_swap->bufNativeStart; - ut->chunkNativeLimit = u8b_swap->bufNativeLimit; - ut->nativeIndexingLimit = u8b_swap->bufNILimit; - - // For zero terminated strings, keep track of the maximum point - // scanned so far. - if (nulTerminated && srcIx>ut->c) { - ut->c = srcIx; - if (c==0) { - // We scanned to the end. - // Remember the actual length. - ut->b = srcIx; - ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - } - } - return TRUE; - } - - -fillReverse: - { - // Move the incoming index to a code point boundary. - // Can only do this if the incoming index is somewhere in the interior of the string. - // If index is at the end, there is no character there to look at. - if (ix != ut->b) { - // Note: this function will only move the index back if it is on a trail byte - // and there is a preceding lead byte and the sequence from the lead - // through this trail could be part of a valid UTF-8 sequence - // Otherwise the index remains unchanged. - U8_SET_CP_START(s8, 0, ix); - } - - // Swap the UText buffers. - // We want to fill what was previously the alternate buffer, - // and make what was the current buffer be the new alternate. - UTF8Buf *u8b_swap = (UTF8Buf *)ut->q; - ut->q = ut->p; - ut->p = u8b_swap; - - UChar *buf = u8b_swap->buf; - uint8_t *mapToNative = u8b_swap->mapToNative; - uint8_t *mapToUChars = u8b_swap->mapToUChars; - int32_t toUCharsMapStart = ix - sizeof(UTF8Buf::mapToUChars) + 1; - // Note that toUCharsMapStart can be negative. Happens when the remaining - // text from current position to the beginning is less than the buffer size. - // + 1 because mapToUChars must have a slot at the end for the bufNativeLimit entry. - int32_t destIx = UTF8_TEXT_CHUNK_SIZE+2; // Start in the overflow region - // at end of buffer to leave room - // for a surrogate pair at the - // buffer start. - int32_t srcIx = ix; - int32_t bufNILimit = destIx; - UChar32 c; - - // Map to/from Native Indexes, fill in for the position at the end of - // the buffer. - // - mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart); - mapToUChars[srcIx - toUCharsMapStart] = (uint8_t)destIx; - - // Fill the chunk buffer - // Work backwards, filling from the end of the buffer towards the front. - // - while (destIx>2 && (srcIx - toUCharsMapStart > 5) && (srcIx > 0)) { - srcIx--; - destIx--; - - // Get last byte of the UTF-8 character - c = s8[srcIx]; - if (c<0x80) { - // Special case ASCII range for speed. - buf[destIx] = (UChar)c; - U_ASSERT(toUCharsMapStart <= srcIx); - mapToUChars[srcIx - toUCharsMapStart] = (uint8_t)destIx; - mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart); - } else { - // General case, handle everything non-ASCII. - - int32_t sIx = srcIx; // ix of last byte of multi-byte u8 char - - // Get the full character from the UTF8 string. - // use code derived from tbe macros in utf8.h - // Leaves srcIx pointing at the first byte of the UTF-8 char. - // - c=utf8_prevCharSafeBody(s8, 0, &srcIx, c, -3); - // leaves srcIx at first byte of the multi-byte char. - - // Store the character in UTF-16 buffer. - if (c<0x10000) { - buf[destIx] = (UChar)c; - mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart); - } else { - buf[destIx] = U16_TRAIL(c); - mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart); - buf[--destIx] = U16_LEAD(c); - mapToNative[destIx] = (uint8_t)(srcIx - toUCharsMapStart); - } - - // Fill in the map from native indexes to UChars buf index. - do { - mapToUChars[sIx-- - toUCharsMapStart] = (uint8_t)destIx; - } while (sIx >= srcIx); - U_ASSERT(toUCharsMapStart <= (srcIx+1)); - - // Set native indexing limit to be the current position. - // We are processing a non-ascii, non-native-indexing char now; - // the limit will be here if the rest of the chars to be - // added to this buffer are ascii. - bufNILimit = destIx; - } - } - u8b_swap->bufNativeStart = srcIx; - u8b_swap->bufNativeLimit = ix; - u8b_swap->bufStartIdx = destIx; - u8b_swap->bufLimitIdx = UTF8_TEXT_CHUNK_SIZE+2; - u8b_swap->bufNILimit = bufNILimit - u8b_swap->bufStartIdx; - u8b_swap->toUCharsMapStart = toUCharsMapStart; - - ut->chunkContents = &buf[u8b_swap->bufStartIdx]; - ut->chunkLength = u8b_swap->bufLimitIdx - u8b_swap->bufStartIdx; - ut->chunkOffset = ut->chunkLength; - ut->chunkNativeStart = u8b_swap->bufNativeStart; - ut->chunkNativeLimit = u8b_swap->bufNativeLimit; - ut->nativeIndexingLimit = u8b_swap->bufNILimit; - return TRUE; - } - -} - - - -// -// This is a slightly modified copy of u_strFromUTF8, -// Inserts a Replacement Char rather than failing on invalid UTF-8 -// Removes unnecessary features. -// -static UChar* -utext_strFromUTF8(UChar *dest, - int32_t destCapacity, - int32_t *pDestLength, - const char* src, - int32_t srcLength, // required. NUL terminated not supported. - UErrorCode *pErrorCode - ) -{ - - UChar *pDest = dest; - UChar *pDestLimit = (dest!=NULL)?(dest+destCapacity):NULL; - UChar32 ch=0; - int32_t index = 0; - int32_t reqLength = 0; - uint8_t* pSrc = (uint8_t*) src; - - - while((index < srcLength)&&(pDest<pDestLimit)){ - ch = pSrc[index++]; - if(ch <=0x7f){ - *pDest++=(UChar)ch; - }else{ - ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, -3); - if(U_IS_BMP(ch)){ - *(pDest++)=(UChar)ch; - }else{ - *(pDest++)=U16_LEAD(ch); - if(pDest<pDestLimit){ - *(pDest++)=U16_TRAIL(ch); - }else{ - reqLength++; - break; - } - } - } - } - /* donot fill the dest buffer just count the UChars needed */ - while(index < srcLength){ - ch = pSrc[index++]; - if(ch <= 0x7f){ - reqLength++; - }else{ - ch=utf8_nextCharSafeBody(pSrc, &index, srcLength, ch, -3); - reqLength+=U16_LENGTH(ch); - } - } - - reqLength+=(int32_t)(pDest - dest); - - if(pDestLength){ - *pDestLength = reqLength; - } - - /* Terminate the buffer */ - u_terminateUChars(dest,destCapacity,reqLength,pErrorCode); - - return dest; -} - - - -static int32_t U_CALLCONV -utf8TextExtract(UText *ut, - int64_t start, int64_t limit, - UChar *dest, int32_t destCapacity, - UErrorCode *pErrorCode) { - if(U_FAILURE(*pErrorCode)) { - return 0; - } - if(destCapacity<0 || (dest==NULL && destCapacity>0)) { - *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; - return 0; - } - int32_t length = ut->b; - int32_t start32 = pinIndex(start, length); - int32_t limit32 = pinIndex(limit, length); - - if(start32>limit32) { - *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; - return 0; - } - - - // adjust the incoming indexes to land on code point boundaries if needed. - // adjust by no more than three, because that is the largest number of trail bytes - // in a well formed UTF8 character. - const uint8_t *buf = (const uint8_t *)ut->context; - int i; - if (start32 < ut->chunkNativeLimit) { - for (i=0; i<3; i++) { - if (U8_IS_SINGLE(buf[start32]) || U8_IS_LEAD(buf[start32]) || start32==0) { - break; - } - start32--; - } - } - - if (limit32 < ut->chunkNativeLimit) { - for (i=0; i<3; i++) { - if (U8_IS_SINGLE(buf[limit32]) || U8_IS_LEAD(buf[limit32]) || limit32==0) { - break; - } - limit32--; - } - } - - // Do the actual extract. - int32_t destLength=0; - utext_strFromUTF8(dest, destCapacity, &destLength, - (const char *)ut->context+start32, limit32-start32, - pErrorCode); - utf8TextAccess(ut, limit32, TRUE); - return destLength; -} - -// -// utf8TextMapOffsetToNative -// -// Map a chunk (UTF-16) offset to a native index. -static int64_t U_CALLCONV -utf8TextMapOffsetToNative(const UText *ut) { - // - UTF8Buf *u8b = (UTF8Buf *)ut->p; - U_ASSERT(ut->chunkOffset>ut->nativeIndexingLimit && ut->chunkOffset<=ut->chunkLength); - int32_t nativeOffset = u8b->mapToNative[ut->chunkOffset + u8b->bufStartIdx] + u8b->toUCharsMapStart; - U_ASSERT(nativeOffset >= ut->chunkNativeStart && nativeOffset <= ut->chunkNativeLimit); - return nativeOffset; -} - -// -// Map a native index to the corrsponding chunk offset -// -static int32_t U_CALLCONV -utf8TextMapIndexToUTF16(const UText *ut, int64_t index64) { - U_ASSERT(index64 <= 0x7fffffff); - int32_t index = (int32_t)index64; - UTF8Buf *u8b = (UTF8Buf *)ut->p; - U_ASSERT(index>=ut->chunkNativeStart+ut->nativeIndexingLimit); - U_ASSERT(index<=ut->chunkNativeLimit); - int32_t mapIndex = index - u8b->toUCharsMapStart; - U_ASSERT(mapIndex < (int32_t)sizeof(UTF8Buf::mapToUChars)); - int32_t offset = u8b->mapToUChars[mapIndex] - u8b->bufStartIdx; - U_ASSERT(offset>=0 && offset<=ut->chunkLength); - return offset; -} - -static UText * U_CALLCONV -utf8TextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status) -{ - // First do a generic shallow clone. Does everything needed for the UText struct itself. - dest = shallowTextClone(dest, src, status); - - // For deep clones, make a copy of the string. - // The copied storage is owned by the newly created clone. - // - // TODO: There is an isssue with using utext_nativeLength(). - // That function is non-const in cases where the input was NUL terminated - // and the length has not yet been determined. - // This function (clone()) is const. - // There potentially a thread safety issue lurking here. - // - if (deep && U_SUCCESS(*status)) { - int32_t len = (int32_t)utext_nativeLength((UText *)src); - char *copyStr = (char *)uprv_malloc(len+1); - if (copyStr == NULL) { - *status = U_MEMORY_ALLOCATION_ERROR; - } else { - uprv_memcpy(copyStr, src->context, len+1); - dest->context = copyStr; - dest->providerProperties |= I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT); - } - } - return dest; -} - - -static void U_CALLCONV -utf8TextClose(UText *ut) { - // Most of the work of close is done by the generic UText framework close. - // All that needs to be done here is to delete the UTF8 string if the UText - // owns it. This occurs if the UText was created by cloning. - if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) { - char *s = (char *)ut->context; - uprv_free(s); - ut->context = NULL; - } -} - -U_CDECL_END - - -static const struct UTextFuncs utf8Funcs = -{ - sizeof(UTextFuncs), - 0, 0, 0, // Reserved alignment padding - utf8TextClone, - utf8TextLength, - utf8TextAccess, - utf8TextExtract, - NULL, /* replace*/ - NULL, /* copy */ - utf8TextMapOffsetToNative, - utf8TextMapIndexToUTF16, - utf8TextClose, - NULL, // spare 1 - NULL, // spare 2 - NULL // spare 3 -}; - - -static const char gEmptyString[] = {0}; - -U_CAPI UText * U_EXPORT2 -utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status) { - if(U_FAILURE(*status)) { - return NULL; - } - if(s==NULL && length==0) { - s = gEmptyString; - } - - if(s==NULL || length<-1 || length>INT32_MAX) { - *status=U_ILLEGAL_ARGUMENT_ERROR; - return NULL; - } - - ut = utext_setup(ut, sizeof(UTF8Buf) * 2, status); - if (U_FAILURE(*status)) { - return ut; - } - - ut->pFuncs = &utf8Funcs; - ut->context = s; - ut->b = (int32_t)length; - ut->c = (int32_t)length; - if (ut->c < 0) { - ut->c = 0; - ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - } - ut->p = ut->pExtra; - ut->q = (char *)ut->pExtra + sizeof(UTF8Buf); - return ut; - -} - - - - - - - - -//------------------------------------------------------------------------------ -// -// UText implementation wrapper for Replaceable (read/write) -// -// Use of UText data members: -// context pointer to Replaceable. -// p pointer to Replaceable if it is owned by the UText. -// -//------------------------------------------------------------------------------ - - - -// minimum chunk size for this implementation: 3 -// to allow for possible trimming for code point boundaries -enum { REP_TEXT_CHUNK_SIZE=10 }; - -struct ReplExtra { - /* - * Chunk UChars. - * +1 to simplify filling with surrogate pair at the end. - */ - UChar s[REP_TEXT_CHUNK_SIZE+1]; -}; - - -U_CDECL_BEGIN - -static UText * U_CALLCONV -repTextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status) { - // First do a generic shallow clone. Does everything needed for the UText struct itself. - dest = shallowTextClone(dest, src, status); - - // For deep clones, make a copy of the Replaceable. - // The copied Replaceable storage is owned by the newly created UText clone. - // A non-NULL pointer in UText.p is the signal to the close() function to delete - // it. - // - if (deep && U_SUCCESS(*status)) { - const Replaceable *replSrc = (const Replaceable *)src->context; - dest->context = replSrc->clone(); - dest->providerProperties |= I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT); - - // with deep clone, the copy is writable, even when the source is not. - dest->providerProperties |= I32_FLAG(UTEXT_PROVIDER_WRITABLE); - } - return dest; -} - - -static void U_CALLCONV -repTextClose(UText *ut) { - // Most of the work of close is done by the generic UText framework close. - // All that needs to be done here is delete the Replaceable if the UText - // owns it. This occurs if the UText was created by cloning. - if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) { - Replaceable *rep = (Replaceable *)ut->context; - delete rep; - ut->context = NULL; - } -} - - -static int64_t U_CALLCONV -repTextLength(UText *ut) { - const Replaceable *replSrc = (const Replaceable *)ut->context; - int32_t len = replSrc->length(); - return len; -} - - -static UBool U_CALLCONV -repTextAccess(UText *ut, int64_t index, UBool forward) { - const Replaceable *rep=(const Replaceable *)ut->context; - int32_t length=rep->length(); // Full length of the input text (bigger than a chunk) - - // clip the requested index to the limits of the text. - int32_t index32 = pinIndex(index, length); - U_ASSERT(index<=INT32_MAX); - - - /* - * Compute start/limit boundaries around index, for a segment of text - * to be extracted. - * To allow for the possibility that our user gave an index to the trailing - * half of a surrogate pair, we must request one extra preceding UChar when - * going in the forward direction. This will ensure that the buffer has the - * entire code point at the specified index. - */ - if(forward) { - - if (index32>=ut->chunkNativeStart && index32<ut->chunkNativeLimit) { - // Buffer already contains the requested position. - ut->chunkOffset = (int32_t)(index - ut->chunkNativeStart); - return TRUE; - } - if (index32>=length && ut->chunkNativeLimit==length) { - // Request for end of string, and buffer already extends up to it. - // Can't get the data, but don't change the buffer. - ut->chunkOffset = length - (int32_t)ut->chunkNativeStart; - return FALSE; - } - - ut->chunkNativeLimit = index + REP_TEXT_CHUNK_SIZE - 1; - // Going forward, so we want to have the buffer with stuff at and beyond - // the requested index. The -1 gets us one code point before the - // requested index also, to handle the case of the index being on - // a trail surrogate of a surrogate pair. - if(ut->chunkNativeLimit > length) { - ut->chunkNativeLimit = length; - } - // unless buffer ran off end, start is index-1. - ut->chunkNativeStart = ut->chunkNativeLimit - REP_TEXT_CHUNK_SIZE; - if(ut->chunkNativeStart < 0) { - ut->chunkNativeStart = 0; - } - } else { - // Reverse iteration. Fill buffer with data preceding the requested index. - if (index32>ut->chunkNativeStart && index32<=ut->chunkNativeLimit) { - // Requested position already in buffer. - ut->chunkOffset = index32 - (int32_t)ut->chunkNativeStart; - return TRUE; - } - if (index32==0 && ut->chunkNativeStart==0) { - // Request for start, buffer already begins at start. - // No data, but keep the buffer as is. - ut->chunkOffset = 0; - return FALSE; - } - - // Figure out the bounds of the chunk to extract for reverse iteration. - // Need to worry about chunk not splitting surrogate pairs, and while still - // containing the data we need. - // Fix by requesting a chunk that includes an extra UChar at the end. - // If this turns out to be a lead surrogate, we can lop it off and still have - // the data we wanted. - ut->chunkNativeStart = index32 + 1 - REP_TEXT_CHUNK_SIZE; - if (ut->chunkNativeStart < 0) { - ut->chunkNativeStart = 0; - } - - ut->chunkNativeLimit = index32 + 1; - if (ut->chunkNativeLimit > length) { - ut->chunkNativeLimit = length; - } - } - - // Extract the new chunk of text from the Replaceable source. - ReplExtra *ex = (ReplExtra *)ut->pExtra; - // UnicodeString with its buffer a writable alias to the chunk buffer - UnicodeString buffer(ex->s, 0 /*buffer length*/, REP_TEXT_CHUNK_SIZE /*buffer capacity*/); - rep->extractBetween((int32_t)ut->chunkNativeStart, (int32_t)ut->chunkNativeLimit, buffer); - - ut->chunkContents = ex->s; - ut->chunkLength = (int32_t)(ut->chunkNativeLimit - ut->chunkNativeStart); - ut->chunkOffset = (int32_t)(index32 - ut->chunkNativeStart); - - // Surrogate pairs from the input text must not span chunk boundaries. - // If end of chunk could be the start of a surrogate, trim it off. - if (ut->chunkNativeLimit < length && - U16_IS_LEAD(ex->s[ut->chunkLength-1])) { - ut->chunkLength--; - ut->chunkNativeLimit--; - if (ut->chunkOffset > ut->chunkLength) { - ut->chunkOffset = ut->chunkLength; - } - } - - // if the first UChar in the chunk could be the trailing half of a surrogate pair, - // trim it off. - if(ut->chunkNativeStart>0 && U16_IS_TRAIL(ex->s[0])) { - ++(ut->chunkContents); - ++(ut->chunkNativeStart); - --(ut->chunkLength); - --(ut->chunkOffset); - } - - // adjust the index/chunkOffset to a code point boundary - U16_SET_CP_START(ut->chunkContents, 0, ut->chunkOffset); - - // Use fast indexing for get/setNativeIndex() - ut->nativeIndexingLimit = ut->chunkLength; - - return TRUE; -} - - - -static int32_t U_CALLCONV -repTextExtract(UText *ut, - int64_t start, int64_t limit, - UChar *dest, int32_t destCapacity, - UErrorCode *status) { - const Replaceable *rep=(const Replaceable *)ut->context; - int32_t length=rep->length(); - - if(U_FAILURE(*status)) { - return 0; - } - if(destCapacity<0 || (dest==NULL && destCapacity>0)) { - *status=U_ILLEGAL_ARGUMENT_ERROR; - } - if(start>limit) { - *status=U_INDEX_OUTOFBOUNDS_ERROR; - return 0; - } - - int32_t start32 = pinIndex(start, length); - int32_t limit32 = pinIndex(limit, length); - - // adjust start, limit if they point to trail half of surrogates - if (start32<length && U16_IS_TRAIL(rep->charAt(start32)) && - U_IS_SUPPLEMENTARY(rep->char32At(start32))){ - start32--; - } - if (limit32<length && U16_IS_TRAIL(rep->charAt(limit32)) && - U_IS_SUPPLEMENTARY(rep->char32At(limit32))){ - limit32--; - } - - length=limit32-start32; - if(length>destCapacity) { - limit32 = start32 + destCapacity; - } - UnicodeString buffer(dest, 0, destCapacity); // writable alias - rep->extractBetween(start32, limit32, buffer); - repTextAccess(ut, limit32, TRUE); - - return u_terminateUChars(dest, destCapacity, length, status); -} - -static int32_t U_CALLCONV -repTextReplace(UText *ut, - int64_t start, int64_t limit, - const UChar *src, int32_t length, - UErrorCode *status) { - Replaceable *rep=(Replaceable *)ut->context; - int32_t oldLength; - - if(U_FAILURE(*status)) { - return 0; - } - if(src==NULL && length!=0) { - *status=U_ILLEGAL_ARGUMENT_ERROR; - return 0; - } - oldLength=rep->length(); // will subtract from new length - if(start>limit ) { - *status=U_INDEX_OUTOFBOUNDS_ERROR; - return 0; - } - - int32_t start32 = pinIndex(start, oldLength); - int32_t limit32 = pinIndex(limit, oldLength); - - // Snap start & limit to code point boundaries. - if (start32<oldLength && U16_IS_TRAIL(rep->charAt(start32)) && - start32>0 && U16_IS_LEAD(rep->charAt(start32-1))) - { - start32--; - } - if (limit32<oldLength && U16_IS_LEAD(rep->charAt(limit32-1)) && - U16_IS_TRAIL(rep->charAt(limit32))) - { - limit32++; - } - - // Do the actual replace operation using methods of the Replaceable class - UnicodeString replStr((UBool)(length<0), src, length); // read-only alias - rep->handleReplaceBetween(start32, limit32, replStr); - int32_t newLength = rep->length(); - int32_t lengthDelta = newLength - oldLength; - - // Is the UText chunk buffer OK? - if (ut->chunkNativeLimit > start32) { - // this replace operation may have impacted the current chunk. - // invalidate it, which will force a reload on the next access. - invalidateChunk(ut); - } - - // set the iteration position to the end of the newly inserted replacement text. - int32_t newIndexPos = limit32 + lengthDelta; - repTextAccess(ut, newIndexPos, TRUE); - - return lengthDelta; -} - - -static void U_CALLCONV -repTextCopy(UText *ut, - int64_t start, int64_t limit, - int64_t destIndex, - UBool move, - UErrorCode *status) -{ - Replaceable *rep=(Replaceable *)ut->context; - int32_t length=rep->length(); - - if(U_FAILURE(*status)) { - return; - } - if (start>limit || (start<destIndex && destIndex<limit)) - { - *status=U_INDEX_OUTOFBOUNDS_ERROR; - return; - } - - int32_t start32 = pinIndex(start, length); - int32_t limit32 = pinIndex(limit, length); - int32_t destIndex32 = pinIndex(destIndex, length); - - // TODO: snap input parameters to code point boundaries. - - if(move) { - // move: copy to destIndex, then replace original with nothing - int32_t segLength=limit32-start32; - rep->copy(start32, limit32, destIndex32); - if(destIndex32<start32) { - start32+=segLength; - limit32+=segLength; - } - rep->handleReplaceBetween(start32, limit32, UnicodeString()); - } else { - // copy - rep->copy(start32, limit32, destIndex32); - } - - // If the change to the text touched the region in the chunk buffer, - // invalidate the buffer. - int32_t firstAffectedIndex = destIndex32; - if (move && start32<firstAffectedIndex) { - firstAffectedIndex = start32; - } - if (firstAffectedIndex < ut->chunkNativeLimit) { - // changes may have affected range covered by the chunk - invalidateChunk(ut); - } - - // Put iteration position at the newly inserted (moved) block, - int32_t nativeIterIndex = destIndex32 + limit32 - start32; - if (move && destIndex32>start32) { - // moved a block of text towards the end of the string. - nativeIterIndex = destIndex32; - } - - // Set position, reload chunk if needed. - repTextAccess(ut, nativeIterIndex, TRUE); -} - -static const struct UTextFuncs repFuncs = -{ - sizeof(UTextFuncs), - 0, 0, 0, // Reserved alignment padding - repTextClone, - repTextLength, - repTextAccess, - repTextExtract, - repTextReplace, - repTextCopy, - NULL, // MapOffsetToNative, - NULL, // MapIndexToUTF16, - repTextClose, - NULL, // spare 1 - NULL, // spare 2 - NULL // spare 3 -}; - - -U_CAPI UText * U_EXPORT2 -utext_openReplaceable(UText *ut, Replaceable *rep, UErrorCode *status) -{ - if(U_FAILURE(*status)) { - return NULL; - } - if(rep==NULL) { - *status=U_ILLEGAL_ARGUMENT_ERROR; - return NULL; - } - ut = utext_setup(ut, sizeof(ReplExtra), status); - if(U_FAILURE(*status)) { - return ut; - } - - ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_WRITABLE); - if(rep->hasMetaData()) { - ut->providerProperties |=I32_FLAG(UTEXT_PROVIDER_HAS_META_DATA); - } - - ut->pFuncs = &repFuncs; - ut->context = rep; - return ut; -} - -U_CDECL_END - - - - - - - - -//------------------------------------------------------------------------------ -// -// UText implementation for UnicodeString (read/write) and -// for const UnicodeString (read only) -// (same implementation, only the flags are different) -// -// Use of UText data members: -// context pointer to UnicodeString -// p pointer to UnicodeString IF this UText owns the string -// and it must be deleted on close(). NULL otherwise. -// -//------------------------------------------------------------------------------ - -U_CDECL_BEGIN - - -static UText * U_CALLCONV -unistrTextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status) { - // First do a generic shallow clone. Does everything needed for the UText struct itself. - dest = shallowTextClone(dest, src, status); - - // For deep clones, make a copy of the UnicodeSring. - // The copied UnicodeString storage is owned by the newly created UText clone. - // A non-NULL pointer in UText.p is the signal to the close() function to delete - // the UText. - // - if (deep && U_SUCCESS(*status)) { - const UnicodeString *srcString = (const UnicodeString *)src->context; - dest->context = new UnicodeString(*srcString); - dest->providerProperties |= I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT); - - // with deep clone, the copy is writable, even when the source is not. - dest->providerProperties |= I32_FLAG(UTEXT_PROVIDER_WRITABLE); - } - return dest; -} - -static void U_CALLCONV -unistrTextClose(UText *ut) { - // Most of the work of close is done by the generic UText framework close. - // All that needs to be done here is delete the UnicodeString if the UText - // owns it. This occurs if the UText was created by cloning. - if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) { - UnicodeString *str = (UnicodeString *)ut->context; - delete str; - ut->context = NULL; - } -} - - -static int64_t U_CALLCONV -unistrTextLength(UText *t) { - return ((const UnicodeString *)t->context)->length(); -} - - -static UBool U_CALLCONV -unistrTextAccess(UText *ut, int64_t index, UBool forward) { - int32_t length = ut->chunkLength; - ut->chunkOffset = pinIndex(index, length); - - // Check whether request is at the start or end - UBool retVal = (forward && index<length) || (!forward && index>0); - return retVal; -} - - - -static int32_t U_CALLCONV -unistrTextExtract(UText *t, - int64_t start, int64_t limit, - UChar *dest, int32_t destCapacity, - UErrorCode *pErrorCode) { - const UnicodeString *us=(const UnicodeString *)t->context; - int32_t length=us->length(); - - if(U_FAILURE(*pErrorCode)) { - return 0; - } - if(destCapacity<0 || (dest==NULL && destCapacity>0)) { - *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; - } - if(start<0 || start>limit) { - *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; - return 0; - } - - int32_t start32 = start<length ? us->getChar32Start((int32_t)start) : length; - int32_t limit32 = limit<length ? us->getChar32Start((int32_t)limit) : length; - - length=limit32-start32; - if (destCapacity>0 && dest!=NULL) { - int32_t trimmedLength = length; - if(trimmedLength>destCapacity) { - trimmedLength=destCapacity; - } - us->extract(start32, trimmedLength, dest); - t->chunkOffset = start32+trimmedLength; - } else { - t->chunkOffset = start32; - } - u_terminateUChars(dest, destCapacity, length, pErrorCode); - return length; -} - -static int32_t U_CALLCONV -unistrTextReplace(UText *ut, - int64_t start, int64_t limit, - const UChar *src, int32_t length, - UErrorCode *pErrorCode) { - UnicodeString *us=(UnicodeString *)ut->context; - int32_t oldLength; - - if(U_FAILURE(*pErrorCode)) { - return 0; - } - if(src==NULL && length!=0) { - *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; - } - if(start>limit) { - *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; - return 0; - } - oldLength=us->length(); - int32_t start32 = pinIndex(start, oldLength); - int32_t limit32 = pinIndex(limit, oldLength); - if (start32 < oldLength) { - start32 = us->getChar32Start(start32); - } - if (limit32 < oldLength) { - limit32 = us->getChar32Start(limit32); - } - - // replace - us->replace(start32, limit32-start32, src, length); - int32_t newLength = us->length(); - - // Update the chunk description. - ut->chunkContents = us->getBuffer(); - ut->chunkLength = newLength; - ut->chunkNativeLimit = newLength; - ut->nativeIndexingLimit = newLength; - - // Set iteration position to the point just following the newly inserted text. - int32_t lengthDelta = newLength - oldLength; - ut->chunkOffset = limit32 + lengthDelta; - - return lengthDelta; -} - -static void U_CALLCONV -unistrTextCopy(UText *ut, - int64_t start, int64_t limit, - int64_t destIndex, - UBool move, - UErrorCode *pErrorCode) { - UnicodeString *us=(UnicodeString *)ut->context; - int32_t length=us->length(); - - if(U_FAILURE(*pErrorCode)) { - return; - } - int32_t start32 = pinIndex(start, length); - int32_t limit32 = pinIndex(limit, length); - int32_t destIndex32 = pinIndex(destIndex, length); - - if( start32>limit32 || (start32<destIndex32 && destIndex32<limit32)) { - *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; - return; - } - - if(move) { - // move: copy to destIndex, then remove original - int32_t segLength=limit32-start32; - us->copy(start32, limit32, destIndex32); - if(destIndex32<start32) { - start32+=segLength; - } - us->remove(start32, segLength); - } else { - // copy - us->copy(start32, limit32, destIndex32); - } - - // update chunk description, set iteration position. - ut->chunkContents = us->getBuffer(); - if (move==FALSE) { - // copy operation, string length grows - ut->chunkLength += limit32-start32; - ut->chunkNativeLimit = ut->chunkLength; - ut->nativeIndexingLimit = ut->chunkLength; - } - - // Iteration position to end of the newly inserted text. - ut->chunkOffset = destIndex32+limit32-start32; - if (move && destIndex32>start32) { - ut->chunkOffset = destIndex32; - } - -} - -static const struct UTextFuncs unistrFuncs = -{ - sizeof(UTextFuncs), - 0, 0, 0, // Reserved alignment padding - unistrTextClone, - unistrTextLength, - unistrTextAccess, - unistrTextExtract, - unistrTextReplace, - unistrTextCopy, - NULL, // MapOffsetToNative, - NULL, // MapIndexToUTF16, - unistrTextClose, - NULL, // spare 1 - NULL, // spare 2 - NULL // spare 3 -}; - - - -U_CDECL_END - - -U_CAPI UText * U_EXPORT2 -utext_openUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) { - ut = utext_openConstUnicodeString(ut, s, status); - if (U_SUCCESS(*status)) { - ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_WRITABLE); - } - return ut; -} - - - -U_CAPI UText * U_EXPORT2 -utext_openConstUnicodeString(UText *ut, const UnicodeString *s, UErrorCode *status) { - if (U_SUCCESS(*status) && s->isBogus()) { - // The UnicodeString is bogus, but we still need to detach the UText - // from whatever it was hooked to before, if anything. - utext_openUChars(ut, NULL, 0, status); - *status = U_ILLEGAL_ARGUMENT_ERROR; - return ut; - } - ut = utext_setup(ut, 0, status); - // note: use the standard (writable) function table for UnicodeString. - // The flag settings disable writing, so having the functions in - // the table is harmless. - if (U_SUCCESS(*status)) { - ut->pFuncs = &unistrFuncs; - ut->context = s; - ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS); - ut->chunkContents = s->getBuffer(); - ut->chunkLength = s->length(); - ut->chunkNativeStart = 0; - ut->chunkNativeLimit = ut->chunkLength; - ut->nativeIndexingLimit = ut->chunkLength; - } - return ut; -} - -//------------------------------------------------------------------------------ -// -// UText implementation for const UChar * strings -// -// Use of UText data members: -// context pointer to UnicodeString -// a length. -1 if not yet known. -// -// TODO: support 64 bit lengths. -// -//------------------------------------------------------------------------------ - -U_CDECL_BEGIN - - -static UText * U_CALLCONV -ucstrTextClone(UText *dest, const UText * src, UBool deep, UErrorCode * status) { - // First do a generic shallow clone. - dest = shallowTextClone(dest, src, status); - - // For deep clones, make a copy of the string. - // The copied storage is owned by the newly created clone. - // A non-NULL pointer in UText.p is the signal to the close() function to delete - // it. - // - if (deep && U_SUCCESS(*status)) { - U_ASSERT(utext_nativeLength(dest) < INT32_MAX); - int32_t len = (int32_t)utext_nativeLength(dest); - - // The cloned string IS going to be NUL terminated, whether or not the original was. - const UChar *srcStr = (const UChar *)src->context; - UChar *copyStr = (UChar *)uprv_malloc((len+1) * sizeof(UChar)); - if (copyStr == NULL) { - *status = U_MEMORY_ALLOCATION_ERROR; - } else { - int64_t i; - for (i=0; i<len; i++) { - copyStr[i] = srcStr[i]; - } - copyStr[len] = 0; - dest->context = copyStr; - dest->providerProperties |= I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT); - } - } - return dest; -} - - -static void U_CALLCONV -ucstrTextClose(UText *ut) { - // Most of the work of close is done by the generic UText framework close. - // All that needs to be done here is delete the string if the UText - // owns it. This occurs if the UText was created by cloning. - if (ut->providerProperties & I32_FLAG(UTEXT_PROVIDER_OWNS_TEXT)) { - UChar *s = (UChar *)ut->context; - uprv_free(s); - ut->context = NULL; - } -} - - - -static int64_t U_CALLCONV -ucstrTextLength(UText *ut) { - if (ut->a < 0) { - // null terminated, we don't yet know the length. Scan for it. - // Access is not convenient for doing this - // because the current interation postion can't be changed. - const UChar *str = (const UChar *)ut->context; - for (;;) { - if (str[ut->chunkNativeLimit] == 0) { - break; - } - ut->chunkNativeLimit++; - } - ut->a = ut->chunkNativeLimit; - ut->chunkLength = (int32_t)ut->chunkNativeLimit; - ut->nativeIndexingLimit = ut->chunkLength; - ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - } - return ut->a; -} - - -static UBool U_CALLCONV -ucstrTextAccess(UText *ut, int64_t index, UBool forward) { - const UChar *str = (const UChar *)ut->context; - - // pin the requested index to the bounds of the string, - // and set current iteration position. - if (index<0) { - index = 0; - } else if (index < ut->chunkNativeLimit) { - // The request data is within the chunk as it is known so far. - // Put index on a code point boundary. - U16_SET_CP_START(str, 0, index); - } else if (ut->a >= 0) { - // We know the length of this string, and the user is requesting something - // at or beyond the length. Pin the requested index to the length. - index = ut->a; - } else { - // Null terminated string, length not yet known, and the requested index - // is beyond where we have scanned so far. - // Scan to 32 UChars beyond the requested index. The strategy here is - // to avoid fully scanning a long string when the caller only wants to - // see a few characters at its beginning. - int32_t scanLimit = (int32_t)index + 32; - if ((index + 32)>INT32_MAX || (index + 32)<0 ) { // note: int64 expression - scanLimit = INT32_MAX; - } - - int32_t chunkLimit = (int32_t)ut->chunkNativeLimit; - for (; chunkLimit<scanLimit; chunkLimit++) { - if (str[chunkLimit] == 0) { - // We found the end of the string. Remember it, pin the requested index to it, - // and bail out of here. - ut->a = chunkLimit; - ut->chunkLength = chunkLimit; - ut->nativeIndexingLimit = chunkLimit; - if (index >= chunkLimit) { - index = chunkLimit; - } else { - U16_SET_CP_START(str, 0, index); - } - - ut->chunkNativeLimit = chunkLimit; - ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - goto breakout; - } - } - // We scanned through the next batch of UChars without finding the end. - U16_SET_CP_START(str, 0, index); - if (chunkLimit == INT32_MAX) { - // Scanned to the limit of a 32 bit length. - // Forceably trim the overlength string back so length fits in int32 - // TODO: add support for 64 bit strings. - ut->a = chunkLimit; - ut->chunkLength = chunkLimit; - ut->nativeIndexingLimit = chunkLimit; - if (index > chunkLimit) { - index = chunkLimit; - } - ut->chunkNativeLimit = chunkLimit; - ut->providerProperties &= ~I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - } else { - // The endpoint of a chunk must not be left in the middle of a surrogate pair. - // If the current end is on a lead surrogate, back the end up by one. - // It doesn't matter if the end char happens to be an unpaired surrogate, - // and it's simpler not to worry about it. - if (U16_IS_LEAD(str[chunkLimit-1])) { - --chunkLimit; - } - // Null-terminated chunk with end still unknown. - // Update the chunk length to reflect what has been scanned thus far. - // That the full length is still unknown is (still) flagged by - // ut->a being < 0. - ut->chunkNativeLimit = chunkLimit; - ut->nativeIndexingLimit = chunkLimit; - ut->chunkLength = chunkLimit; - } - - } -breakout: - U_ASSERT(index<=INT32_MAX); - ut->chunkOffset = (int32_t)index; - - // Check whether request is at the start or end - UBool retVal = (forward && index<ut->chunkNativeLimit) || (!forward && index>0); - return retVal; -} - - - -static int32_t U_CALLCONV -ucstrTextExtract(UText *ut, - int64_t start, int64_t limit, - UChar *dest, int32_t destCapacity, - UErrorCode *pErrorCode) -{ - if(U_FAILURE(*pErrorCode)) { - return 0; - } - if(destCapacity<0 || (dest==NULL && destCapacity>0) || start>limit) { - *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; - return 0; - } - - //const UChar *s=(const UChar *)ut->context; - int32_t si, di; - - int32_t start32; - int32_t limit32; - - // Access the start. Does two things we need: - // Pins 'start' to the length of the string, if it came in out-of-bounds. - // Snaps 'start' to the beginning of a code point. - ucstrTextAccess(ut, start, TRUE); - const UChar *s=ut->chunkContents; - start32 = ut->chunkOffset; - - int32_t strLength=(int32_t)ut->a; - if (strLength >= 0) { - limit32 = pinIndex(limit, strLength); - } else { - limit32 = pinIndex(limit, INT32_MAX); - } - di = 0; - for (si=start32; si<limit32; si++) { - if (strLength<0 && s[si]==0) { - // Just hit the end of a null-terminated string. - ut->a = si; // set string length for this UText - ut->chunkNativeLimit = si; - ut->chunkLength = si; - ut->nativeIndexingLimit = si; - strLength = si; - limit32 = si; - break; - } - U_ASSERT(di>=0); /* to ensure di never exceeds INT32_MAX, which must not happen logically */ - if (di<destCapacity) { - // only store if there is space. - dest[di] = s[si]; - } else { - if (strLength>=0) { - // We have filled the destination buffer, and the string length is known. - // Cut the loop short. There is no need to scan string termination. - di = limit32 - start32; - si = limit32; - break; - } - } - di++; - } - - // If the limit index points to a lead surrogate of a pair, - // add the corresponding trail surrogate to the destination. - if (si>0 && U16_IS_LEAD(s[si-1]) && - ((si<strLength || strLength<0) && U16_IS_TRAIL(s[si]))) - { - if (di<destCapacity) { - // store only if there is space in the output buffer. - dest[di++] = s[si]; - } - si++; - } - - // Put iteration position at the point just following the extracted text - if (si <= ut->chunkNativeLimit) { - ut->chunkOffset = si; - } else { - ucstrTextAccess(ut, si, TRUE); - } - - // Add a terminating NUL if space in the buffer permits, - // and set the error status as required. - u_terminateUChars(dest, destCapacity, di, pErrorCode); - return di; -} - -static const struct UTextFuncs ucstrFuncs = -{ - sizeof(UTextFuncs), - 0, 0, 0, // Reserved alignment padding - ucstrTextClone, - ucstrTextLength, - ucstrTextAccess, - ucstrTextExtract, - NULL, // Replace - NULL, // Copy - NULL, // MapOffsetToNative, - NULL, // MapIndexToUTF16, - ucstrTextClose, - NULL, // spare 1 - NULL, // spare 2 - NULL, // spare 3 -}; - -U_CDECL_END - -static const UChar gEmptyUString[] = {0}; - -U_CAPI UText * U_EXPORT2 -utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status) { - if (U_FAILURE(*status)) { - return NULL; - } - if(s==NULL && length==0) { - s = gEmptyUString; - } - if (s==NULL || length < -1 || length>INT32_MAX) { - *status = U_ILLEGAL_ARGUMENT_ERROR; - return NULL; - } - ut = utext_setup(ut, 0, status); - if (U_SUCCESS(*status)) { - ut->pFuncs = &ucstrFuncs; - ut->context = s; - ut->providerProperties = I32_FLAG(UTEXT_PROVIDER_STABLE_CHUNKS); - if (length==-1) { - ut->providerProperties |= I32_FLAG(UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE); - } - ut->a = length; - ut->chunkContents = s; - ut->chunkNativeStart = 0; - ut->chunkNativeLimit = length>=0? length : 0; - ut->chunkLength = (int32_t)ut->chunkNativeLimit; - ut->chunkOffset = 0; - ut->nativeIndexingLimit = ut->chunkLength; - } - return ut; -} - - -//------------------------------------------------------------------------------ -// -// UText implementation for text from ICU CharacterIterators -// -// Use of UText data members: -// context pointer to the CharacterIterator -// a length of the full text. -// p pointer to buffer 1 -// b start index of local buffer 1 contents -// q pointer to buffer 2 -// c start index of local buffer 2 contents -// r pointer to the character iterator if the UText owns it. -// Null otherwise. -// -//------------------------------------------------------------------------------ -#define CIBufSize 16 - -U_CDECL_BEGIN -static void U_CALLCONV -charIterTextClose(UText *ut) { - // Most of the work of close is done by the generic UText framework close. - // All that needs to be done here is delete the CharacterIterator if the UText - // owns it. This occurs if the UText was created by cloning. - CharacterIterator *ci = (CharacterIterator *)ut->r; - delete ci; - ut->r = NULL; -} - -static int64_t U_CALLCONV -charIterTextLength(UText *ut) { - return (int32_t)ut->a; -} - -static UBool U_CALLCONV -charIterTextAccess(UText *ut, int64_t index, UBool forward) { - CharacterIterator *ci = (CharacterIterator *)ut->context; - - int32_t clippedIndex = (int32_t)index; - if (clippedIndex<0) { - clippedIndex=0; - } else if (clippedIndex>=ut->a) { - clippedIndex=(int32_t)ut->a; - } - int32_t neededIndex = clippedIndex; - if (!forward && neededIndex>0) { - // reverse iteration, want the position just before what was asked for. - neededIndex--; - } else if (forward && neededIndex==ut->a && neededIndex>0) { - // Forward iteration, don't ask for something past the end of the text. - neededIndex--; - } - - // Find the native index of the start of the buffer containing what we want. - neededIndex -= neededIndex % CIBufSize; - - UChar *buf = NULL; - UBool needChunkSetup = TRUE; - int i; - if (ut->chunkNativeStart == neededIndex) { - // The buffer we want is already the current chunk. - needChunkSetup = FALSE; - } else if (ut->b == neededIndex) { - // The first buffer (buffer p) has what we need. - buf = (UChar *)ut->p; - } else if (ut->c == neededIndex) { - // The second buffer (buffer q) has what we need. - buf = (UChar *)ut->q; - } else { - // Neither buffer already has what we need. - // Load new data from the character iterator. - // Use the buf that is not the current buffer. - buf = (UChar *)ut->p; - if (ut->p == ut->chunkContents) { - buf = (UChar *)ut->q; - } - ci->setIndex(neededIndex); - for (i=0; i<CIBufSize; i++) { - buf[i] = ci->nextPostInc(); - if (i+neededIndex > ut->a) { - break; - } - } - } - - // We have a buffer with the data we need. - // Set it up as the current chunk, if it wasn't already. - if (needChunkSetup) { - ut->chunkContents = buf; - ut->chunkLength = CIBufSize; - ut->chunkNativeStart = neededIndex; - ut->chunkNativeLimit = neededIndex + CIBufSize; - if (ut->chunkNativeLimit > ut->a) { - ut->chunkNativeLimit = ut->a; - ut->chunkLength = (int32_t)(ut->chunkNativeLimit)-(int32_t)(ut->chunkNativeStart); - } - ut->nativeIndexingLimit = ut->chunkLength; - U_ASSERT(ut->chunkOffset>=0 && ut->chunkOffset<=CIBufSize); - } - ut->chunkOffset = clippedIndex - (int32_t)ut->chunkNativeStart; - UBool success = (forward? ut->chunkOffset<ut->chunkLength : ut->chunkOffset>0); - return success; -} - -static UText * U_CALLCONV -charIterTextClone(UText *dest, const UText *src, UBool deep, UErrorCode * status) { - if (U_FAILURE(*status)) { - return NULL; - } - - if (deep) { - // There is no CharacterIterator API for cloning the underlying text storage. - *status = U_UNSUPPORTED_ERROR; - return NULL; - } else { - CharacterIterator *srcCI =(CharacterIterator *)src->context; - srcCI = srcCI->clone(); - dest = utext_openCharacterIterator(dest, srcCI, status); - if (U_FAILURE(*status)) { - return dest; - } - // cast off const on getNativeIndex. - // For CharacterIterator based UTexts, this is safe, the operation is const. - int64_t ix = utext_getNativeIndex((UText *)src); - utext_setNativeIndex(dest, ix); - dest->r = srcCI; // flags that this UText owns the CharacterIterator - } - return dest; -} - -static int32_t U_CALLCONV -charIterTextExtract(UText *ut, - int64_t start, int64_t limit, - UChar *dest, int32_t destCapacity, - UErrorCode *status) -{ - if(U_FAILURE(*status)) { - return 0; - } - if(destCapacity<0 || (dest==NULL && destCapacity>0) || start>limit) { - *status=U_ILLEGAL_ARGUMENT_ERROR; - return 0; - } - int32_t length = (int32_t)ut->a; - int32_t start32 = pinIndex(start, length); - int32_t limit32 = pinIndex(limit, length); - int32_t desti = 0; - int32_t srci; - int32_t copyLimit; - - CharacterIterator *ci = (CharacterIterator *)ut->context; - ci->setIndex32(start32); // Moves ix to lead of surrogate pair, if needed. - srci = ci->getIndex(); - copyLimit = srci; - while (srci<limit32) { - UChar32 c = ci->next32PostInc(); - int32_t len = U16_LENGTH(c); - U_ASSERT(desti+len>0); /* to ensure desti+len never exceeds MAX_INT32, which must not happen logically */ - if (desti+len <= destCapacity) { - U16_APPEND_UNSAFE(dest, desti, c); - copyLimit = srci+len; - } else { - desti += len; - *status = U_BUFFER_OVERFLOW_ERROR; - } - srci += len; - } - - charIterTextAccess(ut, copyLimit, TRUE); - - u_terminateUChars(dest, destCapacity, desti, status); - return desti; -} - -static const struct UTextFuncs charIterFuncs = -{ - sizeof(UTextFuncs), - 0, 0, 0, // Reserved alignment padding - charIterTextClone, - charIterTextLength, - charIterTextAccess, - charIterTextExtract, - NULL, // Replace - NULL, // Copy - NULL, // MapOffsetToNative, - NULL, // MapIndexToUTF16, - charIterTextClose, - NULL, // spare 1 - NULL, // spare 2 - NULL // spare 3 -}; -U_CDECL_END - - -U_CAPI UText * U_EXPORT2 -utext_openCharacterIterator(UText *ut, CharacterIterator *ci, UErrorCode *status) { - if (U_FAILURE(*status)) { - return NULL; - } - - if (ci->startIndex() > 0) { - // No support for CharacterIterators that do not start indexing from zero. - *status = U_UNSUPPORTED_ERROR; - return NULL; - } - - // Extra space in UText for 2 buffers of CIBufSize UChars each. - int32_t extraSpace = 2 * CIBufSize * sizeof(UChar); - ut = utext_setup(ut, extraSpace, status); - if (U_SUCCESS(*status)) { - ut->pFuncs = &charIterFuncs; - ut->context = ci; - ut->providerProperties = 0; - ut->a = ci->endIndex(); // Length of text - ut->p = ut->pExtra; // First buffer - ut->b = -1; // Native index of first buffer contents - ut->q = (UChar*)ut->pExtra+CIBufSize; // Second buffer - ut->c = -1; // Native index of second buffer contents - - // Initialize current chunk contents to be empty. - // First access will fault something in. - // Note: The initial nativeStart and chunkOffset must sum to zero - // so that getNativeIndex() will correctly compute to zero - // if no call to Access() has ever been made. They can't be both - // zero without Access() thinking that the chunk is valid. - ut->chunkContents = (UChar *)ut->p; - ut->chunkNativeStart = -1; - ut->chunkOffset = 1; - ut->chunkNativeLimit = 0; - ut->chunkLength = 0; - ut->nativeIndexingLimit = ut->chunkOffset; // enables native indexing - } - return ut; -} |