ICU 56 update step 1

source/i18n/collationcompare.cpp

 /*
 *******************************************************************************
-* Copyright (C) 1996-2014, International Business Machines
+* Copyright (C) 1996-2015, 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"
 
@@ skipping 19 matching lines @@
     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;
@@ skipping 34 matching lines @@
                             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);
+            if(settings.hasReordering()) {
+                leftPrimary = settings.reorder(leftPrimary);
+                rightPrimary = settings.reorder(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.
@@ skipping 17 matching lines @@
                 }
                 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.
+                uint32_t p;
                 int32_t leftLimit = leftStart;
-                uint32_t leftLower32;
-                while((leftLower32 = (uint32_t)left.getCE(leftLimit)) >
-                            Collation::MERGE_SEPARATOR_LOWER32 ||
-                        leftLower32 == 0) {
+                while((p = (uint32_t)(left.getCE(leftLimit) >> 32)) >
+                            Collation::MERGE_SEPARATOR_PRIMARY ||
+                        p == 0) {
                     ++leftLimit;
                 }
                 int32_t rightLimit = rightStart;
-                uint32_t rightLower32;
-                while((rightLower32 = (uint32_t)right.getCE(rightLimit)) >
-                            Collation::MERGE_SEPARATOR_LOWER32 ||
-                        rightLower32 == 0) {
+                while((p = (uint32_t)(right.getCE(rightLimit) >> 32)) >
+                            Collation::MERGE_SEPARATOR_PRIMARY ||
+                        p == 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; }
+                if(p == Collation::NO_CE_PRIMARY) { 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;
@@ skipping 80 matching lines @@
         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.
+                // Pass through NO_CE and keep real tertiary weights larger than that.
                 // 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(leftTertiary > Collation::NO_CE_WEIGHT16) {
                     if(leftLower32 > 0xffff) {
                         leftTertiary ^= 0xc000;
                     } else {
                         leftTertiary += 0x4000;
                     }
                 }
-                if(rightTertiary > Collation::MERGE_SEPARATOR_WEIGHT16) {
+                if(rightTertiary > Collation::NO_CE_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.
+            if(leftQuaternary <= Collation::NO_CE_WEIGHT16) {
+                // Variable primary or completely ignorable or NO_CE.
                 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.
+            if(rightQuaternary <= Collation::NO_CE_WEIGHT16) {
+                // Variable primary or completely ignorable or NO_CE.
                 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);
+            if(settings.hasReordering()) {
+                leftQuaternary = settings.reorder(leftQuaternary);
+                rightQuaternary = settings.reorder(rightQuaternary);
             }
             return (leftQuaternary < rightQuaternary) ? UCOL_LESS : UCOL_GREATER;
         }
-        if(leftQuaternary == Collation::NO_CE_WEIGHT16) { break; }
+        if(leftQuaternary == Collation::NO_CE_PRIMARY) { break; }
     }
     return UCOL_EQUAL;
 }
 
 U_NAMESPACE_END
 
 #endif  // !UCONFIG_NO_COLLATION