[apple/icu.git] / icuSources / common / udataswp.h

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   Copyright (C) 2003-2014, International Business Machines
*   Corporation and others.  All Rights Reserved.
*
*******************************************************************************
*   file name:  udataswp.h
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2003jun05
*   created by: Markus W. Scherer
*
*   Definitions for ICU data transformations for different platforms,
*   changing between big- and little-endian data and/or between
*   charset families (ASCII<->EBCDIC).
*/

#ifndef __UDATASWP_H__
#define __UDATASWP_H__

#include <stdarg.h>
#include "unicode/utypes.h"

/* forward declaration */

U_CDECL_BEGIN

struct UDataSwapper;
typedef struct UDataSwapper UDataSwapper;

/**
 * Function type for data transformation.
 * Transforms data, or just returns the length of the data if
 * the input length is -1.
 * Swap functions assume that their data pointers are aligned properly.
 *
 * Quick implementation outline:
 * (best to copy and adapt and existing swapper implementation)
 * check that the data looks like the expected format
 * if(length<0) {
 *   preflight:
 *   never dereference outData
 *   read inData and determine the data size
 *   assume that inData is long enough for this
 * } else {
 *   outData can be NULL if length==0
 *   inData==outData (in-place swapping) possible but not required!
 *   verify that length>=(actual size)
 *   if there is a chance that not every byte up to size is reached
 *     due to padding etc.:
 *   if(inData!=outData) {
 *     memcpy(outData, inData, actual size);
 *   }
 *   swap contents
 * }
 * return actual size
 *
 * Further implementation notes:
 * - read integers from inData before swapping them
 *   because in-place swapping can make them unreadable
 * - compareInvChars compares a local Unicode string with already-swapped
 *   output charset strings
 *
 * @param ds Pointer to UDataSwapper containing global data about the
 *           transformation and function pointers for handling primitive
 *           types.
 * @param inData Pointer to the input data to be transformed or examined.
 * @param length Length of the data, counting bytes. May be -1 for preflighting.
 *               If length>=0, then transform the data.
 *               If length==-1, then only determine the length of the data.
 *               The length cannot be determined from the data itself for all
 *               types of data (e.g., not for simple arrays of integers).
 * @param outData Pointer to the output data buffer.
 *                If length>=0 (transformation), then the output buffer must
 *                have a capacity of at least length.
 *                If length==-1, then outData will not be used and can be NULL.
 * @param pErrorCode ICU UErrorCode parameter, must not be NULL and must
 *                   fulfill U_SUCCESS on input.
 * @return The actual length of the data.
 *
 * @see UDataSwapper
 * @internal ICU 2.8
 */
typedef int32_t U_CALLCONV
UDataSwapFn(const UDataSwapper *ds,
            const void *inData, int32_t length, void *outData,
            UErrorCode *pErrorCode);

/**
 * Convert one uint16_t from input to platform endianness.
 * @internal ICU 2.8
 */
typedef uint16_t U_CALLCONV
UDataReadUInt16(uint16_t x);

/**
 * Convert one uint32_t from input to platform endianness.
 * @internal ICU 2.8
 */
typedef uint32_t U_CALLCONV
UDataReadUInt32(uint32_t x);

/**
 * Convert one uint16_t from platform to input endianness.
 * @internal ICU 2.8
 */
typedef void U_CALLCONV
UDataWriteUInt16(uint16_t *p, uint16_t x);

/**
 * Convert one uint32_t from platform to input endianness.
 * @internal ICU 2.8
 */
typedef void U_CALLCONV
UDataWriteUInt32(uint32_t *p, uint32_t x);

/**
 * Compare invariant-character strings, one in the output data and the
 * other one caller-provided in Unicode.
 * An output data string is compared because strings are usually swapped
 * before the rest of the data, to allow for sorting of string tables
 * according to the output charset.
 * You can use -1 for the length parameters of NUL-terminated strings as usual.
 * Returns Unicode code point order for invariant characters.
 * @internal ICU 2.8
 */
typedef int32_t U_CALLCONV
UDataCompareInvChars(const UDataSwapper *ds,
                     const char *outString, int32_t outLength,
                     const UChar *localString, int32_t localLength);

/**
 * Function for message output when an error occurs during data swapping.
 * A format string and variable number of arguments are passed
 * like for vprintf().
 *
 * @param context A function-specific context pointer.
 * @param fmt The format string.
 * @param args The arguments for format string inserts.
 *
 * @internal ICU 2.8
 */
typedef void U_CALLCONV
UDataPrintError(void *context, const char *fmt, va_list args);

struct UDataSwapper {
    /** Input endianness. @internal ICU 2.8 */
    UBool inIsBigEndian;
    /** Input charset family. @see U_CHARSET_FAMILY @internal ICU 2.8 */
    uint8_t inCharset;
    /** Output endianness. @internal ICU 2.8 */
    UBool outIsBigEndian;
    /** Output charset family. @see U_CHARSET_FAMILY @internal ICU 2.8 */
    uint8_t outCharset;

    /* basic functions for reading data values */

    /** Convert one uint16_t from input to platform endianness. @internal ICU 2.8 */
    UDataReadUInt16 *readUInt16;
    /** Convert one uint32_t from input to platform endianness. @internal ICU 2.8 */
    UDataReadUInt32 *readUInt32;
    /** Compare an invariant-character output string with a local one. @internal ICU 2.8 */
    UDataCompareInvChars *compareInvChars;

    /* basic functions for writing data values */

    /** Convert one uint16_t from platform to input endianness. @internal ICU 2.8 */
    UDataWriteUInt16 *writeUInt16;
    /** Convert one uint32_t from platform to input endianness. @internal ICU 2.8 */
    UDataWriteUInt32 *writeUInt32;

    /* basic functions for data transformations */

    /** Transform an array of 16-bit integers. @internal ICU 2.8 */
    UDataSwapFn *swapArray16;
    /** Transform an array of 32-bit integers. @internal ICU 2.8 */
    UDataSwapFn *swapArray32;
    /** Transform an array of 64-bit integers. @internal ICU 53 */
    UDataSwapFn *swapArray64;
    /** Transform an invariant-character string. @internal ICU 2.8 */
    UDataSwapFn *swapInvChars;

    /**
     * Function for message output when an error occurs during data swapping.
     * Can be NULL.
     * @internal ICU 2.8
     */
    UDataPrintError *printError;
    /** Context pointer for printError. @internal ICU 2.8 */
    void *printErrorContext;
};

U_CDECL_END

U_CAPI UDataSwapper * U_EXPORT2
udata_openSwapper(UBool inIsBigEndian, uint8_t inCharset,
                  UBool outIsBigEndian, uint8_t outCharset,
                  UErrorCode *pErrorCode);

/**
 * Open a UDataSwapper for the given input data and the specified output
 * characteristics.
 * Values of -1 for any of the characteristics mean the local platform's
 * characteristics.
 *
 * @see udata_swap
 * @internal ICU 2.8
 */
U_CAPI UDataSwapper * U_EXPORT2
udata_openSwapperForInputData(const void *data, int32_t length,
                              UBool outIsBigEndian, uint8_t outCharset,
                              UErrorCode *pErrorCode);

U_CAPI void U_EXPORT2
udata_closeSwapper(UDataSwapper *ds);

/**
 * Read the beginning of an ICU data piece, recognize magic bytes,
 * swap the structure.
 * Set a U_UNSUPPORTED_ERROR if it does not look like an ICU data piece.
 *
 * @return The size of the data header, in bytes.
 *
 * @internal ICU 2.8
 */
U_CAPI int32_t U_EXPORT2
udata_swapDataHeader(const UDataSwapper *ds,
                     const void *inData, int32_t length, void *outData,
                     UErrorCode *pErrorCode);

/**
 * Convert one int16_t from input to platform endianness.
 * @internal ICU 2.8
 */
U_CAPI int16_t U_EXPORT2
udata_readInt16(const UDataSwapper *ds, int16_t x);

/**
 * Convert one int32_t from input to platform endianness.
 * @internal ICU 2.8
 */
U_CAPI int32_t U_EXPORT2
udata_readInt32(const UDataSwapper *ds, int32_t x);

/**
 * Swap a block of invariant, NUL-terminated strings, but not padding
 * bytes after the last string.
 * @internal
 */
U_CAPI int32_t U_EXPORT2
udata_swapInvStringBlock(const UDataSwapper *ds,
                         const void *inData, int32_t length, void *outData,
                         UErrorCode *pErrorCode);

U_CAPI void U_EXPORT2
udata_printError(const UDataSwapper *ds,
                 const char *fmt,
                 ...);

/* internal exports from putil.c -------------------------------------------- */

/* declared here to keep them out of the public putil.h */

/**
 * Swap invariant char * strings ASCII->EBCDIC.
 * @internal
 */
U_CAPI int32_t U_EXPORT2
uprv_ebcdicFromAscii(const UDataSwapper *ds,
                     const void *inData, int32_t length, void *outData,
                     UErrorCode *pErrorCode);

/**
 * Copy invariant ASCII char * strings and verify they are invariant.
 * @internal
 */
U_CFUNC int32_t
uprv_copyAscii(const UDataSwapper *ds,
               const void *inData, int32_t length, void *outData,
               UErrorCode *pErrorCode);

/**
 * Swap invariant char * strings EBCDIC->ASCII.
 * @internal
 */
U_CFUNC int32_t
uprv_asciiFromEbcdic(const UDataSwapper *ds,
                     const void *inData, int32_t length, void *outData,
                     UErrorCode *pErrorCode);

/**
 * Copy invariant EBCDIC char * strings and verify they are invariant.
 * @internal
 */
U_CFUNC int32_t
uprv_copyEbcdic(const UDataSwapper *ds,
                const void *inData, int32_t length, void *outData,
                UErrorCode *pErrorCode);

/**
 * Compare ASCII invariant char * with Unicode invariant UChar *
 * @internal
 */
U_CFUNC int32_t
uprv_compareInvAscii(const UDataSwapper *ds,
                     const char *outString, int32_t outLength,
                     const UChar *localString, int32_t localLength);

/**
 * Compare EBCDIC invariant char * with Unicode invariant UChar *
 * @internal
 */
U_CFUNC int32_t
uprv_compareInvEbcdic(const UDataSwapper *ds,
                      const char *outString, int32_t outLength,
                      const UChar *localString, int32_t localLength);

/**
 * \def uprv_compareInvWithUChar
 * Compare an invariant-character strings with a UChar string
 * @internal
 */
#if U_CHARSET_FAMILY==U_ASCII_FAMILY
#   define uprv_compareInvWithUChar uprv_compareInvAscii
#elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
#   define uprv_compareInvWithUChar uprv_compareInvEbcdic
#else
#   error Unknown charset family!
#endif

// utrie_swap.cpp -----------------------------------------------------------***

/**
 * Swaps a serialized UTrie.
 * @internal
 */
U_CAPI int32_t U_EXPORT2
utrie_swap(const UDataSwapper *ds,
           const void *inData, int32_t length, void *outData,
           UErrorCode *pErrorCode);

/**
 * Swaps a serialized UTrie2.
 * @internal
 */
U_CAPI int32_t U_EXPORT2
utrie2_swap(const UDataSwapper *ds,
            const void *inData, int32_t length, void *outData,
            UErrorCode *pErrorCode);

/**
 * Swaps a serialized UCPTrie.
 * @internal
 */
U_CAPI int32_t U_EXPORT2
ucptrie_swap(const UDataSwapper *ds,
             const void *inData, int32_t length, void *outData,
             UErrorCode *pErrorCode);

/**
 * Swaps a serialized UTrie, UTrie2, or UCPTrie.
 * @internal
 */
U_CAPI int32_t U_EXPORT2
utrie_swapAnyVersion(const UDataSwapper *ds,
                     const void *inData, int32_t length, void *outData,
                     UErrorCode *pErrorCode);

/* material... -------------------------------------------------------------- */

#if 0

/* udata.h */

/**
 * Public API function in udata.c
 *
 * Same as udata_openChoice() but automatically swaps the data.
 * isAcceptable, if not NULL, may accept data with endianness and charset family
 * different from the current platform's properties.
 * If the data is acceptable and the platform properties do not match, then
 * the swap function is called to swap an allocated version of the data.
 * Preflighting may or may not be performed depending on whether the size of
 * the loaded data item is known.
 *
 * @param isAcceptable Same as for udata_openChoice(). May be NULL.
 *
 * @internal ICU 2.8
 */
U_CAPI UDataMemory * U_EXPORT2
udata_openSwap(const char *path, const char *type, const char *name,
               UDataMemoryIsAcceptable *isAcceptable, void *isAcceptableContext,
               UDataSwapFn *swap,
               UDataPrintError *printError, void *printErrorContext,
               UErrorCode *pErrorCode);

#endif

#endif
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
374ca955 A	3	/*
	4	*******************************************************************************
	5	*
57a6839d	6	* Copyright (C) 2003-2014, International Business Machines
374ca955 A	7	* Corporation and others. All Rights Reserved.
	8	*
	9	*******************************************************************************
	10	* file name: udataswp.h
f3c0d7a5	11	* encoding: UTF-8
374ca955 A	12	* tab size: 8 (not used)
	13	* indentation:4
	14	*
	15	* created on: 2003jun05
	16	* created by: Markus W. Scherer
	17	*
	18	* Definitions for ICU data transformations for different platforms,
	19	* changing between big- and little-endian data and/or between
	20	* charset families (ASCII<->EBCDIC).
	21	*/
	22
	23	#ifndef __UDATASWP_H__
	24	#define __UDATASWP_H__
	25
	26	#include <stdarg.h>
	27	#include "unicode/utypes.h"
	28
	29	/* forward declaration */
	30
	31	U_CDECL_BEGIN
	32
	33	struct UDataSwapper;
	34	typedef struct UDataSwapper UDataSwapper;
	35
	36	/**
	37	* Function type for data transformation.
	38	* Transforms data, or just returns the length of the data if
	39	* the input length is -1.
	40	* Swap functions assume that their data pointers are aligned properly.
	41	*
	42	* Quick implementation outline:
	43	* (best to copy and adapt and existing swapper implementation)
	44	* check that the data looks like the expected format
	45	* if(length<0) {
	46	* preflight:
	47	* never dereference outData
	48	* read inData and determine the data size
	49	* assume that inData is long enough for this
	50	* } else {
	51	* outData can be NULL if length==0
	52	* inData==outData (in-place swapping) possible but not required!
	53	* verify that length>=(actual size)
	54	* if there is a chance that not every byte up to size is reached
	55	* due to padding etc.:
	56	* if(inData!=outData) {
	57	* memcpy(outData, inData, actual size);
	58	* }
	59	* swap contents
	60	* }
	61	* return actual size
	62	*
	63	* Further implementation notes:
	64	* - read integers from inData before swapping them
	65	* because in-place swapping can make them unreadable
	66	* - compareInvChars compares a local Unicode string with already-swapped
	67	* output charset strings
	68	*
	69	* @param ds Pointer to UDataSwapper containing global data about the
	70	* transformation and function pointers for handling primitive
	71	* types.
	72	* @param inData Pointer to the input data to be transformed or examined.
	73	* @param length Length of the data, counting bytes. May be -1 for preflighting.
	74	* If length>=0, then transform the data.
	75	* If length==-1, then only determine the length of the data.
76	* The length cannot be determined from the data itself for all
77	* types of data (e.g., not for simple arrays of integers).
78	* @param outData Pointer to the output data buffer.
79	* If length>=0 (transformation), then the output buffer must
80	* have a capacity of at least length.
81	* If length==-1, then outData will not be used and can be NULL.
82	* @param pErrorCode ICU UErrorCode parameter, must not be NULL and must
83	* fulfill U_SUCCESS on input.
84	* @return The actual length of the data.
85	*
86	* @see UDataSwapper
73c04bcf	87	* @internal ICU 2.8
374ca955 A	88	*/
	89	typedef int32_t U_CALLCONV
	90	UDataSwapFn(const UDataSwapper *ds,
	91	const void inData, int32_t length, void outData,
	92	UErrorCode *pErrorCode);
	93
	94	/**
	95	* Convert one uint16_t from input to platform endianness.
73c04bcf	96	* @internal ICU 2.8
374ca955 A	97	*/
	98	typedef uint16_t U_CALLCONV
	99	UDataReadUInt16(uint16_t x);
	100
	101	/**
	102	* Convert one uint32_t from input to platform endianness.
73c04bcf	103	* @internal ICU 2.8
374ca955 A	104	*/
	105	typedef uint32_t U_CALLCONV
	106	UDataReadUInt32(uint32_t x);
	107
	108	/**
	109	* Convert one uint16_t from platform to input endianness.
73c04bcf	110	* @internal ICU 2.8
374ca955 A	111	*/
	112	typedef void U_CALLCONV
	113	UDataWriteUInt16(uint16_t *p, uint16_t x);
	114
	115	/**
	116	* Convert one uint32_t from platform to input endianness.
73c04bcf	117	* @internal ICU 2.8
374ca955 A	118	*/
	119	typedef void U_CALLCONV
	120	UDataWriteUInt32(uint32_t *p, uint32_t x);
	121
	122	/**
	123	* Compare invariant-character strings, one in the output data and the
	124	* other one caller-provided in Unicode.
	125	* An output data string is compared because strings are usually swapped
	126	* before the rest of the data, to allow for sorting of string tables
	127	* according to the output charset.
	128	* You can use -1 for the length parameters of NUL-terminated strings as usual.
	129	* Returns Unicode code point order for invariant characters.
73c04bcf	130	* @internal ICU 2.8
374ca955 A	131	*/
	132	typedef int32_t U_CALLCONV
	133	UDataCompareInvChars(const UDataSwapper *ds,
	134	const char *outString, int32_t outLength,
	135	const UChar *localString, int32_t localLength);
	136
	137	/**
	138	* Function for message output when an error occurs during data swapping.
	139	* A format string and variable number of arguments are passed
	140	* like for vprintf().
	141	*
	142	* @param context A function-specific context pointer.
	143	* @param fmt The format string.
	144	* @param args The arguments for format string inserts.
	145	*
73c04bcf	146	* @internal ICU 2.8
374ca955 A	147	*/
	148	typedef void U_CALLCONV
	149	UDataPrintError(void context, const char fmt, va_list args);
	150
	151	struct UDataSwapper {
73c04bcf	152	/** Input endianness. @internal ICU 2.8 */
374ca955	153	UBool inIsBigEndian;
73c04bcf	154	/** Input charset family. @see U_CHARSET_FAMILY @internal ICU 2.8 */
374ca955	155	uint8_t inCharset;
73c04bcf	156	/** Output endianness. @internal ICU 2.8 */
374ca955	157	UBool outIsBigEndian;
73c04bcf	158	/** Output charset family. @see U_CHARSET_FAMILY @internal ICU 2.8 */
374ca955 A	159	uint8_t outCharset;
	160
	161	/* basic functions for reading data values */
	162
73c04bcf	163	/** Convert one uint16_t from input to platform endianness. @internal ICU 2.8 */
374ca955	164	UDataReadUInt16 *readUInt16;
73c04bcf	165	/** Convert one uint32_t from input to platform endianness. @internal ICU 2.8 */
374ca955	166	UDataReadUInt32 *readUInt32;
73c04bcf	167	/** Compare an invariant-character output string with a local one. @internal ICU 2.8 */
374ca955 A	168	UDataCompareInvChars *compareInvChars;
	169
	170	/* basic functions for writing data values */
	171
73c04bcf	172	/** Convert one uint16_t from platform to input endianness. @internal ICU 2.8 */
374ca955	173	UDataWriteUInt16 *writeUInt16;
73c04bcf	174	/** Convert one uint32_t from platform to input endianness. @internal ICU 2.8 */
374ca955 A	175	UDataWriteUInt32 *writeUInt32;
	176
	177	/* basic functions for data transformations */
	178
73c04bcf	179	/** Transform an array of 16-bit integers. @internal ICU 2.8 */
374ca955	180	UDataSwapFn *swapArray16;
73c04bcf	181	/** Transform an array of 32-bit integers. @internal ICU 2.8 */
374ca955	182	UDataSwapFn *swapArray32;
57a6839d A	183	/** Transform an array of 64-bit integers. @internal ICU 53 */
57a6839d A	184	UDataSwapFn *swapArray64;
73c04bcf	185	/** Transform an invariant-character string. @internal ICU 2.8 */
374ca955 A	186	UDataSwapFn *swapInvChars;
	187
	188	/**
	189	* Function for message output when an error occurs during data swapping.
	190	* Can be NULL.
73c04bcf	191	* @internal ICU 2.8
374ca955 A	192	*/
374ca955 A	193	UDataPrintError *printError;
73c04bcf	194	/** Context pointer for printError. @internal ICU 2.8 */
374ca955 A	195	void *printErrorContext;
	196	};
	197
	198	U_CDECL_END
	199
	200	U_CAPI UDataSwapper * U_EXPORT2
	201	udata_openSwapper(UBool inIsBigEndian, uint8_t inCharset,
	202	UBool outIsBigEndian, uint8_t outCharset,
	203	UErrorCode *pErrorCode);
	204
	205	/**
	206	* Open a UDataSwapper for the given input data and the specified output
	207	* characteristics.
	208	* Values of -1 for any of the characteristics mean the local platform's
	209	* characteristics.
	210	*
	211	* @see udata_swap
73c04bcf	212	* @internal ICU 2.8
374ca955 A	213	*/
	214	U_CAPI UDataSwapper * U_EXPORT2
	215	udata_openSwapperForInputData(const void *data, int32_t length,
	216	UBool outIsBigEndian, uint8_t outCharset,
	217	UErrorCode *pErrorCode);
	218
	219	U_CAPI void U_EXPORT2
	220	udata_closeSwapper(UDataSwapper *ds);
	221
	222	/**
	223	* Read the beginning of an ICU data piece, recognize magic bytes,
	224	* swap the structure.
	225	* Set a U_UNSUPPORTED_ERROR if it does not look like an ICU data piece.
	226	*
	227	* @return The size of the data header, in bytes.
	228	*
73c04bcf	229	* @internal ICU 2.8
374ca955 A	230	*/
	231	U_CAPI int32_t U_EXPORT2
	232	udata_swapDataHeader(const UDataSwapper *ds,
	233	const void inData, int32_t length, void outData,
	234	UErrorCode *pErrorCode);
	235
	236	/**
	237	* Convert one int16_t from input to platform endianness.
73c04bcf	238	* @internal ICU 2.8
374ca955 A	239	*/
	240	U_CAPI int16_t U_EXPORT2
	241	udata_readInt16(const UDataSwapper *ds, int16_t x);
	242
	243	/**
	244	* Convert one int32_t from input to platform endianness.
73c04bcf	245	* @internal ICU 2.8
374ca955 A	246	*/
	247	U_CAPI int32_t U_EXPORT2
	248	udata_readInt32(const UDataSwapper *ds, int32_t x);
	249
	250	/**
	251	* Swap a block of invariant, NUL-terminated strings, but not padding
	252	* bytes after the last string.
	253	* @internal
	254	*/
	255	U_CAPI int32_t U_EXPORT2
	256	udata_swapInvStringBlock(const UDataSwapper *ds,
	257	const void inData, int32_t length, void outData,
	258	UErrorCode *pErrorCode);
	259
	260	U_CAPI void U_EXPORT2
	261	udata_printError(const UDataSwapper *ds,
	262	const char *fmt,
	263	...);
	264
	265	/* internal exports from putil.c -------------------------------------------- */
	266
	267	/* declared here to keep them out of the public putil.h */
	268
	269	/**
	270	* Swap invariant char * strings ASCII->EBCDIC.
	271	* @internal
	272	*/
73c04bcf	273	U_CAPI int32_t U_EXPORT2
374ca955 A	274	uprv_ebcdicFromAscii(const UDataSwapper *ds,
	275	const void inData, int32_t length, void outData,
	276	UErrorCode *pErrorCode);
	277
	278	/**
	279	* Copy invariant ASCII char * strings and verify they are invariant.
	280	* @internal
	281	*/
	282	U_CFUNC int32_t
	283	uprv_copyAscii(const UDataSwapper *ds,
	284	const void inData, int32_t length, void outData,
	285	UErrorCode *pErrorCode);
	286
	287	/**
	288	* Swap invariant char * strings EBCDIC->ASCII.
	289	* @internal
	290	*/
	291	U_CFUNC int32_t
	292	uprv_asciiFromEbcdic(const UDataSwapper *ds,
	293	const void inData, int32_t length, void outData,
	294	UErrorCode *pErrorCode);
	295
	296	/**
	297	* Copy invariant EBCDIC char * strings and verify they are invariant.
	298	* @internal
	299	*/
	300	U_CFUNC int32_t
	301	uprv_copyEbcdic(const UDataSwapper *ds,
	302	const void inData, int32_t length, void outData,
	303	UErrorCode *pErrorCode);
	304
	305	/**
	306	* Compare ASCII invariant char * with Unicode invariant UChar *
	307	* @internal
	308	*/
	309	U_CFUNC int32_t
	310	uprv_compareInvAscii(const UDataSwapper *ds,
	311	const char *outString, int32_t outLength,
	312	const UChar *localString, int32_t localLength);
	313
	314	/**
	315	* Compare EBCDIC invariant char * with Unicode invariant UChar *
	316	* @internal
	317	*/
	318	U_CFUNC int32_t
	319	uprv_compareInvEbcdic(const UDataSwapper *ds,
	320	const char *outString, int32_t outLength,
	321	const UChar *localString, int32_t localLength);
	322
f3c0d7a5 A	323	/**
	324	* \def uprv_compareInvWithUChar
	325	* Compare an invariant-character strings with a UChar string
	326	* @internal
	327	*/
	328	#if U_CHARSET_FAMILY==U_ASCII_FAMILY
	329	# define uprv_compareInvWithUChar uprv_compareInvAscii
	330	#elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
	331	# define uprv_compareInvWithUChar uprv_compareInvEbcdic
	332	#else
	333	# error Unknown charset family!
	334	#endif
	335
3d1f044b A	336	// utrie_swap.cpp -----------------------------------------------------------***
	337
	338	/**
	339	* Swaps a serialized UTrie.
	340	* @internal
	341	*/
	342	U_CAPI int32_t U_EXPORT2
	343	utrie_swap(const UDataSwapper *ds,
	344	const void inData, int32_t length, void outData,
	345	UErrorCode *pErrorCode);
	346
	347	/**
	348	* Swaps a serialized UTrie2.
	349	* @internal
	350	*/
	351	U_CAPI int32_t U_EXPORT2
	352	utrie2_swap(const UDataSwapper *ds,
	353	const void inData, int32_t length, void outData,
	354	UErrorCode *pErrorCode);
	355
	356	/**
	357	* Swaps a serialized UCPTrie.
	358	* @internal
	359	*/
	360	U_CAPI int32_t U_EXPORT2
	361	ucptrie_swap(const UDataSwapper *ds,
	362	const void inData, int32_t length, void outData,
	363	UErrorCode *pErrorCode);
	364
	365	/**
	366	* Swaps a serialized UTrie, UTrie2, or UCPTrie.
	367	* @internal
	368	*/
	369	U_CAPI int32_t U_EXPORT2
	370	utrie_swapAnyVersion(const UDataSwapper *ds,
	371	const void inData, int32_t length, void outData,
	372	UErrorCode *pErrorCode);
f3c0d7a5	373
374ca955 A	374	/* material... -------------------------------------------------------------- */
	375
	376	#if 0
	377
	378	/* udata.h */
	379
	380	/**
	381	* Public API function in udata.c
	382	*
	383	* Same as udata_openChoice() but automatically swaps the data.
	384	* isAcceptable, if not NULL, may accept data with endianness and charset family
	385	* different from the current platform's properties.
	386	* If the data is acceptable and the platform properties do not match, then
	387	* the swap function is called to swap an allocated version of the data.
	388	* Preflighting may or may not be performed depending on whether the size of
	389	* the loaded data item is known.
	390	*
	391	* @param isAcceptable Same as for udata_openChoice(). May be NULL.
	392	*
73c04bcf	393	* @internal ICU 2.8
374ca955 A	394	*/
	395	U_CAPI UDataMemory * U_EXPORT2
	396	udata_openSwap(const char path, const char type, const char *name,
	397	UDataMemoryIsAcceptable isAcceptable, void isAcceptableContext,
	398	UDataSwapFn *swap,
	399	UDataPrintError printError, void printErrorContext,
	400	UErrorCode *pErrorCode);
	401
	402	#endif
	403
	404	#endif