return uloc_isRightToLeft(getBaseName());
}
+U_NAMESPACE_END
+
// The following must at least allow for rg key value (6) plus terminator (1).
#define ULOC_RG_BUFLEN 8
return u_terminateChars(region, regionCapacity, rgLen, status);
}
-U_NAMESPACE_END
/* ISO-2022 ----------------------------------------------------------------- */
/*Forward declaration */
-U_CFUNC void
+U_CFUNC void U_CALLCONV
ucnv_fromUnicode_UTF8(UConverterFromUnicodeArgs * args,
UErrorCode * err);
-U_CFUNC void
+U_CFUNC void U_CALLCONV
ucnv_fromUnicode_UTF8_OFFSETS_LOGIC(UConverterFromUnicodeArgs * args,
UErrorCode * err);
} Variant2022;
/*********** ISO 2022 Converter Protos ***********/
-static void
+static void U_CALLCONV
_ISO2022Open(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode);
-static void
+static void U_CALLCONV
_ISO2022Close(UConverter *converter);
-static void
+static void U_CALLCONV
_ISO2022Reset(UConverter *converter, UConverterResetChoice choice);
-static const char*
+static const char U_CALLCONV*
_ISO2022getName(const UConverter* cnv);
-static void
+static void U_CALLCONV
_ISO_2022_WriteSub(UConverterFromUnicodeArgs *args, int32_t offsetIndex, UErrorCode *err);
-static UConverter *
+static UConverter U_CALLCONV*
_ISO_2022_SafeClone(const UConverter *cnv, void *stackBuffer, int32_t *pBufferSize, UErrorCode *status);
#ifdef U_ENABLE_GENERIC_ISO_2022
-static void
+static void U_CALLCONV
T_UConverter_toUnicode_ISO_2022_OFFSETS_LOGIC(UConverterToUnicodeArgs* args, UErrorCode* err);
#endif
}
}
-static void
+static void U_CALLCONV
_ISO2022Open(UConverter *cnv, UConverterLoadArgs *pArgs, UErrorCode *errorCode){
char myLocale[6]={' ',' ',' ',' ',' ',' '};
}
-static void
+static void U_CALLCONV
_ISO2022Close(UConverter *converter) {
UConverterDataISO2022* myData =(UConverterDataISO2022 *) (converter->extraInfo);
UConverterSharedData **array = myData->myConverterArray;
}
}
-static void
+static void U_CALLCONV
_ISO2022Reset(UConverter *converter, UConverterResetChoice choice) {
UConverterDataISO2022 *myConverterData=(UConverterDataISO2022 *) (converter->extraInfo);
if(choice<=UCNV_RESET_TO_UNICODE) {
}
}
-static const char*
+static const char U_CALLCONV*
_ISO2022getName(const UConverter* cnv){
if(cnv->extraInfo){
UConverterDataISO2022* myData= (UConverterDataISO2022*)cnv->extraInfo;
*
*/
-static void
+static void U_CALLCONV
T_UConverter_toUnicode_ISO_2022_OFFSETS_LOGIC(UConverterToUnicodeArgs* args,
UErrorCode* err){
const char* mySourceLimit, *realSourceLimit;
0x212C /* U+FF9F */
};
-static void
+static void U_CALLCONV
UConverter_fromUnicode_ISO_2022_JP_OFFSETS_LOGIC(UConverterFromUnicodeArgs* args, UErrorCode* err) {
UConverter *cnv = args->converter;
UConverterDataISO2022 *converterData;
/*************** to unicode *******************/
-static void
+static void U_CALLCONV
UConverter_toUnicode_ISO_2022_JP_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
UErrorCode* err){
char tempBuf[2];
* ii) There are only 2 shifting sequences SO to shift into double byte mode
* and SI to shift into single byte mode
*/
-static void
+static void U_CALLCONV
UConverter_fromUnicode_ISO_2022_KR_OFFSETS_LOGIC_IBM(UConverterFromUnicodeArgs* args, UErrorCode* err){
UConverter* saveConv = args->converter;
args->converter=saveConv;
}
-static void
+static void U_CALLCONV
UConverter_fromUnicode_ISO_2022_KR_OFFSETS_LOGIC(UConverterFromUnicodeArgs* args, UErrorCode* err){
const UChar *source = args->source;
/************************ To Unicode ***************************************/
-static void
+static void U_CALLCONV
UConverter_toUnicode_ISO_2022_KR_OFFSETS_LOGIC_IBM(UConverterToUnicodeArgs *args,
UErrorCode* err){
char const* sourceStart;
}
}
-static void
+static void U_CALLCONV
UConverter_toUnicode_ISO_2022_KR_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
UErrorCode* err){
char tempBuf[2];
CNS_11643_1992_Plane_7_STR
};
-static void
+static void U_CALLCONV
UConverter_fromUnicode_ISO_2022_CN_OFFSETS_LOGIC(UConverterFromUnicodeArgs* args, UErrorCode* err){
UConverter *cnv = args->converter;
UConverterDataISO2022 *converterData;
}
-static void
+static void U_CALLCONV
UConverter_toUnicode_ISO_2022_CN_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
UErrorCode* err){
char tempBuf[3];
}
#endif /* #if !UCONFIG_ONLY_HTML_CONVERSION */
-static void
+static void U_CALLCONV
_ISO_2022_WriteSub(UConverterFromUnicodeArgs *args, int32_t offsetIndex, UErrorCode *err) {
UConverter *cnv = args->converter;
UConverterDataISO2022 *myConverterData=(UConverterDataISO2022 *) cnv->extraInfo;
};
-static UConverter *
+static UConverter U_CALLCONV *
_ISO_2022_SafeClone(
const UConverter *cnv,
void *stackBuffer,
return &localClone->cnv;
}
-static void
+static void U_CALLCONV
_ISO_2022_GetUnicodeSet(const UConverter *cnv,
const USetAdder *sa,
UConverterUnicodeSet which,
#endif
/* @see ucnv_compareNames */
-U_CFUNC char * U_EXPORT2
+U_CAPI char * U_EXPORT2
ucnv_io_stripASCIIForCompare(char *dst, const char *name) {
char *dstItr = dst;
uint8_t type, nextType;
return dst;
}
-U_CFUNC char * U_EXPORT2
+U_CAPI char * U_EXPORT2
ucnv_io_stripEBCDICForCompare(char *dst, const char *name) {
char *dstItr = dst;
uint8_t type, nextType;
return value;
}
-static const char* U_CALLCONV
+static const char U_CALLCONV *
ucnv_io_nextStandardAliases(UEnumeration *enumerator,
int32_t* resultLength,
UErrorCode * /*pErrorCode*/)
return gMainTable.converterListSize;
}
-static const char* U_CALLCONV
+static const char U_CALLCONV *
ucnv_io_nextAllConverters(UEnumeration *enumerator,
int32_t* resultLength,
UErrorCode * /*pErrorCode*/)
/* alias table swapping ----------------------------------------------------- */
-typedef char * U_CALLCONV StripForCompareFn(char *dst, const char *name);
+typedef char U_CALLCONV * StripForCompareFn(char *dst, const char *name);
/*
* row of a temporary array
STACK_ROW_CAPACITY=500
};
-static int32_t
+static int32_t U_CALLCONV
io_compareRows(const void *context, const void *left, const void *right) {
char strippedLeft[UCNV_MAX_CONVERTER_NAME_LENGTH],
strippedRight[UCNV_MAX_CONVERTER_NAME_LENGTH];
# error U_CHARSET_FAMILY is not valid
#endif
-U_CAPI char * U_EXPORT2
+U_CAPI char U_CALLCONV *
ucnv_io_stripASCIIForCompare(char *dst, const char *name);
-U_CAPI char * U_EXPORT2
+U_CAPI char U_CALLCONV *
ucnv_io_stripEBCDICForCompare(char *dst, const char *name);
/**
}
-static void
+static void U_CALLCONV
_Bocu1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
* re-copy the original function and remove the variables
* offsets, sourceIndex, and nextSourceIndex.
*/
-static void
+static void U_CALLCONV
_Bocu1FromUnicode(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
}
}
-static void
+static void U_CALLCONV
_Bocu1ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
* re-copy the original function and remove the variables
* offsets, sourceIndex, and nextSourceIndex.
*/
-static void
+static void U_CALLCONV
_Bocu1ToUnicode(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
typedef UBool U_CALLCONV
UConverterEnumToUCallback(const void *context, uint32_t value, UChar32 codePoints[32]);
-static void
+static void U_CALLCONV
ucnv_MBCSLoad(UConverterSharedData *sharedData,
UConverterLoadArgs *pArgs,
const uint8_t *raw,
UErrorCode *pErrorCode);
-static void
+static void U_CALLCONV
ucnv_MBCSUnload(UConverterSharedData *sharedData);
-static void
+static void U_CALLCONV
ucnv_MBCSOpen(UConverter *cnv,
UConverterLoadArgs *pArgs,
UErrorCode *pErrorCode);
-static UChar32
+static UChar32 U_CALLCONV
ucnv_MBCSGetNextUChar(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode);
-static void
+static void U_CALLCONV
ucnv_MBCSGetStarters(const UConverter* cnv,
UBool starters[256],
UErrorCode *pErrorCode);
-static const char *
+static const char U_CALLCONV *
ucnv_MBCSGetName(const UConverter *cnv);
-static void
+static void U_CALLCONV
ucnv_MBCSWriteSub(UConverterFromUnicodeArgs *pArgs,
int32_t offsetIndex,
UErrorCode *pErrorCode);
-static UChar32
+static UChar32 U_CALLCONV
ucnv_MBCSGetNextUChar(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode);
-static void
+static void U_CALLCONV
ucnv_SBCSFromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
UConverterToUnicodeArgs *pToUArgs,
UErrorCode *pErrorCode);
-static void
+static void U_CALLCONV
ucnv_MBCSGetUnicodeSet(const UConverter *cnv,
const USetAdder *sa,
UConverterUnicodeSet which,
UErrorCode *pErrorCode);
-static void
+static void U_CALLCONV
ucnv_DBCSFromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
UConverterToUnicodeArgs *pToUArgs,
UErrorCode *pErrorCode);
NULL
};
-
/* Static data is in tools/makeconv/ucnvstat.c for data-based
* converters. Be sure to update it as well.
*/
}
}
-U_CFUNC void
+U_CFUNC void
ucnv_MBCSGetFilteredUnicodeSetForUnicode(const UConverterSharedData *sharedData,
const USetAdder *sa,
UConverterUnicodeSet which,
pErrorCode);
}
-static void
+static void U_CALLCONV
ucnv_MBCSGetUnicodeSet(const UConverter *cnv,
const USetAdder *sa,
UConverterUnicodeSet which,
/* MBCS setup functions ----------------------------------------------------- */
-static void
+static void U_CALLCONV
ucnv_MBCSLoad(UConverterSharedData *sharedData,
UConverterLoadArgs *pArgs,
const uint8_t *raw,
}
}
-static void
+static void U_CALLCONV
ucnv_MBCSUnload(UConverterSharedData *sharedData) {
UConverterMBCSTable *mbcsTable=&sharedData->mbcs;
}
}
-static void
+static void U_CALLCONV
ucnv_MBCSOpen(UConverter *cnv,
UConverterLoadArgs *pArgs,
UErrorCode *pErrorCode) {
#endif
}
-static const char *
+static const char U_CALLCONV *
ucnv_MBCSGetName(const UConverter *cnv) {
if((cnv->options&UCNV_OPTION_SWAP_LFNL)!=0 && cnv->sharedData->mbcs.swapLFNLName!=NULL) {
return cnv->sharedData->mbcs.swapLFNLName;
/* MBCS-to-Unicode conversion functions ------------------------------------- */
-static UChar32
+static UChar32 U_CALLCONV
ucnv_MBCSGetFallback(UConverterMBCSTable *mbcsTable, uint32_t offset) {
const _MBCSToUFallback *toUFallbacks;
uint32_t i, start, limit;
*
* All normal mappings and errors are handled here.
*/
-static UChar32
+static UChar32 U_CALLCONV
ucnv_MBCSGetNextUChar(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
static const UChar32
utf8_offsets[7]={ 0, 0, 0x3080, 0xE2080, 0x3C82080 };
-static void
+static void U_CALLCONV
ucnv_SBCSFromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
UConverterToUnicodeArgs *pToUArgs,
UErrorCode *pErrorCode) {
pFromUArgs->target=(char *)target;
}
-static void
+static void U_CALLCONV
ucnv_DBCSFromUTF8(UConverterFromUnicodeArgs *pFromUArgs,
UConverterToUnicodeArgs *pToUArgs,
UErrorCode *pErrorCode) {
/* miscellaneous ------------------------------------------------------------ */
-static void
+static void U_CALLCONV
ucnv_MBCSGetStarters(const UConverter* cnv,
UBool starters[256],
UErrorCode *) {
return (UBool)MBCS_ENTRY_IS_TRANSITION(sharedData->mbcs.stateTable[0][(uint8_t)byte]);
}
-static void
+static void U_CALLCONV
ucnv_MBCSWriteSub(UConverterFromUnicodeArgs *pArgs,
int32_t offsetIndex,
UErrorCode *pErrorCode) {
uprv_free(pDCEl); /* delete 'this' */
}
-static void udata_initHashTable(UErrorCode &err) {
+static void U_CALLCONV udata_initHashTable(UErrorCode &err) {
U_ASSERT(gCommonDataCache == NULL);
gCommonDataCache = uhash_open(uhash_hashChars, uhash_compareChars, NULL, &err);
if (U_FAILURE(err)) {
return result;
}
-static const char* U_CALLCONV
+static const char U_CALLCONV*
uloc_kw_nextKeyword(UEnumeration* en,
int32_t* resultLength,
UErrorCode* /*status*/) {
U_COMMON_API UBool U_EXPORT2 umtx_initImplPreInit(UInitOnce &);
U_COMMON_API void U_EXPORT2 umtx_initImplPostInit(UInitOnce &);
-template<class T> void umtx_initOnce(UInitOnce &uio, T *obj, void (T::*fp)()) {
+template<class T> void umtx_initOnce(UInitOnce &uio, T *obj, void (T::*U_CALLCONV fp)()) {
if (umtx_loadAcquire(uio.fState) == 2) {
return;
}
// umtx_initOnce variant for plain functions, or static class functions.
// No context parameter.
-inline void umtx_initOnce(UInitOnce &uio, void (*fp)()) {
+inline void umtx_initOnce(UInitOnce &uio, void (*U_CALLCONV fp)()) {
if (umtx_loadAcquire(uio.fState) == 2) {
return;
}
// umtx_initOnce variant for plain functions, or static class functions.
// With ErrorCode, No context parameter.
-inline void umtx_initOnce(UInitOnce &uio, void (*fp)(UErrorCode &), UErrorCode &errCode) {
+inline void umtx_initOnce(UInitOnce &uio, void (*U_CALLCONV fp)(UErrorCode &), UErrorCode &errCode) {
if (U_FAILURE(errCode)) {
return;
}
// umtx_initOnce variant for plain functions, or static class functions,
// with a context parameter.
-template<class T> void umtx_initOnce(UInitOnce &uio, void (*fp)(T), T context) {
+template<class T> void umtx_initOnce(UInitOnce &uio, void (*U_CALLCONV fp)(T), T context) {
if (umtx_loadAcquire(uio.fState) == 2) {
return;
}
// umtx_initOnce variant for plain functions, or static class functions,
// with a context parameter and an error code.
-template<class T> void umtx_initOnce(UInitOnce &uio, void (*fp)(T, UErrorCode &), T context, UErrorCode &errCode) {
+template<class T> void umtx_initOnce(UInitOnce &uio, void (*U_CALLCONV fp)(T, UErrorCode &), T context, UErrorCode &errCode) {
if (U_FAILURE(errCode)) {
return;
}
* This is only used for non-ICU-API functions.
* When a function is a public ICU API,
* you must use the U_CAPI and U_EXPORT2 qualifiers.
+ *
+ * Please note, you need to use U_CALLCONV before the *.
+ *
+ * YES: "static const char U_CALLCONV *func( . . . )"
+ * NO: "static const char* U_CALLCONV func( . . . )"
+ *
* @stable ICU 2.0
*/
#if U_PLATFORM == U_PF_OS390 && defined(__cplusplus)
}
/** INTERNAL: Initializes the cache for resources */
-static void createCache(UErrorCode &status) {
+static void U_CALLCONV createCache(UErrorCode &status) {
U_ASSERT(cache == NULL);
cache = uhash_open(hashEntry, compareEntries, NULL, &status);
ucln_common_registerCleanup(UCLN_COMMON_URES, ures_cleanup);
return ures_getSize(&ctx->installed);
}
-static const char* U_CALLCONV
+static const char U_CALLCONV *
ures_loc_nextLocale(UEnumeration* en,
int32_t* resultLength,
UErrorCode* status) {
int32_t keyIndex, sortIndex;
} Row;
-static int32_t
+static int32_t U_CALLCONV
ures_compareRows(const void *context, const void *left, const void *right) {
const char *keyChars=(const char *)context;
return (int32_t)uprv_strcmp(keyChars+((const Row *)left)->keyIndex,
U_CDECL_END
-void
+void U_CALLCONV
CollationRoot::load(UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return; }
LocalPointer<CollationTailoring> t(new CollationTailoring(NULL));
static const CollationSettings *getSettings(UErrorCode &errorCode);
private:
- static void load(UErrorCode &errorCode);
+ static void U_CALLCONV load(UErrorCode &errorCode);
};
U_NAMESPACE_END
UInitOnce initOnce = U_INITONCE_INITIALIZER;
-UBool dayPeriodRulesCleanup() {
+U_CFUNC UBool U_CALLCONV dayPeriodRulesCleanup() {
delete[] data->rules;
uhash_close(data->localeToRuleSetNumMap);
delete data;
} // namespace
-void DayPeriodRules::load(UErrorCode &errorCode) {
+void U_CALLCONV DayPeriodRules::load(UErrorCode &errorCode) {
if (U_FAILURE(errorCode)) {
return;
}
// Translates "morning1" to DAYPERIOD_MORNING1, for example.
static DayPeriod getDayPeriodFromString(const char *type_str);
- static void load(UErrorCode &errorCode);
+ static void U_CALLCONV load(UErrorCode &errorCode);
// Sets period type for all hours in [startHour, limitHour).
void add(int32_t startHour, int32_t limitHour, DayPeriod period);
}
// Deleter function to be used by 'arrays'
- static void deleteUnicodeStringArray(void *uArray) {
+ static void U_CALLCONV deleteUnicodeStringArray(void *uArray) {
delete[] static_cast<UnicodeString *>(uArray);
}
// Deleter function to be used by 'maps'
- static void deleteHashtable(void *table) {
+ static void U_CALLCONV deleteHashtable(void *table) {
delete static_cast<Hashtable *>(table);
}
};
UHashtable *localeToAllowedHourFormatsMap = NULL;
// Value deleter for hashmap.
-void deleteAllowedHourFormats(void *ptr) {
+U_CFUNC void U_CALLCONV deleteAllowedHourFormats(void *ptr) {
uprv_free(ptr);
}
// Close hashmap at cleanup.
-UBool allowedHourFormatsCleanup() {
+U_CFUNC UBool U_CALLCONV allowedHourFormatsCleanup() {
uhash_close(localeToAllowedHourFormatsMap);
return TRUE;
}
AllowedHourFormatsSink::~AllowedHourFormatsSink() {}
-void DateTimePatternGenerator::loadAllowedHourFormatsData(UErrorCode &status) {
+U_CFUNC void U_CALLCONV DateTimePatternGenerator::loadAllowedHourFormatsData(UErrorCode &status) {
if (U_FAILURE(status)) { return; }
localeToAllowedHourFormatsMap = uhash_open(
uhash_hashChars, uhash_compareChars, NULL, &status);
}
-void U_CALLCONV
+U_CFUNC void U_CALLCONV
IslamicCalendar::initializeSystemDefaultCentury()
{
// initialize systemDefaultCentury and systemDefaultCenturyYear based
* are considered to fall within so that its start date is 80 years
* before the current time.
*/
- static void initializeSystemDefaultCentury(void);
+ static void U_CALLCONV initializeSystemDefaultCentury(void);
};
U_NAMESPACE_END
* If the region data has already loaded, then this method simply returns without doing
* anything meaningful.
*/
-void Region::loadRegionData(UErrorCode &status) {
+void U_CALLCONV Region::loadRegionData(UErrorCode &status) {
// Construct service objs first
LocalUHashtablePointer newRegionIDMap(uhash_open(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, &status));
return data->isUnsafeBackward(c, settings->isNumeric());
}
-void
+void U_CALLCONV
RuleBasedCollator::computeMaxExpansions(const CollationTailoring *t, UErrorCode &errorCode) {
t->maxExpansions = CollationElementIterator::computeMaxExpansions(t->data, errorCode);
}
/**
* Initialize static memory. Called through umtx_initOnce only.
*/
-void TransliteratorIDParser::init(UErrorCode &status) {
+void U_CALLCONV TransliteratorIDParser::init(UErrorCode &status) {
U_ASSERT(SPECIAL_INVERSES == NULL);
ucln_i18n_registerCleanup(UCLN_I18N_TRANSLITERATOR, utrans_transliterator_cleanup);
/**
* Initialize static memory.
*/
- static void init(UErrorCode &status);
+ static void U_CALLCONV init(UErrorCode &status);
friend class SingleID;
};
static cleanupFunc *gCleanupFunctions[UCLN_I18N_COUNT];
-static UBool i18n_cleanup(void)
+static UBool U_CALLCONV i18n_cleanup(void)
{
int32_t libType = UCLN_I18N_START;
(void)copyright; /* Suppress unused variable warning with clang. */
const CollationCacheEntry *createCacheEntry(UErrorCode &errorCode);
private:
- static void loadRootRules(UErrorCode &errorCode);
+ static void U_CALLCONV loadRootRules(UErrorCode &errorCode);
// The following members are used by loadTailoring()
// and the cache callback.
U_CDECL_END
-void
+U_CAPI void U_CALLCONV
CollationLoader::loadRootRules(UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return; }
rootBundle = ures_open(U_ICUDATA_COLL, kRootLocaleName, &errorCode);
UBool isAvailableFormatSet(const UnicodeString &key) const;
void copyHashtable(Hashtable *other, UErrorCode &status);
UBool isCanonicalItem(const UnicodeString& item) const;
- static void loadAllowedHourFormatsData(UErrorCode &status);
+ static void U_CALLCONV loadAllowedHourFormatsData(UErrorCode &status);
void getAllowedHourFormats(const Locale &locale, UErrorCode &status);
struct AppendItemFormatsSink;
* anything meaningful.
*/
- static void loadRegionData(UErrorCode &status);
+ static void U_CALLCONV loadRegionData(UErrorCode &status);
};
*/
UBool isUnsafe(UChar32 c) const;
- static void computeMaxExpansions(const CollationTailoring *t, UErrorCode &errorCode);
+ static void U_CALLCONV computeMaxExpansions(const CollationTailoring *t, UErrorCode &errorCode);
UBool initMaxExpansions(UErrorCode &errorCode) const;
void setFastLatinOptions(CollationSettings &ownedSettings) const;
return TRUE;
}
-static void uspoof_loadDefaultData(UErrorCode& status) {
+static void U_CALLCONV uspoof_loadDefaultData(UErrorCode& status) {
UDataMemory *udm = udata_openChoice(NULL, "cfu", "confusables",
spoofDataIsAcceptable,
NULL, // context, would receive dataVersion if supplied.
static cleanupFunc *gCleanupFunctions[UCLN_IO_COUNT];
-static UBool io_cleanup(void)
+static UBool U_CALLCONV io_cleanup(void)
{
int32_t libType = UCLN_IO_START;