| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * Copyright (C) 2013-2014, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| * collationrootelements.cpp |
| * |
| * created on: 2013mar05 |
| * created by: Markus W. Scherer |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| #include "collation.h" |
| #include "collationrootelements.h" |
| #include "uassert.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| int64_t |
| CollationRootElements::lastCEWithPrimaryBefore(uint32_t p) const { |
| if(p == 0) { return 0; } |
| U_ASSERT(p > elements[elements[IX_FIRST_PRIMARY_INDEX]]); |
| int32_t index = findP(p); |
| uint32_t q = elements[index]; |
| uint32_t secTer; |
| if(p == (q & 0xffffff00)) { |
| // p == elements[index] is a root primary. Find the CE before it. |
| // We must not be in a primary range. |
| U_ASSERT((q & PRIMARY_STEP_MASK) == 0); |
| secTer = elements[index - 1]; |
| if((secTer & SEC_TER_DELTA_FLAG) == 0) { |
| // Primary CE just before p. |
| p = secTer & 0xffffff00; |
| secTer = Collation::COMMON_SEC_AND_TER_CE; |
| } else { |
| // secTer = last secondary & tertiary for the previous primary |
| index -= 2; |
| for(;;) { |
| p = elements[index]; |
| if((p & SEC_TER_DELTA_FLAG) == 0) { |
| p &= 0xffffff00; |
| break; |
| } |
| --index; |
| } |
| } |
| } else { |
| // p > elements[index] which is the previous primary. |
| // Find the last secondary & tertiary weights for it. |
| p = q & 0xffffff00; |
| secTer = Collation::COMMON_SEC_AND_TER_CE; |
| for(;;) { |
| q = elements[++index]; |
| if((q & SEC_TER_DELTA_FLAG) == 0) { |
| // We must not be in a primary range. |
| U_ASSERT((q & PRIMARY_STEP_MASK) == 0); |
| break; |
| } |
| secTer = q; |
| } |
| } |
| return ((int64_t)p << 32) | (secTer & ~SEC_TER_DELTA_FLAG); |
| } |
| |
| int64_t |
| CollationRootElements::firstCEWithPrimaryAtLeast(uint32_t p) const { |
| if(p == 0) { return 0; } |
| int32_t index = findP(p); |
| if(p != (elements[index] & 0xffffff00)) { |
| for(;;) { |
| p = elements[++index]; |
| if((p & SEC_TER_DELTA_FLAG) == 0) { |
| // First primary after p. We must not be in a primary range. |
| U_ASSERT((p & PRIMARY_STEP_MASK) == 0); |
| break; |
| } |
| } |
| } |
| // The code above guarantees that p has at most 3 bytes: (p & 0xff) == 0. |
| return ((int64_t)p << 32) | Collation::COMMON_SEC_AND_TER_CE; |
| } |
| |
| uint32_t |
| CollationRootElements::getPrimaryBefore(uint32_t p, UBool isCompressible) const { |
| int32_t index = findPrimary(p); |
| int32_t step; |
| uint32_t q = elements[index]; |
| if(p == (q & 0xffffff00)) { |
| // Found p itself. Return the previous primary. |
| // See if p is at the end of a previous range. |
| step = (int32_t)q & PRIMARY_STEP_MASK; |
| if(step == 0) { |
| // p is not at the end of a range. Look for the previous primary. |
| do { |
| p = elements[--index]; |
| } while((p & SEC_TER_DELTA_FLAG) != 0); |
| return p & 0xffffff00; |
| } |
| } else { |
| // p is in a range, and not at the start. |
| uint32_t nextElement = elements[index + 1]; |
| U_ASSERT(isEndOfPrimaryRange(nextElement)); |
| step = (int32_t)nextElement & PRIMARY_STEP_MASK; |
| } |
| // Return the previous range primary. |
| if((p & 0xffff) == 0) { |
| return Collation::decTwoBytePrimaryByOneStep(p, isCompressible, step); |
| } else { |
| return Collation::decThreeBytePrimaryByOneStep(p, isCompressible, step); |
| } |
| } |
| |
| uint32_t |
| CollationRootElements::getSecondaryBefore(uint32_t p, uint32_t s) const { |
| int32_t index; |
| uint32_t previousSec, sec; |
| if(p == 0) { |
| index = (int32_t)elements[IX_FIRST_SECONDARY_INDEX]; |
| // Gap at the beginning of the secondary CE range. |
| previousSec = 0; |
| sec = elements[index] >> 16; |
| } else { |
| index = findPrimary(p) + 1; |
| previousSec = Collation::BEFORE_WEIGHT16; |
| sec = getFirstSecTerForPrimary(index) >> 16; |
| } |
| U_ASSERT(s >= sec); |
| while(s > sec) { |
| previousSec = sec; |
| U_ASSERT((elements[index] & SEC_TER_DELTA_FLAG) != 0); |
| sec = elements[index++] >> 16; |
| } |
| U_ASSERT(sec == s); |
| return previousSec; |
| } |
| |
| uint32_t |
| CollationRootElements::getTertiaryBefore(uint32_t p, uint32_t s, uint32_t t) const { |
| U_ASSERT((t & ~Collation::ONLY_TERTIARY_MASK) == 0); |
| int32_t index; |
| uint32_t previousTer, secTer; |
| if(p == 0) { |
| if(s == 0) { |
| index = (int32_t)elements[IX_FIRST_TERTIARY_INDEX]; |
| // Gap at the beginning of the tertiary CE range. |
| previousTer = 0; |
| } else { |
| index = (int32_t)elements[IX_FIRST_SECONDARY_INDEX]; |
| previousTer = Collation::BEFORE_WEIGHT16; |
| } |
| secTer = elements[index] & ~SEC_TER_DELTA_FLAG; |
| } else { |
| index = findPrimary(p) + 1; |
| previousTer = Collation::BEFORE_WEIGHT16; |
| secTer = getFirstSecTerForPrimary(index); |
| } |
| uint32_t st = (s << 16) | t; |
| while(st > secTer) { |
| if((secTer >> 16) == s) { previousTer = secTer; } |
| U_ASSERT((elements[index] & SEC_TER_DELTA_FLAG) != 0); |
| secTer = elements[index++] & ~SEC_TER_DELTA_FLAG; |
| } |
| U_ASSERT(secTer == st); |
| return previousTer & 0xffff; |
| } |
| |
| uint32_t |
| CollationRootElements::getPrimaryAfter(uint32_t p, int32_t index, UBool isCompressible) const { |
| U_ASSERT(p == (elements[index] & 0xffffff00) || isEndOfPrimaryRange(elements[index + 1])); |
| uint32_t q = elements[++index]; |
| int32_t step; |
| if((q & SEC_TER_DELTA_FLAG) == 0 && (step = (int32_t)q & PRIMARY_STEP_MASK) != 0) { |
| // Return the next primary in this range. |
| if((p & 0xffff) == 0) { |
| return Collation::incTwoBytePrimaryByOffset(p, isCompressible, step); |
| } else { |
| return Collation::incThreeBytePrimaryByOffset(p, isCompressible, step); |
| } |
| } else { |
| // Return the next primary in the list. |
| while((q & SEC_TER_DELTA_FLAG) != 0) { |
| q = elements[++index]; |
| } |
| U_ASSERT((q & PRIMARY_STEP_MASK) == 0); |
| return q; |
| } |
| } |
| |
| uint32_t |
| CollationRootElements::getSecondaryAfter(int32_t index, uint32_t s) const { |
| uint32_t secTer; |
| uint32_t secLimit; |
| if(index == 0) { |
| // primary = 0 |
| U_ASSERT(s != 0); |
| index = (int32_t)elements[IX_FIRST_SECONDARY_INDEX]; |
| secTer = elements[index]; |
| // Gap at the end of the secondary CE range. |
| secLimit = 0x10000; |
| } else { |
| U_ASSERT(index >= (int32_t)elements[IX_FIRST_PRIMARY_INDEX]); |
| secTer = getFirstSecTerForPrimary(index + 1); |
| // If this is an explicit sec/ter unit, then it will be read once more. |
| // Gap for secondaries of primary CEs. |
| secLimit = getSecondaryBoundary(); |
| } |
| for(;;) { |
| uint32_t sec = secTer >> 16; |
| if(sec > s) { return sec; } |
| secTer = elements[++index]; |
| if((secTer & SEC_TER_DELTA_FLAG) == 0) { return secLimit; } |
| } |
| } |
| |
| uint32_t |
| CollationRootElements::getTertiaryAfter(int32_t index, uint32_t s, uint32_t t) const { |
| uint32_t secTer; |
| uint32_t terLimit; |
| if(index == 0) { |
| // primary = 0 |
| if(s == 0) { |
| U_ASSERT(t != 0); |
| index = (int32_t)elements[IX_FIRST_TERTIARY_INDEX]; |
| // Gap at the end of the tertiary CE range. |
| terLimit = 0x4000; |
| } else { |
| index = (int32_t)elements[IX_FIRST_SECONDARY_INDEX]; |
| // Gap for tertiaries of primary/secondary CEs. |
| terLimit = getTertiaryBoundary(); |
| } |
| secTer = elements[index] & ~SEC_TER_DELTA_FLAG; |
| } else { |
| U_ASSERT(index >= (int32_t)elements[IX_FIRST_PRIMARY_INDEX]); |
| secTer = getFirstSecTerForPrimary(index + 1); |
| // If this is an explicit sec/ter unit, then it will be read once more. |
| terLimit = getTertiaryBoundary(); |
| } |
| uint32_t st = (s << 16) | t; |
| for(;;) { |
| if(secTer > st) { |
| U_ASSERT((secTer >> 16) == s); |
| return secTer & 0xffff; |
| } |
| secTer = elements[++index]; |
| // No tertiary greater than t for this primary+secondary. |
| if((secTer & SEC_TER_DELTA_FLAG) == 0 || (secTer >> 16) > s) { return terLimit; } |
| secTer &= ~SEC_TER_DELTA_FLAG; |
| } |
| } |
| |
| uint32_t |
| CollationRootElements::getFirstSecTerForPrimary(int32_t index) const { |
| uint32_t secTer = elements[index]; |
| if((secTer & SEC_TER_DELTA_FLAG) == 0) { |
| // No sec/ter delta. |
| return Collation::COMMON_SEC_AND_TER_CE; |
| } |
| secTer &= ~SEC_TER_DELTA_FLAG; |
| if(secTer > Collation::COMMON_SEC_AND_TER_CE) { |
| // Implied sec/ter. |
| return Collation::COMMON_SEC_AND_TER_CE; |
| } |
| // Explicit sec/ter below common/common. |
| return secTer; |
| } |
| |
| int32_t |
| CollationRootElements::findPrimary(uint32_t p) const { |
| // Requirement: p must occur as a root primary. |
| U_ASSERT((p & 0xff) == 0); // at most a 3-byte primary |
| int32_t index = findP(p); |
| // If p is in a range, then we just assume that p is an actual primary in this range. |
| // (Too cumbersome/expensive to check.) |
| // Otherwise, it must be an exact match. |
| U_ASSERT(isEndOfPrimaryRange(elements[index + 1]) || p == (elements[index] & 0xffffff00)); |
| return index; |
| } |
| |
| int32_t |
| CollationRootElements::findP(uint32_t p) const { |
| // p need not occur as a root primary. |
| // For example, it might be a reordering group boundary. |
| U_ASSERT((p >> 24) != Collation::UNASSIGNED_IMPLICIT_BYTE); |
| // modified binary search |
| int32_t start = (int32_t)elements[IX_FIRST_PRIMARY_INDEX]; |
| U_ASSERT(p >= elements[start]); |
| int32_t limit = length - 1; |
| U_ASSERT(elements[limit] >= PRIMARY_SENTINEL); |
| U_ASSERT(p < elements[limit]); |
| while((start + 1) < limit) { |
| // Invariant: elements[start] and elements[limit] are primaries, |
| // and elements[start]<=p<=elements[limit]. |
| int32_t i = (start + limit) / 2; |
| uint32_t q = elements[i]; |
| if((q & SEC_TER_DELTA_FLAG) != 0) { |
| // Find the next primary. |
| int32_t j = i + 1; |
| for(;;) { |
| if(j == limit) { break; } |
| q = elements[j]; |
| if((q & SEC_TER_DELTA_FLAG) == 0) { |
| i = j; |
| break; |
| } |
| ++j; |
| } |
| if((q & SEC_TER_DELTA_FLAG) != 0) { |
| // Find the preceding primary. |
| j = i - 1; |
| for(;;) { |
| if(j == start) { break; } |
| q = elements[j]; |
| if((q & SEC_TER_DELTA_FLAG) == 0) { |
| i = j; |
| break; |
| } |
| --j; |
| } |
| if((q & SEC_TER_DELTA_FLAG) != 0) { |
| // No primary between start and limit. |
| break; |
| } |
| } |
| } |
| if(p < (q & 0xffffff00)) { // Reset the "step" bits of a range end primary. |
| limit = i; |
| } else { |
| start = i; |
| } |
| } |
| return start; |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif // !UCONFIG_NO_COLLATION |
