src/third_party/icu/source/common/ucnv_cnv.h - cobalt - Git at Google

 /*
 **********************************************************************
 *   Copyright (C) 1999-2011, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *
 *   ucnv_cnv.h:
 *   Definitions for converter implementations.
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   05/09/00    helena      Added implementation to handle fallback mappings.
 *   06/29/2000  helena      Major rewrite of the callback APIs.
 */

 #ifndef UCNV_CNV_H
 #define UCNV_CNV_H

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_CONVERSION

 #include "unicode/ucnv.h"
 #include "unicode/ucnv_err.h"
 #include "unicode/uset.h"
 #include "uset_imp.h"

 U_CDECL_BEGIN

 /* this is used in fromUnicode DBCS tables as an "unassigned" marker */
 #define missingCharMarker 0xFFFF

 /*
  * #define missingUCharMarker 0xfffe
  *
  * commented out because there are actually two values used in toUnicode tables:
  * U+fffe "unassigned"
  * U+ffff "illegal"
  */

 /** Forward declaration, see ucnv_bld.h */
 struct UConverterSharedData;
 typedef struct UConverterSharedData UConverterSharedData;

 /* function types for UConverterImpl ---------------------------------------- */

 /* struct with arguments for UConverterLoad and ucnv_load() */
 typedef struct {
     int32_t size;               /* sizeof(UConverterLoadArgs) */
     int32_t nestedLoads;        /* count nested ucnv_load() calls */
     UBool onlyTestIsLoadable;   /* input: don't actually load */
     UBool reserved0;            /* reserved - for good alignment of the pointers */
     int16_t reserved;           /* reserved - for good alignment of the pointers */
     uint32_t options;
     const char *pkg, *name, *locale;
 } UConverterLoadArgs;

 #define UCNV_LOAD_ARGS_INITIALIZER \
     { (int32_t)sizeof(UConverterLoadArgs), 0, FALSE, FALSE, 0, 0, NULL, NULL, NULL }

 typedef void (*UConverterLoad) (UConverterSharedData *sharedData,
                                 UConverterLoadArgs *pArgs,
                                 const uint8_t *raw, UErrorCode *pErrorCode);
 typedef void (*UConverterUnload) (UConverterSharedData *sharedData);

 typedef void (*UConverterOpen) (UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *pErrorCode);
 typedef void (*UConverterClose) (UConverter *cnv);

 typedef enum UConverterResetChoice {
     UCNV_RESET_BOTH,
     UCNV_RESET_TO_UNICODE,
     UCNV_RESET_FROM_UNICODE
 } UConverterResetChoice;

 typedef void (*UConverterReset) (UConverter *cnv, UConverterResetChoice choice);

 /*
  * Converter implementation function(s) for ucnv_toUnicode().
  * If the toUnicodeWithOffsets function pointer is NULL,
  * then the toUnicode function will be used and the offsets will be set to -1.
  *
  * Must maintain state across buffers. Use toUBytes[toULength] for partial input
  * sequences; it will be checked in ucnv.c at the end of the input stream
  * to detect truncated input.
  * Some converters may need additional detection and may then set U_TRUNCATED_CHAR_FOUND.
  *
  * The toUnicodeWithOffsets must write exactly as many offset values as target
  * units. Write offset values of -1 for when the source index corresponding to
  * the output unit is not known (e.g., the character started in an earlier buffer).
  * The pArgs->offsets pointer need not be moved forward.
  *
  * At function return, either one of the following conditions must be true:
  * - U_BUFFER_OVERFLOW_ERROR and the target is full: target==targetLimit
  * - another error code with toUBytes[toULength] set to the offending input
  * - no error, and the source is consumed: source==sourceLimit
  *
  * The ucnv.c code will handle the end of the input (reset)
  * (reset, and truncation detection) and callbacks.
  */
 typedef void (*UConverterToUnicode) (UConverterToUnicodeArgs *, UErrorCode *);

 /*
  * Same rules as for UConverterToUnicode.
  * A lead surrogate is kept in fromUChar32 across buffers, and if an error
  * occurs, then the offending input code point must be put into fromUChar32
  * as well.
  */
 typedef void (*UConverterFromUnicode) (UConverterFromUnicodeArgs *, UErrorCode *);

 /*
  * Converter implementation function for ucnv_convertEx(), for direct conversion
  * between two charsets without pivoting through UTF-16.
  * The rules are the same as for UConverterToUnicode and UConverterFromUnicode.
  * In addition,
  * - The toUnicode side must behave and keep state exactly like the
  *   UConverterToUnicode implementation for the same source charset.
  * - A U_USING_DEFAULT_WARNING can be set to request to temporarily fall back
  *   to pivoting. When this function is called, the conversion framework makes
  *   sure that this warning is not set on input.
  * - Continuing a partial match and flushing the toUnicode replay buffer
  *   are handled by pivoting, using the toUnicode and fromUnicode functions.
  */
 typedef void (*UConverterConvert) (UConverterFromUnicodeArgs *pFromUArgs,
                                    UConverterToUnicodeArgs *pToUArgs,
                                    UErrorCode *pErrorCode);

 /*
  * Converter implementation function for ucnv_getNextUChar().
  * If the function pointer is NULL, then the toUnicode function will be used.
  *
  * Will be called at a character boundary (toULength==0).
  * May return with
  * - U_INDEX_OUTOFBOUNDS_ERROR if there was no output for the input
  *   (the return value will be ignored)
  * - U_TRUNCATED_CHAR_FOUND or another error code (never U_BUFFER_OVERFLOW_ERROR!)
  *   with toUBytes[toULength] set to the offending input
  *   (the return value will be ignored)
  * - return UCNV_GET_NEXT_UCHAR_USE_TO_U, without moving the source pointer,
  *   to indicate that the ucnv.c code shall call the toUnicode function instead
  * - return a real code point result
  *
  * Unless UCNV_GET_NEXT_UCHAR_USE_TO_U is returned, the source bytes must be consumed.
  *
  * The ucnv.c code will handle the end of the input (reset)
  * (except for truncation detection!) and callbacks.
  */
 typedef UChar32 (*UConverterGetNextUChar) (UConverterToUnicodeArgs *, UErrorCode *);

 typedef void (*UConverterGetStarters)(const UConverter* converter,
                                       UBool starters[256],
                                       UErrorCode *pErrorCode);

 /* If this function pointer is null or if the function returns null
  * the name field in static data struct should be returned by
  * ucnv_getName() API function
  */
 typedef const char * (*UConverterGetName) (const UConverter *cnv);

 /**
  * Write the codepage substitution character.
  * If this function is not set, then ucnv_cbFromUWriteSub() writes
  * the substitution character from UConverter.
  * For stateful converters, it is typically necessary to handle this
  * specificially for the converter in order to properly maintain the state.
  */
 typedef void (*UConverterWriteSub) (UConverterFromUnicodeArgs *pArgs, int32_t offsetIndex, UErrorCode *pErrorCode);

 /**
  * For converter-specific safeClone processing
  * If this function is not set, then ucnv_safeClone assumes that the converter has no private data that changes
  * after the converter is done opening.
  * If this function is set, then it is called just after a memcpy() of
  * converter data to the new, empty converter, and is expected to set up
  * the initial state of the converter.  It is not expected to increment the
  * reference counts of the standard data types such as the shared data.
  */
 typedef UConverter * (*UConverterSafeClone) (const UConverter   *cnv,
                                              void               *stackBuffer,
                                              int32_t            *pBufferSize,
                                              UErrorCode         *status);

 /**
  * Filters for some ucnv_getUnicodeSet() implementation code.
  */
 typedef enum UConverterSetFilter {
     UCNV_SET_FILTER_NONE,
     UCNV_SET_FILTER_DBCS_ONLY,
     UCNV_SET_FILTER_2022_CN,
     UCNV_SET_FILTER_SJIS,
     UCNV_SET_FILTER_GR94DBCS,
     UCNV_SET_FILTER_HZ,
     UCNV_SET_FILTER_COUNT
 } UConverterSetFilter;

 /**
  * Fills the set of Unicode code points that can be converted by an ICU converter.
  * The API function ucnv_getUnicodeSet() clears the USet before calling
  * the converter's getUnicodeSet() implementation; the converter should only
  * add the appropriate code points to allow recursive use.
  * For example, the ISO-2022-JP converter will call each subconverter's
  * getUnicodeSet() implementation to consecutively add code points to
  * the same USet, which will result in a union of the sets of all subconverters.
  *
  * For more documentation, see ucnv_getUnicodeSet() in ucnv.h.
  */
 typedef void (*UConverterGetUnicodeSet) (const UConverter *cnv,
                                          const USetAdder *sa,
                                          UConverterUnicodeSet which,
                                          UErrorCode *pErrorCode);

 UBool CONVERSION_U_SUCCESS (UErrorCode err);

 /**
  * UConverterImpl contains all the data and functions for a converter type.
  * Its function pointers work much like a C++ vtable.
  * Many converter types need to define only a subset of the functions;
  * when a function pointer is NULL, then a default action will be performed.
  *
  * Every converter type must implement toUnicode, fromUnicode, and getNextUChar,
  * otherwise the converter may crash.
  * Every converter type that has variable-length codepage sequences should
  * also implement toUnicodeWithOffsets and fromUnicodeWithOffsets for
  * correct offset handling.
  * All other functions may or may not be implemented - it depends only on
  * whether the converter type needs them.
  *
  * When open() fails, then close() will be called, if present.
  */
 struct UConverterImpl {
     UConverterType type;

     UConverterLoad load;
     UConverterUnload unload;

     UConverterOpen open;
     UConverterClose close;
     UConverterReset reset;

     UConverterToUnicode toUnicode;
     UConverterToUnicode toUnicodeWithOffsets;
     UConverterFromUnicode fromUnicode;
     UConverterFromUnicode fromUnicodeWithOffsets;
     UConverterGetNextUChar getNextUChar;

     UConverterGetStarters getStarters;
     UConverterGetName getName;
     UConverterWriteSub writeSub;
     UConverterSafeClone safeClone;
     UConverterGetUnicodeSet getUnicodeSet;

     UConverterConvert toUTF8;
     UConverterConvert fromUTF8;
 };

 extern const UConverterSharedData
     _MBCSData, _Latin1Data,
     _UTF8Data, _UTF16BEData, _UTF16LEData, _UTF32BEData, _UTF32LEData,
     _ISO2022Data,
     _LMBCSData1,_LMBCSData2, _LMBCSData3, _LMBCSData4, _LMBCSData5, _LMBCSData6,
     _LMBCSData8,_LMBCSData11,_LMBCSData16,_LMBCSData17,_LMBCSData18,_LMBCSData19,
     _HZData,_ISCIIData, _SCSUData, _ASCIIData,
     _UTF7Data, _Bocu1Data, _UTF16Data, _UTF32Data, _CESU8Data, _IMAPData, _CompoundTextData;

 U_CDECL_END

 /** Always use fallbacks from codepage to Unicode */
 #define TO_U_USE_FALLBACK(useFallback) TRUE
 #define UCNV_TO_U_USE_FALLBACK(cnv) TRUE

 /** Use fallbacks from Unicode to codepage when cnv->useFallback or for private-use code points */
 #define IS_PRIVATE_USE(c) ((uint32_t)((c)-0xe000)<0x1900 || (uint32_t)((c)-0xf0000)<0x20000)
 #define FROM_U_USE_FALLBACK(useFallback, c) ((useFallback) || IS_PRIVATE_USE(c))
 #define UCNV_FROM_U_USE_FALLBACK(cnv, c) FROM_U_USE_FALLBACK((cnv)->useFallback, c)

 /**
  * Magic number for ucnv_getNextUChar(), returned by a
  * getNextUChar() implementation to indicate to use the converter's toUnicode()
  * instead of the native function.
  * @internal
  */
 #define UCNV_GET_NEXT_UCHAR_USE_TO_U -9

 U_CFUNC void
 ucnv_getCompleteUnicodeSet(const UConverter *cnv,
                    const USetAdder *sa,
                    UConverterUnicodeSet which,
                    UErrorCode *pErrorCode);

 U_CFUNC void
 ucnv_getNonSurrogateUnicodeSet(const UConverter *cnv,
                                const USetAdder *sa,
                                UConverterUnicodeSet which,
                                UErrorCode *pErrorCode);

 U_CFUNC void
 ucnv_fromUWriteBytes(UConverter *cnv,
                      const char *bytes, int32_t length,
                      char **target, const char *targetLimit,
                      int32_t **offsets,
                      int32_t sourceIndex,
                      UErrorCode *pErrorCode);
 U_CFUNC void
 ucnv_toUWriteUChars(UConverter *cnv,
                     const UChar *uchars, int32_t length,
                     UChar **target, const UChar *targetLimit,
                     int32_t **offsets,
                     int32_t sourceIndex,
                     UErrorCode *pErrorCode);

 U_CFUNC void
 ucnv_toUWriteCodePoint(UConverter *cnv,
                        UChar32 c,
                        UChar **target, const UChar *targetLimit,
                        int32_t **offsets,
                        int32_t sourceIndex,
                        UErrorCode *pErrorCode);

 #endif

 #endif /* UCNV_CNV */
	/*
	**********************************************************************
	* Copyright (C) 1999-2011, International Business Machines
	* Corporation and others. All Rights Reserved.
	**********************************************************************
	*
	* ucnv_cnv.h:
	* Definitions for converter implementations.
	*
	* Modification History:
	*
	* Date Name Description
	* 05/09/00 helena Added implementation to handle fallback mappings.
	* 06/29/2000 helena Major rewrite of the callback APIs.
	*/

	#ifndef UCNV_CNV_H
	#define UCNV_CNV_H

	#include "unicode/utypes.h"

	#if !UCONFIG_NO_CONVERSION

	#include "unicode/ucnv.h"
	#include "unicode/ucnv_err.h"
	#include "unicode/uset.h"
	#include "uset_imp.h"

	U_CDECL_BEGIN

	/* this is used in fromUnicode DBCS tables as an "unassigned" marker */
	#define missingCharMarker 0xFFFF

	/*
	* #define missingUCharMarker 0xfffe
	*
	* commented out because there are actually two values used in toUnicode tables:
	* U+fffe "unassigned"
	* U+ffff "illegal"
	*/

	/** Forward declaration, see ucnv_bld.h */
	struct UConverterSharedData;
	typedef struct UConverterSharedData UConverterSharedData;

	/* function types for UConverterImpl ---------------------------------------- */

	/* struct with arguments for UConverterLoad and ucnv_load() */
	typedef struct {
	int32_t size; /* sizeof(UConverterLoadArgs) */
	int32_t nestedLoads; /* count nested ucnv_load() calls */
	UBool onlyTestIsLoadable; /* input: don't actually load */
	UBool reserved0; /* reserved - for good alignment of the pointers */
	int16_t reserved; /* reserved - for good alignment of the pointers */
	uint32_t options;
	const char pkg, name, *locale;
	} UConverterLoadArgs;

	#define UCNV_LOAD_ARGS_INITIALIZER \
	{ (int32_t)sizeof(UConverterLoadArgs), 0, FALSE, FALSE, 0, 0, NULL, NULL, NULL }

	typedef void (UConverterLoad) (UConverterSharedData sharedData,
	UConverterLoadArgs *pArgs,
	const uint8_t raw, UErrorCode pErrorCode);
	typedef void (UConverterUnload) (UConverterSharedData sharedData);

	typedef void (UConverterOpen) (UConverter cnv, UConverterLoadArgs pArgs, UErrorCode pErrorCode);
	typedef void (UConverterClose) (UConverter cnv);

	typedef enum UConverterResetChoice {
	UCNV_RESET_BOTH,
	UCNV_RESET_TO_UNICODE,
	UCNV_RESET_FROM_UNICODE
	} UConverterResetChoice;

	typedef void (UConverterReset) (UConverter cnv, UConverterResetChoice choice);

	/*
	* Converter implementation function(s) for ucnv_toUnicode().
	* If the toUnicodeWithOffsets function pointer is NULL,
	* then the toUnicode function will be used and the offsets will be set to -1.
	*
	* Must maintain state across buffers. Use toUBytes[toULength] for partial input
	* sequences; it will be checked in ucnv.c at the end of the input stream
	* to detect truncated input.
	* Some converters may need additional detection and may then set U_TRUNCATED_CHAR_FOUND.
	*
	* The toUnicodeWithOffsets must write exactly as many offset values as target
	* units. Write offset values of -1 for when the source index corresponding to
	* the output unit is not known (e.g., the character started in an earlier buffer).
	* The pArgs->offsets pointer need not be moved forward.
	*
	* At function return, either one of the following conditions must be true:
	* - U_BUFFER_OVERFLOW_ERROR and the target is full: target==targetLimit
	* - another error code with toUBytes[toULength] set to the offending input
	* - no error, and the source is consumed: source==sourceLimit
	*
	* The ucnv.c code will handle the end of the input (reset)
	* (reset, and truncation detection) and callbacks.
	*/
	typedef void (UConverterToUnicode) (UConverterToUnicodeArgs , UErrorCode *);

	/*
	* Same rules as for UConverterToUnicode.
	* A lead surrogate is kept in fromUChar32 across buffers, and if an error
	* occurs, then the offending input code point must be put into fromUChar32
	* as well.
	*/
	typedef void (UConverterFromUnicode) (UConverterFromUnicodeArgs , UErrorCode *);

	/*
	* Converter implementation function for ucnv_convertEx(), for direct conversion
	* between two charsets without pivoting through UTF-16.
	* The rules are the same as for UConverterToUnicode and UConverterFromUnicode.
	* In addition,
	* - The toUnicode side must behave and keep state exactly like the
	* UConverterToUnicode implementation for the same source charset.
	* - A U_USING_DEFAULT_WARNING can be set to request to temporarily fall back
	* to pivoting. When this function is called, the conversion framework makes
	* sure that this warning is not set on input.
	* - Continuing a partial match and flushing the toUnicode replay buffer
	* are handled by pivoting, using the toUnicode and fromUnicode functions.
	*/
	typedef void (UConverterConvert) (UConverterFromUnicodeArgs pFromUArgs,
	UConverterToUnicodeArgs *pToUArgs,
	UErrorCode *pErrorCode);

	/*
	* Converter implementation function for ucnv_getNextUChar().
	* If the function pointer is NULL, then the toUnicode function will be used.
	*
	* Will be called at a character boundary (toULength==0).
	* May return with
	* - U_INDEX_OUTOFBOUNDS_ERROR if there was no output for the input
	* (the return value will be ignored)
	* - U_TRUNCATED_CHAR_FOUND or another error code (never U_BUFFER_OVERFLOW_ERROR!)
	* with toUBytes[toULength] set to the offending input
	* (the return value will be ignored)
	* - return UCNV_GET_NEXT_UCHAR_USE_TO_U, without moving the source pointer,
	* to indicate that the ucnv.c code shall call the toUnicode function instead
	* - return a real code point result
	*
	* Unless UCNV_GET_NEXT_UCHAR_USE_TO_U is returned, the source bytes must be consumed.
	*
	* The ucnv.c code will handle the end of the input (reset)
	* (except for truncation detection!) and callbacks.
	*/
	typedef UChar32 (UConverterGetNextUChar) (UConverterToUnicodeArgs , UErrorCode *);

	typedef void (UConverterGetStarters)(const UConverter converter,
	UBool starters[256],
	UErrorCode *pErrorCode);

	/* If this function pointer is null or if the function returns null
	* the name field in static data struct should be returned by
	* ucnv_getName() API function
	*/
	typedef const char * (UConverterGetName) (const UConverter cnv);

	/**
	* Write the codepage substitution character.
	* If this function is not set, then ucnv_cbFromUWriteSub() writes
	* the substitution character from UConverter.
	* For stateful converters, it is typically necessary to handle this
	* specificially for the converter in order to properly maintain the state.
	*/
	typedef void (UConverterWriteSub) (UConverterFromUnicodeArgs pArgs, int32_t offsetIndex, UErrorCode *pErrorCode);

	/**
	* For converter-specific safeClone processing
	* If this function is not set, then ucnv_safeClone assumes that the converter has no private data that changes
	* after the converter is done opening.
	* If this function is set, then it is called just after a memcpy() of
	* converter data to the new, empty converter, and is expected to set up
	* the initial state of the converter. It is not expected to increment the
	* reference counts of the standard data types such as the shared data.
	*/
	typedef UConverter * (UConverterSafeClone) (const UConverter cnv,
	void *stackBuffer,
	int32_t *pBufferSize,
	UErrorCode *status);

	/**
	* Filters for some ucnv_getUnicodeSet() implementation code.
	*/
	typedef enum UConverterSetFilter {
	UCNV_SET_FILTER_NONE,
	UCNV_SET_FILTER_DBCS_ONLY,
	UCNV_SET_FILTER_2022_CN,
	UCNV_SET_FILTER_SJIS,
	UCNV_SET_FILTER_GR94DBCS,
	UCNV_SET_FILTER_HZ,
	UCNV_SET_FILTER_COUNT
	} UConverterSetFilter;

	/**
	* Fills the set of Unicode code points that can be converted by an ICU converter.
	* The API function ucnv_getUnicodeSet() clears the USet before calling
	* the converter's getUnicodeSet() implementation; the converter should only
	* add the appropriate code points to allow recursive use.
	* For example, the ISO-2022-JP converter will call each subconverter's
	* getUnicodeSet() implementation to consecutively add code points to
	* the same USet, which will result in a union of the sets of all subconverters.
	*
	* For more documentation, see ucnv_getUnicodeSet() in ucnv.h.
	*/
	typedef void (UConverterGetUnicodeSet) (const UConverter cnv,
	const USetAdder *sa,
	UConverterUnicodeSet which,
	UErrorCode *pErrorCode);

	UBool CONVERSION_U_SUCCESS (UErrorCode err);

	/**
	* UConverterImpl contains all the data and functions for a converter type.
	* Its function pointers work much like a C++ vtable.
	* Many converter types need to define only a subset of the functions;
	* when a function pointer is NULL, then a default action will be performed.
	*
	* Every converter type must implement toUnicode, fromUnicode, and getNextUChar,
	* otherwise the converter may crash.
	* Every converter type that has variable-length codepage sequences should
	* also implement toUnicodeWithOffsets and fromUnicodeWithOffsets for
	* correct offset handling.
	* All other functions may or may not be implemented - it depends only on
	* whether the converter type needs them.
	*
	* When open() fails, then close() will be called, if present.
	*/
	struct UConverterImpl {
	UConverterType type;

	UConverterLoad load;
	UConverterUnload unload;

	UConverterOpen open;
	UConverterClose close;
	UConverterReset reset;

	UConverterToUnicode toUnicode;
	UConverterToUnicode toUnicodeWithOffsets;
	UConverterFromUnicode fromUnicode;
	UConverterFromUnicode fromUnicodeWithOffsets;
	UConverterGetNextUChar getNextUChar;

	UConverterGetStarters getStarters;
	UConverterGetName getName;
	UConverterWriteSub writeSub;
	UConverterSafeClone safeClone;
	UConverterGetUnicodeSet getUnicodeSet;

	UConverterConvert toUTF8;
	UConverterConvert fromUTF8;
	};

	extern const UConverterSharedData
	_MBCSData, _Latin1Data,
	_UTF8Data, _UTF16BEData, _UTF16LEData, _UTF32BEData, _UTF32LEData,
	_ISO2022Data,
	_LMBCSData1,_LMBCSData2, _LMBCSData3, _LMBCSData4, _LMBCSData5, _LMBCSData6,
	_LMBCSData8,_LMBCSData11,_LMBCSData16,_LMBCSData17,_LMBCSData18,_LMBCSData19,
	_HZData,_ISCIIData, _SCSUData, _ASCIIData,
	_UTF7Data, _Bocu1Data, _UTF16Data, _UTF32Data, _CESU8Data, _IMAPData, _CompoundTextData;

	U_CDECL_END

	/** Always use fallbacks from codepage to Unicode */
	#define TO_U_USE_FALLBACK(useFallback) TRUE
	#define UCNV_TO_U_USE_FALLBACK(cnv) TRUE

	/** Use fallbacks from Unicode to codepage when cnv->useFallback or for private-use code points */
	#define IS_PRIVATE_USE(c) ((uint32_t)((c)-0xe000)<0x1900 \|\| (uint32_t)((c)-0xf0000)<0x20000)
	#define FROM_U_USE_FALLBACK(useFallback, c) ((useFallback) \|\| IS_PRIVATE_USE(c))
	#define UCNV_FROM_U_USE_FALLBACK(cnv, c) FROM_U_USE_FALLBACK((cnv)->useFallback, c)

	/**
	* Magic number for ucnv_getNextUChar(), returned by a
	* getNextUChar() implementation to indicate to use the converter's toUnicode()
	* instead of the native function.
	* @internal
	*/
	#define UCNV_GET_NEXT_UCHAR_USE_TO_U -9

	U_CFUNC void
	ucnv_getCompleteUnicodeSet(const UConverter *cnv,
	const USetAdder *sa,
	UConverterUnicodeSet which,
	UErrorCode *pErrorCode);

	U_CFUNC void
	ucnv_getNonSurrogateUnicodeSet(const UConverter *cnv,
	const USetAdder *sa,
	UConverterUnicodeSet which,
	UErrorCode *pErrorCode);

	U_CFUNC void
	ucnv_fromUWriteBytes(UConverter *cnv,
	const char *bytes, int32_t length,
	char *target, const char targetLimit,
	int32_t **offsets,
	int32_t sourceIndex,
	UErrorCode *pErrorCode);
	U_CFUNC void
	ucnv_toUWriteUChars(UConverter *cnv,
	const UChar *uchars, int32_t length,
	UChar *target, const UChar targetLimit,
	int32_t **offsets,
	int32_t sourceIndex,
	UErrorCode *pErrorCode);

	U_CFUNC void
	ucnv_toUWriteCodePoint(UConverter *cnv,
	UChar32 c,
	UChar *target, const UChar targetLimit,
	int32_t **offsets,
	int32_t sourceIndex,
	UErrorCode *pErrorCode);

	#endif

	#endif /* UCNV_CNV */