// Copyright (C) 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
* Copyright (C) 2008-2011, International Business Machines
* Corporation, Google and others. All Rights Reserved.
*
*******************************************************************************
*/
// Author : eldawy@google.com (Mohamed Eldawy)
// ucnvsel.cpp
//
// Purpose: To generate a list of encodings capable of handling
// a given Unicode text
//
// Started 09-April-2008
/**
* \file
*
* This is an implementation of an encoding selector.
* The goal is, given a unicode string, find the encodings
* this string can be mapped to. To make processing faster
* a trie is built when you call ucnvsel_open() that
* stores all encodings a codepoint can map to
*/
#include "unicode/ucnvsel.h"
#if !UCONFIG_NO_CONVERSION
#include <string.h>
#include "unicode/uchar.h"
#include "unicode/uniset.h"
#include "unicode/ucnv.h"
#include "unicode/ustring.h"
#include "unicode/uchriter.h"
#include "utrie2.h"
#include "propsvec.h"
#include "uassert.h"
#include "ucmndata.h"
#include "uenumimp.h"
#include "cmemory.h"
#include "cstring.h"
U_NAMESPACE_USE
struct UConverterSelector {
UTrie2 *trie; // 16 bit trie containing offsets into pv
uint32_t* pv; // table of bits!
int32_t pvCount;
char** encodings; // which encodings did user ask to use?
int32_t encodingsCount;
int32_t encodingStrLength;
uint8_t* swapped;
UBool ownPv, ownEncodingStrings;
};
static void generateSelectorData(UConverterSelector* result,
UPropsVectors *upvec,
const USet* excludedCodePoints,
const UConverterUnicodeSet whichSet,
UErrorCode* status) {
if (U_FAILURE(*status)) {
return;
}
int32_t columns = (result->encodingsCount+31)/32;
// set errorValue to all-ones
for (int32_t col = 0; col < columns; col++) {
upvec_setValue(upvec, UPVEC_ERROR_VALUE_CP, UPVEC_ERROR_VALUE_CP,
col, ~0, ~0, status);
}
for (int32_t i = 0; i < result->encodingsCount; ++i) {
uint32_t mask;
uint32_t column;
int32_t item_count;
int32_t j;
UConverter* test_converter = ucnv_open(result->encodings[i], status);
if (U_FAILURE(*status)) {
return;
}
USet* unicode_point_set;
unicode_point_set = uset_open(1, 0); // empty set
ucnv_getUnicodeSet(test_converter, unicode_point_set,
whichSet, status);
if (U_FAILURE(*status)) {
ucnv_close(test_converter);
return;
}
column = i / 32;
mask = 1 << (i%32);
// now iterate over intervals on set i!
item_count = uset_getItemCount(unicode_point_set);
for (j = 0; j < item_count; ++j) {
UChar32 start_char;
UChar32 end_char;
UErrorCode smallStatus = U_ZERO_ERROR;
uset_getItem(unicode_point_set, j, &start_char, &end_char, NULL, 0,
&smallStatus);
if (U_FAILURE(smallStatus)) {
// this will be reached for the converters that fill the set with
// strings. Those should be ignored by our system
} else {
upvec_setValue(upvec, start_char, end_char, column, ~0, mask,
status);
}
}
ucnv_close(test_converter);
uset_close(unicode_point_set);
if (U_FAILURE(*status)) {
return;
}
}
// handle excluded encodings! Simply set their values to all 1's in the upvec
if (excludedCodePoints) {
int32_t item_count = uset_getItemCount(excludedCodePoints);
for (int32_t j = 0; j < item_count; ++j) {
UChar32 start_char;
UChar32 end_char;
uset_getItem(excludedCodePoints, j, &start_char, &end_char, NULL, 0,
status);
for (int32_t col = 0; col < columns; col++) {
upvec_setValue(upvec, start_char, end_char, col, ~0, ~0,
status);
}
}
}
// alright. Now, let's put things in the same exact form you'd get when you
// unserialize things.
result->trie = upvec_compactToUTrie2WithRowIndexes(upvec, status);
result->pv = upvec_cloneArray(upvec, &result->pvCount, NULL, status);
result->pvCount *= columns; // number of uint32_t = rows * columns
result->ownPv = TRUE;
}
/* open a selector. If converterListSize is 0, build for all converters.
If excludedCodePoints is NULL, don't exclude any codepoints */
U_CAPI UConverterSelector* U_EXPORT2
ucnvsel_open(const char* const* converterList, int32_t converterListSize,
const USet* excludedCodePoints,
const UConverterUnicodeSet whichSet, UErrorCode* status) {
// check if already failed
if (U_FAILURE(*status)) {
return NULL;
}
// ensure args make sense!
if (converterListSize < 0 || (converterList == NULL && converterListSize != 0)) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
// allocate a new converter
LocalUConverterSelectorPointer newSelector(
(UConverterSelector*)uprv_malloc(sizeof(UConverterSelector)));
if (newSelector.isNull()) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
uprv_memset(newSelector.getAlias(), 0, sizeof(UConverterSelector));
if (converterListSize == 0) {
converterList = NULL;
converterListSize = ucnv_countAvailable();
}
newSelector->encodings =
(char**)uprv_malloc(converterListSize * sizeof(char*));
if (!newSelector->encodings) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
newSelector->encodings[0] = NULL; // now we can call ucnvsel_close()
// make a backup copy of the list of converters
int32_t totalSize = 0;
int32_t i;
for (i = 0; i < converterListSize; i++) {
totalSize +=
(int32_t)uprv_strlen(converterList != NULL ? converterList[i] : ucnv_getAvailableName(i)) + 1;
}
// 4-align the totalSize to 4-align the size of the serialized form
int32_t encodingStrPadding = totalSize & 3;
if (encodingStrPadding != 0) {
encodingStrPadding = 4 - encodingStrPadding;
}
newSelector->encodingStrLength = totalSize += encodingStrPadding;
char* allStrings = (char*) uprv_malloc(totalSize);
if (!allStrings) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
for (i = 0; i < converterListSize; i++) {
newSelector->encodings[i] = allStrings;
uprv_strcpy(newSelector->encodings[i],
converterList != NULL ? converterList[i] : ucnv_getAvailableName(i));
allStrings += uprv_strlen(newSelector->encodings[i]) + 1;
}
while (encodingStrPadding > 0) {
*allStrings++ = 0;
--encodingStrPadding;
}
newSelector->ownEncodingStrings = TRUE;
newSelector->encodingsCount = converterListSize;
UPropsVectors *upvec = upvec_open((converterListSize+31)/32, status);
generateSelectorData(newSelector.getAlias(), upvec, excludedCodePoints, whichSet, status);
upvec_close(upvec);
if (U_FAILURE(*status)) {
return NULL;
}
return newSelector.orphan();
}
/* close opened selector */
U_CAPI void U_EXPORT2
ucnvsel_close(UConverterSelector *sel) {
if (!sel) {
return;
}
if (sel->ownEncodingStrings) {
uprv_free(sel->encodings[0]);
}
uprv_free(sel->encodings);
if (sel->ownPv) {
uprv_free(sel->pv);
}
utrie2_close(sel->trie);
uprv_free(sel->swapped);
uprv_free(sel);
}
static const UDataInfo dataInfo = {
sizeof(UDataInfo),
0,
U_IS_BIG_ENDIAN,
U_CHARSET_FAMILY,
U_SIZEOF_UCHAR,
0,
{ 0x43, 0x53, 0x65, 0x6c }, /* dataFormat="CSel" */
{ 1, 0, 0, 0 }, /* formatVersion */
{ 0, 0, 0, 0 } /* dataVersion */
};
enum {
UCNVSEL_INDEX_TRIE_SIZE, // trie size in bytes
UCNVSEL_INDEX_PV_COUNT, // number of uint32_t in the bit vectors
UCNVSEL_INDEX_NAMES_COUNT, // number of encoding names
UCNVSEL_INDEX_NAMES_LENGTH, // number of encoding name bytes including padding
UCNVSEL_INDEX_SIZE = 15, // bytes following the DataHeader
UCNVSEL_INDEX_COUNT = 16
};
/*
* Serialized form of a UConverterSelector, formatVersion 1:
*
* The serialized form begins with a standard ICU DataHeader with a UDataInfo
* as the template above.
* This is followed by:
* int32_t indexes[UCNVSEL_INDEX_COUNT]; // see index entry constants above
* serialized UTrie2; // indexes[UCNVSEL_INDEX_TRIE_SIZE] bytes
* uint32_t pv[indexes[UCNVSEL_INDEX_PV_COUNT]]; // bit vectors
* char* encodingNames[indexes[UCNVSEL_INDEX_NAMES_LENGTH]]; // NUL-terminated strings + padding
*/
/* serialize a selector */
U_CAPI int32_t U_EXPORT2
ucnvsel_serialize(const UConverterSelector* sel,
void* buffer, int32_t bufferCapacity, UErrorCode* status) {
// check if already failed
if (U_FAILURE(*status)) {
return 0;
}
// ensure args make sense!
uint8_t *p = (uint8_t *)buffer;
if (bufferCapacity < 0 ||
(bufferCapacity > 0 && (p == NULL || (U_POINTER_MASK_LSB(p, 3) != 0)))
) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
// add up the size of the serialized form
int32_t serializedTrieSize = utrie2_serialize(sel->trie, NULL, 0, status);
if (*status != U_BUFFER_OVERFLOW_ERROR && U_FAILURE(*status)) {
return 0;
}
*status = U_ZERO_ERROR;
DataHeader header;
uprv_memset(&header, 0, sizeof(header));
header.dataHeader.headerSize = (uint16_t)((sizeof(header) + 15) & ~15);
header.dataHeader.magic1 = 0xda;
header.dataHeader.magic2 = 0x27;
uprv_memcpy(&header.info, &dataInfo, sizeof(dataInfo));
int32_t indexes[UCNVSEL_INDEX_COUNT] = {
serializedTrieSize,
sel->pvCount,
sel->encodingsCount,
sel->encodingStrLength
};
int32_t totalSize =
header.dataHeader.headerSize +
(int32_t)sizeof(indexes) +
serializedTrieSize +
sel->pvCount * 4 +
sel->encodingStrLength;
indexes[UCNVSEL_INDEX_SIZE] = totalSize - header.dataHeader.headerSize;
if (totalSize > bufferCapacity) {
*status = U_BUFFER_OVERFLOW_ERROR;
return totalSize;
}
// ok, save!
int32_t length = header.dataHeader.headerSize;
uprv_memcpy(p, &header, sizeof(header));
uprv_memset(p + sizeof(header), 0, length - sizeof(header));
p += length;
length = (int32_t)sizeof(indexes);
uprv_memcpy(p, indexes, length);
p += length;
utrie2_serialize(sel->trie, p, serializedTrieSize, status);
p += serializedTrieSize;
length = sel->pvCount * 4;
uprv_memcpy(p, sel->pv, length);
p += length;
uprv_memcpy(p, sel->encodings[0], sel->encodingStrLength);
p += sel->encodingStrLength;
return totalSize;
}
/**
* swap a selector into the desired Endianness and Asciiness of
* the system. Just as FYI, selectors are always saved in the format
* of the system that created them. They are only converted if used
* on another system. In other words, selectors created on different
* system can be different even if the params are identical (endianness
* and Asciiness differences only)
*
* @param ds pointer to data swapper containing swapping info
* @param inData pointer to incoming data
* @param length length of inData in bytes
* @param outData pointer to output data. Capacity should
* be at least equal to capacity of inData
* @param status an in/out ICU UErrorCode
* @return 0 on failure, number of bytes swapped on success
* number of bytes swapped can be smaller than length
*/
static int32_t
ucnvsel_swap(const UDataSwapper *ds,
const void *inData, int32_t length,
void *outData, UErrorCode *status) {
/* udata_swapDataHeader checks the arguments */
int32_t headerSize = udata_swapDataHeader(ds, inData, length, outData, status);
if(U_FAILURE(*status)) {
return 0;
}
/* check data format and format version */
const UDataInfo *pInfo = (const UDataInfo *)((const char *)inData + 4);
if(!(
pInfo->dataFormat[0] == 0x43 && /* dataFormat="CSel" */
pInfo->dataFormat[1] == 0x53 &&
pInfo->dataFormat[2] == 0x65 &&
pInfo->dataFormat[3] == 0x6c
)) {
udata_printError(ds, "ucnvsel_swap(): data format %02x.%02x.%02x.%02x is not recognized as UConverterSelector data\n",
pInfo->dataFormat[0], pInfo->dataFormat[1],
pInfo->dataFormat[2], pInfo->dataFormat[3]);
*status = U_INVALID_FORMAT_ERROR;
return 0;
}
if(pInfo->formatVersion[0] != 1) {
udata_printError(ds, "ucnvsel_swap(): format version %02x is not supported\n",
pInfo->formatVersion[0]);
*status = U_UNSUPPORTED_ERROR;
return 0;
}
if(length >= 0) {
length -= headerSize;
if(length < 16*4) {
udata_printError(ds, "ucnvsel_swap(): too few bytes (%d after header) for UConverterSelector data\n",
length);
*status = U_INDEX_OUTOFBOUNDS_ERROR;
return 0;
}
}
const uint8_t *inBytes = (const uint8_t *)inData + headerSize;
uint8_t *outBytes = (uint8_t *)outData + headerSize;
/* read the indexes */
const int32_t *inIndexes = (const int32_t *)inBytes;
int32_t indexes[16];
int32_t i;
for(i = 0; i < 16; ++i) {
indexes[i] = udata_readInt32(ds, inIndexes[i]);
}
/* get the total length of the data */
int32_t size = indexes[UCNVSEL_INDEX_SIZE];
if(length >= 0) {
if(length < size) {
udata_printError(ds, "ucnvsel_swap(): too few bytes (%d after header) for all of UConverterSelector data\n",
length);
*status = U_INDEX_OUTOFBOUNDS_ERROR;
return 0;
}
/* copy the data for inaccessible bytes */
if(inBytes != outBytes) {
uprv_memcpy(outBytes, inBytes, size);
}
int32_t offset = 0, count;
/* swap the int32_t indexes[] */
count = UCNVSEL_INDEX_COUNT*4;
ds->swapArray32(ds, inBytes, count, outBytes, status);
offset += count;
/* swap the UTrie2 */
count = indexes[UCNVSEL_INDEX_TRIE_SIZE];
utrie2_swap(ds, inBytes + offset, count, outBytes + offset, status);
offset += count;
/* swap the uint32_t pv[] */
count = indexes[UCNVSEL_INDEX_PV_COUNT]*4;
ds->swapArray32(ds, inBytes + offset, count, outBytes + offset, status);
offset += count;
/* swap the encoding names */
count = indexes[UCNVSEL_INDEX_NAMES_LENGTH];
ds->swapInvChars(ds, inBytes + offset, count, outBytes + offset, status);
offset += count;
U_ASSERT(offset == size);
}
return headerSize + size;
}
/* unserialize a selector */
U_CAPI UConverterSelector* U_EXPORT2
ucnvsel_openFromSerialized(const void* buffer, int32_t length, UErrorCode* status) {
// check if already failed
if (U_FAILURE(*status)) {
return NULL;
}
// ensure args make sense!
const uint8_t *p = (const uint8_t *)buffer;
if (length <= 0 ||
(length > 0 && (p == NULL || (U_POINTER_MASK_LSB(p, 3) != 0)))
) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
// header
if (length < 32) {
// not even enough space for a minimal header
*status = U_INDEX_OUTOFBOUNDS_ERROR;
return NULL;
}
const DataHeader *pHeader = (const DataHeader *)p;
if (!(
pHeader->dataHeader.magic1==0xda &&
pHeader->dataHeader.magic2==0x27 &&
pHeader->info.dataFormat[0] == 0x43 &&
pHeader->info.dataFormat[1] == 0x53 &&
pHeader->info.dataFormat[2] == 0x65 &&
pHeader->info.dataFormat[3] == 0x6c
)) {
/* header not valid or dataFormat not recognized */
*status = U_INVALID_FORMAT_ERROR;
return NULL;
}
if (pHeader->info.formatVersion[0] != 1) {
*status = U_UNSUPPORTED_ERROR;
return NULL;
}
uint8_t* swapped = NULL;
if (pHeader->info.isBigEndian != U_IS_BIG_ENDIAN ||
pHeader->info.charsetFamily != U_CHARSET_FAMILY
) {
// swap the data
UDataSwapper *ds =
udata_openSwapperForInputData(p, length, U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, status);
int32_t totalSize = ucnvsel_swap(ds, p, -1, NULL, status);
if (U_FAILURE(*status)) {
udata_closeSwapper(ds);
return NULL;
}
if (length < totalSize) {
udata_closeSwapper(ds);
*status = U_INDEX_OUTOFBOUNDS_ERROR;
return NULL;
}
swapped = (uint8_t*)uprv_malloc(totalSize);
if (swapped == NULL) {
udata_closeSwapper(ds);
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
ucnvsel_swap(ds, p, length, swapped, status);
udata_closeSwapper(ds);
if (U_FAILURE(*status)) {
uprv_free(swapped);
return NULL;
}
p = swapped;
pHeader = (const DataHeader *)p;
}
if (length < (pHeader->dataHeader.headerSize + 16 * 4)) {
// not even enough space for the header and the indexes
uprv_free(swapped);
*status = U_INDEX_OUTOFBOUNDS_ERROR;
return NULL;
}
p += pHeader->dataHeader.headerSize;
length -= pHeader->dataHeader.headerSize;
// indexes
const int32_t *indexes = (const int32_t *)p;
if (length < indexes[UCNVSEL_INDEX_SIZE]) {
uprv_free(swapped);
*status = U_INDEX_OUTOFBOUNDS_ERROR;
return NULL;
}
p += UCNVSEL_INDEX_COUNT * 4;
// create and populate the selector object
UConverterSelector* sel = (UConverterSelector*)uprv_malloc(sizeof(UConverterSelector));
char **encodings =
(char **)uprv_malloc(
indexes[UCNVSEL_INDEX_NAMES_COUNT] * sizeof(char *));
if (sel == NULL || encodings == NULL) {
uprv_free(swapped);
uprv_free(sel);
uprv_free(encodings);
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
uprv_memset(sel, 0, sizeof(UConverterSelector));
sel->pvCount = indexes[UCNVSEL_INDEX_PV_COUNT];
sel->encodings = encodings;
sel->encodingsCount = indexes[UCNVSEL_INDEX_NAMES_COUNT];
sel->encodingStrLength = indexes[UCNVSEL_INDEX_NAMES_LENGTH];
sel->swapped = swapped;
// trie
sel->trie = utrie2_openFromSerialized(UTRIE2_16_VALUE_BITS,
p, indexes[UCNVSEL_INDEX_TRIE_SIZE], NULL,
status);
p += indexes[UCNVSEL_INDEX_TRIE_SIZE];
if (U_FAILURE(*status)) {
ucnvsel_close(sel);
return NULL;
}
// bit vectors
sel->pv = (uint32_t *)p;
p += sel->pvCount * 4;
// encoding names
char* s = (char*)p;
for (int32_t i = 0; i < sel->encodingsCount; ++i) {
sel->encodings[i] = s;
s += uprv_strlen(s) + 1;
}
p += sel->encodingStrLength;
return sel;
}
// a bunch of functions for the enumeration thingie! Nothing fancy here. Just
// iterate over the selected encodings
struct Enumerator {
int16_t* index;
int16_t length;
int16_t cur;
const UConverterSelector* sel;
};
U_CDECL_BEGIN
static void U_CALLCONV
ucnvsel_close_selector_iterator(UEnumeration *enumerator) {
uprv_free(((Enumerator*)(enumerator->context))->index);
uprv_free(enumerator->context);
uprv_free(enumerator);
}
static int32_t U_CALLCONV
ucnvsel_count_encodings(UEnumeration *enumerator, UErrorCode *status) {
// check if already failed
if (U_FAILURE(*status)) {
return 0;
}
return ((Enumerator*)(enumerator->context))->length;
}
static const char* U_CALLCONV ucnvsel_next_encoding(UEnumeration* enumerator,
int32_t* resultLength,
UErrorCode* status) {
// check if already failed
if (U_FAILURE(*status)) {
return NULL;
}
int16_t cur = ((Enumerator*)(enumerator->context))->cur;
const UConverterSelector* sel;
const char* result;
if (cur >= ((Enumerator*)(enumerator->context))->length) {
return NULL;
}
sel = ((Enumerator*)(enumerator->context))->sel;
result = sel->encodings[((Enumerator*)(enumerator->context))->index[cur] ];
((Enumerator*)(enumerator->context))->cur++;
if (resultLength) {
*resultLength = (int32_t)uprv_strlen(result);
}
return result;
}
static void U_CALLCONV ucnvsel_reset_iterator(UEnumeration* enumerator,
UErrorCode* status) {
// check if already failed
if (U_FAILURE(*status)) {
return ;
}
((Enumerator*)(enumerator->context))->cur = 0;
}
U_CDECL_END
static const UEnumeration defaultEncodings = {
NULL,
NULL,
ucnvsel_close_selector_iterator,
ucnvsel_count_encodings,
uenum_unextDefault,
ucnvsel_next_encoding,
ucnvsel_reset_iterator
};
// internal fn to intersect two sets of masks
// returns whether the mask has reduced to all zeros
static UBool intersectMasks(uint32_t* dest, const uint32_t* source1, int32_t len) {
int32_t i;
uint32_t oredDest = 0;
for (i = 0 ; i < len ; ++i) {
oredDest |= (dest[i] &= source1[i]);
}
return oredDest == 0;
}
// internal fn to count how many 1's are there in a mask
// algorithm taken from http://graphics.stanford.edu/~seander/bithacks.html
static int16_t countOnes(uint32_t* mask, int32_t len) {
int32_t i, totalOnes = 0;
for (i = 0 ; i < len ; ++i) {
uint32_t ent = mask[i];
for (; ent; totalOnes++)
{
ent &= ent - 1; // clear the least significant bit set
}
}
return totalOnes;
}
/* internal function! */
static UEnumeration *selectForMask(const UConverterSelector* sel,
uint32_t *mask, UErrorCode *status) {
// this is the context we will use. Store a table of indices to which
// encodings are legit.
struct Enumerator* result = (Enumerator*)uprv_malloc(sizeof(Enumerator));
if (result == NULL) {
uprv_free(mask);
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
result->index = NULL; // this will be allocated later!
result->length = result->cur = 0;
result->sel = sel;
UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration));
if (en == NULL) {
// TODO(markus): Combine Enumerator and UEnumeration into one struct.
uprv_free(mask);
uprv_free(result);
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
memcpy(en, &defaultEncodings, sizeof(UEnumeration));
en->context = result;
int32_t columns = (sel->encodingsCount+31)/32;
int16_t numOnes = countOnes(mask, columns);
// now, we know the exact space we need for index
if (numOnes > 0) {
result->index = (int16_t*) uprv_malloc(numOnes * sizeof(int16_t));
int32_t i, j;
int16_t k = 0;
for (j = 0 ; j < columns; j++) {
uint32_t v = mask[j];
for (i = 0 ; i < 32 && k < sel->encodingsCount; i++, k++) {
if ((v & 1) != 0) {
result->index[result->length++] = k;
}
v >>= 1;
}
}
} //otherwise, index will remain NULL (and will never be touched by
//the enumerator code anyway)
uprv_free(mask);
return en;
}
/* check a string against the selector - UTF16 version */
U_CAPI UEnumeration * U_EXPORT2
ucnvsel_selectForString(const UConverterSelector* sel,
const UChar *s, int32_t length, UErrorCode *status) {
// check if already failed
if (U_FAILURE(*status)) {
return NULL;
}
// ensure args make sense!
if (sel == NULL || (s == NULL && length != 0)) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
int32_t columns = (sel->encodingsCount+31)/32;
uint32_t* mask = (uint32_t*) uprv_malloc(columns * 4);
if (mask == NULL) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
uprv_memset(mask, ~0, columns *4);
if(s!=NULL) {
const UChar *limit;
if (length >= 0) {
limit = s + length;
} else {
limit = NULL;
}
while (limit == NULL ? *s != 0 : s != limit) {
UChar32 c;
uint16_t pvIndex;
UTRIE2_U16_NEXT16(sel->trie, s, limit, c, pvIndex);
if (intersectMasks(mask, sel->pv+pvIndex, columns)) {
break;
}
}
}
return selectForMask(sel, mask, status);
}
/* check a string against the selector - UTF8 version */
U_CAPI UEnumeration * U_EXPORT2
ucnvsel_selectForUTF8(const UConverterSelector* sel,
const char *s, int32_t length, UErrorCode *status) {
// check if already failed
if (U_FAILURE(*status)) {
return NULL;
}
// ensure args make sense!
if (sel == NULL || (s == NULL && length != 0)) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
int32_t columns = (sel->encodingsCount+31)/32;
uint32_t* mask = (uint32_t*) uprv_malloc(columns * 4);
if (mask == NULL) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
uprv_memset(mask, ~0, columns *4);
if (length < 0) {
length = (int32_t)uprv_strlen(s);
}
if(s!=NULL) {
const char *limit = s + length;
while (s != limit) {
uint16_t pvIndex;
UTRIE2_U8_NEXT16(sel->trie, s, limit, pvIndex);
if (intersectMasks(mask, sel->pv+pvIndex, columns)) {
break;
}
}
}
return selectForMask(sel, mask, status);
}
#endif // !UCONFIG_NO_CONVERSION