ICU 56 update step 1

source/i18n/collationfastlatin.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2013-2014, International Business Machines
+* Copyright (C) 2013-2015, International Business Machines
 * Corporation and others.  All Rights Reserved.
 *******************************************************************************
 * collationfastlatin.cpp
 *
 * created on: 2013aug18
 * created by: Markus W. Scherer
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_COLLATION
 
 #include "unicode/ucol.h"
 #include "collationdata.h"
 #include "collationfastlatin.h"
 #include "collationsettings.h"
-#include "putilimp.h"  // U_ALIGN_CODE
 #include "uassert.h"
 
 U_NAMESPACE_BEGIN
 
 int32_t
 CollationFastLatin::getOptions(const CollationData *data, const CollationSettings &settings,
                                uint16_t *primaries, int32_t capacity) {
     const uint16_t *table = data->fastLatinTable;
     if(table == NULL) { return -1; }
     U_ASSERT(capacity == LATIN_LIMIT);
     if(capacity != LATIN_LIMIT) { return -1; }
 
     uint32_t miniVarTop;
     if((settings.options & CollationSettings::ALTERNATE_MASK) == 0) {
         // No mini primaries are variable, set a variableTop just below the
         // lowest long mini primary.
         miniVarTop = MIN_LONG - 1;
     } else {
-        uint32_t v1 = settings.variableTop >> 24;
         int32_t headerLength = *table & 0xff;
-        int32_t i = headerLength - 1;
-        if(i <= 0 || v1 > (table[i] & 0x7fu)) {
+        int32_t i = 1 + settings.getMaxVariable();
+        if(i >= headerLength) {
             return -1;  // variableTop >= digits, should not occur
         }
-        while(i > 1 && v1 <= (table[i - 1] & 0x7fu)) { --i; }
-        // In the table header, the miniVarTop is in bits 15..7, with 4 zero bits 19..16 implied.
-        // Shift right to make it comparable with long mini primaries in bits 15..3.
-        miniVarTop = (table[i] & 0xff80) >> 4;
+        miniVarTop = table[i];
     }
 
-    const uint8_t *reorderTable = settings.reorderTable;
-    if(reorderTable != NULL) {
-        const uint16_t *scripts = data->scripts;
-        int32_t length = data->scriptsLength;
-        uint32_t prevLastByte = 0;
-        for(int32_t i = 0; i < length;) {
-            // reordered last byte of the group
-            uint32_t lastByte = reorderTable[scripts[i] & 0xff];
-            if(lastByte < prevLastByte) {
-                // The permutation affects the groups up to Latin.
-                return -1;
+    UBool digitsAreReordered = FALSE;
+    if(settings.hasReordering()) {
+        uint32_t prevStart = 0;
+        uint32_t beforeDigitStart = 0;
+        uint32_t digitStart = 0;
+        uint32_t afterDigitStart = 0;
+        for(int32_t group = UCOL_REORDER_CODE_FIRST;
+                group < UCOL_REORDER_CODE_FIRST + CollationData::MAX_NUM_SPECIAL_REORDER_CODES;
+                ++group) {
+            uint32_t start = data->getFirstPrimaryForGroup(group);
+            start = settings.reorder(start);
+            if(group == UCOL_REORDER_CODE_DIGIT) {
+                beforeDigitStart = prevStart;
+                digitStart = start;
+            } else if(start != 0) {
+                if(start < prevStart) {
+                    // The permutation affects the groups up to Latin.
+                    return -1;
+                }
+                // In the future, there might be a special group between digits & Latin.
+                if(digitStart != 0 && afterDigitStart == 0 && prevStart == beforeDigitStart) {
+                    afterDigitStart = start;
+                }
+                prevStart = start;
             }
-            if(scripts[i + 2] == USCRIPT_LATIN) { break; }
-            i = i + 2 + scripts[i + 1];
-            prevLastByte = lastByte;
+        }
+        uint32_t latinStart = data->getFirstPrimaryForGroup(USCRIPT_LATIN);
+        latinStart = settings.reorder(latinStart);
+        if(latinStart < prevStart) {
+            return -1;
+        }
+        if(afterDigitStart == 0) {
+            afterDigitStart = latinStart;
+        }
+        if(!(beforeDigitStart < digitStart && digitStart < afterDigitStart)) {
+            digitsAreReordered = TRUE;
         }
     }
 
     table += (table[0] & 0xff);  // skip the header
     for(UChar32 c = 0; c < LATIN_LIMIT; ++c) {
         uint32_t p = table[c];
         if(p >= MIN_SHORT) {
             p &= SHORT_PRIMARY_MASK;
         } else if(p > miniVarTop) {
             p &= LONG_PRIMARY_MASK;
         } else {
             p = 0;
         }
         primaries[c] = (uint16_t)p;
     }
-    if((settings.options & CollationSettings::NUMERIC) != 0) {
+    if(digitsAreReordered || (settings.options & CollationSettings::NUMERIC) != 0) {
         // Bail out for digits.
         for(UChar32 c = 0x30; c <= 0x39; ++c) { primaries[c] = 0; }
     }
 
     // Shift the miniVarTop above other options.
     return ((int32_t)miniVarTop << 16) | settings.options;
 }
 
 int32_t
 CollationFastLatin::compareUTF16(const uint16_t *table, const uint16_t *primaries, int32_t options,
                                  const UChar *left, int32_t leftLength,
                                  const UChar *right, int32_t rightLength) {
     // This is a modified copy of CollationCompare::compareUpToQuaternary(),
     // optimized for common Latin text.
     // Keep them in sync!
     // Keep compareUTF16() and compareUTF8() in sync very closely!
 
     U_ASSERT((table[0] >> 8) == VERSION);
     table += (table[0] & 0xff);  // skip the header
     uint32_t variableTop = (uint32_t)options >> 16;  // see getOptions()
     options &= 0xffff;  // needed for CollationSettings::getStrength() to work
 
     // Check for supported characters, fetch mini CEs, and compare primaries.
-    U_ALIGN_CODE(16);
     int32_t leftIndex = 0, rightIndex = 0;
     /**
      * Single mini CE or a pair.
      * The current mini CE is in the lower 16 bits, the next one is in the upper 16 bits.
      * If there is only one, then it is in the lower bits, and the upper bits are 0.
      */
     uint32_t leftPair = 0, rightPair = 0;
     for(;;) {
         // We fetch CEs until we get a non-ignorable primary or reach the end.
         while(leftPair == 0) {
@@ skipping 316 matching lines @@
                                  const uint8_t *left, int32_t leftLength,
                                  const uint8_t *right, int32_t rightLength) {
     // Keep compareUTF16() and compareUTF8() in sync very closely!
 
     U_ASSERT((table[0] >> 8) == VERSION);
     table += (table[0] & 0xff);  // skip the header
     uint32_t variableTop = (uint32_t)options >> 16;  // see RuleBasedCollator::getFastLatinOptions()
     options &= 0xffff;  // needed for CollationSettings::getStrength() to work
 
     // Check for supported characters, fetch mini CEs, and compare primaries.
-    U_ALIGN_CODE(16);
     int32_t leftIndex = 0, rightIndex = 0;
     /**
      * Single mini CE or a pair.
      * The current mini CE is in the lower 16 bits, the next one is in the upper 16 bits.
      * If there is only one, then it is in the lower bits, and the upper bits are 0.
      */
     uint32_t leftPair = 0, rightPair = 0;
     // Note: There is no need to assemble the code point.
     // We only need to look up the table entry for the character,
     // and nextPair() looks for whether c==0.
@@ skipping 621 matching lines @@
             U_ASSERT(ce >= MIN_LONG);
             pair &= TWO_LONG_PRIMARIES_MASK;  // variable
         }
     }
     return pair;
 }
 
 U_NAMESPACE_END
 
 #endif  // !UCONFIG_NO_COLLATION