ICU 56 update step 1

source/i18n/collationfastlatinbuilder.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2013-2014, International Business Machines
+* Copyright (C) 2013-2015, International Business Machines
 * Corporation and others.  All Rights Reserved.
 *******************************************************************************
 * collationfastlatinbuilder.cpp
 *
 * created on: 2013aug09
 * created by: Markus W. Scherer
 */
 
 #define DEBUG_COLLATION_FAST_LATIN_BUILDER 0  // 0 or 1 or 2
 #if DEBUG_COLLATION_FAST_LATIN_BUILDER
@@ skipping 115 matching lines @@
     UBool ok = !shortPrimaryOverflow &&
             encodeCharCEs(errorCode) && encodeContractions(errorCode);
     contractionCEs.removeAllElements();  // might reduce heap memory usage
     uniqueCEs.removeAllElements();
     return ok;
 }
 
 UBool
 CollationFastLatinBuilder::loadGroups(const CollationData &data, UErrorCode &errorCode) {
     if(U_FAILURE(errorCode)) { return FALSE; }
-    result.append(0);  // reserved for version & headerLength
+    headerLength = 1 + NUM_SPECIAL_GROUPS;
+    uint32_t r0 = (CollationFastLatin::VERSION << 8) | headerLength;
+    result.append((UChar)r0);
     // The first few reordering groups should be special groups
     // (space, punct, ..., digit) followed by Latn, then Grek and other scripts.
-    for(int32_t i = 0;;) {
-        if(i >= data.scriptsLength) {
-            // no Latn script
-            errorCode = U_INTERNAL_PROGRAM_ERROR;
+    for(int32_t i = 0; i < NUM_SPECIAL_GROUPS; ++i) {
+        lastSpecialPrimaries[i] = data.getLastPrimaryForGroup(UCOL_REORDER_CODE_FIRST + i);
+        if(lastSpecialPrimaries[i] == 0) {
+            // missing data
             return FALSE;
         }
-        uint32_t head = data.scripts[i];
-        uint32_t lastByte = head & 0xff;  // last primary byte in the group
-        int32_t group = data.scripts[i + 2];
-        if(group == UCOL_REORDER_CODE_DIGIT) {
-            firstDigitPrimary = (head & 0xff00) << 16;
-            headerLength = result.length();
-            uint32_t r0 = (CollationFastLatin::VERSION << 8) | headerLength;
-            result.setCharAt(0, (UChar)r0);
-        } else if(group == USCRIPT_LATIN) {
-            if(firstDigitPrimary == 0) {
-                // no digit group
-                errorCode = U_INTERNAL_PROGRAM_ERROR;
-                return FALSE;
-            }
-            firstLatinPrimary = (head & 0xff00) << 16;
-            lastLatinPrimary = (lastByte << 24) | 0xffffff;
-            break;
-        } else if(firstDigitPrimary == 0) {
-            // a group below digits
-            if(lastByte > 0x7f) {
-                // We only use 7 bits for the last byte of a below-digits group.
-                // This does not warrant an errorCode, but we do not build a fast Latin table.
-                return FALSE;
-            }
-            result.append((UChar)lastByte);
-        }
-        i = i + 2 + data.scripts[i + 1];
+        result.append(0);  // reserve a slot for this group
+    }
+
+    firstDigitPrimary = data.getFirstPrimaryForGroup(UCOL_REORDER_CODE_DIGIT);
+    firstLatinPrimary = data.getFirstPrimaryForGroup(USCRIPT_LATIN);
+    lastLatinPrimary = data.getLastPrimaryForGroup(USCRIPT_LATIN);
+    if(firstDigitPrimary == 0 || firstLatinPrimary == 0) {
+        // missing data
+        return FALSE;
     }
     return TRUE;
 }
 
 UBool
 CollationFastLatinBuilder::inSameGroup(uint32_t p, uint32_t q) const {
     // Both or neither need to be encoded as short primaries,
     // so that we can test only one and use the same bit mask.
     if(p >= firstShortPrimary) {
         return q >= firstShortPrimary;
     } else if(q >= firstShortPrimary) {
         return FALSE;
     }
     // Both or neither must be potentially-variable,
     // so that we can test only one and determine if both are variable.
-    if(p >= firstDigitPrimary) {
-        return q >= firstDigitPrimary;
-    } else if(q >= firstDigitPrimary) {
+    uint32_t lastVariablePrimary = lastSpecialPrimaries[NUM_SPECIAL_GROUPS - 1];
+    if(p > lastVariablePrimary) {
+        return q > lastVariablePrimary;
+    } else if(q > lastVariablePrimary) {
         return FALSE;
     }
     // Both will be encoded with long mini primaries.
     // They must be in the same special reordering group,
     // so that we can test only one and determine if both are variable.
-    p >>= 24;  // first primary byte
-    q >>= 24;
     U_ASSERT(p != 0 && q != 0);
-    U_ASSERT(p <= result[headerLength - 1]);  // the loop will terminate
-    for(int32_t i = 1;; ++i) {
-        uint32_t lastByte = result[i];
-        if(p <= lastByte) {
-            return q <= lastByte;
-        } else if(q <= lastByte) {
+    for(int32_t i = 0;; ++i) {  // will terminate
+        uint32_t lastPrimary = lastSpecialPrimaries[i];
+        if(p <= lastPrimary) {
+            return q <= lastPrimary;
+        } else if(q <= lastPrimary) {
             return FALSE;
         }
     }
 }
 
 void
 CollationFastLatinBuilder::resetCEs() {
     contractionCEs.removeAllElements();
     uniqueCEs.removeAllElements();
     shortPrimaryOverflow = FALSE;
@@ skipping 227 matching lines @@
 
 UBool
 CollationFastLatinBuilder::encodeUniqueCEs(UErrorCode &errorCode) {
     if(U_FAILURE(errorCode)) { return FALSE; }
     uprv_free(miniCEs);
     miniCEs = (uint16_t *)uprv_malloc(uniqueCEs.size() * 2);
     if(miniCEs == NULL) {
         errorCode = U_MEMORY_ALLOCATION_ERROR;
         return FALSE;
     }
-    int32_t group = 1;
-    uint32_t lastGroupByte = result[group];
+    int32_t group = 0;
+    uint32_t lastGroupPrimary = lastSpecialPrimaries[group];
     // The lowest unique CE must be at least a secondary CE.
     U_ASSERT(((uint32_t)uniqueCEs.elementAti(0) >> 16) != 0);
     uint32_t prevPrimary = 0;
     uint32_t prevSecondary = 0;
     uint32_t pri = 0;
     uint32_t sec = 0;
     uint32_t ter = CollationFastLatin::COMMON_TER;
     for(int32_t i = 0; i < uniqueCEs.size(); ++i) {
         int64_t ce = uniqueCEs.elementAti(i);
         // Note: At least one of the p/s/t weights changes from one unique CE to the next.
         // (uniqueCEs does not store case bits.)
         uint32_t p = (uint32_t)(ce >> 32);
         if(p != prevPrimary) {
-            uint32_t p1 = p >> 24;
-            while(p1 > lastGroupByte) {
+            while(p > lastGroupPrimary) {
                 U_ASSERT(pri <= CollationFastLatin::MAX_LONG);
-                // Add the last "long primary" in or before the group
-                // into the upper 9 bits of the group entry.
-                result.setCharAt(group, (UChar)((pri << 4) | lastGroupByte));
-                if(++group < headerLength) {  // group is 1-based
-                    lastGroupByte = result[group];
+                // Set the group's header entry to the
+                // last "long primary" in or before the group.
+                result.setCharAt(1 + group, (UChar)pri);
+                if(++group < NUM_SPECIAL_GROUPS) {
+                    lastGroupPrimary = lastSpecialPrimaries[group];
                 } else {
-                    lastGroupByte = 0xff;
+                    lastGroupPrimary = 0xffffffff;
                     break;
                 }
             }
             if(p < firstShortPrimary) {
                 if(pri == 0) {
                     pri = CollationFastLatin::MIN_LONG;
                 } else if(pri < CollationFastLatin::MAX_LONG) {
                     pri += CollationFastLatin::LONG_INC;
                 } else {
 #if DEBUG_COLLATION_FAST_LATIN_BUILDER
@@ skipping 236 matching lines @@
         // Secondary CE, or a CE with a short primary, copy the case bits.
         case1 = (case1 >> (14 - 3)) + CollationFastLatin::LOWER_CASE;
         miniCE1 |= case1;
     }
     return (miniCE << 16) | miniCE1;
 }
 
 U_NAMESPACE_END
 
 #endif  // !UCONFIG_NO_COLLATION