[ tor-browser ].git.dasho

ucptrie.cpp (22096B)
      1 // © 2017 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 
      4 // ucptrie.cpp (modified from utrie2.cpp)
      5 // created: 2017dec29 Markus W. Scherer
      6 
      7 // #define UCPTRIE_DEBUG
      8 #ifdef UCPTRIE_DEBUG
      9 #   include <stdio.h>
     10 #endif
     11 
     12 #include "unicode/utypes.h"
     13 #include "unicode/ucptrie.h"
     14 #include "unicode/utf.h"
     15 #include "unicode/utf8.h"
     16 #include "unicode/utf16.h"
     17 #include "cmemory.h"
     18 #include "uassert.h"
     19 #include "ucptrie_impl.h"
     20 
     21 U_CAPI UCPTrie * U_EXPORT2
     22 ucptrie_openFromBinary(UCPTrieType type, UCPTrieValueWidth valueWidth,
     23                       const void *data, int32_t length, int32_t *pActualLength,
     24                       UErrorCode *pErrorCode) {
     25    if (U_FAILURE(*pErrorCode)) {
     26        return nullptr;
     27    }
     28 
     29    if (length <= 0 || (U_POINTER_MASK_LSB(data, 3) != 0) ||
     30            type < UCPTRIE_TYPE_ANY || UCPTRIE_TYPE_SMALL < type ||
     31            valueWidth < UCPTRIE_VALUE_BITS_ANY || UCPTRIE_VALUE_BITS_8 < valueWidth) {
     32        *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
     33        return nullptr;
     34    }
     35 
     36    // Enough data for a trie header?
     37    if (length < (int32_t)sizeof(UCPTrieHeader)) {
     38        *pErrorCode = U_INVALID_FORMAT_ERROR;
     39        return nullptr;
     40    }
     41 
     42    // Check the signature.
     43    const UCPTrieHeader *header = (const UCPTrieHeader *)data;
     44    if (header->signature != UCPTRIE_SIG) {
     45        *pErrorCode = U_INVALID_FORMAT_ERROR;
     46        return nullptr;
     47    }
     48 
     49    int32_t options = header->options;
     50    int32_t typeInt = (options >> 6) & 3;
     51    int32_t valueWidthInt = options & UCPTRIE_OPTIONS_VALUE_BITS_MASK;
     52    if (typeInt > UCPTRIE_TYPE_SMALL || valueWidthInt > UCPTRIE_VALUE_BITS_8 ||
     53            (options & UCPTRIE_OPTIONS_RESERVED_MASK) != 0) {
     54        *pErrorCode = U_INVALID_FORMAT_ERROR;
     55        return nullptr;
     56    }
     57    UCPTrieType actualType = (UCPTrieType)typeInt;
     58    UCPTrieValueWidth actualValueWidth = (UCPTrieValueWidth)valueWidthInt;
     59    if (type < 0) {
     60        type = actualType;
     61    }
     62    if (valueWidth < 0) {
     63        valueWidth = actualValueWidth;
     64    }
     65    if (type != actualType || valueWidth != actualValueWidth) {
     66        *pErrorCode = U_INVALID_FORMAT_ERROR;
     67        return nullptr;
     68    }
     69 
     70    // Get the length values and offsets.
     71    UCPTrie tempTrie;
     72    uprv_memset(&tempTrie, 0, sizeof(tempTrie));
     73    tempTrie.indexLength = header->indexLength;
     74    tempTrie.dataLength =
     75        ((options & UCPTRIE_OPTIONS_DATA_LENGTH_MASK) << 4) | header->dataLength;
     76    tempTrie.index3NullOffset = header->index3NullOffset;
     77    tempTrie.dataNullOffset =
     78        ((options & UCPTRIE_OPTIONS_DATA_NULL_OFFSET_MASK) << 8) | header->dataNullOffset;
     79 
     80    tempTrie.highStart = header->shiftedHighStart << UCPTRIE_SHIFT_2;
     81    tempTrie.shifted12HighStart = (tempTrie.highStart + 0xfff) >> 12;
     82    tempTrie.type = type;
     83    tempTrie.valueWidth = valueWidth;
     84 
     85    // Calculate the actual length.
     86    int32_t actualLength = (int32_t)sizeof(UCPTrieHeader) + tempTrie.indexLength * 2;
     87    if (valueWidth == UCPTRIE_VALUE_BITS_16) {
     88        actualLength += tempTrie.dataLength * 2;
     89    } else if (valueWidth == UCPTRIE_VALUE_BITS_32) {
     90        actualLength += tempTrie.dataLength * 4;
     91    } else {
     92        actualLength += tempTrie.dataLength;
     93    }
     94    if (length < actualLength) {
     95        *pErrorCode = U_INVALID_FORMAT_ERROR;  // Not enough bytes.
     96        return nullptr;
     97    }
     98 
     99    // Allocate the trie.
    100    UCPTrie *trie = (UCPTrie *)uprv_malloc(sizeof(UCPTrie));
    101    if (trie == nullptr) {
    102        *pErrorCode = U_MEMORY_ALLOCATION_ERROR;
    103        return nullptr;
    104    }
    105    uprv_memcpy(trie, &tempTrie, sizeof(tempTrie));
    106 #ifdef UCPTRIE_DEBUG
    107    trie->name = "fromSerialized";
    108 #endif
    109 
    110    // Set the pointers to its index and data arrays.
    111    const uint16_t *p16 = (const uint16_t *)(header + 1);
    112    trie->index = p16;
    113    p16 += trie->indexLength;
    114 
    115    // Get the data.
    116    int32_t nullValueOffset = trie->dataNullOffset;
    117    if (nullValueOffset >= trie->dataLength) {
    118        nullValueOffset = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
    119    }
    120    switch (valueWidth) {
    121    case UCPTRIE_VALUE_BITS_16:
    122        trie->data.ptr16 = p16;
    123        trie->nullValue = trie->data.ptr16[nullValueOffset];
    124        break;
    125    case UCPTRIE_VALUE_BITS_32:
    126        trie->data.ptr32 = (const uint32_t *)p16;
    127        trie->nullValue = trie->data.ptr32[nullValueOffset];
    128        break;
    129    case UCPTRIE_VALUE_BITS_8:
    130        trie->data.ptr8 = (const uint8_t *)p16;
    131        trie->nullValue = trie->data.ptr8[nullValueOffset];
    132        break;
    133    default:
    134        // Unreachable because valueWidth was checked above.
    135        *pErrorCode = U_INVALID_FORMAT_ERROR;
    136        return nullptr;
    137    }
    138 
    139    if (pActualLength != nullptr) {
    140        *pActualLength = actualLength;
    141    }
    142    return trie;
    143 }
    144 
    145 U_CAPI void U_EXPORT2
    146 ucptrie_close(UCPTrie *trie) {
    147    uprv_free(trie);
    148 }
    149 
    150 U_CAPI UCPTrieType U_EXPORT2
    151 ucptrie_getType(const UCPTrie *trie) {
    152    return (UCPTrieType)trie->type;
    153 }
    154 
    155 U_CAPI UCPTrieValueWidth U_EXPORT2
    156 ucptrie_getValueWidth(const UCPTrie *trie) {
    157    return (UCPTrieValueWidth)trie->valueWidth;
    158 }
    159 
    160 U_CAPI int32_t U_EXPORT2
    161 ucptrie_internalSmallIndex(const UCPTrie *trie, UChar32 c) {
    162    int32_t i1 = c >> UCPTRIE_SHIFT_1;
    163    if (trie->type == UCPTRIE_TYPE_FAST) {
    164        U_ASSERT(0xffff < c && c < trie->highStart);
    165        i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH;
    166    } else {
    167        U_ASSERT((uint32_t)c < (uint32_t)trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT);
    168        i1 += UCPTRIE_SMALL_INDEX_LENGTH;
    169    }
    170    int32_t i3Block = trie->index[
    171        (int32_t)trie->index[i1] + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)];
    172    int32_t i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK;
    173    int32_t dataBlock;
    174    if ((i3Block & 0x8000) == 0) {
    175        // 16-bit indexes
    176        dataBlock = trie->index[i3Block + i3];
    177    } else {
    178        // 18-bit indexes stored in groups of 9 entries per 8 indexes.
    179        i3Block = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3);
    180        i3 &= 7;
    181        dataBlock = ((int32_t)trie->index[i3Block++] << (2 + (2 * i3))) & 0x30000;
    182        dataBlock |= trie->index[i3Block + i3];
    183    }
    184    return dataBlock + (c & UCPTRIE_SMALL_DATA_MASK);
    185 }
    186 
    187 U_CAPI int32_t U_EXPORT2
    188 ucptrie_internalSmallU8Index(const UCPTrie *trie, int32_t lt1, uint8_t t2, uint8_t t3) {
    189    UChar32 c = (lt1 << 12) | (t2 << 6) | t3;
    190    if (c >= trie->highStart) {
    191        // Possible because the UTF-8 macro compares with shifted12HighStart which may be higher.
    192        return trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
    193    }
    194    return ucptrie_internalSmallIndex(trie, c);
    195 }
    196 
    197 U_CAPI int32_t U_EXPORT2
    198 ucptrie_internalU8PrevIndex(const UCPTrie *trie, UChar32 c,
    199                            const uint8_t *start, const uint8_t *src) {
    200    int32_t i, length;
    201    // Support 64-bit pointers by avoiding cast of arbitrary difference.
    202    if ((src - start) <= 7) {
    203        i = length = (int32_t)(src - start);
    204    } else {
    205        i = length = 7;
    206        start = src - 7;
    207    }
    208    c = utf8_prevCharSafeBody(start, 0, &i, c, -1);
    209    i = length - i;  // Number of bytes read backward from src.
    210    int32_t idx = _UCPTRIE_CP_INDEX(trie, 0xffff, c);
    211    return (idx << 3) | i;
    212 }
    213 
    214 namespace {
    215 
    216 inline uint32_t getValue(UCPTrieData data, UCPTrieValueWidth valueWidth, int32_t dataIndex) {
    217    switch (valueWidth) {
    218    case UCPTRIE_VALUE_BITS_16:
    219        return data.ptr16[dataIndex];
    220    case UCPTRIE_VALUE_BITS_32:
    221        return data.ptr32[dataIndex];
    222    case UCPTRIE_VALUE_BITS_8:
    223        return data.ptr8[dataIndex];
    224    default:
    225        // Unreachable if the trie is properly initialized.
    226        return 0xffffffff;
    227    }
    228 }
    229 
    230 }  // namespace
    231 
    232 U_CAPI uint32_t U_EXPORT2
    233 ucptrie_get(const UCPTrie *trie, UChar32 c) {
    234    int32_t dataIndex;
    235    if ((uint32_t)c <= 0x7f) {
    236        // linear ASCII
    237        dataIndex = c;
    238    } else {
    239        UChar32 fastMax = trie->type == UCPTRIE_TYPE_FAST ? 0xffff : UCPTRIE_SMALL_MAX;
    240        dataIndex = _UCPTRIE_CP_INDEX(trie, fastMax, c);
    241    }
    242    return getValue(trie->data, (UCPTrieValueWidth)trie->valueWidth, dataIndex);
    243 }
    244 
    245 namespace {
    246 
    247 constexpr int32_t MAX_UNICODE = 0x10ffff;
    248 
    249 inline uint32_t maybeFilterValue(uint32_t value, uint32_t trieNullValue, uint32_t nullValue,
    250                                 UCPMapValueFilter *filter, const void *context) {
    251    if (value == trieNullValue) {
    252        value = nullValue;
    253    } else if (filter != nullptr) {
    254        value = filter(context, value);
    255    }
    256    return value;
    257 }
    258 
    259 UChar32 getRange(const void *t, UChar32 start,
    260                 UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
    261    if (static_cast<uint32_t>(start) > MAX_UNICODE) {
    262        return U_SENTINEL;
    263    }
    264    const UCPTrie *trie = reinterpret_cast<const UCPTrie *>(t);
    265    UCPTrieValueWidth valueWidth = static_cast<UCPTrieValueWidth>(trie->valueWidth);
    266    if (start >= trie->highStart) {
    267        if (pValue != nullptr) {
    268            int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
    269            uint32_t value = getValue(trie->data, valueWidth, di);
    270            if (filter != nullptr) { value = filter(context, value); }
    271            *pValue = value;
    272        }
    273        return MAX_UNICODE;
    274    }
    275 
    276    uint32_t nullValue = trie->nullValue;
    277    if (filter != nullptr) { nullValue = filter(context, nullValue); }
    278    const uint16_t *index = trie->index;
    279 
    280    int32_t prevI3Block = -1;
    281    int32_t prevBlock = -1;
    282    UChar32 c = start;
    283    uint32_t trieValue, value = nullValue;
    284    bool haveValue = false;
    285    do {
    286        int32_t i3Block;
    287        int32_t i3;
    288        int32_t i3BlockLength;
    289        int32_t dataBlockLength;
    290        if (c <= 0xffff && (trie->type == UCPTRIE_TYPE_FAST || c <= UCPTRIE_SMALL_MAX)) {
    291            i3Block = 0;
    292            i3 = c >> UCPTRIE_FAST_SHIFT;
    293            i3BlockLength = trie->type == UCPTRIE_TYPE_FAST ?
    294                UCPTRIE_BMP_INDEX_LENGTH : UCPTRIE_SMALL_INDEX_LENGTH;
    295            dataBlockLength = UCPTRIE_FAST_DATA_BLOCK_LENGTH;
    296        } else {
    297            // Use the multi-stage index.
    298            int32_t i1 = c >> UCPTRIE_SHIFT_1;
    299            if (trie->type == UCPTRIE_TYPE_FAST) {
    300                U_ASSERT(0xffff < c && c < trie->highStart);
    301                i1 += UCPTRIE_BMP_INDEX_LENGTH - UCPTRIE_OMITTED_BMP_INDEX_1_LENGTH;
    302            } else {
    303                U_ASSERT(c < trie->highStart && trie->highStart > UCPTRIE_SMALL_LIMIT);
    304                i1 += UCPTRIE_SMALL_INDEX_LENGTH;
    305            }
    306            i3Block = trie->index[
    307                static_cast<int32_t>(trie->index[i1]) + ((c >> UCPTRIE_SHIFT_2) & UCPTRIE_INDEX_2_MASK)];
    308            if (i3Block == prevI3Block && (c - start) >= UCPTRIE_CP_PER_INDEX_2_ENTRY) {
    309                // The index-3 block is the same as the previous one, and filled with value.
    310                U_ASSERT((c & (UCPTRIE_CP_PER_INDEX_2_ENTRY - 1)) == 0);
    311                c += UCPTRIE_CP_PER_INDEX_2_ENTRY;
    312                continue;
    313            }
    314            prevI3Block = i3Block;
    315            if (i3Block == trie->index3NullOffset) {
    316                // This is the index-3 null block.
    317                if (haveValue) {
    318                    if (nullValue != value) {
    319                        return c - 1;
    320                    }
    321                } else {
    322                    trieValue = trie->nullValue;
    323                    value = nullValue;
    324                    if (pValue != nullptr) { *pValue = nullValue; }
    325                    haveValue = true;
    326                }
    327                prevBlock = trie->dataNullOffset;
    328                c = (c + UCPTRIE_CP_PER_INDEX_2_ENTRY) & ~(UCPTRIE_CP_PER_INDEX_2_ENTRY - 1);
    329                continue;
    330            }
    331            i3 = (c >> UCPTRIE_SHIFT_3) & UCPTRIE_INDEX_3_MASK;
    332            i3BlockLength = UCPTRIE_INDEX_3_BLOCK_LENGTH;
    333            dataBlockLength = UCPTRIE_SMALL_DATA_BLOCK_LENGTH;
    334        }
    335        // Enumerate data blocks for one index-3 block.
    336        do {
    337            int32_t block;
    338            if ((i3Block & 0x8000) == 0) {
    339                block = index[i3Block + i3];
    340            } else {
    341                // 18-bit indexes stored in groups of 9 entries per 8 indexes.
    342                int32_t group = (i3Block & 0x7fff) + (i3 & ~7) + (i3 >> 3);
    343                int32_t gi = i3 & 7;
    344                block = (static_cast<int32_t>(index[group++]) << (2 + (2 * gi))) & 0x30000;
    345                block |= index[group + gi];
    346            }
    347            if (block == prevBlock && (c - start) >= dataBlockLength) {
    348                // The block is the same as the previous one, and filled with value.
    349                U_ASSERT((c & (dataBlockLength - 1)) == 0);
    350                c += dataBlockLength;
    351            } else {
    352                int32_t dataMask = dataBlockLength - 1;
    353                prevBlock = block;
    354                if (block == trie->dataNullOffset) {
    355                    // This is the data null block.
    356                    if (haveValue) {
    357                        if (nullValue != value) {
    358                            return c - 1;
    359                        }
    360                    } else {
    361                        trieValue = trie->nullValue;
    362                        value = nullValue;
    363                        if (pValue != nullptr) { *pValue = nullValue; }
    364                        haveValue = true;
    365                    }
    366                    c = (c + dataBlockLength) & ~dataMask;
    367                } else {
    368                    int32_t di = block + (c & dataMask);
    369                    uint32_t trieValue2 = getValue(trie->data, valueWidth, di);
    370                    if (haveValue) {
    371                        if (trieValue2 != trieValue) {
    372                            if (filter == nullptr ||
    373                                    maybeFilterValue(trieValue2, trie->nullValue, nullValue,
    374                                                     filter, context) != value) {
    375                                return c - 1;
    376                            }
    377                            trieValue = trieValue2;  // may or may not help
    378                        }
    379                    } else {
    380                        trieValue = trieValue2;
    381                        value = maybeFilterValue(trieValue2, trie->nullValue, nullValue,
    382                                                 filter, context);
    383                        if (pValue != nullptr) { *pValue = value; }
    384                        haveValue = true;
    385                    }
    386                    while ((++c & dataMask) != 0) {
    387                        trieValue2 = getValue(trie->data, valueWidth, ++di);
    388                        if (trieValue2 != trieValue) {
    389                            if (filter == nullptr ||
    390                                    maybeFilterValue(trieValue2, trie->nullValue, nullValue,
    391                                                     filter, context) != value) {
    392                                return c - 1;
    393                            }
    394                            trieValue = trieValue2;  // may or may not help
    395                        }
    396                    }
    397                }
    398            }
    399        } while (++i3 < i3BlockLength);
    400    } while (c < trie->highStart);
    401    U_ASSERT(haveValue);
    402    int32_t di = trie->dataLength - UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET;
    403    uint32_t highValue = getValue(trie->data, valueWidth, di);
    404    if (maybeFilterValue(highValue, trie->nullValue, nullValue,
    405                         filter, context) != value) {
    406        return c - 1;
    407    } else {
    408        return MAX_UNICODE;
    409    }
    410 }
    411 
    412 }  // namespace
    413 
    414 U_CFUNC UChar32
    415 ucptrie_internalGetRange(UCPTrieGetRange *getRange,
    416                         const void *trie, UChar32 start,
    417                         UCPMapRangeOption option, uint32_t surrogateValue,
    418                         UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
    419    if (option == UCPMAP_RANGE_NORMAL) {
    420        return getRange(trie, start, filter, context, pValue);
    421    }
    422    uint32_t value;
    423    if (pValue == nullptr) {
    424        // We need to examine the range value even if the caller does not want it.
    425        pValue = &value;
    426    }
    427    UChar32 surrEnd = option == UCPMAP_RANGE_FIXED_ALL_SURROGATES ? 0xdfff : 0xdbff;
    428    UChar32 end = getRange(trie, start, filter, context, pValue);
    429    if (end < 0xd7ff || start > surrEnd) {
    430        return end;
    431    }
    432    // The range overlaps with surrogates, or ends just before the first one.
    433    if (*pValue == surrogateValue) {
    434        if (end >= surrEnd) {
    435            // Surrogates followed by a non-surrogateValue range,
    436            // or surrogates are part of a larger surrogateValue range.
    437            return end;
    438        }
    439    } else {
    440        if (start <= 0xd7ff) {
    441            return 0xd7ff;  // Non-surrogateValue range ends before surrogateValue surrogates.
    442        }
    443        // Start is a surrogate with a non-surrogateValue code *unit* value.
    444        // Return a surrogateValue code *point* range.
    445        *pValue = surrogateValue;
    446        if (end > surrEnd) {
    447            return surrEnd;  // Surrogate range ends before non-surrogateValue rest of range.
    448        }
    449    }
    450    // See if the surrogateValue surrogate range can be merged with
    451    // an immediately following range.
    452    uint32_t value2;
    453    UChar32 end2 = getRange(trie, surrEnd + 1, filter, context, &value2);
    454    if (value2 == surrogateValue) {
    455        return end2;
    456    }
    457    return surrEnd;
    458 }
    459 
    460 U_CAPI UChar32 U_EXPORT2
    461 ucptrie_getRange(const UCPTrie *trie, UChar32 start,
    462                 UCPMapRangeOption option, uint32_t surrogateValue,
    463                 UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
    464    return ucptrie_internalGetRange(getRange, trie, start,
    465                                    option, surrogateValue,
    466                                    filter, context, pValue);
    467 }
    468 
    469 U_CAPI int32_t U_EXPORT2
    470 ucptrie_toBinary(const UCPTrie *trie,
    471                 void *data, int32_t capacity,
    472                 UErrorCode *pErrorCode) {
    473    if (U_FAILURE(*pErrorCode)) {
    474        return 0;
    475    }
    476 
    477    UCPTrieType type = (UCPTrieType)trie->type;
    478    UCPTrieValueWidth valueWidth = (UCPTrieValueWidth)trie->valueWidth;
    479    if (type < UCPTRIE_TYPE_FAST || UCPTRIE_TYPE_SMALL < type ||
    480            valueWidth < UCPTRIE_VALUE_BITS_16 || UCPTRIE_VALUE_BITS_8 < valueWidth ||
    481            capacity < 0 ||
    482            (capacity > 0 && (data == nullptr || (U_POINTER_MASK_LSB(data, 3) != 0)))) {
    483        *pErrorCode = U_ILLEGAL_ARGUMENT_ERROR;
    484        return 0;
    485    }
    486 
    487    int32_t length = (int32_t)sizeof(UCPTrieHeader) + trie->indexLength * 2;
    488    switch (valueWidth) {
    489    case UCPTRIE_VALUE_BITS_16:
    490        length += trie->dataLength * 2;
    491        break;
    492    case UCPTRIE_VALUE_BITS_32:
    493        length += trie->dataLength * 4;
    494        break;
    495    case UCPTRIE_VALUE_BITS_8:
    496        length += trie->dataLength;
    497        break;
    498    default:
    499        // unreachable
    500        break;
    501    }
    502    if (capacity < length) {
    503        *pErrorCode = U_BUFFER_OVERFLOW_ERROR;
    504        return length;
    505    }
    506 
    507    char *bytes = (char *)data;
    508    UCPTrieHeader *header = (UCPTrieHeader *)bytes;
    509    header->signature = UCPTRIE_SIG;  // "Tri3"
    510    header->options = (uint16_t)(
    511        ((trie->dataLength & 0xf0000) >> 4) |
    512        ((trie->dataNullOffset & 0xf0000) >> 8) |
    513        (trie->type << 6) |
    514        valueWidth);
    515    header->indexLength = (uint16_t)trie->indexLength;
    516    header->dataLength = (uint16_t)trie->dataLength;
    517    header->index3NullOffset = trie->index3NullOffset;
    518    header->dataNullOffset = (uint16_t)trie->dataNullOffset;
    519    header->shiftedHighStart = trie->highStart >> UCPTRIE_SHIFT_2;
    520    bytes += sizeof(UCPTrieHeader);
    521 
    522    uprv_memcpy(bytes, trie->index, trie->indexLength * 2);
    523    bytes += trie->indexLength * 2;
    524 
    525    switch (valueWidth) {
    526    case UCPTRIE_VALUE_BITS_16:
    527        uprv_memcpy(bytes, trie->data.ptr16, trie->dataLength * 2);
    528        break;
    529    case UCPTRIE_VALUE_BITS_32:
    530        uprv_memcpy(bytes, trie->data.ptr32, trie->dataLength * 4);
    531        break;
    532    case UCPTRIE_VALUE_BITS_8:
    533        uprv_memcpy(bytes, trie->data.ptr8, trie->dataLength);
    534        break;
    535    default:
    536        // unreachable
    537        break;
    538    }
    539    return length;
    540 }
    541 
    542 namespace {
    543 
    544 #ifdef UCPTRIE_DEBUG
    545 long countNull(const UCPTrie *trie) {
    546    uint32_t nullValue=trie->nullValue;
    547    int32_t length=trie->dataLength;
    548    long count=0;
    549    switch (trie->valueWidth) {
    550    case UCPTRIE_VALUE_BITS_16:
    551        for(int32_t i=0; i<length; ++i) {
    552            if(trie->data.ptr16[i]==nullValue) { ++count; }
    553        }
    554        break;
    555    case UCPTRIE_VALUE_BITS_32:
    556        for(int32_t i=0; i<length; ++i) {
    557            if(trie->data.ptr32[i]==nullValue) { ++count; }
    558        }
    559        break;
    560    case UCPTRIE_VALUE_BITS_8:
    561        for(int32_t i=0; i<length; ++i) {
    562            if(trie->data.ptr8[i]==nullValue) { ++count; }
    563        }
    564        break;
    565    default:
    566        // unreachable
    567        break;
    568    }
    569    return count;
    570 }
    571 
    572 U_CFUNC void
    573 ucptrie_printLengths(const UCPTrie *trie, const char *which) {
    574    long indexLength=trie->indexLength;
    575    long dataLength=(long)trie->dataLength;
    576    long totalLength=(long)sizeof(UCPTrieHeader)+indexLength*2+
    577            dataLength*(trie->valueWidth==UCPTRIE_VALUE_BITS_16 ? 2 :
    578                        trie->valueWidth==UCPTRIE_VALUE_BITS_32 ? 4 : 1);
    579    printf("**UCPTrieLengths(%s %s)** index:%6ld  data:%6ld  countNull:%6ld  serialized:%6ld\n",
    580           which, trie->name, indexLength, dataLength, countNull(trie), totalLength);
    581 }
    582 #endif
    583 
    584 }  // namespace
    585 
    586 // UCPMap ----
    587 // Initially, this is the same as UCPTrie. This may well change.
    588 
    589 U_CAPI uint32_t U_EXPORT2
    590 ucpmap_get(const UCPMap *map, UChar32 c) {
    591    return ucptrie_get(reinterpret_cast<const UCPTrie *>(map), c);
    592 }
    593 
    594 U_CAPI UChar32 U_EXPORT2
    595 ucpmap_getRange(const UCPMap *map, UChar32 start,
    596                UCPMapRangeOption option, uint32_t surrogateValue,
    597                UCPMapValueFilter *filter, const void *context, uint32_t *pValue) {
    598    return ucptrie_getRange(reinterpret_cast<const UCPTrie *>(map), start,
    599                            option, surrogateValue,
    600                            filter, context, pValue);
    601 }
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE