601 lines
22 KiB
C++
601 lines
22 KiB
C++
// © 2017 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
|
|
// ucptrie.cpp (modified from utrie2.cpp)
|
|
// created: 2017dec29 Markus W. Scherer
|
|
|
|
// #define UCPTRIE_DEBUG
|
|
#ifdef UCPTRIE_DEBUG
|
|
# include <stdio.h>
|
|
#endif
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/ucptrie.h"
|
|
#include "unicode/utf.h"
|
|
#include "unicode/utf8.h"
|
|
#include "unicode/utf16.h"
|
|
#include "cmemory.h"
|
|
#include "uassert.h"
|
|
#include "ucptrie_impl.h"
|
|
|
|
U_CAPI UCPTrie * U_EXPORT2
|
|
ucptrie_openFromBinary(UCPTrieType type, UCPTrieValueWidth valueWidth,
|
|
const void *data, int32_t length, int32_t *pActualLength,
|
|
UErrorCode *pErrorCode) {
|
|
if (U_FAILURE(*pErrorCode)) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (length <= 0 || (U_POINTER_MASK_LSB(data, 3) != 0) ||
|
|
type < UCPTRIE_TYPE_ANY || UCPTRIE_TYPE_SMALL < type ||
|
|
valueWidth < UCPTRIE_VALUE_BITS_ANY || UCPTRIE_VALUE_BITS_8 < valueWidth) {
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return nullptr;
|
|
}
|
|
|
|
// Enough data for a trie header?
|
|
if (length < (int32_t)sizeof(UCPTrieHeader)) {
|
|
*pErrorCode = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
|
|
// Check the signature.
|
|
const UCPTrieHeader *header = (const UCPTrieHeader *)data;
|
|
if (header->signature != UCPTRIE_SIG) {
|
|
*pErrorCode = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
|
|
int32_t options = header->options;
|
|
int32_t typeInt = (options >> 6) & 3;
|
|
int32_t valueWidthInt = options & UCPTRIE_OPTIONS_VALUE_BITS_MASK;
|
|
if (typeInt > UCPTRIE_TYPE_SMALL || valueWidthInt > UCPTRIE_VALUE_BITS_8 ||
|
|
(options & UCPTRIE_OPTIONS_RESERVED_MASK) != 0) {
|
|
*pErrorCode = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
UCPTrieType actualType = (UCPTrieType)typeInt;
|
|
UCPTrieValueWidth actualValueWidth = (UCPTrieValueWidth)valueWidthInt;
|
|
if (type < 0) {
|
|
type = actualType;
|
|
}
|
|
if (valueWidth < 0) {
|
|
valueWidth = actualValueWidth;
|
|
}
|
|
if (type != actualType || valueWidth != actualValueWidth) {
|
|
*pErrorCode = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
|
|
// Get the length values and offsets.
|
|
UCPTrie tempTrie;
|
|
uprv_memset(&tempTrie, 0, sizeof(tempTrie));
|
|
tempTrie.indexLength = header->indexLength;
|
|
tempTrie.dataLength =
|
|
((options & UCPTRIE_OPTIONS_DATA_LENGTH_MASK) << 4) | header->dataLength;
|
|
tempTrie.index3NullOffset = header->index3NullOffset;
|
|
tempTrie.dataNullOffset =
|
|
((options & UCPTRIE_OPTIONS_DATA_NULL_OFFSET_MASK) << 8) | header->dataNullOffset;
|
|
|
|
tempTrie.highStart = header->shiftedHighStart << UCPTRIE_SHIFT_2;
|
|
tempTrie.shifted12HighStart = (tempTrie.highStart + 0xfff) >> 12;
|
|
tempTrie.type = type;
|
|
tempTrie.valueWidth = valueWidth;
|
|
|
|
// Calculate the actual length.
|
|
int32_t actualLength = (int32_t)sizeof(UCPTrieHeader) + tempTrie.indexLength * 2;
|
|
if (valueWidth == UCPTRIE_VALUE_BITS_16) {
|
|
actualLength += tempTrie.dataLength * 2;
|
|
} else if (valueWidth == UCPTRIE_VALUE_BITS_32) {
|
|
actualLength += tempTrie.dataLength * 4;
|
|
} else {
|
|
actualLength += tempTrie.dataLength;
|
|
}
|
|
if (length < actualLength) {
|
|
*pErrorCode = U_INVALID_FORMAT_ERROR; // Not enough bytes.
|
|
return nullptr;
|
|
}
|
|
|
|
// Allocate the trie.
|
|
UCPTrie *trie = (UCPTrie *)uprv_malloc(sizeof(UCPTrie));
|
|
if (trie == nullptr) {
|
|
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
|
|
return nullptr;
|
|
}
|
|
uprv_memcpy(trie, &tempTrie, sizeof(tempTrie));
|
|
#ifdef UCPTRIE_DEBUG
|
|
trie->name = "fromSerialized";
|
|
#endif
|
|
|
|
// Set the pointers to its index and data arrays.
|
|
const uint16_t *p16 = (const uint16_t *)(header + 1);
|
|
trie->index = p16;
|
|
p16 += trie->indexLength;
|
|
|
|
// Get the data.
|
|
int32_t nullValueOffset = trie->dataNullOffset;
|
|
if (nullValueOffset >= trie->dataLength) {
|
|
nullValueOffset = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
|
|
}
|
|
switch (valueWidth) {
|
|
case UCPTRIE_VALUE_BITS_16:
|
|
trie->data.ptr16 = p16;
|
|
trie->nullValue = trie->data.ptr16[nullValueOffset];
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_32:
|
|
trie->data.ptr32 = (const uint32_t *)p16;
|
|
trie->nullValue = trie->data.ptr32[nullValueOffset];
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_8:
|
|
trie->data.ptr8 = (const uint8_t *)p16;
|
|
trie->nullValue = trie->data.ptr8[nullValueOffset];
|
|
break;
|
|
default:
|
|
// Unreachable because valueWidth was checked above.
|
|
*pErrorCode = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
|
|
if (pActualLength != nullptr) {
|
|
*pActualLength = actualLength;
|
|
}
|
|
return trie;
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
ucptrie_close(UCPTrie *trie) {
|
|
uprv_free(trie);
|
|
}
|
|
|
|
U_CAPI UCPTrieType U_EXPORT2
|
|
ucptrie_getType(const UCPTrie *trie) {
|
|
return (UCPTrieType)trie->type;
|
|
}
|
|
|
|
U_CAPI UCPTrieValueWidth U_EXPORT2
|
|
ucptrie_getValueWidth(const UCPTrie *trie) {
|
|
return (UCPTrieValueWidth)trie->valueWidth;
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c) {
|
|
int32_t i1 = c >> UCPTRIE_SHIFT_1;
|
|
if (trie->type == UCPTRIE_TYPE_FAST) {
|
|
U_ASSERT(0xffff < c && c < trie->highStart);
|
|
i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH;
|
|
} else {
|
|
U_ASSERT((uint32_t)c < (uint32_t)trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT);
|
|
i1 += UCPTRIE_SMALL_INDEX_LENGTH;
|
|
}
|
|
int32_t i3Block = trie->index[
|
|
(int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)];
|
|
int32_t i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK;
|
|
int32_t dataBlock;
|
|
if ((i3Block & 0x8000) == 0) {
|
|
// 16-bit indexes
|
|
dataBlock = trie->index[i3Block + i3];
|
|
} else {
|
|
// 18-bit indexes stored in groups of 9 entries per 8 indexes.
|
|
i3Block = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3);
|
|
i3 &= 7;
|
|
dataBlock = ((int32_t)trie->index[i3Block++] << (2 + (2 * i3))) & 0x30000;
|
|
dataBlock |= trie->index[i3Block + i3];
|
|
}
|
|
return dataBlock + (c & UCPTRIE_SMALL_DATA_MASK);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
ucptrie_internalSmallU8Index(const UCPTrie *trie, int32_t lt1, uint8_t t2, uint8_t t3) {
|
|
UChar32 c = (lt1 << 12) | (t2 << 6) | t3;
|
|
if (c >= trie->highStart) {
|
|
// Possible because the UTF-8 macro compares with shifted12HighStart which may be higher.
|
|
return trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
|
|
}
|
|
return ucptrie_internalSmallIndex(trie, c);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
ucptrie_internalU8PrevIndex(const UCPTrie *trie, UChar32 c,
|
|
const uint8_t *start, const uint8_t *src) {
|
|
int32_t i, length;
|
|
// Support 64-bit pointers by avoiding cast of arbitrary difference.
|
|
if ((src - start) <= 7) {
|
|
i = length = (int32_t)(src - start);
|
|
} else {
|
|
i = length = 7;
|
|
start = src - 7;
|
|
}
|
|
c = utf8_prevCharSafeBody(start, 0, &i, c, -1);
|
|
i = length - i; // Number of bytes read backward from src.
|
|
int32_t idx = _UCPTRIE_CP_INDEX(trie, 0xffff, c);
|
|
return (idx << 3) | i;
|
|
}
|
|
|
|
namespace {
|
|
|
|
inline uint32_t getValue(UCPTrieData data, UCPTrieValueWidth valueWidth, int32_t dataIndex) {
|
|
switch (valueWidth) {
|
|
case UCPTRIE_VALUE_BITS_16:
|
|
return data.ptr16[dataIndex];
|
|
case UCPTRIE_VALUE_BITS_32:
|
|
return data.ptr32[dataIndex];
|
|
case UCPTRIE_VALUE_BITS_8:
|
|
return data.ptr8[dataIndex];
|
|
default:
|
|
// Unreachable if the trie is properly initialized.
|
|
return 0xffffffff;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
U_CAPI uint32_t U_EXPORT2
|
|
ucptrie_get(const UCPTrie *trie, UChar32 c) {
|
|
int32_t dataIndex;
|
|
if ((uint32_t)c <= 0x7f) {
|
|
// linear ASCII
|
|
dataIndex = c;
|
|
} else {
|
|
UChar32 fastMax = trie->type == UCPTRIE_TYPE_FAST ? 0xffff : UCPTRIE_SMALL_MAX;
|
|
dataIndex = _UCPTRIE_CP_INDEX(trie, fastMax, c);
|
|
}
|
|
return getValue(trie->data, (UCPTrieValueWidth)trie->valueWidth, dataIndex);
|
|
}
|
|
|
|
namespace {
|
|
|
|
constexpr int32_t MAX_UNICODE = 0x10ffff;
|
|
|
|
inline uint32_t maybeFilterValue(uint32_t value, uint32_t trieNullValue, uint32_t nullValue,
|
|
UCPMapValueFilter *filter, const void *context) {
|
|
if (value == trieNullValue) {
|
|
value = nullValue;
|
|
} else if (filter != nullptr) {
|
|
value = filter(context, value);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
UChar32 getRange(const void *t, UChar32 start,
|
|
UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
|
|
if ((uint32_t)start > MAX_UNICODE) {
|
|
return U_SENTINEL;
|
|
}
|
|
const UCPTrie *trie = reinterpret_cast<const UCPTrie *>(t);
|
|
UCPTrieValueWidth valueWidth = (UCPTrieValueWidth)trie->valueWidth;
|
|
if (start >= trie->highStart) {
|
|
if (pValue != nullptr) {
|
|
int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
|
|
uint32_t value = getValue(trie->data, valueWidth, di);
|
|
if (filter != nullptr) { value = filter(context, value); }
|
|
*pValue = value;
|
|
}
|
|
return MAX_UNICODE;
|
|
}
|
|
|
|
uint32_t nullValue = trie->nullValue;
|
|
if (filter != nullptr) { nullValue = filter(context, nullValue); }
|
|
const uint16_t *index = trie->index;
|
|
|
|
int32_t prevI3Block = -1;
|
|
int32_t prevBlock = -1;
|
|
UChar32 c = start;
|
|
uint32_t trieValue, value = nullValue;
|
|
bool haveValue = false;
|
|
do {
|
|
int32_t i3Block;
|
|
int32_t i3;
|
|
int32_t i3BlockLength;
|
|
int32_t dataBlockLength;
|
|
if (c <= 0xffff && (trie->type == UCPTRIE_TYPE_FAST || c <= UCPTRIE_SMALL_MAX)) {
|
|
i3Block = 0;
|
|
i3 = c >> UCPTRIE_FAST_SHIFT;
|
|
i3BlockLength = trie->type == UCPTRIE_TYPE_FAST ?
|
|
UCPTRIE_BMP_INDEX_LENGTH : UCPTRIE_SMALL_INDEX_LENGTH;
|
|
dataBlockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH;
|
|
} else {
|
|
// Use the multi-stage index.
|
|
int32_t i1 = c >> UCPTRIE_SHIFT_1;
|
|
if (trie->type == UCPTRIE_TYPE_FAST) {
|
|
U_ASSERT(0xffff < c && c < trie->highStart);
|
|
i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH;
|
|
} else {
|
|
U_ASSERT(c < trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT);
|
|
i1 += UCPTRIE_SMALL_INDEX_LENGTH;
|
|
}
|
|
i3Block = trie->index[
|
|
(int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)];
|
|
if (i3Block == prevI3Block && (c - start) >= UCPTRIE_CP_PER_INDEX_2_ENTRY) {
|
|
// The index-3 block is the same as the previous one, and filled with value.
|
|
U_ASSERT((c & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0);
|
|
c += UCPTRIE_CP_PER_INDEX_2_ENTRY;
|
|
continue;
|
|
}
|
|
prevI3Block = i3Block;
|
|
if (i3Block == trie->index3NullOffset) {
|
|
// This is the index-3 null block.
|
|
if (haveValue) {
|
|
if (nullValue != value) {
|
|
return c - 1;
|
|
}
|
|
} else {
|
|
trieValue = trie->nullValue;
|
|
value = nullValue;
|
|
if (pValue != nullptr) { *pValue = nullValue; }
|
|
haveValue = true;
|
|
}
|
|
prevBlock = trie->dataNullOffset;
|
|
c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1);
|
|
continue;
|
|
}
|
|
i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK;
|
|
i3BlockLength = UCPTRIE_INDEX_3_BLOCK_LENGTH;
|
|
dataBlockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH;
|
|
}
|
|
// Enumerate data blocks for one index-3 block.
|
|
do {
|
|
int32_t block;
|
|
if ((i3Block & 0x8000) == 0) {
|
|
block = index[i3Block + i3];
|
|
} else {
|
|
// 18-bit indexes stored in groups of 9 entries per 8 indexes.
|
|
int32_t group = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3);
|
|
int32_t gi = i3 & 7;
|
|
block = ((int32_t)index[group++] << (2 + (2 * gi))) & 0x30000;
|
|
block |= index[group + gi];
|
|
}
|
|
if (block == prevBlock && (c - start) >= dataBlockLength) {
|
|
// The block is the same as the previous one, and filled with value.
|
|
U_ASSERT((c & (dataBlockLength - 1)) == 0);
|
|
c += dataBlockLength;
|
|
} else {
|
|
int32_t dataMask = dataBlockLength - 1;
|
|
prevBlock = block;
|
|
if (block == trie->dataNullOffset) {
|
|
// This is the data null block.
|
|
if (haveValue) {
|
|
if (nullValue != value) {
|
|
return c - 1;
|
|
}
|
|
} else {
|
|
trieValue = trie->nullValue;
|
|
value = nullValue;
|
|
if (pValue != nullptr) { *pValue = nullValue; }
|
|
haveValue = true;
|
|
}
|
|
c = (c + dataBlockLength) & ~dataMask;
|
|
} else {
|
|
int32_t di = block + (c & dataMask);
|
|
uint32_t trieValue2 = getValue(trie->data, valueWidth, di);
|
|
if (haveValue) {
|
|
if (trieValue2 != trieValue) {
|
|
if (filter == nullptr ||
|
|
maybeFilterValue(trieValue2, trie->nullValue, nullValue,
|
|
filter, context) != value) {
|
|
return c - 1;
|
|
}
|
|
trieValue = trieValue2; // may or may not help
|
|
}
|
|
} else {
|
|
trieValue = trieValue2;
|
|
value = maybeFilterValue(trieValue2, trie->nullValue, nullValue,
|
|
filter, context);
|
|
if (pValue != nullptr) { *pValue = value; }
|
|
haveValue = true;
|
|
}
|
|
while ((++c & dataMask) != 0) {
|
|
trieValue2 = getValue(trie->data, valueWidth, ++di);
|
|
if (trieValue2 != trieValue) {
|
|
if (filter == nullptr ||
|
|
maybeFilterValue(trieValue2, trie->nullValue, nullValue,
|
|
filter, context) != value) {
|
|
return c - 1;
|
|
}
|
|
trieValue = trieValue2; // may or may not help
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while (++i3 < i3BlockLength);
|
|
} while (c < trie->highStart);
|
|
U_ASSERT(haveValue);
|
|
int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
|
|
uint32_t highValue = getValue(trie->data, valueWidth, di);
|
|
if (maybeFilterValue(highValue, trie->nullValue, nullValue,
|
|
filter, context) != value) {
|
|
return c - 1;
|
|
} else {
|
|
return MAX_UNICODE;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
U_CFUNC UChar32
|
|
ucptrie_internalGetRange(UCPTrieGetRange *getRange,
|
|
const void *trie, UChar32 start,
|
|
UCPMapRangeOption option, uint32_t surrogateValue,
|
|
UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
|
|
if (option == UCPMAP_RANGE_NORMAL) {
|
|
return getRange(trie, start, filter, context, pValue);
|
|
}
|
|
uint32_t value;
|
|
if (pValue == nullptr) {
|
|
// We need to examine the range value even if the caller does not want it.
|
|
pValue = &value;
|
|
}
|
|
UChar32 surrEnd = option == UCPMAP_RANGE_FIXED_ALL_SURROGATES ? 0xdfff : 0xdbff;
|
|
UChar32 end = getRange(trie, start, filter, context, pValue);
|
|
if (end < 0xd7ff || start > surrEnd) {
|
|
return end;
|
|
}
|
|
// The range overlaps with surrogates, or ends just before the first one.
|
|
if (*pValue == surrogateValue) {
|
|
if (end >= surrEnd) {
|
|
// Surrogates followed by a non-surrogateValue range,
|
|
// or surrogates are part of a larger surrogateValue range.
|
|
return end;
|
|
}
|
|
} else {
|
|
if (start <= 0xd7ff) {
|
|
return 0xd7ff; // Non-surrogateValue range ends before surrogateValue surrogates.
|
|
}
|
|
// Start is a surrogate with a non-surrogateValue code *unit* value.
|
|
// Return a surrogateValue code *point* range.
|
|
*pValue = surrogateValue;
|
|
if (end > surrEnd) {
|
|
return surrEnd; // Surrogate range ends before non-surrogateValue rest of range.
|
|
}
|
|
}
|
|
// See if the surrogateValue surrogate range can be merged with
|
|
// an immediately following range.
|
|
uint32_t value2;
|
|
UChar32 end2 = getRange(trie, surrEnd + 1, filter, context, &value2);
|
|
if (value2 == surrogateValue) {
|
|
return end2;
|
|
}
|
|
return surrEnd;
|
|
}
|
|
|
|
U_CAPI UChar32 U_EXPORT2
|
|
ucptrie_getRange(const UCPTrie *trie, UChar32 start,
|
|
UCPMapRangeOption option, uint32_t surrogateValue,
|
|
UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
|
|
return ucptrie_internalGetRange(getRange, trie, start,
|
|
option, surrogateValue,
|
|
filter, context, pValue);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
ucptrie_toBinary(const UCPTrie *trie,
|
|
void *data, int32_t capacity,
|
|
UErrorCode *pErrorCode) {
|
|
if (U_FAILURE(*pErrorCode)) {
|
|
return 0;
|
|
}
|
|
|
|
UCPTrieType type = (UCPTrieType)trie->type;
|
|
UCPTrieValueWidth valueWidth = (UCPTrieValueWidth)trie->valueWidth;
|
|
if (type < UCPTRIE_TYPE_FAST || UCPTRIE_TYPE_SMALL < type ||
|
|
valueWidth < UCPTRIE_VALUE_BITS_16 || UCPTRIE_VALUE_BITS_8 < valueWidth ||
|
|
capacity < 0 ||
|
|
(capacity > 0 && (data == nullptr || (U_POINTER_MASK_LSB(data, 3) != 0)))) {
|
|
*pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return 0;
|
|
}
|
|
|
|
int32_t length = (int32_t)sizeof(UCPTrieHeader) + trie->indexLength * 2;
|
|
switch (valueWidth) {
|
|
case UCPTRIE_VALUE_BITS_16:
|
|
length += trie->dataLength * 2;
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_32:
|
|
length += trie->dataLength * 4;
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_8:
|
|
length += trie->dataLength;
|
|
break;
|
|
default:
|
|
// unreachable
|
|
break;
|
|
}
|
|
if (capacity < length) {
|
|
*pErrorCode = U_BUFFER_OVERFLOW_ERROR;
|
|
return length;
|
|
}
|
|
|
|
char *bytes = (char *)data;
|
|
UCPTrieHeader *header = (UCPTrieHeader *)bytes;
|
|
header->signature = UCPTRIE_SIG; // "Tri3"
|
|
header->options = (uint16_t)(
|
|
((trie->dataLength & 0xf0000) >> 4) |
|
|
((trie->dataNullOffset & 0xf0000) >> 8) |
|
|
(trie->type << 6) |
|
|
valueWidth);
|
|
header->indexLength = (uint16_t)trie->indexLength;
|
|
header->dataLength = (uint16_t)trie->dataLength;
|
|
header->index3NullOffset = trie->index3NullOffset;
|
|
header->dataNullOffset = (uint16_t)trie->dataNullOffset;
|
|
header->shiftedHighStart = trie->highStart >> UCPTRIE_SHIFT_2;
|
|
bytes += sizeof(UCPTrieHeader);
|
|
|
|
uprv_memcpy(bytes, trie->index, trie->indexLength * 2);
|
|
bytes += trie->indexLength * 2;
|
|
|
|
switch (valueWidth) {
|
|
case UCPTRIE_VALUE_BITS_16:
|
|
uprv_memcpy(bytes, trie->data.ptr16, trie->dataLength * 2);
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_32:
|
|
uprv_memcpy(bytes, trie->data.ptr32, trie->dataLength * 4);
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_8:
|
|
uprv_memcpy(bytes, trie->data.ptr8, trie->dataLength);
|
|
break;
|
|
default:
|
|
// unreachable
|
|
break;
|
|
}
|
|
return length;
|
|
}
|
|
|
|
namespace {
|
|
|
|
#ifdef UCPTRIE_DEBUG
|
|
long countNull(const UCPTrie *trie) {
|
|
uint32_t nullValue=trie->nullValue;
|
|
int32_t length=trie->dataLength;
|
|
long count=0;
|
|
switch (trie->valueWidth) {
|
|
case UCPTRIE_VALUE_BITS_16:
|
|
for(int32_t i=0; i<length; ++i) {
|
|
if(trie->data.ptr16[i]==nullValue) { ++count; }
|
|
}
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_32:
|
|
for(int32_t i=0; i<length; ++i) {
|
|
if(trie->data.ptr32[i]==nullValue) { ++count; }
|
|
}
|
|
break;
|
|
case UCPTRIE_VALUE_BITS_8:
|
|
for(int32_t i=0; i<length; ++i) {
|
|
if(trie->data.ptr8[i]==nullValue) { ++count; }
|
|
}
|
|
break;
|
|
default:
|
|
// unreachable
|
|
break;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
U_CFUNC void
|
|
ucptrie_printLengths(const UCPTrie *trie, const char *which) {
|
|
long indexLength=trie->indexLength;
|
|
long dataLength=(long)trie->dataLength;
|
|
long totalLength=(long)sizeof(UCPTrieHeader)+indexLength*2+
|
|
dataLength*(trie->valueWidth==UCPTRIE_VALUE_BITS_16 ? 2 :
|
|
trie->valueWidth==UCPTRIE_VALUE_BITS_32 ? 4 : 1);
|
|
printf("**UCPTrieLengths(%s %s)** index:%6ld data:%6ld countNull:%6ld serialized:%6ld\n",
|
|
which, trie->name, indexLength, dataLength, countNull(trie), totalLength);
|
|
}
|
|
#endif
|
|
|
|
} // namespace
|
|
|
|
// UCPMap ----
|
|
// Initially, this is the same as UCPTrie. This may well change.
|
|
|
|
U_CAPI uint32_t U_EXPORT2
|
|
ucpmap_get(const UCPMap *map, UChar32 c) {
|
|
return ucptrie_get(reinterpret_cast<const UCPTrie *>(map), c);
|
|
}
|
|
|
|
U_CAPI UChar32 U_EXPORT2
|
|
ucpmap_getRange(const UCPMap *map, UChar32 start,
|
|
UCPMapRangeOption option, uint32_t surrogateValue,
|
|
UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
|
|
return ucptrie_getRange(reinterpret_cast<const UCPTrie *>(map), start,
|
|
option, surrogateValue,
|
|
filter, context, pValue);
|
|
}
|