Home | History | Annotate | Download | only in i18n 
      1 /*
      2 *******************************************************************************
      3 * Copyright (C) 2013-2015, International Business Machines
      4 * Corporation and others.  All Rights Reserved.
      5 *******************************************************************************
      6 * collationsettings.cpp
      7 *
      8 * created on: 2013feb07
      9 * created by: Markus W. Scherer
     10 */
     11 
     12 #include "unicode/utypes.h"
     13 
     14 #if !UCONFIG_NO_COLLATION
     15 
     16 #include "unicode/ucol.h"
     17 #include "cmemory.h"
     18 #include "collation.h"
     19 #include "collationdata.h"
     20 #include "collationsettings.h"
     21 #include "sharedobject.h"
     22 #include "uassert.h"
     23 #include "umutex.h"
     24 #include "uvectr32.h"
     25 
     26 U_NAMESPACE_BEGIN
     27 
     28 CollationSettings::CollationSettings(const CollationSettings &other)
     29         : SharedObject(other),
     30           options(other.options), variableTop(other.variableTop),
     31           reorderTable(NULL),
     32           minHighNoReorder(other.minHighNoReorder),
     33           reorderRanges(NULL), reorderRangesLength(0),
     34           reorderCodes(NULL), reorderCodesLength(0), reorderCodesCapacity(0),
     35           fastLatinOptions(other.fastLatinOptions) {
     36     UErrorCode errorCode = U_ZERO_ERROR;
     37     copyReorderingFrom(other, errorCode);
     38     if(fastLatinOptions >= 0) {
     39         uprv_memcpy(fastLatinPrimaries, other.fastLatinPrimaries, sizeof(fastLatinPrimaries));
     40     }
     41 }
     42 
     43 CollationSettings::~CollationSettings() {
     44     if(reorderCodesCapacity != 0) {
     45         uprv_free(const_cast<int32_t *>(reorderCodes));
     46     }
     47 }
     48 
     49 UBool
     50 CollationSettings::operator==(const CollationSettings &other) const {
     51     if(options != other.options) { return FALSE; }
     52     if((options & ALTERNATE_MASK) != 0 && variableTop != other.variableTop) { return FALSE; }
     53     if(reorderCodesLength != other.reorderCodesLength) { return FALSE; }
     54     for(int32_t i = 0; i < reorderCodesLength; ++i) {
     55         if(reorderCodes[i] != other.reorderCodes[i]) { return FALSE; }
     56     }
     57     return TRUE;
     58 }
     59 
     60 int32_t
     61 CollationSettings::hashCode() const {
     62     int32_t h = options << 8;
     63     if((options & ALTERNATE_MASK) != 0) { h ^= variableTop; }
     64     h ^= reorderCodesLength;
     65     for(int32_t i = 0; i < reorderCodesLength; ++i) {
     66         h ^= (reorderCodes[i] << i);
     67     }
     68     return h;
     69 }
     70 
     71 void
     72 CollationSettings::resetReordering() {
     73     // When we turn off reordering, we want to set a NULL permutation
     74     // rather than a no-op permutation.
     75     // Keep the memory via reorderCodes and its capacity.
     76     reorderTable = NULL;
     77     minHighNoReorder = 0;
     78     reorderRangesLength = 0;
     79     reorderCodesLength = 0;
     80 }
     81 
     82 void
     83 CollationSettings::aliasReordering(const CollationData &data, const int32_t *codes, int32_t length,
     84                                    const uint32_t *ranges, int32_t rangesLength,
     85                                    const uint8_t *table, UErrorCode &errorCode) {
     86     if(U_FAILURE(errorCode)) { return; }
     87     if(table != NULL &&
     88             (rangesLength == 0 ?
     89                     !reorderTableHasSplitBytes(table) :
     90                     rangesLength >= 2 &&
     91                     // The first offset must be 0. The last offset must not be 0.
     92                     (ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0)) {
     93         // We need to release the memory before setting the alias pointer.
     94         if(reorderCodesCapacity != 0) {
     95             uprv_free(const_cast<int32_t *>(reorderCodes));
     96             reorderCodesCapacity = 0;
     97         }
     98         reorderTable = table;
     99         reorderCodes = codes;
    100         reorderCodesLength = length;
    101         // Drop ranges before the first split byte. They are reordered by the table.
    102         // This then speeds up reordering of the remaining ranges.
    103         int32_t firstSplitByteRangeIndex = 0;
    104         while(firstSplitByteRangeIndex < rangesLength &&
    105                 (ranges[firstSplitByteRangeIndex] & 0xff0000) == 0) {
    106             // The second byte of the primary limit is 0.
    107             ++firstSplitByteRangeIndex;
    108         }
    109         if(firstSplitByteRangeIndex == rangesLength) {
    110             U_ASSERT(!reorderTableHasSplitBytes(table));
    111             minHighNoReorder = 0;
    112             reorderRanges = NULL;
    113             reorderRangesLength = 0;
    114         } else {
    115             U_ASSERT(table[ranges[firstSplitByteRangeIndex] >> 24] == 0);
    116             minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000;
    117             reorderRanges = ranges + firstSplitByteRangeIndex;
    118             reorderRangesLength = rangesLength - firstSplitByteRangeIndex;
    119         }
    120         return;
    121     }
    122     // Regenerate missing data.
    123     setReordering(data, codes, length, errorCode);
    124 }
    125 
    126 void
    127 CollationSettings::setReordering(const CollationData &data,
    128                                  const int32_t *codes, int32_t codesLength,
    129                                  UErrorCode &errorCode) {
    130     if(U_FAILURE(errorCode)) { return; }
    131     if(codesLength == 0 || (codesLength == 1 && codes[0] == UCOL_REORDER_CODE_NONE)) {
    132         resetReordering();
    133         return;
    134     }
    135     UVector32 rangesList(errorCode);
    136     data.makeReorderRanges(codes, codesLength, rangesList, errorCode);
    137     if(U_FAILURE(errorCode)) { return; }
    138     int32_t rangesLength = rangesList.size();
    139     if(rangesLength == 0) {
    140         resetReordering();
    141         return;
    142     }
    143     const uint32_t *ranges = reinterpret_cast<uint32_t *>(rangesList.getBuffer());
    144     // ranges[] contains at least two (limit, offset) pairs.
    145     // The first offset must be 0. The last offset must not be 0.
    146     // Separators (at the low end) and trailing weights (at the high end)
    147     // are never reordered.
    148     U_ASSERT(rangesLength >= 2);
    149     U_ASSERT((ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0);
    150     minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000;
    151 
    152     // Write the lead byte permutation table.
    153     // Set a 0 for each lead byte that has a range boundary in the middle.
    154     uint8_t table[256];
    155     int32_t b = 0;
    156     int32_t firstSplitByteRangeIndex = -1;
    157     for(int32_t i = 0; i < rangesLength; ++i) {
    158         uint32_t pair = ranges[i];
    159         int32_t limit1 = (int32_t)(pair >> 24);
    160         while(b < limit1) {
    161             table[b] = (uint8_t)(b + pair);
    162             ++b;
    163         }
    164         // Check the second byte of the limit.
    165         if((pair & 0xff0000) != 0) {
    166             table[limit1] = 0;
    167             b = limit1 + 1;
    168             if(firstSplitByteRangeIndex < 0) {
    169                 firstSplitByteRangeIndex = i;
    170             }
    171         }
    172     }
    173     while(b <= 0xff) {
    174         table[b] = (uint8_t)b;
    175         ++b;
    176     }
    177     if(firstSplitByteRangeIndex < 0) {
    178         // The lead byte permutation table alone suffices for reordering.
    179         rangesLength = 0;
    180     } else {
    181         // Remove the ranges below the first split byte.
    182         ranges += firstSplitByteRangeIndex;
    183         rangesLength -= firstSplitByteRangeIndex;
    184     }
    185     setReorderArrays(codes, codesLength, ranges, rangesLength, table, errorCode);
    186 }
    187 
    188 void
    189 CollationSettings::setReorderArrays(const int32_t *codes, int32_t codesLength,
    190                                     const uint32_t *ranges, int32_t rangesLength,
    191                                     const uint8_t *table, UErrorCode &errorCode) {
    192     if(U_FAILURE(errorCode)) { return; }
    193     int32_t *ownedCodes;
    194     int32_t totalLength = codesLength + rangesLength;
    195     U_ASSERT(totalLength > 0);
    196     if(totalLength <= reorderCodesCapacity) {
    197         ownedCodes = const_cast<int32_t *>(reorderCodes);
    198     } else {
    199         // Allocate one memory block for the codes, the ranges, and the 16-aligned table.
    200         int32_t capacity = (totalLength + 3) & ~3;  // round up to a multiple of 4 ints
    201         ownedCodes = (int32_t *)uprv_malloc(capacity * 4 + 256);
    202         if(ownedCodes == NULL) {
    203             resetReordering();
    204             errorCode = U_MEMORY_ALLOCATION_ERROR;
    205             return;
    206         }
    207         if(reorderCodesCapacity != 0) {
    208             uprv_free(const_cast<int32_t *>(reorderCodes));
    209         }
    210         reorderCodes = ownedCodes;
    211         reorderCodesCapacity = capacity;
    212     }
    213     uprv_memcpy(ownedCodes + reorderCodesCapacity, table, 256);
    214     uprv_memcpy(ownedCodes, codes, codesLength * 4);
    215     uprv_memcpy(ownedCodes + codesLength, ranges, rangesLength * 4);
    216     reorderTable = reinterpret_cast<const uint8_t *>(reorderCodes + reorderCodesCapacity);
    217     reorderCodesLength = codesLength;
    218     reorderRanges = reinterpret_cast<uint32_t *>(ownedCodes) + codesLength;
    219     reorderRangesLength = rangesLength;
    220 }
    221 
    222 void
    223 CollationSettings::copyReorderingFrom(const CollationSettings &other, UErrorCode &errorCode) {
    224     if(U_FAILURE(errorCode)) { return; }
    225     if(!other.hasReordering()) {
    226         resetReordering();
    227         return;
    228     }
    229     minHighNoReorder = other.minHighNoReorder;
    230     if(other.reorderCodesCapacity == 0) {
    231         // The reorder arrays are aliased to memory-mapped data.
    232         reorderTable = other.reorderTable;
    233         reorderRanges = other.reorderRanges;
    234         reorderRangesLength = other.reorderRangesLength;
    235         reorderCodes = other.reorderCodes;
    236         reorderCodesLength = other.reorderCodesLength;
    237     } else {
    238         setReorderArrays(other.reorderCodes, other.reorderCodesLength,
    239                          other.reorderRanges, other.reorderRangesLength,
    240                          other.reorderTable, errorCode);
    241     }
    242 }
    243 
    244 UBool
    245 CollationSettings::reorderTableHasSplitBytes(const uint8_t table[256]) {
    246     U_ASSERT(table[0] == 0);
    247     for(int32_t i = 1; i < 256; ++i) {
    248         if(table[i] == 0) {
    249             return TRUE;
    250         }
    251     }
    252     return FALSE;
    253 }
    254 
    255 uint32_t
    256 CollationSettings::reorderEx(uint32_t p) const {
    257     if(p >= minHighNoReorder) { return p; }
    258     // Round up p so that its lower 16 bits are >= any offset bits.
    259     // Then compare q directly with (limit, offset) pairs.
    260     uint32_t q = p | 0xffff;
    261     uint32_t r;
    262     const uint32_t *ranges = reorderRanges;
    263     while(q >= (r = *ranges)) { ++ranges; }
    264     return p + (r << 24);
    265 }
    266 
    267 void
    268 CollationSettings::setStrength(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) {
    269     if(U_FAILURE(errorCode)) { return; }
    270     int32_t noStrength = options & ~STRENGTH_MASK;
    271     switch(value) {
    272     case UCOL_PRIMARY:
    273     case UCOL_SECONDARY:
    274     case UCOL_TERTIARY:
    275     case UCOL_QUATERNARY:
    276     case UCOL_IDENTICAL:
    277         options = noStrength | (value << STRENGTH_SHIFT);
    278         break;
    279     case UCOL_DEFAULT:
    280         options = noStrength | (defaultOptions & STRENGTH_MASK);
    281         break;
    282     default:
    283         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    284         break;
    285     }
    286 }
    287 
    288 void
    289 CollationSettings::setFlag(int32_t bit, UColAttributeValue value,
    290                            int32_t defaultOptions, UErrorCode &errorCode) {
    291     if(U_FAILURE(errorCode)) { return; }
    292     switch(value) {
    293     case UCOL_ON:
    294         options |= bit;
    295         break;
    296     case UCOL_OFF:
    297         options &= ~bit;
    298         break;
    299     case UCOL_DEFAULT:
    300         options = (options & ~bit) | (defaultOptions & bit);
    301         break;
    302     default:
    303         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    304         break;
    305     }
    306 }
    307 
    308 void
    309 CollationSettings::setCaseFirst(UColAttributeValue value,
    310                                 int32_t defaultOptions, UErrorCode &errorCode) {
    311     if(U_FAILURE(errorCode)) { return; }
    312     int32_t noCaseFirst = options & ~CASE_FIRST_AND_UPPER_MASK;
    313     switch(value) {
    314     case UCOL_OFF:
    315         options = noCaseFirst;
    316         break;
    317     case UCOL_LOWER_FIRST:
    318         options = noCaseFirst | CASE_FIRST;
    319         break;
    320     case UCOL_UPPER_FIRST:
    321         options = noCaseFirst | CASE_FIRST_AND_UPPER_MASK;
    322         break;
    323     case UCOL_DEFAULT:
    324         options = noCaseFirst | (defaultOptions & CASE_FIRST_AND_UPPER_MASK);
    325         break;
    326     default:
    327         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    328         break;
    329     }
    330 }
    331 
    332 void
    333 CollationSettings::setAlternateHandling(UColAttributeValue value,
    334                                         int32_t defaultOptions, UErrorCode &errorCode) {
    335     if(U_FAILURE(errorCode)) { return; }
    336     int32_t noAlternate = options & ~ALTERNATE_MASK;
    337     switch(value) {
    338     case UCOL_NON_IGNORABLE:
    339         options = noAlternate;
    340         break;
    341     case UCOL_SHIFTED:
    342         options = noAlternate | SHIFTED;
    343         break;
    344     case UCOL_DEFAULT:
    345         options = noAlternate | (defaultOptions & ALTERNATE_MASK);
    346         break;
    347     default:
    348         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    349         break;
    350     }
    351 }
    352 
    353 void
    354 CollationSettings::setMaxVariable(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) {
    355     if(U_FAILURE(errorCode)) { return; }
    356     int32_t noMax = options & ~MAX_VARIABLE_MASK;
    357     switch(value) {
    358     case MAX_VAR_SPACE:
    359     case MAX_VAR_PUNCT:
    360     case MAX_VAR_SYMBOL:
    361     case MAX_VAR_CURRENCY:
    362         options = noMax | (value << MAX_VARIABLE_SHIFT);
    363         break;
    364     case UCOL_DEFAULT:
    365         options = noMax | (defaultOptions & MAX_VARIABLE_MASK);
    366         break;
    367     default:
    368         errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    369         break;
    370     }
    371 }
    372 
    373 U_NAMESPACE_END
    374 
    375 #endif  // !UCONFIG_NO_COLLATION
    376