| /* |
| ******************************************************************************* |
| * Copyright (C) 1996-2014, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| * collationcompare.cpp |
| * |
| * created on: 2012feb14 with new and old collation code |
| * created by: Markus W. Scherer |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_COLLATION |
| |
| #include "unicode/ucol.h" |
| #include "cmemory.h" |
| #include "collation.h" |
| #include "collationcompare.h" |
| #include "collationiterator.h" |
| #include "collationsettings.h" |
| #include "uassert.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| UCollationResult |
| CollationCompare::compareUpToQuaternary(CollationIterator &left, CollationIterator &right, |
| const CollationSettings &settings, |
| UErrorCode &errorCode) { |
| if(U_FAILURE(errorCode)) { return UCOL_EQUAL; } |
| |
| int32_t options = settings.options; |
| uint32_t variableTop; |
| if((options & CollationSettings::ALTERNATE_MASK) == 0) { |
| variableTop = 0; |
| } else { |
| // +1 so that we can use "<" and primary ignorables test out early. |
| variableTop = settings.variableTop + 1; |
| } |
| UBool anyVariable = FALSE; |
| |
| // Fetch CEs, compare primaries, store secondary & tertiary weights. |
| U_ALIGN_CODE(16); |
| for(;;) { |
| // We fetch CEs until we get a non-ignorable primary or reach the end. |
| uint32_t leftPrimary; |
| do { |
| int64_t ce = left.nextCE(errorCode); |
| leftPrimary = (uint32_t)(ce >> 32); |
| if(leftPrimary < variableTop && leftPrimary > Collation::MERGE_SEPARATOR_PRIMARY) { |
| // Variable CE, shift it to quaternary level. |
| // Ignore all following primary ignorables, and shift further variable CEs. |
| anyVariable = TRUE; |
| do { |
| // Store only the primary of the variable CE. |
| left.setCurrentCE(ce & INT64_C(0xffffffff00000000)); |
| for(;;) { |
| ce = left.nextCE(errorCode); |
| leftPrimary = (uint32_t)(ce >> 32); |
| if(leftPrimary == 0) { |
| left.setCurrentCE(0); |
| } else { |
| break; |
| } |
| } |
| } while(leftPrimary < variableTop && |
| leftPrimary > Collation::MERGE_SEPARATOR_PRIMARY); |
| } |
| } while(leftPrimary == 0); |
| |
| uint32_t rightPrimary; |
| do { |
| int64_t ce = right.nextCE(errorCode); |
| rightPrimary = (uint32_t)(ce >> 32); |
| if(rightPrimary < variableTop && rightPrimary > Collation::MERGE_SEPARATOR_PRIMARY) { |
| // Variable CE, shift it to quaternary level. |
| // Ignore all following primary ignorables, and shift further variable CEs. |
| anyVariable = TRUE; |
| do { |
| // Store only the primary of the variable CE. |
| right.setCurrentCE(ce & INT64_C(0xffffffff00000000)); |
| for(;;) { |
| ce = right.nextCE(errorCode); |
| rightPrimary = (uint32_t)(ce >> 32); |
| if(rightPrimary == 0) { |
| right.setCurrentCE(0); |
| } else { |
| break; |
| } |
| } |
| } while(rightPrimary < variableTop && |
| rightPrimary > Collation::MERGE_SEPARATOR_PRIMARY); |
| } |
| } while(rightPrimary == 0); |
| |
| if(leftPrimary != rightPrimary) { |
| // Return the primary difference, with script reordering. |
| const uint8_t *reorderTable = settings.reorderTable; |
| if (reorderTable != NULL) { |
| leftPrimary = Collation::reorder(reorderTable, leftPrimary); |
| rightPrimary = Collation::reorder(reorderTable, rightPrimary); |
| } |
| return (leftPrimary < rightPrimary) ? UCOL_LESS : UCOL_GREATER; |
| } |
| if(leftPrimary == Collation::NO_CE_PRIMARY) { break; } |
| } |
| if(U_FAILURE(errorCode)) { return UCOL_EQUAL; } |
| |
| // Compare the buffered secondary & tertiary weights. |
| // We might skip the secondary level but continue with the case level |
| // which is turned on separately. |
| if(CollationSettings::getStrength(options) >= UCOL_SECONDARY) { |
| if((options & CollationSettings::BACKWARD_SECONDARY) == 0) { |
| int32_t leftIndex = 0; |
| int32_t rightIndex = 0; |
| for(;;) { |
| uint32_t leftSecondary; |
| do { |
| leftSecondary = ((uint32_t)left.getCE(leftIndex++)) >> 16; |
| } while(leftSecondary == 0); |
| |
| uint32_t rightSecondary; |
| do { |
| rightSecondary = ((uint32_t)right.getCE(rightIndex++)) >> 16; |
| } while(rightSecondary == 0); |
| |
| if(leftSecondary != rightSecondary) { |
| return (leftSecondary < rightSecondary) ? UCOL_LESS : UCOL_GREATER; |
| } |
| if(leftSecondary == Collation::NO_CE_WEIGHT16) { break; } |
| } |
| } else { |
| // The backwards secondary level compares secondary weights backwards |
| // within segments separated by the merge separator (U+FFFE, weight 02). |
| int32_t leftStart = 0; |
| int32_t rightStart = 0; |
| for(;;) { |
| // Find the merge separator or the NO_CE terminator. |
| int32_t leftLimit = leftStart; |
| uint32_t leftLower32; |
| while((leftLower32 = (uint32_t)left.getCE(leftLimit)) > |
| Collation::MERGE_SEPARATOR_LOWER32 || |
| leftLower32 == 0) { |
| ++leftLimit; |
| } |
| int32_t rightLimit = rightStart; |
| uint32_t rightLower32; |
| while((rightLower32 = (uint32_t)right.getCE(rightLimit)) > |
| Collation::MERGE_SEPARATOR_LOWER32 || |
| rightLower32 == 0) { |
| ++rightLimit; |
| } |
| |
| // Compare the segments. |
| int32_t leftIndex = leftLimit; |
| int32_t rightIndex = rightLimit; |
| for(;;) { |
| int32_t leftSecondary = 0; |
| while(leftSecondary == 0 && leftIndex > leftStart) { |
| leftSecondary = ((uint32_t)left.getCE(--leftIndex)) >> 16; |
| } |
| |
| int32_t rightSecondary = 0; |
| while(rightSecondary == 0 && rightIndex > rightStart) { |
| rightSecondary = ((uint32_t)right.getCE(--rightIndex)) >> 16; |
| } |
| |
| if(leftSecondary != rightSecondary) { |
| return (leftSecondary < rightSecondary) ? UCOL_LESS : UCOL_GREATER; |
| } |
| if(leftSecondary == 0) { break; } |
| } |
| |
| // Did we reach the end of either string? |
| // Both strings have the same number of merge separators, |
| // or else there would have been a primary-level difference. |
| U_ASSERT(left.getCE(leftLimit) == right.getCE(rightLimit)); |
| if(left.getCE(leftLimit) == Collation::NO_CE) { break; } |
| // Skip both merge separators and continue. |
| leftStart = leftLimit + 1; |
| rightStart = rightLimit + 1; |
| } |
| } |
| } |
| |
| if((options & CollationSettings::CASE_LEVEL) != 0) { |
| int32_t strength = CollationSettings::getStrength(options); |
| int32_t leftIndex = 0; |
| int32_t rightIndex = 0; |
| for(;;) { |
| uint32_t leftCase, leftLower32, rightCase; |
| if(strength == UCOL_PRIMARY) { |
| // Primary+caseLevel: Ignore case level weights of primary ignorables. |
| // Otherwise we would get a-umlaut > a |
| // which is not desirable for accent-insensitive sorting. |
| // Check for (lower 32 bits) == 0 as well because variable CEs are stored |
| // with only primary weights. |
| int64_t ce; |
| do { |
| ce = left.getCE(leftIndex++); |
| leftCase = (uint32_t)ce; |
| } while((uint32_t)(ce >> 32) == 0 || leftCase == 0); |
| leftLower32 = leftCase; |
| leftCase &= 0xc000; |
| |
| do { |
| ce = right.getCE(rightIndex++); |
| rightCase = (uint32_t)ce; |
| } while((uint32_t)(ce >> 32) == 0 || rightCase == 0); |
| rightCase &= 0xc000; |
| } else { |
| // Secondary+caseLevel: By analogy with the above, |
| // ignore case level weights of secondary ignorables. |
| // |
| // Note: A tertiary CE has uppercase case bits (0.0.ut) |
| // to keep tertiary+caseFirst well-formed. |
| // |
| // Tertiary+caseLevel: Also ignore case level weights of secondary ignorables. |
| // Otherwise a tertiary CE's uppercase would be no greater than |
| // a primary/secondary CE's uppercase. |
| // (See UCA well-formedness condition 2.) |
| // We could construct a special case weight higher than uppercase, |
| // but it's simpler to always ignore case weights of secondary ignorables, |
| // turning 0.0.ut into 0.0.0.t. |
| // (See LDML Collation, Case Parameters.) |
| do { |
| leftCase = (uint32_t)left.getCE(leftIndex++); |
| } while(leftCase <= 0xffff); |
| leftLower32 = leftCase; |
| leftCase &= 0xc000; |
| |
| do { |
| rightCase = (uint32_t)right.getCE(rightIndex++); |
| } while(rightCase <= 0xffff); |
| rightCase &= 0xc000; |
| } |
| |
| // No need to handle NO_CE and MERGE_SEPARATOR specially: |
| // There is one case weight for each previous-level weight, |
| // so level length differences were handled there. |
| if(leftCase != rightCase) { |
| if((options & CollationSettings::UPPER_FIRST) == 0) { |
| return (leftCase < rightCase) ? UCOL_LESS : UCOL_GREATER; |
| } else { |
| return (leftCase < rightCase) ? UCOL_GREATER : UCOL_LESS; |
| } |
| } |
| if((leftLower32 >> 16) == Collation::NO_CE_WEIGHT16) { break; } |
| } |
| } |
| if(CollationSettings::getStrength(options) <= UCOL_SECONDARY) { return UCOL_EQUAL; } |
| |
| uint32_t tertiaryMask = CollationSettings::getTertiaryMask(options); |
| |
| int32_t leftIndex = 0; |
| int32_t rightIndex = 0; |
| uint32_t anyQuaternaries = 0; |
| for(;;) { |
| uint32_t leftLower32, leftTertiary; |
| do { |
| leftLower32 = (uint32_t)left.getCE(leftIndex++); |
| anyQuaternaries |= leftLower32; |
| U_ASSERT((leftLower32 & Collation::ONLY_TERTIARY_MASK) != 0 || |
| (leftLower32 & 0xc0c0) == 0); |
| leftTertiary = leftLower32 & tertiaryMask; |
| } while(leftTertiary == 0); |
| |
| uint32_t rightLower32, rightTertiary; |
| do { |
| rightLower32 = (uint32_t)right.getCE(rightIndex++); |
| anyQuaternaries |= rightLower32; |
| U_ASSERT((rightLower32 & Collation::ONLY_TERTIARY_MASK) != 0 || |
| (rightLower32 & 0xc0c0) == 0); |
| rightTertiary = rightLower32 & tertiaryMask; |
| } while(rightTertiary == 0); |
| |
| if(leftTertiary != rightTertiary) { |
| if(CollationSettings::sortsTertiaryUpperCaseFirst(options)) { |
| // Pass through NO_CE and MERGE_SEPARATOR |
| // and keep real tertiary weights larger than the MERGE_SEPARATOR. |
| // Do not change the artificial uppercase weight of a tertiary CE (0.0.ut), |
| // to keep tertiary CEs well-formed. |
| // Their case+tertiary weights must be greater than those of |
| // primary and secondary CEs. |
| if(leftTertiary > Collation::MERGE_SEPARATOR_WEIGHT16) { |
| if(leftLower32 > 0xffff) { |
| leftTertiary ^= 0xc000; |
| } else { |
| leftTertiary += 0x4000; |
| } |
| } |
| if(rightTertiary > Collation::MERGE_SEPARATOR_WEIGHT16) { |
| if(rightLower32 > 0xffff) { |
| rightTertiary ^= 0xc000; |
| } else { |
| rightTertiary += 0x4000; |
| } |
| } |
| } |
| return (leftTertiary < rightTertiary) ? UCOL_LESS : UCOL_GREATER; |
| } |
| if(leftTertiary == Collation::NO_CE_WEIGHT16) { break; } |
| } |
| if(CollationSettings::getStrength(options) <= UCOL_TERTIARY) { return UCOL_EQUAL; } |
| |
| if(!anyVariable && (anyQuaternaries & 0xc0) == 0) { |
| // If there are no "variable" CEs and no non-zero quaternary weights, |
| // then there are no quaternary differences. |
| return UCOL_EQUAL; |
| } |
| |
| leftIndex = 0; |
| rightIndex = 0; |
| for(;;) { |
| uint32_t leftQuaternary; |
| do { |
| int64_t ce = left.getCE(leftIndex++); |
| leftQuaternary = (uint32_t)ce & 0xffff; |
| if(leftQuaternary == 0) { |
| // Variable primary or completely ignorable. |
| leftQuaternary = (uint32_t)(ce >> 32); |
| } else if(leftQuaternary <= Collation::MERGE_SEPARATOR_WEIGHT16) { |
| // Leave NO_CE or MERGE_SEPARATOR as is. |
| } else { |
| // Regular CE, not tertiary ignorable. |
| // Preserve the quaternary weight in bits 7..6. |
| leftQuaternary |= 0xffffff3f; |
| } |
| } while(leftQuaternary == 0); |
| |
| uint32_t rightQuaternary; |
| do { |
| int64_t ce = right.getCE(rightIndex++); |
| rightQuaternary = (uint32_t)ce & 0xffff; |
| if(rightQuaternary == 0) { |
| // Variable primary or completely ignorable. |
| rightQuaternary = (uint32_t)(ce >> 32); |
| } else if(rightQuaternary <= Collation::MERGE_SEPARATOR_WEIGHT16) { |
| // Leave NO_CE or MERGE_SEPARATOR as is. |
| } else { |
| // Regular CE, not tertiary ignorable. |
| // Preserve the quaternary weight in bits 7..6. |
| rightQuaternary |= 0xffffff3f; |
| } |
| } while(rightQuaternary == 0); |
| |
| if(leftQuaternary != rightQuaternary) { |
| // Return the difference, with script reordering. |
| const uint8_t *reorderTable = settings.reorderTable; |
| if (reorderTable != NULL) { |
| leftQuaternary = Collation::reorder(reorderTable, leftQuaternary); |
| rightQuaternary = Collation::reorder(reorderTable, rightQuaternary); |
| } |
| return (leftQuaternary < rightQuaternary) ? UCOL_LESS : UCOL_GREATER; |
| } |
| if(leftQuaternary == Collation::NO_CE_WEIGHT16) { break; } |
| } |
| return UCOL_EQUAL; |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif // !UCONFIG_NO_COLLATION |
