1341 lines
45 KiB
C
1341 lines
45 KiB
C
/*
|
|
******************************************************************************
|
|
*
|
|
* Copyright (C) 1999-2003, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
******************************************************************************
|
|
*
|
|
*
|
|
* ucnv_io.c:
|
|
* initializes global variables and defines functions pertaining to file
|
|
* access, and name resolution aspect of the library.
|
|
*
|
|
* new implementation:
|
|
*
|
|
* created on: 1999nov22
|
|
* created by: Markus W. Scherer
|
|
*
|
|
* Use the binary cnvalias.icu (created from convrtrs.txt) to work
|
|
* with aliases for converter names.
|
|
*
|
|
* Date Name Description
|
|
* 11/22/1999 markus Created
|
|
* 06/28/2002 grhoten Major overhaul of the converter alias design.
|
|
* Now an alias can map to different converters
|
|
* depending on the specified standard.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/putil.h"
|
|
#include "unicode/ucnv.h" /* This file implements ucnv_xXXX() APIs */
|
|
#include "unicode/udata.h"
|
|
|
|
#include "umutex.h"
|
|
#include "uarrsort.h"
|
|
#include "udataswp.h"
|
|
#include "cstring.h"
|
|
#include "cmemory.h"
|
|
#include "ucnv_io.h"
|
|
#include "uenumimp.h"
|
|
#include "ucln_cmn.h"
|
|
|
|
/* Format of cnvalias.icu -----------------------------------------------------
|
|
*
|
|
* cnvalias.icu is a binary, memory-mappable form of convrtrs.txt.
|
|
* This binary form contains several tables. All indexes are to uint16_t
|
|
* units, and not to the bytes (uint8_t units). Addressing everything on
|
|
* 16-bit boundaries allows us to store more information with small index
|
|
* numbers, which are also 16-bit in size. The majority of the table (except
|
|
* the string table) are 16-bit numbers.
|
|
*
|
|
* First there is the size of the Table of Contents (TOC). The TOC
|
|
* entries contain the size of each section. In order to find the offset
|
|
* you just need to sum up the previous offsets.
|
|
* The TOC length and entries are an array of uint32_t values.
|
|
* The first section after the TOC starts immediately after the TOC.
|
|
*
|
|
* 1) This section contains a list of converters. This list contains indexes
|
|
* into the string table for the converter name. The index of this list is
|
|
* also used by other sections, which are mentioned later on.
|
|
* This list is not sorted.
|
|
*
|
|
* 2) This section contains a list of tags. This list contains indexes
|
|
* into the string table for the tag name. The index of this list is
|
|
* also used by other sections, which are mentioned later on.
|
|
* This list is in priority order of standards.
|
|
*
|
|
* 3) This section contains a list of sorted unique aliases. This
|
|
* list contains indexes into the string table for the alias name. The
|
|
* index of this list is also used by other sections, like the 4th section.
|
|
* The index for the 3rd and 4th section is used to get the
|
|
* alias -> converter name mapping. Section 3 and 4 form a two column table.
|
|
*
|
|
* 4) This section contains a list of mapped converter names. Consider this
|
|
* as a table that maps the 3rd section to the 1st section. This list contains
|
|
* indexes into the 1st section. The index of this list is the same index in
|
|
* the 3rd section. There is also some extra information in the high bits of
|
|
* each converter index in this table. Currently it's only used to say that
|
|
* an alias mapped to this converter is ambiguous. See UCNV_CONVERTER_INDEX_MASK
|
|
* and UCNV_AMBIGUOUS_ALIAS_MAP_BIT for more information. This section is
|
|
* the predigested form of the 5th section so that an alias lookup can be fast.
|
|
*
|
|
* 5) This section contains a 2D array with indexes to the 6th section. This
|
|
* section is the full form of all alias mappings. The column index is the
|
|
* index into the converter list (column header). The row index is the index
|
|
* to tag list (row header). This 2D array is the top part a 3D array. The
|
|
* third dimension is in the 6th section.
|
|
*
|
|
* 6) This is blob of variable length arrays. Each array starts with a size,
|
|
* and is followed by indexes to alias names in the string table. This is
|
|
* the third dimension to the section 5. No other section should be referencing
|
|
* this section.
|
|
*
|
|
* 7) Reserved at this time (There is no information). This _usually_ has a
|
|
* size of 0. Future versions may add more information here.
|
|
*
|
|
* 8) This is the string table. All strings are indexed on an even address.
|
|
* There are two reasons for this. First many chip architectures locate strings
|
|
* faster on even address boundaries. Second, since all indexes are 16-bit
|
|
* numbers, this string table can be 128KB in size instead of 64KB when we
|
|
* only have strings starting on an even address.
|
|
*
|
|
*
|
|
* Here is the concept of section 5 and 6. It's a 3D cube. Each tag
|
|
* has a unique alias among all converters. That same alias can
|
|
* be mentioned in other standards on different converters,
|
|
* but only one alias per tag can be unique.
|
|
*
|
|
*
|
|
* Converter Names (Usually in TR22 form)
|
|
* -------------------------------------------.
|
|
* T / /|
|
|
* a / / |
|
|
* g / / |
|
|
* s / / |
|
|
* / / |
|
|
* ------------------------------------------/ |
|
|
* A | | |
|
|
* l | | |
|
|
* i | | /
|
|
* a | | /
|
|
* s | | /
|
|
* e | | /
|
|
* s | |/
|
|
* -------------------------------------------
|
|
*
|
|
*
|
|
*
|
|
* Here is what it really looks like. It's like swiss cheese.
|
|
* There are holes. Some converters aren't recognized by
|
|
* a standard, or they are really old converters that the
|
|
* standard doesn't recognize anymore.
|
|
*
|
|
* Converter Names (Usually in TR22 form)
|
|
* -------------------------------------------.
|
|
* T /##########################################/|
|
|
* a / # # /#
|
|
* g / # ## ## ### # ### ### ### #/
|
|
* s / # ##### #### ## ## #/#
|
|
* / ### # # ## # # # ### # # #/##
|
|
* ------------------------------------------/# #
|
|
* A |### # # ## # # # ### # # #|# #
|
|
* l |# # # # # ## # #|# #
|
|
* i |# # # # # # #|#
|
|
* a |# #|#
|
|
* s | #|#
|
|
* e
|
|
* s
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* Used by the UEnumeration API
|
|
*/
|
|
typedef struct UAliasContext {
|
|
uint32_t listOffset;
|
|
uint32_t listIdx;
|
|
} UAliasContext;
|
|
|
|
static const char DATA_NAME[] = "cnvalias";
|
|
static const char DATA_TYPE[] = "icu";
|
|
|
|
static UDataMemory *gAliasData=NULL;
|
|
|
|
enum {
|
|
tocLengthIndex=0,
|
|
converterListIndex=1,
|
|
tagListIndex=2,
|
|
aliasListIndex=3,
|
|
untaggedConvArrayIndex=4,
|
|
taggedAliasArrayIndex=5,
|
|
taggedAliasListsIndex=6,
|
|
reservedIndex1=7,
|
|
stringTableIndex=8,
|
|
minTocLength=8, /* min. tocLength in the file, does not count the tocLengthIndex! */
|
|
offsetsCount /* length of the swapper's temporary offsets[] */
|
|
};
|
|
|
|
static const uint16_t *gConverterList = NULL;
|
|
static const uint16_t *gTagList = NULL;
|
|
static const uint16_t *gAliasList = NULL;
|
|
static const uint16_t *gUntaggedConvArray = NULL;
|
|
static const uint16_t *gTaggedAliasArray = NULL;
|
|
static const uint16_t *gTaggedAliasLists = NULL;
|
|
static const uint16_t *gStringTable = NULL;
|
|
|
|
static uint32_t gConverterListSize;
|
|
static uint32_t gTagListSize;
|
|
static uint32_t gAliasListSize;
|
|
static uint32_t gUntaggedConvArraySize;
|
|
static uint32_t gTaggedAliasArraySize;
|
|
static uint32_t gTaggedAliasListsSize;
|
|
static uint32_t gStringTableSize;
|
|
|
|
static const char **gAvailableConverters = NULL;
|
|
static uint16_t gAvailableConverterCount = 0;
|
|
|
|
static char gDefaultConverterNameBuffer[UCNV_MAX_CONVERTER_NAME_LENGTH + 1]; /* +1 for NULL */
|
|
static const char *gDefaultConverterName = NULL;
|
|
|
|
#define GET_STRING(idx) (const char *)(gStringTable + (idx))
|
|
|
|
static UBool U_CALLCONV
|
|
isAcceptable(void *context,
|
|
const char *type, const char *name,
|
|
const UDataInfo *pInfo) {
|
|
return (UBool)(
|
|
pInfo->size>=20 &&
|
|
pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
|
|
pInfo->charsetFamily==U_CHARSET_FAMILY &&
|
|
pInfo->dataFormat[0]==0x43 && /* dataFormat="CvAl" */
|
|
pInfo->dataFormat[1]==0x76 &&
|
|
pInfo->dataFormat[2]==0x41 &&
|
|
pInfo->dataFormat[3]==0x6c &&
|
|
pInfo->formatVersion[0]==3);
|
|
}
|
|
|
|
static UBool
|
|
haveAliasData(UErrorCode *pErrorCode) {
|
|
int haveData;
|
|
|
|
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
|
|
return FALSE;
|
|
}
|
|
|
|
umtx_lock(NULL);
|
|
haveData = (int)(gAliasData==NULL);
|
|
umtx_unlock(NULL);
|
|
|
|
/* load converter alias data from file if necessary */
|
|
if (haveData) {
|
|
UDataMemory *data = NULL;
|
|
const uint16_t *table = NULL;
|
|
uint32_t tableStart;
|
|
uint32_t currOffset;
|
|
uint32_t reservedSize1;
|
|
|
|
data = udata_openChoice(NULL, DATA_TYPE, DATA_NAME, isAcceptable, NULL, pErrorCode);
|
|
if(U_FAILURE(*pErrorCode)) {
|
|
return FALSE;
|
|
}
|
|
|
|
table = (const uint16_t *)udata_getMemory(data);
|
|
|
|
tableStart = ((const uint32_t *)(table))[0];
|
|
if (tableStart < minTocLength) {
|
|
*pErrorCode = U_INVALID_FORMAT_ERROR;
|
|
udata_close(data);
|
|
return FALSE;
|
|
}
|
|
|
|
umtx_lock(NULL);
|
|
if(gAliasData==NULL) {
|
|
gAliasData = data;
|
|
data=NULL;
|
|
|
|
gConverterListSize = ((const uint32_t *)(table))[1];
|
|
gTagListSize = ((const uint32_t *)(table))[2];
|
|
gAliasListSize = ((const uint32_t *)(table))[3];
|
|
gUntaggedConvArraySize = ((const uint32_t *)(table))[4];
|
|
gTaggedAliasArraySize = ((const uint32_t *)(table))[5];
|
|
gTaggedAliasListsSize = ((const uint32_t *)(table))[6];
|
|
reservedSize1 = ((const uint32_t *)(table))[7]; /* reserved */
|
|
gStringTableSize = ((const uint32_t *)(table))[8];
|
|
|
|
currOffset = tableStart * (sizeof(uint32_t)/sizeof(uint16_t)) + (sizeof(uint32_t)/sizeof(uint16_t));
|
|
gConverterList = table + currOffset;
|
|
|
|
currOffset += gConverterListSize;
|
|
gTagList = table + currOffset;
|
|
|
|
currOffset += gTagListSize;
|
|
gAliasList = table + currOffset;
|
|
|
|
currOffset += gAliasListSize;
|
|
gUntaggedConvArray = table + currOffset;
|
|
|
|
currOffset += gUntaggedConvArraySize;
|
|
gTaggedAliasArray = table + currOffset;
|
|
|
|
/* aliasLists is a 1's based array, but it has a padding character */
|
|
currOffset += gTaggedAliasArraySize;
|
|
gTaggedAliasLists = table + currOffset;
|
|
|
|
currOffset += gTaggedAliasListsSize;
|
|
/* reserved */
|
|
|
|
currOffset += reservedSize1;
|
|
gStringTable = table + currOffset;
|
|
|
|
}
|
|
umtx_unlock(NULL);
|
|
|
|
/* if a different thread set it first, then close the extra data */
|
|
if(data!=NULL) {
|
|
udata_close(data); /* NULL if it was set correctly */
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static U_INLINE UBool
|
|
isAlias(const char *alias, UErrorCode *pErrorCode) {
|
|
if(alias==NULL) {
|
|
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
return FALSE;
|
|
} else if(*alias==0) {
|
|
return FALSE;
|
|
} else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
UBool
|
|
ucnv_io_cleanup()
|
|
{
|
|
if (gAliasData) {
|
|
udata_close(gAliasData);
|
|
gAliasData = NULL;
|
|
}
|
|
|
|
ucnv_io_flushAvailableConverterCache();
|
|
|
|
gConverterListSize = 0;
|
|
gTagListSize = 0;
|
|
gAliasListSize = 0;
|
|
gUntaggedConvArraySize = 0;
|
|
gTaggedAliasArraySize = 0;
|
|
gTaggedAliasListsSize = 0;
|
|
gStringTableSize = 0;
|
|
|
|
gConverterList = NULL;
|
|
gTagList = NULL;
|
|
gAliasList = NULL;
|
|
gUntaggedConvArray = NULL;
|
|
gTaggedAliasArray = NULL;
|
|
gTaggedAliasLists = NULL;
|
|
gStringTable = NULL;
|
|
|
|
gDefaultConverterName = NULL;
|
|
gDefaultConverterNameBuffer[0] = 0;
|
|
|
|
return TRUE; /* Everything was cleaned up */
|
|
}
|
|
|
|
|
|
static uint32_t getTagNumber(const char *tagname) {
|
|
if (gTagList) {
|
|
uint32_t tagNum;
|
|
for (tagNum = 0; tagNum < gTagListSize; tagNum++) {
|
|
if (!uprv_stricmp(GET_STRING(gTagList[tagNum]), tagname)) {
|
|
return tagNum;
|
|
}
|
|
}
|
|
}
|
|
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
/* @see ucnv_compareNames */
|
|
U_CFUNC char * U_EXPORT2
|
|
ucnv_io_stripASCIIForCompare(char *dst, const char *name) {
|
|
char c1 = *name;
|
|
char *dstItr = dst;
|
|
|
|
while (c1) {
|
|
/* Ignore delimiters '-', '_', and ' ' */
|
|
while ((c1 = *name) == 0x2d || c1 == 0x5f || c1 == 0x20) {
|
|
++name;
|
|
}
|
|
|
|
/* lowercase for case-insensitive comparison */
|
|
*(dstItr++) = uprv_asciitolower(c1);
|
|
++name;
|
|
}
|
|
return dst;
|
|
}
|
|
|
|
U_CFUNC char * U_EXPORT2
|
|
ucnv_io_stripEBCDICForCompare(char *dst, const char *name) {
|
|
char c1 = *name;
|
|
char *dstItr = dst;
|
|
|
|
while (c1) {
|
|
/* Ignore delimiters '-', '_', and ' ' */
|
|
while ((c1 = *name) == 0x60 || c1 == 0x6d || c1 == 0x40) {
|
|
++name;
|
|
}
|
|
|
|
/* lowercase for case-insensitive comparison */
|
|
*(dstItr++) = uprv_ebcdictolower(c1);
|
|
++name;
|
|
}
|
|
return dst;
|
|
}
|
|
|
|
/**
|
|
* Do a fuzzy compare of a two converter/alias names. The comparison
|
|
* is case-insensitive. It also ignores the characters '-', '_', and
|
|
* ' ' (dash, underscore, and space). Thus the strings "UTF-8",
|
|
* "utf_8", and "Utf 8" are exactly equivalent.
|
|
*
|
|
* This is a symmetrical (commutative) operation; order of arguments
|
|
* is insignificant. This is an important property for sorting the
|
|
* list (when the list is preprocessed into binary form) and for
|
|
* performing binary searches on it at run time.
|
|
*
|
|
* @param name1 a converter name or alias, zero-terminated
|
|
* @param name2 a converter name or alias, zero-terminated
|
|
* @return 0 if the names match, or a negative value if the name1
|
|
* lexically precedes name2, or a positive value if the name1
|
|
* lexically follows name2.
|
|
*
|
|
* @see ucnv_io_stripForCompare
|
|
*/
|
|
U_CAPI int U_EXPORT2
|
|
ucnv_compareNames(const char *name1, const char *name2) {
|
|
int rc;
|
|
char c1, c2;
|
|
|
|
for (;;) {
|
|
/* Ignore delimiters '-', '_', and ' ' */
|
|
while ((c1 = *name1) == '-' || c1 == '_' || c1 == ' ') {
|
|
++name1;
|
|
}
|
|
while ((c2 = *name2) == '-' || c2 == '_' || c2 == ' ') {
|
|
++name2;
|
|
}
|
|
|
|
/* If we reach the ends of both strings then they match */
|
|
if ((c1|c2)==0) {
|
|
return 0;
|
|
}
|
|
|
|
/* Case-insensitive comparison */
|
|
rc = (int)(unsigned char)uprv_tolower(c1) -
|
|
(int)(unsigned char)uprv_tolower(c2);
|
|
if (rc != 0) {
|
|
return rc;
|
|
}
|
|
++name1;
|
|
++name2;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* search for an alias
|
|
* return the converter number index for gConverterList
|
|
*/
|
|
static U_INLINE uint32_t
|
|
findConverter(const char *alias, UErrorCode *pErrorCode) {
|
|
uint32_t mid, start, limit;
|
|
uint32_t lastMid;
|
|
int result;
|
|
|
|
/* do a binary search for the alias */
|
|
start = 0;
|
|
limit = gUntaggedConvArraySize;
|
|
mid = limit;
|
|
lastMid = UINT32_MAX;
|
|
|
|
for (;;) {
|
|
mid = (uint32_t)((start + limit) / 2);
|
|
if (lastMid == mid) { /* Have we moved? */
|
|
break; /* We haven't moved, and it wasn't found. */
|
|
}
|
|
lastMid = mid;
|
|
result = ucnv_compareNames(alias, GET_STRING(gAliasList[mid]));
|
|
|
|
if (result < 0) {
|
|
limit = mid;
|
|
} else if (result > 0) {
|
|
start = mid;
|
|
} else {
|
|
/* Since the gencnval tool folds duplicates into one entry,
|
|
* this alias in gAliasList is unique, but different standards
|
|
* may map an alias to different converters.
|
|
*/
|
|
if (gUntaggedConvArray[mid] & UCNV_AMBIGUOUS_ALIAS_MAP_BIT) {
|
|
*pErrorCode = U_AMBIGUOUS_ALIAS_WARNING;
|
|
}
|
|
return gUntaggedConvArray[mid] & UCNV_CONVERTER_INDEX_MASK;
|
|
}
|
|
}
|
|
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
/*
|
|
* Is this alias in this list?
|
|
* alias and listOffset should be non-NULL.
|
|
*/
|
|
static U_INLINE UBool
|
|
isAliasInList(const char *alias, uint32_t listOffset) {
|
|
if (listOffset) {
|
|
uint32_t currAlias;
|
|
uint32_t listCount = gTaggedAliasLists[listOffset];
|
|
/* +1 to skip listCount */
|
|
const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
|
|
for (currAlias = 0; currAlias < listCount; currAlias++) {
|
|
if (currList[currAlias]
|
|
&& ucnv_compareNames(alias, GET_STRING(currList[currAlias]))==0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Search for an standard name of an alias (what is the default name
|
|
* that this standard uses?)
|
|
* return the listOffset for gTaggedAliasLists. If it's 0,
|
|
* the it couldn't be found, but the parameters are valid.
|
|
*/
|
|
static uint32_t
|
|
findTaggedAliasListsOffset(const char *alias, const char *standard, UErrorCode *pErrorCode) {
|
|
uint32_t idx;
|
|
uint32_t listOffset;
|
|
uint32_t convNum;
|
|
UErrorCode myErr = U_ZERO_ERROR;
|
|
uint32_t tagNum = getTagNumber(standard);
|
|
|
|
/* Make a quick guess. Hopefully they used a TR22 canonical alias. */
|
|
convNum = findConverter(alias, &myErr);
|
|
if (myErr != U_ZERO_ERROR) {
|
|
*pErrorCode = myErr;
|
|
}
|
|
|
|
if (tagNum < (gTagListSize - UCNV_NUM_HIDDEN_TAGS) && convNum < gConverterListSize) {
|
|
listOffset = gTaggedAliasArray[tagNum*gConverterListSize + convNum];
|
|
if (listOffset && gTaggedAliasLists[listOffset + 1]) {
|
|
return listOffset;
|
|
}
|
|
if (myErr == U_AMBIGUOUS_ALIAS_WARNING) {
|
|
/* Uh Oh! They used an ambiguous alias.
|
|
We have to search the whole swiss cheese starting
|
|
at the highest standard affinity.
|
|
This may take a while.
|
|
*/
|
|
for (idx = 0; idx < gTaggedAliasArraySize; idx++) {
|
|
listOffset = gTaggedAliasArray[idx];
|
|
if (listOffset && isAliasInList(alias, listOffset)) {
|
|
uint32_t currTagNum = idx/gConverterListSize;
|
|
uint32_t currConvNum = (idx - currTagNum*gConverterListSize);
|
|
uint32_t tempListOffset = gTaggedAliasArray[tagNum*gConverterListSize + currConvNum];
|
|
if (tempListOffset && gTaggedAliasLists[tempListOffset + 1]) {
|
|
return tempListOffset;
|
|
}
|
|
/* else keep on looking */
|
|
/* We could speed this up by starting on the next row
|
|
because an alias is unique per row, right now.
|
|
This would change if alias versioning appears. */
|
|
}
|
|
}
|
|
/* The standard doesn't know about the alias */
|
|
}
|
|
/* else no default name */
|
|
return 0;
|
|
}
|
|
/* else converter or tag not found */
|
|
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
/* Return the canonical name */
|
|
static uint32_t
|
|
findTaggedConverterNum(const char *alias, const char *standard, UErrorCode *pErrorCode) {
|
|
uint32_t idx;
|
|
uint32_t listOffset;
|
|
uint32_t convNum;
|
|
UErrorCode myErr = U_ZERO_ERROR;
|
|
uint32_t tagNum = getTagNumber(standard);
|
|
|
|
/* Make a quick guess. Hopefully they used a TR22 canonical alias. */
|
|
convNum = findConverter(alias, &myErr);
|
|
if (myErr != U_ZERO_ERROR) {
|
|
*pErrorCode = myErr;
|
|
}
|
|
|
|
if (tagNum < (gTagListSize - UCNV_NUM_HIDDEN_TAGS) && convNum < gConverterListSize) {
|
|
listOffset = gTaggedAliasArray[tagNum*gConverterListSize + convNum];
|
|
if (listOffset && isAliasInList(alias, listOffset)) {
|
|
return convNum;
|
|
}
|
|
if (myErr == U_AMBIGUOUS_ALIAS_WARNING) {
|
|
/* Uh Oh! They used an ambiguous alias.
|
|
We have to search one slice of the swiss cheese.
|
|
We search only in the requested tag, not the whole thing.
|
|
This may take a while.
|
|
*/
|
|
uint32_t convStart = (tagNum)*gConverterListSize;
|
|
uint32_t convLimit = (tagNum+1)*gConverterListSize;
|
|
for (idx = convStart; idx < convLimit; idx++) {
|
|
listOffset = gTaggedAliasArray[idx];
|
|
if (listOffset && isAliasInList(alias, listOffset)) {
|
|
return idx-convStart;
|
|
}
|
|
}
|
|
/* The standard doesn't know about the alias */
|
|
}
|
|
/* else no canonical name */
|
|
}
|
|
/* else converter or tag not found */
|
|
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
|
|
|
|
U_CFUNC const char *
|
|
ucnv_io_getConverterName(const char *alias, UErrorCode *pErrorCode) {
|
|
if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
|
|
uint32_t convNum = findConverter(alias, pErrorCode);
|
|
if (convNum < gConverterListSize) {
|
|
return GET_STRING(gConverterList[convNum]);
|
|
}
|
|
/* else converter not found */
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int32_t U_CALLCONV
|
|
ucnv_io_countStandardAliases(UEnumeration *enumerator, UErrorCode *pErrorCode) {
|
|
int32_t value = 0;
|
|
UAliasContext *myContext = (UAliasContext *)(enumerator->context);
|
|
uint32_t listOffset = myContext->listOffset;
|
|
|
|
if (listOffset) {
|
|
value = gTaggedAliasLists[listOffset];
|
|
}
|
|
return value;
|
|
}
|
|
|
|
static const char* U_CALLCONV
|
|
ucnv_io_nextStandardAliases(UEnumeration *enumerator,
|
|
int32_t* resultLength,
|
|
UErrorCode *pErrorCode)
|
|
{
|
|
UAliasContext *myContext = (UAliasContext *)(enumerator->context);
|
|
uint32_t listOffset = myContext->listOffset;
|
|
|
|
if (listOffset) {
|
|
uint32_t listCount = gTaggedAliasLists[listOffset];
|
|
const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
|
|
|
|
if (myContext->listIdx < listCount) {
|
|
const char *myStr = GET_STRING(currList[myContext->listIdx++]);
|
|
if (resultLength) {
|
|
*resultLength = (int32_t)uprv_strlen(myStr);
|
|
}
|
|
return myStr;
|
|
}
|
|
}
|
|
/* Either we accessed a zero length list, or we enumerated too far. */
|
|
*pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
static void U_CALLCONV
|
|
ucnv_io_resetStandardAliases(UEnumeration *enumerator, UErrorCode *pErrorCode) {
|
|
((UAliasContext *)(enumerator->context))->listIdx = 0;
|
|
}
|
|
|
|
static void U_CALLCONV
|
|
ucnv_io_closeUEnumeration(UEnumeration *enumerator) {
|
|
uprv_free(enumerator->context);
|
|
uprv_free(enumerator);
|
|
}
|
|
|
|
/* Enumerate the aliases for the specified converter and standard tag */
|
|
static const UEnumeration gEnumAliases = {
|
|
NULL,
|
|
NULL,
|
|
ucnv_io_closeUEnumeration,
|
|
ucnv_io_countStandardAliases,
|
|
uenum_unextDefault,
|
|
ucnv_io_nextStandardAliases,
|
|
ucnv_io_resetStandardAliases
|
|
};
|
|
|
|
U_CAPI UEnumeration * U_EXPORT2
|
|
ucnv_openStandardNames(const char *convName,
|
|
const char *standard,
|
|
UErrorCode *pErrorCode)
|
|
{
|
|
UEnumeration *myEnum = NULL;
|
|
if (haveAliasData(pErrorCode) && isAlias(convName, pErrorCode)) {
|
|
uint32_t listOffset = findTaggedAliasListsOffset(convName, standard, pErrorCode);
|
|
|
|
/* When listOffset == 0, we want to acknowledge that the
|
|
converter name and standard are okay, but there
|
|
is nothing to enumerate. */
|
|
if (listOffset < gTaggedAliasListsSize) {
|
|
UAliasContext *myContext;
|
|
|
|
myEnum = uprv_malloc(sizeof(UEnumeration));
|
|
if (myEnum == NULL) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
return NULL;
|
|
}
|
|
uprv_memcpy(myEnum, &gEnumAliases, sizeof(UEnumeration));
|
|
myContext = uprv_malloc(sizeof(UAliasContext));
|
|
if (myContext == NULL) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
uprv_free(myEnum);
|
|
return NULL;
|
|
}
|
|
myContext->listOffset = listOffset;
|
|
myContext->listIdx = 0;
|
|
myEnum->context = myContext;
|
|
}
|
|
/* else converter or tag not found */
|
|
}
|
|
return myEnum;
|
|
}
|
|
|
|
U_CFUNC uint16_t
|
|
ucnv_io_countAliases(const char *alias, UErrorCode *pErrorCode) {
|
|
if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
|
|
uint32_t convNum = findConverter(alias, pErrorCode);
|
|
if (convNum < gConverterListSize) {
|
|
/* tagListNum - 1 is the ALL tag */
|
|
int32_t listOffset = gTaggedAliasArray[(gTagListSize - 1)*gConverterListSize + convNum];
|
|
|
|
if (listOffset) {
|
|
return gTaggedAliasLists[listOffset];
|
|
}
|
|
/* else this shouldn't happen. internal program error */
|
|
}
|
|
/* else converter not found */
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
U_CFUNC uint16_t
|
|
ucnv_io_getAliases(const char *alias, uint16_t start, const char **aliases, UErrorCode *pErrorCode) {
|
|
if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
|
|
uint32_t currAlias;
|
|
uint32_t convNum = findConverter(alias, pErrorCode);
|
|
if (convNum < gConverterListSize) {
|
|
/* tagListNum - 1 is the ALL tag */
|
|
int32_t listOffset = gTaggedAliasArray[(gTagListSize - 1)*gConverterListSize + convNum];
|
|
|
|
if (listOffset) {
|
|
uint32_t listCount = gTaggedAliasLists[listOffset];
|
|
/* +1 to skip listCount */
|
|
const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
|
|
|
|
for (currAlias = start; currAlias < listCount; currAlias++) {
|
|
aliases[currAlias] = GET_STRING(currList[currAlias]);
|
|
}
|
|
}
|
|
/* else this shouldn't happen. internal program error */
|
|
}
|
|
/* else converter not found */
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
U_CFUNC const char *
|
|
ucnv_io_getAlias(const char *alias, uint16_t n, UErrorCode *pErrorCode) {
|
|
if(haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
|
|
uint32_t convNum = findConverter(alias, pErrorCode);
|
|
if (convNum < gConverterListSize) {
|
|
/* tagListNum - 1 is the ALL tag */
|
|
int32_t listOffset = gTaggedAliasArray[(gTagListSize - 1)*gConverterListSize + convNum];
|
|
|
|
if (listOffset) {
|
|
uint32_t listCount = gTaggedAliasLists[listOffset];
|
|
/* +1 to skip listCount */
|
|
const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
|
|
|
|
if (n < listCount) {
|
|
return GET_STRING(currList[n]);
|
|
}
|
|
*pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
}
|
|
/* else this shouldn't happen. internal program error */
|
|
}
|
|
/* else converter not found */
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
U_CFUNC uint16_t
|
|
ucnv_io_countStandards(UErrorCode *pErrorCode) {
|
|
if (haveAliasData(pErrorCode)) {
|
|
/* Don't include the empty list */
|
|
return (uint16_t)(gTagListSize - UCNV_NUM_HIDDEN_TAGS);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
U_CAPI const char * U_EXPORT2
|
|
ucnv_getStandard(uint16_t n, UErrorCode *pErrorCode) {
|
|
if (haveAliasData(pErrorCode)) {
|
|
if (n < gTagListSize - UCNV_NUM_HIDDEN_TAGS) {
|
|
return GET_STRING(gTagList[n]);
|
|
}
|
|
*pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
U_CAPI const char * U_EXPORT2
|
|
ucnv_getStandardName(const char *alias, const char *standard, UErrorCode *pErrorCode) {
|
|
if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
|
|
uint32_t listOffset = findTaggedAliasListsOffset(alias, standard, pErrorCode);
|
|
|
|
if (0 < listOffset && listOffset < gTaggedAliasListsSize) {
|
|
const uint16_t *currList = gTaggedAliasLists + listOffset + 1;
|
|
|
|
/* Get the preferred name from this list */
|
|
if (currList[0]) {
|
|
return GET_STRING(currList[0]);
|
|
}
|
|
/* else someone screwed up the alias table. */
|
|
/* *pErrorCode = U_INVALID_FORMAT_ERROR */
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
U_CAPI const char * U_EXPORT2
|
|
ucnv_getCanonicalName(const char *alias, const char *standard, UErrorCode *pErrorCode) {
|
|
if (haveAliasData(pErrorCode) && isAlias(alias, pErrorCode)) {
|
|
uint32_t convNum = findTaggedConverterNum(alias, standard, pErrorCode);
|
|
|
|
if (convNum < gConverterListSize) {
|
|
return GET_STRING(gConverterList[convNum]);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
ucnv_io_flushAvailableConverterCache() {
|
|
if (gAvailableConverters) {
|
|
umtx_lock(NULL);
|
|
gAvailableConverterCount = 0;
|
|
uprv_free((char **)gAvailableConverters);
|
|
gAvailableConverters = NULL;
|
|
umtx_unlock(NULL);
|
|
}
|
|
}
|
|
|
|
static UBool haveAvailableConverterList(UErrorCode *pErrorCode) {
|
|
if (gAvailableConverters == NULL) {
|
|
uint16_t idx;
|
|
uint16_t localConverterCount;
|
|
UErrorCode status;
|
|
const char *converterName;
|
|
const char **localConverterList;
|
|
|
|
if (!haveAliasData(pErrorCode)) {
|
|
return FALSE;
|
|
}
|
|
|
|
/* We can't have more than "*converterTable" converters to open */
|
|
localConverterList = (const char **) uprv_malloc(gConverterListSize * sizeof(char*));
|
|
if (!localConverterList) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
return FALSE;
|
|
}
|
|
|
|
localConverterCount = 0;
|
|
|
|
for (idx = 0; idx < gConverterListSize; idx++) {
|
|
status = U_ZERO_ERROR;
|
|
converterName = GET_STRING(gConverterList[idx]);
|
|
ucnv_close(ucnv_open(converterName, &status));
|
|
if (U_SUCCESS(status)) {
|
|
localConverterList[localConverterCount++] = converterName;
|
|
}
|
|
}
|
|
|
|
umtx_lock(NULL);
|
|
if (gAvailableConverters == NULL) {
|
|
gAvailableConverters = localConverterList;
|
|
gAvailableConverterCount = localConverterCount;
|
|
}
|
|
else {
|
|
uprv_free((char **)localConverterList);
|
|
}
|
|
umtx_unlock(NULL);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
U_CFUNC uint16_t
|
|
ucnv_io_countAvailableConverters(UErrorCode *pErrorCode) {
|
|
if (haveAvailableConverterList(pErrorCode)) {
|
|
return gAvailableConverterCount;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
U_CFUNC const char *
|
|
ucnv_io_getAvailableConverter(uint16_t n, UErrorCode *pErrorCode) {
|
|
if (haveAvailableConverterList(pErrorCode)) {
|
|
if (n < gAvailableConverterCount) {
|
|
return gAvailableConverters[n];
|
|
}
|
|
*pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int32_t U_CALLCONV
|
|
ucnv_io_countAllConverters(UEnumeration *enumerator, UErrorCode *pErrorCode) {
|
|
return gConverterListSize;
|
|
}
|
|
|
|
static const char* U_CALLCONV
|
|
ucnv_io_nextAllConverters(UEnumeration *enumerator,
|
|
int32_t* resultLength,
|
|
UErrorCode *pErrorCode)
|
|
{
|
|
uint16_t *myContext = (uint16_t *)(enumerator->context);
|
|
|
|
if (*myContext < gConverterListSize) {
|
|
const char *myStr = GET_STRING(gConverterList[(*myContext)++]);
|
|
if (resultLength) {
|
|
*resultLength = (int32_t)uprv_strlen(myStr);
|
|
}
|
|
return myStr;
|
|
}
|
|
/* Either we accessed a zero length list, or we enumerated too far. */
|
|
*pErrorCode = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return NULL;
|
|
}
|
|
|
|
static void U_CALLCONV
|
|
ucnv_io_resetAllConverters(UEnumeration *enumerator, UErrorCode *pErrorCode) {
|
|
*((uint16_t *)(enumerator->context)) = 0;
|
|
}
|
|
|
|
static const UEnumeration gEnumAllConverters = {
|
|
NULL,
|
|
NULL,
|
|
ucnv_io_closeUEnumeration,
|
|
ucnv_io_countAllConverters,
|
|
uenum_unextDefault,
|
|
ucnv_io_nextAllConverters,
|
|
ucnv_io_resetAllConverters
|
|
};
|
|
|
|
U_CAPI UEnumeration * U_EXPORT2
|
|
ucnv_openAllNames(UErrorCode *pErrorCode) {
|
|
UEnumeration *myEnum = NULL;
|
|
if (haveAliasData(pErrorCode)) {
|
|
uint16_t *myContext;
|
|
|
|
myEnum = uprv_malloc(sizeof(UEnumeration));
|
|
if (myEnum == NULL) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
return NULL;
|
|
}
|
|
uprv_memcpy(myEnum, &gEnumAllConverters, sizeof(UEnumeration));
|
|
myContext = uprv_malloc(sizeof(uint16_t));
|
|
if (myContext == NULL) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
uprv_free(myEnum);
|
|
return NULL;
|
|
}
|
|
*myContext = 0;
|
|
myEnum->context = myContext;
|
|
}
|
|
return myEnum;
|
|
}
|
|
|
|
U_CFUNC uint16_t
|
|
ucnv_io_countAvailableAliases(UErrorCode *pErrorCode) {
|
|
if (haveAliasData(pErrorCode)) {
|
|
return (uint16_t)gAliasListSize;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* default converter name --------------------------------------------------- */
|
|
|
|
/*
|
|
* In order to be really thread-safe, the get function would have to take
|
|
* a buffer parameter and copy the current string inside a mutex block.
|
|
* This implementation only tries to be really thread-safe while
|
|
* setting the name.
|
|
* It assumes that setting a pointer is atomic.
|
|
*/
|
|
|
|
U_CFUNC const char *
|
|
ucnv_io_getDefaultConverterName() {
|
|
/* local variable to be thread-safe */
|
|
const char *name;
|
|
|
|
umtx_lock(NULL);
|
|
name=gDefaultConverterName;
|
|
umtx_unlock(NULL);
|
|
|
|
if(name==NULL) {
|
|
UErrorCode errorCode = U_ZERO_ERROR;
|
|
UConverter *cnv = NULL;
|
|
int32_t length = 0;
|
|
|
|
umtx_lock(NULL);
|
|
name = uprv_getDefaultCodepage();
|
|
umtx_unlock(NULL);
|
|
|
|
/* if the name is there, test it out and get the canonical name with options */
|
|
if(name != NULL) {
|
|
cnv = ucnv_open(name, &errorCode);
|
|
if(U_SUCCESS(errorCode) && cnv != NULL) {
|
|
name = ucnv_getName(cnv, &errorCode);
|
|
}
|
|
}
|
|
|
|
if(name == NULL || name[0] == 0
|
|
|| U_FAILURE(errorCode) || cnv == NULL
|
|
|| length>=sizeof(gDefaultConverterNameBuffer))
|
|
{
|
|
/* Panic time, let's use a fallback. */
|
|
#if (U_CHARSET_FAMILY == U_ASCII_FAMILY)
|
|
name = "US-ASCII";
|
|
/* there is no 'algorithmic' converter for EBCDIC */
|
|
#elif defined(OS390)
|
|
name = "ibm-1047_P100-1995" UCNV_SWAP_LFNL_OPTION_STRING;
|
|
#else
|
|
name = "ibm-37_P100-1995";
|
|
#endif
|
|
}
|
|
|
|
length=(int32_t)(uprv_strlen(name));
|
|
|
|
/* Copy the name before we close the converter. */
|
|
umtx_lock(NULL);
|
|
uprv_memcpy(gDefaultConverterNameBuffer, name, length);
|
|
gDefaultConverterNameBuffer[length]=0;
|
|
gDefaultConverterName = gDefaultConverterNameBuffer;
|
|
name = gDefaultConverterName;
|
|
umtx_unlock(NULL);
|
|
|
|
/* The close may make the current name go away. */
|
|
ucnv_close(cnv);
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
U_CFUNC void
|
|
ucnv_io_setDefaultConverterName(const char *converterName) {
|
|
if(converterName==NULL) {
|
|
/* reset to the default codepage */
|
|
gDefaultConverterName=NULL;
|
|
} else {
|
|
UErrorCode errorCode=U_ZERO_ERROR;
|
|
const char *name=ucnv_io_getConverterName(converterName, &errorCode);
|
|
|
|
umtx_lock(NULL);
|
|
|
|
if(U_SUCCESS(errorCode) && name!=NULL) {
|
|
gDefaultConverterName=name;
|
|
} else {
|
|
/* do not set the name if the alias lookup failed and it is too long */
|
|
int32_t length=(int32_t)(uprv_strlen(converterName));
|
|
if(length<sizeof(gDefaultConverterNameBuffer)) {
|
|
/* it was not found as an alias, so copy it - accept an empty name */
|
|
uprv_memcpy(gDefaultConverterNameBuffer, converterName, length);
|
|
gDefaultConverterNameBuffer[length]=0;
|
|
gDefaultConverterName=gDefaultConverterNameBuffer;
|
|
}
|
|
}
|
|
|
|
umtx_unlock(NULL);
|
|
}
|
|
}
|
|
|
|
/* alias table swapping ----------------------------------------------------- */
|
|
|
|
typedef char * U_CALLCONV StripForCompareFn(char *dst, const char *name);
|
|
|
|
/*
|
|
* row of a temporary array
|
|
*
|
|
* gets platform-endian charset string indexes and sorting indexes;
|
|
* after sorting this array by strings, the actual arrays are permutated
|
|
* according to the sorting indexes
|
|
*/
|
|
typedef struct Row {
|
|
uint16_t strIndex, sortIndex;
|
|
} Row;
|
|
|
|
typedef struct TempTable {
|
|
const char *chars;
|
|
Row *rows;
|
|
uint16_t *resort;
|
|
StripForCompareFn *stripForCompare;
|
|
} TempTable;
|
|
|
|
enum {
|
|
STACK_ROW_CAPACITY=500
|
|
};
|
|
|
|
static int32_t
|
|
io_compareRows(const void *context, const void *left, const void *right) {
|
|
char strippedLeft[UCNV_MAX_CONVERTER_NAME_LENGTH],
|
|
strippedRight[UCNV_MAX_CONVERTER_NAME_LENGTH];
|
|
|
|
TempTable *tempTable=(TempTable *)context;
|
|
const char *chars=tempTable->chars;
|
|
|
|
return (int32_t)uprv_strcmp(tempTable->stripForCompare(strippedLeft, chars+2*((const Row *)left)->strIndex),
|
|
tempTable->stripForCompare(strippedRight, chars+2*((const Row *)right)->strIndex));
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
ucnv_swapAliases(const UDataSwapper *ds,
|
|
const void *inData, int32_t length, void *outData,
|
|
UErrorCode *pErrorCode) {
|
|
const UDataInfo *pInfo;
|
|
int32_t headerSize;
|
|
|
|
const uint16_t *inTable;
|
|
uint32_t toc[offsetsCount];
|
|
uint32_t offsets[offsetsCount]; /* 16-bit-addressed offsets from inTable/outTable */
|
|
uint32_t i, count, tocLength, topOffset;
|
|
|
|
Row rows[STACK_ROW_CAPACITY];
|
|
uint16_t resort[STACK_ROW_CAPACITY];
|
|
TempTable tempTable;
|
|
|
|
/* udata_swapDataHeader checks the arguments */
|
|
headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode);
|
|
if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
|
|
return 0;
|
|
}
|
|
|
|
/* check data format and format version */
|
|
pInfo=(const UDataInfo *)((const char *)inData+4);
|
|
if(!(
|
|
pInfo->dataFormat[0]==0x43 && /* dataFormat="CvAl" */
|
|
pInfo->dataFormat[1]==0x76 &&
|
|
pInfo->dataFormat[2]==0x41 &&
|
|
pInfo->dataFormat[3]==0x6c &&
|
|
pInfo->formatVersion[0]==3
|
|
)) {
|
|
udata_printError(ds, "ucnv_swapAliases(): data format %02x.%02x.%02x.%02x (format version %02x) is not an alias table\n",
|
|
pInfo->dataFormat[0], pInfo->dataFormat[1],
|
|
pInfo->dataFormat[2], pInfo->dataFormat[3],
|
|
pInfo->formatVersion[0]);
|
|
*pErrorCode=U_UNSUPPORTED_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
/* an alias table must contain at least the table of contents array */
|
|
if(length>=0 && (length-headerSize)<4*(1+minTocLength)) {
|
|
udata_printError(ds, "ucnv_swapAliases(): too few bytes (%d after header) for an alias table\n",
|
|
length-headerSize);
|
|
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
inTable=(const uint16_t *)((const char *)inData+headerSize);
|
|
toc[tocLengthIndex]=tocLength=ds->readUInt32(((const uint32_t *)inTable)[tocLengthIndex]);
|
|
if(tocLength<minTocLength) {
|
|
udata_printError(ds, "ucnv_swapAliases(): table of contents too short (%u sections)\n", tocLength);
|
|
*pErrorCode=U_INVALID_FORMAT_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
/* read the known part of the table of contents */
|
|
for(i=converterListIndex; i<=minTocLength; ++i) {
|
|
toc[i]=ds->readUInt32(((const uint32_t *)inTable)[i]);
|
|
}
|
|
|
|
/* compute offsets */
|
|
offsets[tocLengthIndex]=0;
|
|
offsets[converterListIndex]=2*(1+tocLength); /* count two 16-bit units per toc entry */
|
|
for(i=tagListIndex; i<=stringTableIndex; ++i) {
|
|
offsets[i]=offsets[i-1]+toc[i-1];
|
|
}
|
|
|
|
/* compute the overall size of the after-header data, in numbers of 16-bit units */
|
|
topOffset=offsets[i-1]+toc[i-1];
|
|
|
|
if(length>=0) {
|
|
uint16_t *outTable;
|
|
const uint16_t *p, *p2;
|
|
uint16_t *q, *q2;
|
|
uint16_t oldIndex;
|
|
|
|
if((length-headerSize)<(2*(int32_t)topOffset)) {
|
|
udata_printError(ds, "ucnv_swapAliases(): too few bytes (%d after header) for an alias table\n",
|
|
length-headerSize);
|
|
*pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
outTable=(uint16_t *)((char *)outData+headerSize);
|
|
|
|
/* swap the entire table of contents */
|
|
ds->swapArray32(ds, inTable, 4*(1+tocLength), outTable, pErrorCode);
|
|
|
|
/* swap strings */
|
|
ds->swapInvChars(ds, inTable+offsets[stringTableIndex], 2*(int32_t)toc[stringTableIndex],
|
|
outTable+offsets[stringTableIndex], pErrorCode);
|
|
if(U_FAILURE(*pErrorCode)) {
|
|
udata_printError(ds, "ucnv_swapAliases().swapInvChars(charset names) failed - %s\n",
|
|
u_errorName(*pErrorCode));
|
|
return 0;
|
|
}
|
|
|
|
if(ds->inCharset==ds->outCharset) {
|
|
/* no need to sort, just swap all 16-bit values together */
|
|
ds->swapArray16(ds,
|
|
inTable+offsets[converterListIndex],
|
|
2*(int32_t)(offsets[stringTableIndex]-offsets[converterListIndex]),
|
|
outTable+offsets[converterListIndex],
|
|
pErrorCode);
|
|
} else {
|
|
/* allocate the temporary table for sorting */
|
|
count=toc[aliasListIndex];
|
|
|
|
tempTable.chars=(const char *)(outTable+offsets[stringTableIndex]); /* sort by outCharset */
|
|
|
|
if(count<=STACK_ROW_CAPACITY) {
|
|
tempTable.rows=rows;
|
|
tempTable.resort=resort;
|
|
} else {
|
|
tempTable.rows=(Row *)uprv_malloc(count*sizeof(Row)+count*2);
|
|
if(tempTable.rows==NULL) {
|
|
udata_printError(ds, "ucnv_swapAliases(): unable to allocate memory for sorting tables (max length: %u)\n",
|
|
count);
|
|
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return 0;
|
|
}
|
|
tempTable.resort=(uint16_t *)(tempTable.rows+count);
|
|
}
|
|
|
|
if(ds->outCharset==U_ASCII_FAMILY) {
|
|
tempTable.stripForCompare=ucnv_io_stripASCIIForCompare;
|
|
} else /* U_EBCDIC_FAMILY */ {
|
|
tempTable.stripForCompare=ucnv_io_stripEBCDICForCompare;
|
|
}
|
|
|
|
/*
|
|
* Sort unique aliases+mapped names.
|
|
*
|
|
* We need to sort the list again by outCharset strings because they
|
|
* sort differently for different charset families.
|
|
* First we set up a temporary table with the string indexes and
|
|
* sorting indexes and sort that.
|
|
* Then we permutate and copy/swap the actual values.
|
|
*/
|
|
p=inTable+offsets[aliasListIndex];
|
|
q=outTable+offsets[aliasListIndex];
|
|
|
|
p2=inTable+offsets[untaggedConvArrayIndex];
|
|
q2=outTable+offsets[untaggedConvArrayIndex];
|
|
|
|
for(i=0; i<count; ++i) {
|
|
tempTable.rows[i].strIndex=ds->readUInt16(p[i]);
|
|
tempTable.rows[i].sortIndex=(uint16_t)i;
|
|
}
|
|
|
|
uprv_sortArray(tempTable.rows, (int32_t)count, sizeof(Row),
|
|
io_compareRows, &tempTable,
|
|
FALSE, pErrorCode);
|
|
|
|
if(U_SUCCESS(*pErrorCode)) {
|
|
/* copy/swap/permutate items */
|
|
if(p!=q) {
|
|
for(i=0; i<count; ++i) {
|
|
oldIndex=tempTable.rows[i].sortIndex;
|
|
ds->swapArray16(ds, p+oldIndex, 2, q+i, pErrorCode);
|
|
ds->swapArray16(ds, p2+oldIndex, 2, q2+i, pErrorCode);
|
|
}
|
|
} else {
|
|
/*
|
|
* If we swap in-place, then the permutation must use another
|
|
* temporary array (tempTable.resort)
|
|
* before the results are copied to the outBundle.
|
|
*/
|
|
uint16_t *r=tempTable.resort;
|
|
|
|
for(i=0; i<count; ++i) {
|
|
oldIndex=tempTable.rows[i].sortIndex;
|
|
ds->swapArray16(ds, p+oldIndex, 2, r+i, pErrorCode);
|
|
}
|
|
uprv_memcpy(q, r, 2*count);
|
|
|
|
for(i=0; i<count; ++i) {
|
|
oldIndex=tempTable.rows[i].sortIndex;
|
|
ds->swapArray16(ds, p2+oldIndex, 2, r+i, pErrorCode);
|
|
}
|
|
uprv_memcpy(q2, r, 2*count);
|
|
}
|
|
}
|
|
|
|
if(tempTable.rows!=rows) {
|
|
uprv_free(tempTable.rows);
|
|
}
|
|
|
|
if(U_FAILURE(*pErrorCode)) {
|
|
udata_printError(ds, "ucnv_swapAliases().uprv_sortArray(%u items) failed - %s\n",
|
|
count, u_errorName(*pErrorCode));
|
|
return 0;
|
|
}
|
|
|
|
/* swap remaining 16-bit values */
|
|
ds->swapArray16(ds,
|
|
inTable+offsets[converterListIndex],
|
|
2*(int32_t)(offsets[aliasListIndex]-offsets[converterListIndex]),
|
|
outTable+offsets[converterListIndex],
|
|
pErrorCode);
|
|
ds->swapArray16(ds,
|
|
inTable+offsets[taggedAliasArrayIndex],
|
|
2*(int32_t)(offsets[stringTableIndex]-offsets[taggedAliasArrayIndex]),
|
|
outTable+offsets[taggedAliasArrayIndex],
|
|
pErrorCode);
|
|
}
|
|
}
|
|
|
|
return headerSize+2*(int32_t)topOffset;
|
|
}
|
|
|
|
/*
|
|
* Hey, Emacs, please set the following:
|
|
*
|
|
* Local Variables:
|
|
* indent-tabs-mode: nil
|
|
* End:
|
|
*
|
|
*/
|