| /* |
| ******************************************************************************* |
| * Copyright (C) 2013-2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| * collationsettings.cpp |
| * |
| * created on: 2013feb07 |
| * created by: Markus W. Scherer |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| #include "unicode/ucol.h" |
| #include "cmemory.h" |
| #include "collation.h" |
| #include "collationdata.h" |
| #include "collationsettings.h" |
| #include "sharedobject.h" |
| #include "uassert.h" |
| #include "umutex.h" |
| #include "uvectr32.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| CollationSettings::CollationSettings(const CollationSettings &other) |
| : SharedObject(other), |
| options(other.options), variableTop(other.variableTop), |
| reorderTable(NULL), |
| minHighNoReorder(other.minHighNoReorder), |
| reorderRanges(NULL), reorderRangesLength(0), |
| reorderCodes(NULL), reorderCodesLength(0), reorderCodesCapacity(0), |
| fastLatinOptions(other.fastLatinOptions) { |
| UErrorCode errorCode = U_ZERO_ERROR; |
| copyReorderingFrom(other, errorCode); |
| if(fastLatinOptions >= 0) { |
| uprv_memcpy(fastLatinPrimaries, other.fastLatinPrimaries, sizeof(fastLatinPrimaries)); |
| } |
| } |
| |
| CollationSettings::~CollationSettings() { |
| if(reorderCodesCapacity != 0) { |
| uprv_free(const_cast<int32_t *>(reorderCodes)); |
| } |
| } |
| |
| UBool |
| CollationSettings::operator==(const CollationSettings &other) const { |
| if(options != other.options) { return FALSE; } |
| if((options & ALTERNATE_MASK) != 0 && variableTop != other.variableTop) { return FALSE; } |
| if(reorderCodesLength != other.reorderCodesLength) { return FALSE; } |
| for(int32_t i = 0; i < reorderCodesLength; ++i) { |
| if(reorderCodes[i] != other.reorderCodes[i]) { return FALSE; } |
| } |
| return TRUE; |
| } |
| |
| int32_t |
| CollationSettings::hashCode() const { |
| int32_t h = options << 8; |
| if((options & ALTERNATE_MASK) != 0) { h ^= variableTop; } |
| h ^= reorderCodesLength; |
| for(int32_t i = 0; i < reorderCodesLength; ++i) { |
| h ^= (reorderCodes[i] << i); |
| } |
| return h; |
| } |
| |
| void |
| CollationSettings::resetReordering() { |
| // When we turn off reordering, we want to set a NULL permutation |
| // rather than a no-op permutation. |
| // Keep the memory via reorderCodes and its capacity. |
| reorderTable = NULL; |
| minHighNoReorder = 0; |
| reorderRangesLength = 0; |
| reorderCodesLength = 0; |
| } |
| |
| void |
| CollationSettings::aliasReordering(const CollationData &data, const int32_t *codes, int32_t length, |
| const uint32_t *ranges, int32_t rangesLength, |
| const uint8_t *table, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| if(table != NULL && |
| (rangesLength == 0 ? |
| !reorderTableHasSplitBytes(table) : |
| rangesLength >= 2 && |
| // The first offset must be 0. The last offset must not be 0. |
| (ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0)) { |
| // We need to release the memory before setting the alias pointer. |
| if(reorderCodesCapacity != 0) { |
| uprv_free(const_cast<int32_t *>(reorderCodes)); |
| reorderCodesCapacity = 0; |
| } |
| reorderTable = table; |
| reorderCodes = codes; |
| reorderCodesLength = length; |
| // Drop ranges before the first split byte. They are reordered by the table. |
| // This then speeds up reordering of the remaining ranges. |
| int32_t firstSplitByteRangeIndex = 0; |
| while(firstSplitByteRangeIndex < rangesLength && |
| (ranges[firstSplitByteRangeIndex] & 0xff0000) == 0) { |
| // The second byte of the primary limit is 0. |
| ++firstSplitByteRangeIndex; |
| } |
| if(firstSplitByteRangeIndex == rangesLength) { |
| U_ASSERT(!reorderTableHasSplitBytes(table)); |
| minHighNoReorder = 0; |
| reorderRanges = NULL; |
| reorderRangesLength = 0; |
| } else { |
| U_ASSERT(table[ranges[firstSplitByteRangeIndex] >> 24] == 0); |
| minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000; |
| reorderRanges = ranges + firstSplitByteRangeIndex; |
| reorderRangesLength = rangesLength - firstSplitByteRangeIndex; |
| } |
| return; |
| } |
| // Regenerate missing data. |
| setReordering(data, codes, length, errorCode); |
| } |
| |
| void |
| CollationSettings::setReordering(const CollationData &data, |
| const int32_t *codes, int32_t codesLength, |
| UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| if(codesLength == 0 || (codesLength == 1 && codes[0] == UCOL_REORDER_CODE_NONE)) { |
| resetReordering(); |
| return; |
| } |
| UVector32 rangesList(errorCode); |
| data.makeReorderRanges(codes, codesLength, rangesList, errorCode); |
| if(U_FAILURE(errorCode)) { return; } |
| int32_t rangesLength = rangesList.size(); |
| if(rangesLength == 0) { |
| resetReordering(); |
| return; |
| } |
| const uint32_t *ranges = reinterpret_cast<uint32_t *>(rangesList.getBuffer()); |
| // ranges[] contains at least two (limit, offset) pairs. |
| // The first offset must be 0. The last offset must not be 0. |
| // Separators (at the low end) and trailing weights (at the high end) |
| // are never reordered. |
| U_ASSERT(rangesLength >= 2); |
| U_ASSERT((ranges[0] & 0xffff) == 0 && (ranges[rangesLength - 1] & 0xffff) != 0); |
| minHighNoReorder = ranges[rangesLength - 1] & 0xffff0000; |
| |
| // Write the lead byte permutation table. |
| // Set a 0 for each lead byte that has a range boundary in the middle. |
| uint8_t table[256]; |
| int32_t b = 0; |
| int32_t firstSplitByteRangeIndex = -1; |
| for(int32_t i = 0; i < rangesLength; ++i) { |
| uint32_t pair = ranges[i]; |
| int32_t limit1 = (int32_t)(pair >> 24); |
| while(b < limit1) { |
| table[b] = (uint8_t)(b + pair); |
| ++b; |
| } |
| // Check the second byte of the limit. |
| if((pair & 0xff0000) != 0) { |
| table[limit1] = 0; |
| b = limit1 + 1; |
| if(firstSplitByteRangeIndex < 0) { |
| firstSplitByteRangeIndex = i; |
| } |
| } |
| } |
| while(b <= 0xff) { |
| table[b] = (uint8_t)b; |
| ++b; |
| } |
| if(firstSplitByteRangeIndex < 0) { |
| // The lead byte permutation table alone suffices for reordering. |
| rangesLength = 0; |
| } else { |
| // Remove the ranges below the first split byte. |
| ranges += firstSplitByteRangeIndex; |
| rangesLength -= firstSplitByteRangeIndex; |
| } |
| setReorderArrays(codes, codesLength, ranges, rangesLength, table, errorCode); |
| } |
| |
| void |
| CollationSettings::setReorderArrays(const int32_t *codes, int32_t codesLength, |
| const uint32_t *ranges, int32_t rangesLength, |
| const uint8_t *table, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| int32_t *ownedCodes; |
| int32_t totalLength = codesLength + rangesLength; |
| U_ASSERT(totalLength > 0); |
| if(totalLength <= reorderCodesCapacity) { |
| ownedCodes = const_cast<int32_t *>(reorderCodes); |
| } else { |
| // Allocate one memory block for the codes, the ranges, and the 16-aligned table. |
| int32_t capacity = (totalLength + 3) & ~3; // round up to a multiple of 4 ints |
| ownedCodes = (int32_t *)uprv_malloc(capacity * 4 + 256); |
| if(ownedCodes == NULL) { |
| resetReordering(); |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| if(reorderCodesCapacity != 0) { |
| uprv_free(const_cast<int32_t *>(reorderCodes)); |
| } |
| reorderCodes = ownedCodes; |
| reorderCodesCapacity = capacity; |
| } |
| uprv_memcpy(ownedCodes + reorderCodesCapacity, table, 256); |
| uprv_memcpy(ownedCodes, codes, codesLength * 4); |
| uprv_memcpy(ownedCodes + codesLength, ranges, rangesLength * 4); |
| reorderTable = reinterpret_cast<const uint8_t *>(reorderCodes + reorderCodesCapacity); |
| reorderCodesLength = codesLength; |
| reorderRanges = reinterpret_cast<uint32_t *>(ownedCodes) + codesLength; |
| reorderRangesLength = rangesLength; |
| } |
| |
| void |
| CollationSettings::copyReorderingFrom(const CollationSettings &other, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| if(!other.hasReordering()) { |
| resetReordering(); |
| return; |
| } |
| minHighNoReorder = other.minHighNoReorder; |
| if(other.reorderCodesCapacity == 0) { |
| // The reorder arrays are aliased to memory-mapped data. |
| reorderTable = other.reorderTable; |
| reorderRanges = other.reorderRanges; |
| reorderRangesLength = other.reorderRangesLength; |
| reorderCodes = other.reorderCodes; |
| reorderCodesLength = other.reorderCodesLength; |
| } else { |
| setReorderArrays(other.reorderCodes, other.reorderCodesLength, |
| other.reorderRanges, other.reorderRangesLength, |
| other.reorderTable, errorCode); |
| } |
| } |
| |
| UBool |
| CollationSettings::reorderTableHasSplitBytes(const uint8_t table[256]) { |
| U_ASSERT(table[0] == 0); |
| for(int32_t i = 1; i < 256; ++i) { |
| if(table[i] == 0) { |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| |
| uint32_t |
| CollationSettings::reorderEx(uint32_t p) const { |
| if(p >= minHighNoReorder) { return p; } |
| // Round up p so that its lower 16 bits are >= any offset bits. |
| // Then compare q directly with (limit, offset) pairs. |
| uint32_t q = p | 0xffff; |
| uint32_t r; |
| const uint32_t *ranges = reorderRanges; |
| while(q >= (r = *ranges)) { ++ranges; } |
| return p + (r << 24); |
| } |
| |
| void |
| CollationSettings::setStrength(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| int32_t noStrength = options & ~STRENGTH_MASK; |
| switch(value) { |
| case UCOL_PRIMARY: |
| case UCOL_SECONDARY: |
| case UCOL_TERTIARY: |
| case UCOL_QUATERNARY: |
| case UCOL_IDENTICAL: |
| options = noStrength | (value << STRENGTH_SHIFT); |
| break; |
| case UCOL_DEFAULT: |
| options = noStrength | (defaultOptions & STRENGTH_MASK); |
| break; |
| default: |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| break; |
| } |
| } |
| |
| void |
| CollationSettings::setFlag(int32_t bit, UColAttributeValue value, |
| int32_t defaultOptions, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| switch(value) { |
| case UCOL_ON: |
| options |= bit; |
| break; |
| case UCOL_OFF: |
| options &= ~bit; |
| break; |
| case UCOL_DEFAULT: |
| options = (options & ~bit) | (defaultOptions & bit); |
| break; |
| default: |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| break; |
| } |
| } |
| |
| void |
| CollationSettings::setCaseFirst(UColAttributeValue value, |
| int32_t defaultOptions, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| int32_t noCaseFirst = options & ~CASE_FIRST_AND_UPPER_MASK; |
| switch(value) { |
| case UCOL_OFF: |
| options = noCaseFirst; |
| break; |
| case UCOL_LOWER_FIRST: |
| options = noCaseFirst | CASE_FIRST; |
| break; |
| case UCOL_UPPER_FIRST: |
| options = noCaseFirst | CASE_FIRST_AND_UPPER_MASK; |
| break; |
| case UCOL_DEFAULT: |
| options = noCaseFirst | (defaultOptions & CASE_FIRST_AND_UPPER_MASK); |
| break; |
| default: |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| break; |
| } |
| } |
| |
| void |
| CollationSettings::setAlternateHandling(UColAttributeValue value, |
| int32_t defaultOptions, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| int32_t noAlternate = options & ~ALTERNATE_MASK; |
| switch(value) { |
| case UCOL_NON_IGNORABLE: |
| options = noAlternate; |
| break; |
| case UCOL_SHIFTED: |
| options = noAlternate | SHIFTED; |
| break; |
| case UCOL_DEFAULT: |
| options = noAlternate | (defaultOptions & ALTERNATE_MASK); |
| break; |
| default: |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| break; |
| } |
| } |
| |
| void |
| CollationSettings::setMaxVariable(int32_t value, int32_t defaultOptions, UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return; } |
| int32_t noMax = options & ~MAX_VARIABLE_MASK; |
| switch(value) { |
| case MAX_VAR_SPACE: |
| case MAX_VAR_PUNCT: |
| case MAX_VAR_SYMBOL: |
| case MAX_VAR_CURRENCY: |
| options = noMax | (value << MAX_VARIABLE_SHIFT); |
| break; |
| case UCOL_DEFAULT: |
| options = noMax | (defaultOptions & MAX_VARIABLE_MASK); |
| break; |
| default: |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| break; |
| } |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif // !UCONFIG_NO_COLLATION |
