285 lines
12 KiB
C
285 lines
12 KiB
C
/*
|
|
**********************************************************************
|
|
* Copyright (C) 1999, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
**********************************************************************
|
|
*
|
|
* uconv_cnv.h:
|
|
* defines all the low level conversion functions
|
|
* T_UnicodeConverter_{to,from}Unicode_$ConversionType
|
|
*
|
|
* 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"
|
|
#include "unicode/ucnv_err.h"
|
|
#include "ucnv_bld.h"
|
|
#include "ucnvmbcs.h"
|
|
|
|
union UConverterTable
|
|
{
|
|
UConverterMBCSTable mbcs;
|
|
};
|
|
|
|
|
|
U_CDECL_BEGIN
|
|
|
|
/* this is used in fromUnicode DBCS tables as an "unassigned" marker */
|
|
#define missingCharMarker 0xFFFF
|
|
|
|
/*
|
|
* #define missingUCharMarker 0xfffe
|
|
*
|
|
* there are actually two values used in toUnicode tables:
|
|
* U+fffe "unassigned"
|
|
* U+ffff "illegal"
|
|
*/
|
|
|
|
#define FromU_CALLBACK_MACRO(context, args, codeUnits, length, codePoint, reason, err) \
|
|
{ \
|
|
/*copies current values for the ErrorFunctor to update */ \
|
|
/*Calls the ErrorFunctor */ \
|
|
args->converter->fromUCharErrorBehaviour ( context, \
|
|
args, \
|
|
codeUnits, \
|
|
length, \
|
|
codePoint, \
|
|
reason, \
|
|
err); \
|
|
myTargetIndex = args->target - (char*)myTarget; \
|
|
mySourceIndex = args->source - mySource; \
|
|
}
|
|
/*
|
|
*/
|
|
#define ToU_CALLBACK_MACRO(context, args, codePoints, length, reason, err) \
|
|
{ \
|
|
/*Calls the ErrorFunctor */ \
|
|
args->converter->fromCharErrorBehaviour ( \
|
|
context, \
|
|
args, \
|
|
codePoints, \
|
|
length, \
|
|
reason, \
|
|
err); \
|
|
myTargetIndex = args->target - myTarget; \
|
|
mySourceIndex = args->source - (const char*)mySource; \
|
|
}
|
|
/*
|
|
*/
|
|
#define FromU_CALLBACK_OFFSETS_LOGIC_MACRO(context, args, codeUnits, length, codePoint, reason, err) \
|
|
{ \
|
|
int32_t My_i = myTargetIndex; \
|
|
/*copies current values for the ErrorFunctor to update */ \
|
|
/*Calls the ErrorFunctor */ \
|
|
args->converter->fromUCharErrorBehaviour ( \
|
|
context, \
|
|
args, \
|
|
codeUnits, \
|
|
length, \
|
|
codePoint, \
|
|
reason, \
|
|
err); \
|
|
/*Update the local Indexes so that the conversion can restart at the right points */ \
|
|
myTargetIndex = args->target - (char*)myTarget; \
|
|
mySourceIndex = args->source - mySource; \
|
|
args->offsets = saveOffsets; \
|
|
for (;My_i < myTargetIndex;My_i++) args->offsets[My_i] += currentOffset; \
|
|
}
|
|
/*
|
|
*/
|
|
#define ToU_CALLBACK_OFFSETS_LOGIC_MACRO(context, args, codePoints, length, reason, err) \
|
|
{ \
|
|
args->converter->fromCharErrorBehaviour ( \
|
|
context, \
|
|
args, \
|
|
codePoints, \
|
|
length, \
|
|
reason, \
|
|
err); \
|
|
/*Update the local Indexes so that the conversion can restart at the right points */ \
|
|
myTargetIndex = args->target - myTarget; \
|
|
mySourceIndex = args->source - (const char*)mySource; \
|
|
args->offsets = saveOffsets; \
|
|
for (;My_i < myTargetIndex;My_i++) {args->offsets[My_i] += currentOffset;} \
|
|
}
|
|
|
|
|
|
typedef void (*UConverterLoad) (UConverterSharedData *sharedData, const uint8_t *raw, UErrorCode *pErrorCode);
|
|
typedef void (*UConverterUnload) (UConverterSharedData *sharedData);
|
|
|
|
typedef void (*UConverterOpen) (UConverter *cnv, const char *name, const char *locale,uint32_t options, 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);
|
|
|
|
typedef void (*T_ToUnicodeFunction) (UConverterToUnicodeArgs *, UErrorCode *);
|
|
|
|
typedef void (*T_FromUnicodeFunction) (UConverterFromUnicodeArgs *, UErrorCode *);
|
|
|
|
typedef UChar32 (*T_GetNextUCharFunction) (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);
|
|
|
|
UBool CONVERSION_U_SUCCESS (UErrorCode err);
|
|
|
|
void flushInternalUnicodeBuffer (UConverter * _this,
|
|
UChar * myTarget,
|
|
int32_t * myTargetIndex,
|
|
int32_t targetLength,
|
|
int32_t** offsets,
|
|
UErrorCode * err);
|
|
|
|
void flushInternalCharBuffer (UConverter * _this,
|
|
char *myTarget,
|
|
int32_t * myTargetIndex,
|
|
int32_t targetLength,
|
|
int32_t** offsets,
|
|
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;
|
|
|
|
T_ToUnicodeFunction toUnicode;
|
|
T_ToUnicodeFunction toUnicodeWithOffsets;
|
|
T_FromUnicodeFunction fromUnicode;
|
|
T_FromUnicodeFunction fromUnicodeWithOffsets;
|
|
T_GetNextUCharFunction getNextUChar;
|
|
|
|
UConverterGetStarters getStarters;
|
|
UConverterGetName getName;
|
|
UConverterWriteSub writeSub;
|
|
};
|
|
|
|
extern const UConverterSharedData
|
|
_MBCSData, _Latin1Data,
|
|
_UTF8Data, _UTF16BEData, _UTF16LEData, _UTF32BEData, _UTF32LEData,
|
|
_ISO2022Data,
|
|
_LMBCSData1,_LMBCSData2, _LMBCSData3, _LMBCSData4, _LMBCSData5, _LMBCSData6,
|
|
_LMBCSData8,_LMBCSData11,_LMBCSData16,_LMBCSData17,_LMBCSData18,_LMBCSData19,
|
|
_HZData, _SCSUData, _ASCIIData;
|
|
|
|
U_CDECL_END
|
|
|
|
/**
|
|
* This function is useful for implementations of getNextUChar().
|
|
* After a call to a callback function or to toUnicode(), an output buffer
|
|
* begins with a Unicode code point that needs to be returned as UChar32,
|
|
* and all following code units must be prepended to the - potentially
|
|
* prefilled - overflow buffer in the UConverter.
|
|
* The buffer should be at least of capacity UTF_MAX_CHAR_LENGTH so that a
|
|
* complete UChar32's UChars fit into it.
|
|
*
|
|
* @param cnv The converter that will get remaining UChars copied to its overflow area.
|
|
* @param buffer An array of UChars that was passed into a callback function
|
|
* or a toUnicode() function.
|
|
* @param length The number of code units (UChars) that are actually in the buffer.
|
|
* This must be >0.
|
|
* @return The code point from the first UChars in the buffer.
|
|
*/
|
|
U_CFUNC UChar32
|
|
ucnv_getUChar32KeepOverflow(UConverter *cnv, const UChar *buffer, int32_t length);
|
|
|
|
/**
|
|
* This helper function updates the offsets array after a callback function call.
|
|
* It adds the sourceIndex to each offsets item, or sets each of them to -1 if
|
|
* sourceIndex==-1.
|
|
*
|
|
* @param offsets The pointer to offsets entry that corresponds to the first target
|
|
* unit that the callback wrote.
|
|
* @param length The number of output units that the callback wrote.
|
|
* @param sourceIndex The sourceIndex of the input sequence that the callback
|
|
* function was called for.
|
|
* @return offsets+length if offsets!=NULL, otherwise NULL
|
|
*/
|
|
U_CFUNC int32_t *
|
|
ucnv_updateCallbackOffsets(int32_t *offsets, int32_t length, int32_t sourceIndex);
|
|
|
|
/** 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 FROM_U_USE_FALLBACK(useFallback, c) ((useFallback) || (uint32_t)((c)-0xe000)<0x1900 || (uint32_t)((c)-0xf0000)<0x20000)
|
|
#define UCNV_FROM_U_USE_FALLBACK(cnv, c) FROM_U_USE_FALLBACK((cnv)->useFallback, c)
|
|
|
|
/**
|
|
* This is a simple implementation of ucnv_getNextUChar() that uses the
|
|
* converter's toUnicode() function.
|
|
*
|
|
* \par
|
|
* A surrogate pair from a single byte sequence is always
|
|
* combined to a supplementary code point.
|
|
* A surrogate pair from consecutive byte sequences is only combined
|
|
* if collectPairs is set. This is necessary for SCSU
|
|
* but not allowed for most legacy codepages.
|
|
*
|
|
* @param pArgs The argument structure supplied by ucnv_getNextUChar()
|
|
* @param toU A function pointer to the converter's toUnicode() function
|
|
* @param collectPairs indicates whether separate surrogate results from
|
|
* consecutive byte sequences should be combined into
|
|
* a single code point
|
|
* @param pErrorCode An ICU error code parameter
|
|
* @return The Unicode code point as a result of a conversion of a minimal
|
|
* number of input bytes
|
|
*/
|
|
U_CFUNC UChar32
|
|
ucnv_getNextUCharFromToUImpl(UConverterToUnicodeArgs *pArgs,
|
|
T_ToUnicodeFunction toU,
|
|
UBool collectPairs,
|
|
UErrorCode *pErrorCode);
|
|
|
|
#endif /* UCNV_CNV */
|