The Tor Browser: comparison intl/icu/source/common/ucnv

--1:000000000000
+:a62ddf59ce6f
+/*
+**********************************************************************
+*   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 */

The Tor Browser / file comparison

comparison: intl/icu/source/common/ucnv_cnv.h

intl/icu/source/common/ucnv_cnv.h