// © 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 <cstddef> #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) … static UBool utext_access(UText *ut, int64_t index, UBool forward) { … } U_CAPI UBool U_EXPORT2 utext_moveIndex32(UText *ut, int32_t delta) { … } U_CAPI int64_t U_EXPORT2 utext_nativeLength(UText *ut) { … } U_CAPI UBool U_EXPORT2 utext_isLengthExpensive(const UText *ut) { … } U_CAPI int64_t U_EXPORT2 utext_getNativeIndex(const UText *ut) { … } U_CAPI void U_EXPORT2 utext_setNativeIndex(UText *ut, int64_t index) { … } U_CAPI int64_t U_EXPORT2 utext_getPreviousNativeIndex(UText *ut) { … } // // 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) { … } U_CAPI UChar32 U_EXPORT2 utext_char32At(UText *ut, int64_t nativeIndex) { … } U_CAPI UChar32 U_EXPORT2 utext_next32(UText *ut) { … } U_CAPI UChar32 U_EXPORT2 utext_previous32(UText *ut) { … } U_CAPI UChar32 U_EXPORT2 utext_next32From(UText *ut, int64_t index) { … } U_CAPI UChar32 U_EXPORT2 utext_previous32From(UText *ut, int64_t index) { … } U_CAPI int32_t U_EXPORT2 utext_extract(UText *ut, int64_t start, int64_t limit, char16_t *dest, int32_t destCapacity, UErrorCode *status) { … } U_CAPI UBool U_EXPORT2 utext_equals(const UText *a, const UText *b) { … } U_CAPI UBool U_EXPORT2 utext_isWritable(const UText *ut) { … } U_CAPI void U_EXPORT2 utext_freeze(UText *ut) { … } U_CAPI UBool U_EXPORT2 utext_hasMetaData(const UText *ut) { … } U_CAPI int32_t U_EXPORT2 utext_replace(UText *ut, int64_t nativeStart, int64_t nativeLimit, const char16_t *replacementText, int32_t replacementLength, UErrorCode *status) { … } U_CAPI void U_EXPORT2 utext_copy(UText *ut, int64_t nativeStart, int64_t nativeLimit, int64_t destIndex, UBool move, UErrorCode *status) { … } U_CAPI UText * U_EXPORT2 utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status) { … } //------------------------------------------------------------------------------ // // UText common functions implementation // //------------------------------------------------------------------------------ // // UText.flags bit definitions // enum { … }; // // 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 { … }; static const UText emptyText = …; U_CAPI UText * U_EXPORT2 utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status) { … } U_CAPI UText * U_EXPORT2 utext_close(UText *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) { … } // // 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) { … } 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) { … } // // 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) { … } 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 char16_t indexes to native indexes. // Worst case is three native bytes to one char16_t. (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 { … }; // // UTF8Buf Two of these structs will be set up in the UText's extra allocated space. // Each contains the char16_t 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 { … }; 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) { … } static UBool U_CALLCONV utf8TextAccess(UText *ut, int64_t index, UBool forward) { … } // // This is a slightly modified copy of u_strFromUTF8, // Inserts a Replacement Char rather than failing on invalid UTF-8 // Removes unnecessary features. // static char16_t* utext_strFromUTF8(char16_t *dest, int32_t destCapacity, int32_t *pDestLength, const char* src, int32_t srcLength, // required. NUL terminated not supported. UErrorCode *pErrorCode ) { … } static int32_t U_CALLCONV utf8TextExtract(UText *ut, int64_t start, int64_t limit, char16_t *dest, int32_t destCapacity, UErrorCode *pErrorCode) { … } // // utf8TextMapOffsetToNative // // Map a chunk (UTF-16) offset to a native index. static int64_t U_CALLCONV utf8TextMapOffsetToNative(const UText *ut) { … } // // Map a native index to the corresponding chunk offset // static int32_t U_CALLCONV utf8TextMapIndexToUTF16(const UText *ut, int64_t index64) { … } static UText * U_CALLCONV utf8TextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status) { … } static void U_CALLCONV utf8TextClose(UText *ut) { … } U_CDECL_END static const struct UTextFuncs utf8Funcs = …; static const char gEmptyString[] = …; U_CAPI UText * U_EXPORT2 utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status) { … } //------------------------------------------------------------------------------ // // 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 { … }; struct ReplExtra { … }; U_CDECL_BEGIN static UText * U_CALLCONV repTextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status) { … } static void U_CALLCONV repTextClose(UText *ut) { … } static int64_t U_CALLCONV repTextLength(UText *ut) { … } static UBool U_CALLCONV repTextAccess(UText *ut, int64_t index, UBool forward) { … } static int32_t U_CALLCONV repTextExtract(UText *ut, int64_t start, int64_t limit, char16_t *dest, int32_t destCapacity, UErrorCode *status) { … } static int32_t U_CALLCONV repTextReplace(UText *ut, int64_t start, int64_t limit, const char16_t *src, int32_t length, UErrorCode *status) { … } static void U_CALLCONV repTextCopy(UText *ut, int64_t start, int64_t limit, int64_t destIndex, UBool move, UErrorCode *status) { … } static const struct UTextFuncs repFuncs = …; U_CAPI UText * U_EXPORT2 utext_openReplaceable(UText *ut, Replaceable *rep, UErrorCode *status) { … } 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(). nullptr otherwise. // //------------------------------------------------------------------------------ U_CDECL_BEGIN static UText * U_CALLCONV unistrTextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status) { … } static void U_CALLCONV unistrTextClose(UText *ut) { … } static int64_t U_CALLCONV unistrTextLength(UText *t) { … } static UBool U_CALLCONV unistrTextAccess(UText *ut, int64_t index, UBool forward) { … } static int32_t U_CALLCONV unistrTextExtract(UText *t, int64_t start, int64_t limit, char16_t *dest, int32_t destCapacity, UErrorCode *pErrorCode) { … } static int32_t U_CALLCONV unistrTextReplace(UText *ut, int64_t start, int64_t limit, const char16_t *src, int32_t length, UErrorCode *pErrorCode) { … } static void U_CALLCONV unistrTextCopy(UText *ut, int64_t start, int64_t limit, int64_t destIndex, UBool move, UErrorCode *pErrorCode) { … } static const struct UTextFuncs unistrFuncs = …; U_CDECL_END U_CAPI UText * U_EXPORT2 utext_openUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) { … } U_CAPI UText * U_EXPORT2 utext_openConstUnicodeString(UText *ut, const UnicodeString *s, UErrorCode *status) { … } //------------------------------------------------------------------------------ // // UText implementation for const char16_t * 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) { … } static void U_CALLCONV ucstrTextClose(UText *ut) { … } static int64_t U_CALLCONV ucstrTextLength(UText *ut) { … } static UBool U_CALLCONV ucstrTextAccess(UText *ut, int64_t index, UBool forward) { … } static int32_t U_CALLCONV ucstrTextExtract(UText *ut, int64_t start, int64_t limit, char16_t *dest, int32_t destCapacity, UErrorCode *pErrorCode) { … } static const struct UTextFuncs ucstrFuncs = …; U_CDECL_END static const char16_t gEmptyUString[] = …; U_CAPI UText * U_EXPORT2 utext_openUChars(UText *ut, const char16_t *s, int64_t length, UErrorCode *status) { … } //------------------------------------------------------------------------------ // // 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 … U_CDECL_BEGIN static void U_CALLCONV charIterTextClose(UText *ut) { … } static int64_t U_CALLCONV charIterTextLength(UText *ut) { … } static UBool U_CALLCONV charIterTextAccess(UText *ut, int64_t index, UBool forward) { … } static UText * U_CALLCONV charIterTextClone(UText *dest, const UText *src, UBool deep, UErrorCode * status) { … } static int32_t U_CALLCONV charIterTextExtract(UText *ut, int64_t start, int64_t limit, char16_t *dest, int32_t destCapacity, UErrorCode *status) { … } static const struct UTextFuncs charIterFuncs = …; U_CDECL_END U_CAPI UText * U_EXPORT2 utext_openCharacterIterator(UText *ut, CharacterIterator *ci, UErrorCode *status) { … }
Codebase Browser
chromium