ICU 56 update step 1

source/i18n/collationrootelements.cpp

 /*
 *******************************************************************************
 * Copyright (C) 2013-2014, International Business Machines
 * Corporation and others.  All Rights Reserved.
 *******************************************************************************
 * collationrootelements.cpp
 *
 * created on: 2013mar05
 * created by: Markus W. Scherer
 */
@@ skipping 106 matching lines @@
 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::MERGE_SEPARATOR_WEIGHT16;
-        sec = Collation::COMMON_WEIGHT16;
+        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::MERGE_SEPARATOR_WEIGHT16;
+            previousTer = Collation::BEFORE_WEIGHT16;
         }
         secTer = elements[index] & ~SEC_TER_DELTA_FLAG;
     } else {
         index = findPrimary(p) + 1;
-        previousTer = Collation::MERGE_SEPARATOR_WEIGHT16;
-        secTer = Collation::COMMON_SEC_AND_TER_CE;
+        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;
 }
@@ skipping 15 matching lines @@
         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]);
-        ++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 secTer = elements[index];
-        if((secTer & SEC_TER_DELTA_FLAG) == 0) { return secLimit; }
         uint32_t sec = secTer >> 16;
         if(sec > s) { return sec; }
-        ++index;
+        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]);
-        ++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(;;) {
-        uint32_t secTer = elements[index];
+        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;
-        if(secTer > st) { return secTer & 0xffff; }
-        ++index;
     }
 }
 
+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;
@@ skipping 50 matching lines @@
         } else {
             start = i;
         }
     }
     return start;
 }
 
 U_NAMESPACE_END
 
 #endif  // !UCONFIG_NO_COLLATION