diff options
Diffstat (limited to 'jni/EastAsianWidth/unicode/utext.h')
| -rw-r--r-- | jni/EastAsianWidth/unicode/utext.h | 1558 |
1 files changed, 0 insertions, 1558 deletions
diff --git a/jni/EastAsianWidth/unicode/utext.h b/jni/EastAsianWidth/unicode/utext.h deleted file mode 100644 index c5e8dd6..0000000 --- a/jni/EastAsianWidth/unicode/utext.h +++ /dev/null @@ -1,1558 +0,0 @@ -/* -******************************************************************************* -* -* Copyright (C) 2004-2007, International Business Machines -* Corporation and others. All Rights Reserved. -* -******************************************************************************* -* file name: utext.h -* encoding: US-ASCII -* tab size: 8 (not used) -* indentation:4 -* -* created on: 2004oct06 -* created by: Markus W. Scherer -*/ - -#ifndef __UTEXT_H__ -#define __UTEXT_H__ - -/** - * \file - * \brief C API: Abstract Unicode Text API - * - * The Text Access API provides a means to allow text that is stored in alternative - * formats to work with ICU services. ICU normally operates on text that is - * stored in UTF-16 format, in (UChar *) arrays for the C APIs or as type - * UnicodeString for C++ APIs. - * - * ICU Text Access allows other formats, such as UTF-8 or non-contiguous - * UTF-16 strings, to be placed in a UText wrapper and then passed to ICU services. - * - * There are three general classes of usage for UText: - * - * Application Level Use. This is the simplest usage - applications would - * use one of the utext_open() functions on their input text, and pass - * the resulting UText to the desired ICU service. - * - * Second is usage in ICU Services, such as break iteration, that will need to - * operate on input presented to them as a UText. These implementations - * will need to use the iteration and related UText functions to gain - * access to the actual text. - * - * The third class of UText users are "text providers." These are the - * UText implementations for the various text storage formats. An application - * or system with a unique text storage format can implement a set of - * UText provider functions for that format, which will then allow - * ICU services to operate on that format. - * - * - * <em>Iterating over text</em> - * - * Here is sample code for a forward iteration over the contents of a UText - * - * \code - * UChar32 c; - * UText *ut = whatever(); - * - * for (c=utext_next32From(ut, 0); c>=0; c=utext_next32(ut)) { - * // do whatever with the codepoint c here. - * } - * \endcode - * - * And here is similar code to iterate in the reverse direction, from the end - * of the text towards the beginning. - * - * \code - * UChar32 c; - * UText *ut = whatever(); - * int textLength = utext_nativeLength(ut); - * for (c=utext_previous32From(ut, textLength); c>=0; c=utext_previous32(ut)) { - * // do whatever with the codepoint c here. - * } - * \endcode - * - * <em>Characters and Indexing</em> - * - * Indexing into text by UText functions is nearly always in terms of the native - * indexing of the underlying text storage. The storage format could be UTF-8 - * or UTF-32, for example. When coding to the UText access API, no assumptions - * can be made regarding the size of characters, or how far an index - * may move when iterating between characters. - * - * All indices supplied to UText functions are pinned to the length of the - * text. An out-of-bounds index is not considered to be an error, but is - * adjusted to be in the range 0 <= index <= length of input text. - * - * - * When an index position is returned from a UText function, it will be - * a native index to the underlying text. In the case of multi-unit characters, - * it will always refer to the first position of the character, - * never to the interior. This is essentially the same thing as saying that - * a returned index will always point to a boundary between characters. - * - * When a native index is supplied to a UText function, all indices that - * refer to any part of a multi-unit character representation are considered - * to be equivalent. In the case of multi-unit characters, an incoming index - * will be logically normalized to refer to the start of the character. - * - * It is possible to test whether a native index is on a code point boundary - * by doing a utext_setNativeIndex() followed by a utext_getNativeIndex(). - * If the index is returned unchanged, it was on a code point boundary. If - * an adjusted index is returned, the original index referred to the - * interior of a character. - * - * <em>Conventions for calling UText functions</em> - * - * Most UText access functions have as their first parameter a (UText *) pointer, - * which specifies the UText to be used. Unless otherwise noted, the - * pointer must refer to a valid, open UText. Attempting to - * use a closed UText or passing a NULL pointer is a programming error and - * will produce undefined results or NULL pointer exceptions. - * - * The UText_Open family of functions can either open an existing (closed) - * UText, or heap allocate a new UText. Here is sample code for creating - * a stack-allocated UText. - * - * \code - * char *s = whatever(); // A utf-8 string - * U_ErrorCode status = U_ZERO_ERROR; - * UText ut = UTEXT_INITIALIZER; - * utext_openUTF8(ut, s, -1, &status); - * if (U_FAILURE(status)) { - * // error handling - * } else { - * // work with the UText - * } - * \endcode - * - * Any existing UText passed to an open function _must_ have been initialized, - * either by the UTEXT_INITIALIZER, or by having been originally heap-allocated - * by an open function. Passing NULL will cause the open function to - * heap-allocate and fully initialize a new UText. - * - */ - - - -#include "unicode/utypes.h" -#ifdef XP_CPLUSPLUS -#include "unicode/rep.h" -#include "unicode/unistr.h" -#include "unicode/chariter.h" -#endif - - -U_CDECL_BEGIN - -struct UText; -typedef struct UText UText; /**< C typedef for struct UText. @stable ICU 3.6 */ - - -/*************************************************************************************** - * - * C Functions for creating UText wrappers around various kinds of text strings. - * - ****************************************************************************************/ - - -/** - * Close function for UText instances. - * Cleans up, releases any resources being held by an open UText. - * <p> - * If the UText was originally allocated by one of the utext_open functions, - * the storage associated with the utext will also be freed. - * If the UText storage originated with the application, as it would with - * a local or static instance, the storage will not be deleted. - * - * An open UText can be reset to refer to new string by using one of the utext_open() - * functions without first closing the UText. - * - * @param ut The UText to be closed. - * @return NULL if the UText struct was deleted by the close. If the UText struct - * was originally provided by the caller to the open function, it is - * returned by this function, and may be safely used again in - * a subsequent utext_open. - * - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_close(UText *ut); - - -/** - * Open a read-only UText implementation for UTF-8 strings. - * - * \htmlonly - * Any invalid UTF-8 in the input will be handled in this way: - * a sequence of bytes that has the form of a truncated, but otherwise valid, - * UTF-8 sequence will be replaced by a single unicode replacement character, \uFFFD. - * Any other illegal bytes will each be replaced by a \uFFFD. - * \endhtmlonly - * - * @param ut Pointer to a UText struct. If NULL, a new UText will be created. - * If non-NULL, must refer to an initialized UText struct, which will then - * be reset to reference the specified UTF-8 string. - * @param s A UTF-8 string. Must not be NULL. - * @param length The length of the UTF-8 string in bytes, or -1 if the string is - * zero terminated. - * @param status Errors are returned here. - * @return A pointer to the UText. If a pre-allocated UText was provided, it - * will always be used and returned. - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_openUTF8(UText *ut, const char *s, int64_t length, UErrorCode *status); - - -/** - * Open a read-only UText for UChar * string. - * - * @param ut Pointer to a UText struct. If NULL, a new UText will be created. - * If non-NULL, must refer to an initialized UText struct, which will then - * be reset to reference the specified UChar string. - * @param s A UChar (UTF-16) string - * @param length The number of UChars in the input string, or -1 if the string is - * zero terminated. - * @param status Errors are returned here. - * @return A pointer to the UText. If a pre-allocated UText was provided, it - * will always be used and returned. - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_openUChars(UText *ut, const UChar *s, int64_t length, UErrorCode *status); - - -#ifdef XP_CPLUSPLUS -/** - * Open a writable UText for a non-const UnicodeString. - * - * @param ut Pointer to a UText struct. If NULL, a new UText will be created. - * If non-NULL, must refer to an initialized UText struct, which will then - * be reset to reference the specified input string. - * @param s A UnicodeString. - * @param status Errors are returned here. - * @return Pointer to the UText. If a UText was supplied as input, this - * will always be used and returned. - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_openUnicodeString(UText *ut, U_NAMESPACE_QUALIFIER UnicodeString *s, UErrorCode *status); - - -/** - * Open a UText for a const UnicodeString. The resulting UText will not be writable. - * - * @param ut Pointer to a UText struct. If NULL, a new UText will be created. - * If non-NULL, must refer to an initialized UText struct, which will then - * be reset to reference the specified input string. - * @param s A const UnicodeString to be wrapped. - * @param status Errors are returned here. - * @return Pointer to the UText. If a UText was supplied as input, this - * will always be used and returned. - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_openConstUnicodeString(UText *ut, const U_NAMESPACE_QUALIFIER UnicodeString *s, UErrorCode *status); - - -/** - * Open a writable UText implementation for an ICU Replaceable object. - * @param ut Pointer to a UText struct. If NULL, a new UText will be created. - * If non-NULL, must refer to an already existing UText, which will then - * be reset to reference the specified replaceable text. - * @param rep A Replaceable text object. - * @param status Errors are returned here. - * @return Pointer to the UText. If a UText was supplied as input, this - * will always be used and returned. - * @see Replaceable - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_openReplaceable(UText *ut, U_NAMESPACE_QUALIFIER Replaceable *rep, UErrorCode *status); - -/** - * Open a UText implementation over an ICU CharacterIterator. - * @param ut Pointer to a UText struct. If NULL, a new UText will be created. - * If non-NULL, must refer to an already existing UText, which will then - * be reset to reference the specified replaceable text. - * @param ci A Character Iterator. - * @param status Errors are returned here. - * @return Pointer to the UText. If a UText was supplied as input, this - * will always be used and returned. - * @see Replaceable - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_openCharacterIterator(UText *ut, U_NAMESPACE_QUALIFIER CharacterIterator *ic, UErrorCode *status); - -#endif - - -/** - * Clone a UText. This is much like opening a UText where the source text is itself - * another UText. - * - * A deep clone will copy both the UText data structures and the underlying text. - * The original and cloned UText will operate completely independently; modifications - * made to the text in one will not affect the other. Text providers are not - * required to support deep clones. The user of clone() must check the status return - * and be prepared to handle failures. - * - * The standard UText implementations for UTF8, UChar *, UnicodeString and - * Replaceable all support deep cloning. - * - * The UText returned from a deep clone will be writable, assuming that the text - * provider is able to support writing, even if the source UText had been made - * non-writable by means of UText_freeze(). - * - * A shallow clone replicates only the UText data structures; it does not make - * a copy of the underlying text. Shallow clones can be used as an efficient way to - * have multiple iterators active in a single text string that is not being - * modified. - * - * A shallow clone operation will not fail, barring truly exceptional conditions such - * as memory allocation failures. - * - * Shallow UText clones should be avoided if the UText functions that modify the - * text are expected to be used, either on the original or the cloned UText. - * Any such modifications can cause unpredictable behavior. Read Only - * shallow clones provide some protection against errors of this type by - * disabling text modification via the cloned UText. - * - * A shallow clone made with the readOnly parameter == FALSE will preserve the - * utext_isWritable() state of the source object. Note, however, that - * write operations must be avoided while more than one UText exists that refer - * to the same underlying text. - * - * A UText and its clone may be safely concurrently accessed by separate threads. - * This is true for read access only with shallow clones, and for both read and - * write access with deep clones. - * It is the responsibility of the Text Provider to ensure that this thread safety - * constraint is met. - * - * @param dest A UText struct to be filled in with the result of the clone operation, - * or NULL if the clone function should heap-allocate a new UText struct. - * If non-NULL, must refer to an already existing UText, which will then - * be reset to become the clone. - * @param src The UText to be cloned. - * @param deep TRUE to request a deep clone, FALSE for a shallow clone. - * @param readOnly TRUE to request that the cloned UText have read only access to the - * underlying text. - - * @param status Errors are returned here. For deep clones, U_UNSUPPORTED_ERROR - * will be returned if the text provider is unable to clone the - * original text. - * @return The newly created clone, or NULL if the clone operation failed. - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_clone(UText *dest, const UText *src, UBool deep, UBool readOnly, UErrorCode *status); - - -/** - * Compare two UText objects for equality. - * UTexts are equal if they are iterating over the same text, and - * have the same iteration position within the text. - * If either or both of the parameters are NULL, the comparison is FALSE. - * - * @param a The first of the two UTexts to compare. - * @param b The other UText to be compared. - * @return TRUE if the two UTexts are equal. - * @stable ICU 3.6 - */ -U_STABLE UBool U_EXPORT2 -utext_equals(const UText *a, const UText *b); - - -/***************************************************************************** - * - * Functions to work with the text represeted by a UText wrapper - * - *****************************************************************************/ - -/** - * Get the length of the text. Depending on the characteristics - * of the underlying text representation, this may be expensive. - * @see utext_isLengthExpensive() - * - * - * @param ut the text to be accessed. - * @return the length of the text, expressed in native units. - * - * @stable ICU 3.4 - */ -U_STABLE int64_t U_EXPORT2 -utext_nativeLength(UText *ut); - -/** - * Return TRUE if calculating the length of the text could be expensive. - * Finding the length of NUL terminated strings is considered to be expensive. - * - * Note that the value of this function may change - * as the result of other operations on a UText. - * Once the length of a string has been discovered, it will no longer - * be expensive to report it. - * - * @param ut the text to be accessed. - * @return TRUE if determining the length of the text could be time consuming. - * @stable ICU 3.4 - */ -U_STABLE UBool U_EXPORT2 -utext_isLengthExpensive(const UText *ut); - -/** - * Returns the code point at the requested index, - * or U_SENTINEL (-1) if it is out of bounds. - * - * If the specified index points to the interior of a multi-unit - * character - one of the trail bytes of a UTF-8 sequence, for example - - * the complete code point will be returned. - * - * The iteration position will be set to the start of the returned code point. - * - * This function is roughly equivalent to the the sequence - * utext_setNativeIndex(index); - * utext_current32(); - * (There is a subtle difference if the index is out of bounds by being less than zero - - * utext_setNativeIndex(negative value) sets the index to zero, after which utext_current() - * will return the char at zero. utext_char32At(negative index), on the other hand, will - * return the U_SENTINEL value of -1.) - * - * @param ut the text to be accessed - * @param nativeIndex the native index of the character to be accessed. If the index points - * to other than the first unit of a multi-unit character, it will be adjusted - * to the start of the character. - * @return the code point at the specified index. - * @stable ICU 3.4 - */ -U_STABLE UChar32 U_EXPORT2 -utext_char32At(UText *ut, int64_t nativeIndex); - - -/** - * - * Get the code point at the current iteration position, - * or U_SENTINEL (-1) if the iteration has reached the end of - * the input text. - * - * @param ut the text to be accessed. - * @return the Unicode code point at the current iterator position. - * @stable ICU 3.4 - */ -U_STABLE UChar32 U_EXPORT2 -utext_current32(UText *ut); - - -/** - * Get the code point at the current iteration position of the UText, and - * advance the position to the first index following the character. - * - * If the position is at the end of the text (the index following - * the last character, which is also the length of the text), - * return U_SENTINEL (-1) and do not advance the index. - * - * This is a post-increment operation. - * - * An inline macro version of this function, UTEXT_NEXT32(), - * is available for performance critical use. - * - * @param ut the text to be accessed. - * @return the Unicode code point at the iteration position. - * @see UTEXT_NEXT32 - * @stable ICU 3.4 - */ -U_STABLE UChar32 U_EXPORT2 -utext_next32(UText *ut); - - -/** - * Move the iterator position to the character (code point) whose - * index precedes the current position, and return that character. - * This is a pre-decrement operation. - * - * If the initial position is at the start of the text (index of 0) - * return U_SENTINEL (-1), and leave the position unchanged. - * - * An inline macro version of this function, UTEXT_PREVIOUS32(), - * is available for performance critical use. - * - * @param ut the text to be accessed. - * @return the previous UChar32 code point, or U_SENTINEL (-1) - * if the iteration has reached the start of the text. - * @see UTEXT_PREVIOUS32 - * @stable ICU 3.4 - */ -U_STABLE UChar32 U_EXPORT2 -utext_previous32(UText *ut); - - -/** - * Set the iteration index and return the code point at that index. - * Leave the iteration index at the start of the following code point. - * - * This function is the most efficient and convenient way to - * begin a forward iteration. The results are identical to the those - * from the sequence - * \code - * utext_setIndex(); - * utext_next32(); - * \endcode - * - * @param ut the text to be accessed. - * @param nativeIndex Iteration index, in the native units of the text provider. - * @return Code point which starts at or before index, - * or U_SENTINEL (-1) if it is out of bounds. - * @stable ICU 3.4 - */ -U_STABLE UChar32 U_EXPORT2 -utext_next32From(UText *ut, int64_t nativeIndex); - - - -/** - * Set the iteration index, and return the code point preceding the - * one specified by the initial index. Leave the iteration position - * at the start of the returned code point. - * - * This function is the most efficient and convenient way to - * begin a backwards iteration. - * - * @param ut the text to be accessed. - * @param nativeIndex Iteration index in the native units of the text provider. - * @return Code point preceding the one at the initial index, - * or U_SENTINEL (-1) if it is out of bounds. - * - * @stable ICU 3.4 - */ -U_STABLE UChar32 U_EXPORT2 -utext_previous32From(UText *ut, int64_t nativeIndex); - -/** - * Get the current iterator position, which can range from 0 to - * the length of the text. - * The position is a native index into the input text, in whatever format it - * may have (possibly UTF-8 for example), and may not always be the same as - * the corresponding UChar (UTF-16) index. - * The returned position will always be aligned to a code point boundary. - * - * @param ut the text to be accessed. - * @return the current index position, in the native units of the text provider. - * @stable ICU 3.4 - */ -U_STABLE int64_t U_EXPORT2 -utext_getNativeIndex(const UText *ut); - -/** - * Set the current iteration position to the nearest code point - * boundary at or preceding the specified index. - * The index is in the native units of the original input text. - * If the index is out of range, it will be pinned to be within - * the range of the input text. - * <p> - * It will usually be more efficient to begin an iteration - * using the functions utext_next32From() or utext_previous32From() - * rather than setIndex(). - * <p> - * Moving the index position to an adjacent character is best done - * with utext_next32(), utext_previous32() or utext_moveIndex32(). - * Attempting to do direct arithmetic on the index position is - * complicated by the fact that the size (in native units) of a - * character depends on the underlying representation of the character - * (UTF-8, UTF-16, UTF-32, arbitrary codepage), and is not - * easily knowable. - * - * @param ut the text to be accessed. - * @param nativeIndex the native unit index of the new iteration position. - * @stable ICU 3.4 - */ -U_STABLE void U_EXPORT2 -utext_setNativeIndex(UText *ut, int64_t nativeIndex); - -/** - * Move the iterator postion by delta code points. The number of code points - * is a signed number; a negative delta will move the iterator backwards, - * towards the start of the text. - * <p> - * The index is moved by <code>delta</code> code points - * forward or backward, but no further backward than to 0 and - * no further forward than to utext_nativeLength(). - * The resulting index value will be in between 0 and length, inclusive. - * - * @param ut the text to be accessed. - * @param delta the signed number of code points to move the iteration position. - * @return TRUE if the position could be moved the requested number of positions while - * staying within the range [0 - text length]. - * @stable ICU 3.4 - */ -U_STABLE UBool U_EXPORT2 -utext_moveIndex32(UText *ut, int32_t delta); - -/** - * Get the native index of the character preceeding the current position. - * If the iteration position is already at the start of the text, zero - * is returned. - * The value returned is the same as that obtained from the following sequence, - * but without the side effect of changing the iteration position. - * - * \code - * UText *ut = whatever; - * ... - * utext_previous(ut) - * utext_getNativeIndex(ut); - * \endcode - * - * This function is most useful during forwards iteration, where it will get the - * native index of the character most recently returned from utext_next(). - * - * @param ut the text to be accessed - * @return the native index of the character preceeding the current index position, - * or zero if the current position is at the start of the text. - * @stable ICU 3.6 - */ -U_STABLE int64_t U_EXPORT2 -utext_getPreviousNativeIndex(UText *ut); - - -/** - * - * Extract text from a UText into a UChar buffer. The range of text to be extracted - * is specified in the native indices of the UText provider. These may not necessarily - * be UTF-16 indices. - * <p> - * The size (number of 16 bit UChars) of the data to be extracted is returned. The - * full number of UChars is returned, even when the extracted text is truncated - * because the specified buffer size is too small. - * <p> - * The extracted string will (if you are a user) / must (if you are a text provider) - * be NUL-terminated if there is sufficient space in the destination buffer. This - * terminating NUL is not included in the returned length. - * <p> - * The iteration index is left at the position following the last extracted character. - * - * @param ut the UText from which to extract data. - * @param nativeStart the native index of the first character to extract.\ - * If the specified index is out of range, - * it will be pinned to to be within 0 <= index <= textLength - * @param nativeLimit the native string index of the position following the last - * character to extract. If the specified index is out of range, - * it will be pinned to to be within 0 <= index <= textLength. - * nativeLimit must be >= nativeStart. - * @param dest the UChar (UTF-16) buffer into which the extracted text is placed - * @param destCapacity The size, in UChars, of the destination buffer. May be zero - * for precomputing the required size. - * @param status receives any error status. - * U_BUFFER_OVERFLOW_ERROR: the extracted text was truncated because the - * buffer was too small. Returns number of UChars for preflighting. - * @return Number of UChars in the data to be extracted. Does not include a trailing NUL. - * - * @stable ICU 3.4 - */ -U_STABLE int32_t U_EXPORT2 -utext_extract(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - UChar *dest, int32_t destCapacity, - UErrorCode *status); - - -/************************************************************************************ - * - * #define inline versions of selected performance-critical text access functions - * Caution: do not use auto increment++ or decrement-- expressions - * as parameters to these macros. - * - * For most use, where there is no extreme performance constraint, the - * normal, non-inline functions are a better choice. The resulting code - * will be smaller, and, if the need ever arises, easier to debug. - * - * These are implemented as #defines rather than real functions - * because there is no fully portable way to do inline functions in plain C. - * - ************************************************************************************/ - -/** - * inline version of utext_next32(), for performance-critical situations. - * - * Get the code point at the current iteration position of the UText, and - * advance the position to the first index following the character. - * This is a post-increment operation. - * Returns U_SENTINEL (-1) if the position is at the end of the - * text. - * - * @stable ICU 3.4 - */ -#define UTEXT_NEXT32(ut) \ - ((ut)->chunkOffset < (ut)->chunkLength && ((ut)->chunkContents)[(ut)->chunkOffset]<0xd800 ? \ - ((ut)->chunkContents)[((ut)->chunkOffset)++] : utext_next32(ut)) - -/** - * inline version of utext_previous32(), for performance-critical situations. - * - * Move the iterator position to the character (code point) whose - * index precedes the current position, and return that character. - * This is a pre-decrement operation. - * Returns U_SENTINEL (-1) if the position is at the start of the text. - * - * @stable ICU 3.4 - */ -#define UTEXT_PREVIOUS32(ut) \ - ((ut)->chunkOffset > 0 && \ - (ut)->chunkContents[(ut)->chunkOffset-1] < 0xd800 ? \ - (ut)->chunkContents[--((ut)->chunkOffset)] : utext_previous32(ut)) - -/** - * inline version of utext_getNativeIndex(), for performance-critical situations. - * - * Get the current iterator position, which can range from 0 to - * the length of the text. - * The position is a native index into the input text, in whatever format it - * may have (possibly UTF-8 for example), and may not always be the same as - * the corresponding UChar (UTF-16) index. - * The returned position will always be aligned to a code point boundary. - * - * @stable ICU 3.6 - */ -#define UTEXT_GETNATIVEINDEX(ut) \ - ((ut)->chunkOffset <= (ut)->nativeIndexingLimit? \ - (ut)->chunkNativeStart+(ut)->chunkOffset : \ - (ut)->pFuncs->mapOffsetToNative(ut)) - -/** - * inline version of utext_setNativeIndex(), for performance-critical situations. - * - * Set the current iteration position to the nearest code point - * boundary at or preceding the specified index. - * The index is in the native units of the original input text. - * If the index is out of range, it will be pinned to be within - * the range of the input text. - * - * @draft ICU 3.8 - */ -#define UTEXT_SETNATIVEINDEX(ut, ix) \ - { int64_t __offset = (ix) - (ut)->chunkNativeStart; \ - if (__offset>=0 && __offset<=(int64_t)(ut)->nativeIndexingLimit) { \ - (ut)->chunkOffset=(int32_t)__offset; \ - } else { \ - utext_setNativeIndex((ut), (ix)); } } - - - -/************************************************************************************ - * - * Functions related to writing or modifying the text. - * These will work only with modifiable UTexts. Attempting to - * modify a read-only UText will return an error status. - * - ************************************************************************************/ - - -/** - * Return TRUE if the text can be written (modified) with utext_replace() or - * utext_copy(). For the text to be writable, the text provider must - * be of a type that supports writing and the UText must not be frozen. - * - * Attempting to modify text when utext_isWriteable() is FALSE will fail - - * the text will not be modified, and an error will be returned from the function - * that attempted the modification. - * - * @param ut the UText to be tested. - * @return TRUE if the text is modifiable. - * - * @see utext_freeze() - * @see utext_replace() - * @see utext_copy() - * @stable ICU 3.4 - * - */ -U_STABLE UBool U_EXPORT2 -utext_isWritable(const UText *ut); - - -/** - * Test whether there is meta data associated with the text. - * @see Replaceable::hasMetaData() - * - * @param ut The UText to be tested - * @return TRUE if the underlying text includes meta data. - * @stable ICU 3.4 - */ -U_STABLE UBool U_EXPORT2 -utext_hasMetaData(const UText *ut); - - -/** - * Replace a range of the original text with a replacement text. - * - * Leaves the current iteration position at the position following the - * newly inserted replacement text. - * - * This function is only available on UText types that support writing, - * that is, ones where utext_isWritable() returns TRUE. - * - * When using this function, there should be only a single UText opened onto the - * underlying native text string. Behavior after a replace operation - * on a UText is undefined for any other additional UTexts that refer to the - * modified string. - * - * @param ut the UText representing the text to be operated on. - * @param nativeStart the native index of the start of the region to be replaced - * @param nativeLimit the native index of the character following the region to be replaced. - * @param replacementText pointer to the replacement text - * @param replacementLength length of the replacement text, or -1 if the text is NUL terminated. - * @param status receives any error status. Possible errors include - * U_NO_WRITE_PERMISSION - * - * @return The signed number of (native) storage units by which - * the length of the text expanded or contracted. - * - * @stable ICU 3.4 - */ -U_STABLE int32_t U_EXPORT2 -utext_replace(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - const UChar *replacementText, int32_t replacementLength, - UErrorCode *status); - - - -/** - * - * Copy or move a substring from one position to another within the text, - * while retaining any metadata associated with the text. - * This function is used to duplicate or reorder substrings. - * The destination index must not overlap the source range. - * - * The text to be copied or moved is inserted at destIndex; - * it does not replace or overwrite any existing text. - * - * The iteration position is left following the newly inserted text - * at the destination position. - * - * This function is only available on UText types that support writing, - * that is, ones where utext_isWritable() returns TRUE. - * - * When using this function, there should be only a single UText opened onto the - * underlying native text string. Behavior after a copy operation - * on a UText is undefined in any other additional UTexts that refer to the - * modified string. - * - * @param ut The UText representing the text to be operated on. - * @param nativeStart The native index of the start of the region to be copied or moved - * @param nativeLimit The native index of the character position following the region - * to be copied. - * @param destIndex The native destination index to which the source substring is - * copied or moved. - * @param move If TRUE, then the substring is moved, not copied/duplicated. - * @param status receives any error status. Possible errors include U_NO_WRITE_PERMISSION - * - * @stable ICU 3.4 - */ -U_STABLE void U_EXPORT2 -utext_copy(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - int64_t destIndex, - UBool move, - UErrorCode *status); - - -/** - * <p> - * Freeze a UText. This prevents any modification to the underlying text itself - * by means of functions operating on this UText. - * </p> - * <p> - * Once frozen, a UText can not be unfrozen. The intent is to ensure - * that a the text underlying a frozen UText wrapper cannot be modified via that UText. - * </p> - * <p> - * Caution: freezing a UText will disable changes made via the specific - * frozen UText wrapper only; it will not have any effect on the ability to - * directly modify the text by bypassing the UText. Any such backdoor modifications - * are always an error while UText access is occuring because the underlying - * text can get out of sync with UText's buffering. - * </p> - * - * @param ut The UText to be frozen. - * @see utext_isWritable() - * @stable ICU 3.6 - */ -U_STABLE void U_EXPORT2 -utext_freeze(UText *ut); - - -/** - * UText provider properties (bit field indexes). - * - * @see UText - * @stable ICU 3.4 - */ -enum { - /** - * It is potentially time consuming for the provider to determine the length of the text. - * @stable ICU 3.4 - */ - UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE = 1, - /** - * Text chunks remain valid and usable until the text object is modified or - * deleted, not just until the next time the access() function is called - * (which is the default). - * @stable ICU 3.4 - */ - UTEXT_PROVIDER_STABLE_CHUNKS = 2, - /** - * The provider supports modifying the text via the replace() and copy() - * functions. - * @see Replaceable - * @stable ICU 3.4 - */ - UTEXT_PROVIDER_WRITABLE = 3, - /** - * There is meta data associated with the text. - * @see Replaceable::hasMetaData() - * @stable ICU 3.4 - */ - UTEXT_PROVIDER_HAS_META_DATA = 4, - /** - * Text provider owns the text storage. - * Generally occurs as the result of a deep clone of the UText. - * When closing the UText, the associated text must - * also be closed/deleted/freed/ whatever is appropriate. - * @stable ICU 3.6 - */ - UTEXT_PROVIDER_OWNS_TEXT = 5 -}; - -/** - * Function type declaration for UText.clone(). - * - * clone a UText. Much like opening a UText where the source text is itself - * another UText. - * - * A deep clone will copy both the UText data structures and the underlying text. - * The original and cloned UText will operate completely independently; modifications - * made to the text in one will not effect the other. Text providers are not - * required to support deep clones. The user of clone() must check the status return - * and be prepared to handle failures. - * - * A shallow clone replicates only the UText data structures; it does not make - * a copy of the underlying text. Shallow clones can be used as an efficient way to - * have multiple iterators active in a single text string that is not being - * modified. - * - * A shallow clone operation must not fail except for truly exceptional conditions such - * as memory allocation failures. - * - * A UText and its clone may be safely concurrently accessed by separate threads. - * This is true for both shallow and deep clones. - * It is the responsibility of the Text Provider to ensure that this thread safety - * constraint is met. - - * - * @param dest A UText struct to be filled in with the result of the clone operation, - * or NULL if the clone function should heap-allocate a new UText struct. - * @param src The UText to be cloned. - * @param deep TRUE to request a deep clone, FALSE for a shallow clone. - * @param status Errors are returned here. For deep clones, U_UNSUPPORTED_ERROR - * should be returned if the text provider is unable to clone the - * original text. - * @return The newly created clone, or NULL if the clone operation failed. - * - * @stable ICU 3.4 - */ -typedef UText * U_CALLCONV -UTextClone(UText *dest, const UText *src, UBool deep, UErrorCode *status); - - -/** - * Function type declaration for UText.nativeLength(). - * - * @param ut the UText to get the length of. - * @return the length, in the native units of the original text string. - * @see UText - * @stable ICU 3.4 - */ -typedef int64_t U_CALLCONV -UTextNativeLength(UText *ut); - -/** - * Function type declaration for UText.access(). Get the description of the text chunk - * containing the text at a requested native index. The UText's iteration - * position will be left at the requested index. If the index is out - * of bounds, the iteration position will be left at the start or end - * of the string, as appropriate. - * - * Chunks must begin and end on code point boundaries. A single code point - * comprised of multiple storage units must never span a chunk boundary. - * - * - * @param ut the UText being accessed. - * @param nativeIndex Requested index of the text to be accessed. - * @param forward If TRUE, then the returned chunk must contain text - * starting from the index, so that start<=index<limit. - * If FALSE, then the returned chunk must contain text - * before the index, so that start<index<=limit. - * @return True if the requested index could be accessed. The chunk - * will contain the requested text. - * False value if a chunk cannot be accessed - * (the requested index is out of bounds). - * - * @see UText - * @stable ICU 3.4 - */ -typedef UBool U_CALLCONV -UTextAccess(UText *ut, int64_t nativeIndex, UBool forward); - -/** - * Function type declaration for UText.extract(). - * - * Extract text from a UText into a UChar buffer. The range of text to be extracted - * is specified in the native indices of the UText provider. These may not necessarily - * be UTF-16 indices. - * <p> - * The size (number of 16 bit UChars) in the data to be extracted is returned. The - * full amount is returned, even when the specified buffer size is smaller. - * <p> - * The extracted string will (if you are a user) / must (if you are a text provider) - * be NUL-terminated if there is sufficient space in the destination buffer. - * - * @param ut the UText from which to extract data. - * @param nativeStart the native index of the first characer to extract. - * @param nativeLimit the native string index of the position following the last - * character to extract. - * @param dest the UChar (UTF-16) buffer into which the extracted text is placed - * @param destCapacity The size, in UChars, of the destination buffer. May be zero - * for precomputing the required size. - * @param status receives any error status. - * If U_BUFFER_OVERFLOW_ERROR: Returns number of UChars for - * preflighting. - * @return Number of UChars in the data. Does not include a trailing NUL. - * - * @stable ICU 3.4 - */ -typedef int32_t U_CALLCONV -UTextExtract(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - UChar *dest, int32_t destCapacity, - UErrorCode *status); - -/** - * Function type declaration for UText.replace(). - * - * Replace a range of the original text with a replacement text. - * - * Leaves the current iteration position at the position following the - * newly inserted replacement text. - * - * This function need only be implemented on UText types that support writing. - * - * When using this function, there should be only a single UText opened onto the - * underlying native text string. The function is responsible for updating the - * text chunk within the UText to reflect the updated iteration position, - * taking into account any changes to the underlying string's structure caused - * by the replace operation. - * - * @param ut the UText representing the text to be operated on. - * @param nativeStart the index of the start of the region to be replaced - * @param nativeLimit the index of the character following the region to be replaced. - * @param replacementText pointer to the replacement text - * @param replacmentLength length of the replacement text in UChars, or -1 if the text is NUL terminated. - * @param status receives any error status. Possible errors include - * U_NO_WRITE_PERMISSION - * - * @return The signed number of (native) storage units by which - * the length of the text expanded or contracted. - * - * @stable ICU 3.4 - */ -typedef int32_t U_CALLCONV -UTextReplace(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - const UChar *replacementText, int32_t replacmentLength, - UErrorCode *status); - -/** - * Function type declaration for UText.copy(). - * - * Copy or move a substring from one position to another within the text, - * while retaining any metadata associated with the text. - * This function is used to duplicate or reorder substrings. - * The destination index must not overlap the source range. - * - * The text to be copied or moved is inserted at destIndex; - * it does not replace or overwrite any existing text. - * - * This function need only be implemented for UText types that support writing. - * - * When using this function, there should be only a single UText opened onto the - * underlying native text string. The function is responsible for updating the - * text chunk within the UText to reflect the updated iteration position, - * taking into account any changes to the underlying string's structure caused - * by the replace operation. - * - * @param ut The UText representing the text to be operated on. - * @param nativeStart The index of the start of the region to be copied or moved - * @param nativeLimit The index of the character following the region to be replaced. - * @param nativeDest The destination index to which the source substring is copied or moved. - * @param move If TRUE, then the substring is moved, not copied/duplicated. - * @param status receives any error status. Possible errors include U_NO_WRITE_PERMISSION - * - * @stable ICU 3.4 - */ -typedef void U_CALLCONV -UTextCopy(UText *ut, - int64_t nativeStart, int64_t nativeLimit, - int64_t nativeDest, - UBool move, - UErrorCode *status); - -/** - * Function type declaration for UText.mapOffsetToNative(). - * Map from the current UChar offset within the current text chunk to - * the corresponding native index in the original source text. - * - * This is required only for text providers that do not use native UTF-16 indexes. - * - * @param ut the UText. - * @return Absolute (native) index corresponding to chunkOffset in the current chunk. - * The returned native index should always be to a code point boundary. - * - * @stable ICU 3.4 - */ -typedef int64_t U_CALLCONV -UTextMapOffsetToNative(const UText *ut); - -/** - * Function type declaration for UText.mapIndexToUTF16(). - * Map from a native index to a UChar offset within a text chunk. - * Behavior is undefined if the native index does not fall within the - * current chunk. - * - * This function is required only for text providers that do not use native UTF-16 indexes. - * - * @param ut The UText containing the text chunk. - * @param nativeIndex Absolute (native) text index, chunk->start<=index<=chunk->limit. - * @return Chunk-relative UTF-16 offset corresponding to the specified native - * index. - * - * @stable ICU 3.4 - */ -typedef int32_t U_CALLCONV -UTextMapNativeIndexToUTF16(const UText *ut, int64_t nativeIndex); - - -/** - * Function type declaration for UText.utextClose(). - * - * A Text Provider close function is only required for provider types that make - * allocations in their open function (or other functions) that must be - * cleaned when the UText is closed. - * - * The allocation of the UText struct itself and any "extra" storage - * associated with the UText is handled by the common UText implementation - * and does not require provider specific cleanup in a close function. - * - * Most UText provider implementations do not need to implement this function. - * - * @param ut A UText object to be closed. - * - * @stable ICU 3.4 - */ -typedef void U_CALLCONV -UTextClose(UText *ut); - - -/** - * (public) Function dispatch table for UText. - * Conceptually very much like a C++ Virtual Function Table. - * This struct defines the organization of the table. - * Each text provider implementation must provide an - * actual table that is initialized with the appropriate functions - * for the type of text being handled. - * @stable ICU 3.6 - */ -struct UTextFuncs { - /** - * (public) Function table size, sizeof(UTextFuncs) - * Intended for use should the table grow to accomodate added - * functions in the future, to allow tests for older format - * function tables that do not contain the extensions. - * - * Fields are placed for optimal alignment on - * 32/64/128-bit-pointer machines, by normally grouping together - * 4 32-bit fields, - * 4 pointers, - * 2 64-bit fields - * in sequence. - * @stable ICU 3.6 - */ - int32_t tableSize; - - /** - * (private) Alignment padding. - * Do not use, reserved for use by the UText framework only. - * @internal - */ - int32_t reserved1, reserved2, reserved3; - - - /** - * (public) Function pointer for UTextClone - * - * @see UTextClone - * @stable ICU 3.6 - */ - UTextClone *clone; - - /** - * (public) function pointer for UTextLength - * May be expensive to compute! - * - * @see UTextLength - * @stable ICU 3.6 - */ - UTextNativeLength *nativeLength; - - /** - * (public) Function pointer for UTextAccess. - * - * @see UTextAccess - * @stable ICU 3.6 - */ - UTextAccess *access; - - /** - * (public) Function pointer for UTextExtract. - * - * @see UTextExtract - * @stable ICU 3.6 - */ - UTextExtract *extract; - - /** - * (public) Function pointer for UTextReplace. - * - * @see UTextReplace - * @stable ICU 3.6 - */ - UTextReplace *replace; - - /** - * (public) Function pointer for UTextCopy. - * - * @see UTextCopy - * @stable ICU 3.6 - */ - UTextCopy *copy; - - /** - * (public) Function pointer for UTextMapOffsetToNative. - * - * @see UTextMapOffsetToNative - * @stable ICU 3.6 - */ - UTextMapOffsetToNative *mapOffsetToNative; - - /** - * (public) Function pointer for UTextMapNativeIndexToUTF16. - * - * @see UTextMapNativeIndexToUTF16 - * @stable ICU 3.6 - */ - UTextMapNativeIndexToUTF16 *mapNativeIndexToUTF16; - - /** - * (public) Function pointer for UTextClose. - * - * @see UTextClose - * @stable ICU 3.6 - */ - UTextClose *close; - - /** - * (private) Spare function pointer - * @internal - */ - - UTextClose *spare1; - /** - * (private) Spare function pointer - * @internal - */ - UTextClose *spare2; - - /** - * (private) Spare function pointer - * @internal - */ - UTextClose *spare3; - -}; -typedef struct UTextFuncs UTextFuncs; - - /** - * UText struct. Provides the interface between the generic UText access code - * and the UText provider code that works on specific kinds of - * text (UTF-8, noncontiguous UTF-16, whatever.) - * - * Applications that are using predefined types of text providers - * to pass text data to ICU services will have no need to view the - * internals of the UText structs that they open. - * - * @stable ICU 3.6 - */ -struct UText { - /** - * (private) Magic. Used to help detect when UText functions are handed - * invalid or unitialized UText structs. - * utext_openXYZ() functions take an initialized, - * but not necessarily open, UText struct as an - * optional fill-in parameter. This magic field - * is used to check for that initialization. - * Text provider close functions must NOT clear - * the magic field because that would prevent - * reuse of the UText struct. - * @internal - */ - uint32_t magic; - - - /** - * (private) Flags for managing the allocation and freeing of - * memory associated with this UText. - * @internal - */ - int32_t flags; - - - /** - * Text provider properties. This set of flags is maintainted by the - * text provider implementation. - * @stable ICU 3.4 - */ - int32_t providerProperties; - - /** - * (public) sizeOfStruct=sizeof(UText) - * Allows possible backward compatible extension. - * - * @stable ICU 3.4 - */ - int32_t sizeOfStruct; - - /* ------ 16 byte alignment boundary ----------- */ - - - /** - * (protected) Native index of the first character position following - * the current chunk. - * @stable ICU 3.6 - */ - int64_t chunkNativeLimit; - - /** - * (protected) Size in bytes of the extra space (pExtra). - * @stable ICU 3.4 - */ - int32_t extraSize; - - /** - * (protected) The highest chunk offset where native indexing and - * chunk (UTF-16) indexing correspond. For UTF-16 sources, value - * will be equal to chunkLength. - * - * @stable ICU 3.6 - */ - int32_t nativeIndexingLimit; - - /* ---- 16 byte alignment boundary------ */ - - /** - * (protected) Native index of the first character in the text chunk. - * @stable ICU 3.6 - */ - int64_t chunkNativeStart; - - /** - * (protected) Current iteration position within the text chunk (UTF-16 buffer). - * This is the index to the character that will be returned by utext_next32(). - * @stable ICU 3.6 - */ - int32_t chunkOffset; - - /** - * (protected) Length the text chunk (UTF-16 buffer), in UChars. - * @stable ICU 3.6 - */ - int32_t chunkLength; - - /* ---- 16 byte alignment boundary-- */ - - - /** - * (protected) pointer to a chunk of text in UTF-16 format. - * May refer either to original storage of the source of the text, or - * if conversion was required, to a buffer owned by the UText. - * @stable ICU 3.6 - */ - const UChar *chunkContents; - - /** - * (public) Pointer to Dispatch table for accessing functions for this UText. - * @stable ICU 3.6 - */ - UTextFuncs *pFuncs; - - /** - * (protected) Pointer to additional space requested by the - * text provider during the utext_open operation. - * @stable ICU 3.4 - */ - void *pExtra; - - /** - * (protected) Pointer to string or text-containin object or similar. - * This is the source of the text that this UText is wrapping, in a format - * that is known to the text provider functions. - * @stable ICU 3.4 - */ - const void *context; - - /* --- 16 byte alignment boundary--- */ - - /** - * (protected) Pointer fields available for use by the text provider. - * Not used by UText common code. - * @stable ICU 3.6 - */ - const void *p; - /** - * (protected) Pointer fields available for use by the text provider. - * Not used by UText common code. - * @stable ICU 3.6 - */ - const void *q; - /** - * (protected) Pointer fields available for use by the text provider. - * Not used by UText common code. - * @stable ICU 3.6 - */ - const void *r; - - /** - * Private field reserved for future use by the UText framework - * itself. This is not to be touched by the text providers. - * @internal ICU 3.4 - */ - void *privP; - - - /* --- 16 byte alignment boundary--- */ - - - /** - * (protected) Integer field reserved for use by the text provider. - * Not used by the UText framework, or by the client (user) of the UText. - * @stable ICU 3.4 - */ - int64_t a; - - /** - * (protected) Integer field reserved for use by the text provider. - * Not used by the UText framework, or by the client (user) of the UText. - * @stable ICU 3.4 - */ - int32_t b; - - /** - * (protected) Integer field reserved for use by the text provider. - * Not used by the UText framework, or by the client (user) of the UText. - * @stable ICU 3.4 - */ - int32_t c; - - /* ---- 16 byte alignment boundary---- */ - - - /** - * Private field reserved for future use by the UText framework - * itself. This is not to be touched by the text providers. - * @internal ICU 3.4 - */ - int64_t privA; - /** - * Private field reserved for future use by the UText framework - * itself. This is not to be touched by the text providers. - * @internal ICU 3.4 - */ - int32_t privB; - /** - * Private field reserved for future use by the UText framework - * itself. This is not to be touched by the text providers. - * @internal ICU 3.4 - */ - int32_t privC; -}; - - -/** - * Common function for use by Text Provider implementations to allocate and/or initialize - * a new UText struct. To be called in the implementation of utext_open() functions. - * If the supplied UText parameter is null, a new UText struct will be allocated on the heap. - * If the supplied UText is already open, the provider's close function will be called - * so that the struct can be reused by the open that is in progress. - * - * @param ut pointer to a UText struct to be re-used, or null if a new UText - * should be allocated. - * @param extraSpace The amount of additional space to be allocated as part - * of this UText, for use by types of providers that require - * additional storage. - * @param status Errors are returned here. - * @return pointer to the UText, allocated if necessary, with extra space set up if requested. - * @stable ICU 3.4 - */ -U_STABLE UText * U_EXPORT2 -utext_setup(UText *ut, int32_t extraSpace, UErrorCode *status); - -/** - * @internal - * Value used to help identify correctly initialized UText structs. - * Note: must be publicly visible so that UTEXT_INITIALIZER can access it. - */ -enum { - UTEXT_MAGIC = 0x345ad82c -}; - -/** - * initializer to be used with local (stack) instances of a UText - * struct. UText structs must be initialized before passing - * them to one of the utext_open functions. - * - * @stable ICU 3.6 - */ -#define UTEXT_INITIALIZER { \ - UTEXT_MAGIC, /* magic */ \ - 0, /* flags */ \ - 0, /* providerProps */ \ - sizeof(UText), /* sizeOfStruct */ \ - 0, /* chunkNativeLimit */ \ - 0, /* extraSize */ \ - 0, /* nativeIndexingLimit */ \ - 0, /* chunkNativeStart */ \ - 0, /* chunkOffset */ \ - 0, /* chunkLength */ \ - NULL, /* chunkContents */ \ - NULL, /* pFuncs */ \ - NULL, /* pExtra */ \ - NULL, /* context */ \ - NULL, NULL, NULL, /* p, q, r */ \ - NULL, /* privP */ \ - 0, 0, 0, /* a, b, c */ \ - 0, 0, 0 /* privA,B,C, */ \ - } - - -U_CDECL_END - - - -#endif |