Update ICU to 54.1 step 1

source/i18n/usearch.cpp

 /*
 **********************************************************************
-*   Copyright (C) 2001-2011 IBM and others. All rights reserved.
+*   Copyright (C) 2001-2014 IBM and others. All rights reserved.
 **********************************************************************
 *   Date        Name        Description
 *  07/02/2001   synwee      Creation.
 **********************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_COLLATION && !UCONFIG_NO_BREAK_ITERATION
 
 #include "unicode/usearch.h"
 #include "unicode/ustring.h"
 #include "unicode/uchar.h"
 #include "unicode/utf16.h"
 #include "normalizer2impl.h"
-#include "ucol_imp.h"
 #include "usrchimp.h"
 #include "cmemory.h"
 #include "ucln_in.h"
 #include "uassert.h"
 #include "ustr_imp.h"
 
 U_NAMESPACE_USE
 
 // don't use Boyer-Moore
 // (and if we decide to turn this on again there are several new TODOs that will need to be addressed)
 #define BOYER_MOORE 0
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 // internal definition ---------------------------------------------------
 
 #define LAST_BYTE_MASK_          0xFF
 #define SECOND_LAST_BYTE_SHIFT_  8
 #define SUPPLEMENTARY_MIN_VALUE_ 0x10000
 
 static const Normalizer2Impl *g_nfcImpl = NULL;
 
 // internal methods -------------------------------------------------
 
 /**
 * Fast collation element iterator setOffset.
 * This function does not check for bounds.
 * @param coleiter collation element iterator
 * @param offset to set
 */
 static
 inline void setColEIterOffset(UCollationElements *elems,
                       int32_t             offset)
 {
-    collIterate *ci = &(elems->iteratordata_);
-    ci->pos         = ci->string + offset;
-    ci->CEpos       = ci->toReturn = ci->extendCEs ? ci->extendCEs : ci->CEs;
-    if (ci->flags & UCOL_ITER_INNORMBUF) {
-        ci->flags = ci->origFlags;
-    }
-    ci->fcdPosition = NULL;
-
-    ci->offsetReturn = NULL;
-    ci->offsetStore  = ci->offsetBuffer;
-    ci->offsetRepeatCount = ci->offsetRepeatValue = 0;
+    // Note: Not "fast" any more after the 2013 collation rewrite.
+    // We do not want to expose more internals than necessary.
+    UErrorCode status = U_ZERO_ERROR;
+    ucol_setOffset(elems, offset, &status);
 }
 
 /**
 * Getting the mask for collation strength
 * @param strength collation strength
 * @return collation element mask
 */
 static
 inline uint32_t getMask(UCollationStrength strength)
 {
@@ skipping 216 matching lines @@
 * @param status output error if any, caller to check status before calling
 *               method, status assumed to be success when passed in.
 * @return total number of expansions
 */
 static
 inline uint16_t initializePatternCETable(UStringSearch *strsrch,
                                          UErrorCode    *status)
 {
     UPattern *pattern            = &(strsrch->pattern);
     uint32_t  cetablesize        = INITIAL_ARRAY_SIZE_;
-    int32_t  *cetable            = pattern->CEBuffer;
+    int32_t  *cetable            = pattern->cesBuffer;
     uint32_t  patternlength      = pattern->textLength;
     UCollationElements *coleiter = strsrch->utilIter;
 
     if (coleiter == NULL) {
         coleiter = ucol_openElements(strsrch->collator, pattern->text,
                                      patternlength, status);
         // status will be checked in ucol_next(..) later and if it is an
         // error UCOL_NULLORDER the result of ucol_next(..) and 0 will be
         // returned.
         strsrch->utilIter = coleiter;
     }
     else {
-        uprv_init_collIterate(strsrch->collator, pattern->text,
-                         pattern->textLength,
-                         &coleiter->iteratordata_,
-                         status);
+        ucol_setText(coleiter, pattern->text, pattern->textLength, status);
     }
     if(U_FAILURE(*status)) {
         return 0;
     }
 
-    if (pattern->CE != cetable && pattern->CE) {
-        uprv_free(pattern->CE);
+    if (pattern->ces != cetable && pattern->ces) {
+        uprv_free(pattern->ces);
     }
 
     uint16_t  offset      = 0;
     uint16_t  result      = 0;
     int32_t   ce;
 
     while ((ce = ucol_next(coleiter, status)) != UCOL_NULLORDER &&
            U_SUCCESS(*status)) {
         uint32_t newce = getCE(strsrch, ce);
         if (newce) {
             int32_t *temp = addTouint32_tArray(cetable, offset, &cetablesize,
                                   newce,
                                   patternlength - ucol_getOffset(coleiter) + 1,
                                   status);
             if (U_FAILURE(*status)) {
                 return 0;
             }
             offset ++;
-            if (cetable != temp && cetable != pattern->CEBuffer) {
+            if (cetable != temp && cetable != pattern->cesBuffer) {
                 uprv_free(cetable);
             }
             cetable = temp;
         }
         result += (uint16_t)(ucol_getMaxExpansion(coleiter, ce) - 1);
     }
 
     cetable[offset]   = 0;
-    pattern->CE       = cetable;
-    pattern->CELength = offset;
+    pattern->ces       = cetable;
+    pattern->cesLength = offset;
 
     return result;
 }
 
 /**
 * Initializing the pce table for a pattern.
 * Stores non-ignorable collation keys.
 * Table size will be estimated by the size of the pattern text. Table
 * expansion will be perform as we go along. Adding 1 to ensure that the table
 * size definitely increases.
 * Internal method, status assumed to be a success.
 * @param strsrch string search data
 * @param status output error if any, caller to check status before calling
 *               method, status assumed to be success when passed in.
 * @return total number of expansions
 */
 static
 inline uint16_t initializePatternPCETable(UStringSearch *strsrch,
                                           UErrorCode    *status)
 {
     UPattern *pattern            = &(strsrch->pattern);
     uint32_t  pcetablesize       = INITIAL_ARRAY_SIZE_;
-    int64_t  *pcetable           = pattern->PCEBuffer;
+    int64_t  *pcetable           = pattern->pcesBuffer;
     uint32_t  patternlength      = pattern->textLength;
     UCollationElements *coleiter = strsrch->utilIter;
 
     if (coleiter == NULL) {
         coleiter = ucol_openElements(strsrch->collator, pattern->text,
                                      patternlength, status);
         // status will be checked in ucol_next(..) later and if it is an
         // error UCOL_NULLORDER the result of ucol_next(..) and 0 will be
         // returned.
         strsrch->utilIter = coleiter;
     } else {
-        uprv_init_collIterate(strsrch->collator, pattern->text,
-                              pattern->textLength,
-                              &coleiter->iteratordata_,
-                              status);
+        ucol_setText(coleiter, pattern->text, pattern->textLength, status);
     }
     if(U_FAILURE(*status)) {
         return 0;
     }
 
-    if (pattern->PCE != pcetable && pattern->PCE != NULL) {
-        uprv_free(pattern->PCE);
+    if (pattern->pces != pcetable && pattern->pces != NULL) {
+        uprv_free(pattern->pces);
     }
 
     uint16_t  offset = 0;
     uint16_t  result = 0;
     int64_t   pce;
 
-    uprv_init_pce(coleiter);
+    icu::UCollationPCE iter(coleiter);
 
     // ** Should processed CEs be signed or unsigned?
     // ** (the rest of the code in this file seems to play fast-and-loose with
     // **  whether a CE is signed or unsigned. For example, look at routine above this one.)
-    while ((pce = ucol_nextProcessed(coleiter, NULL, NULL, status)) != UCOL_PROCESSED_NULLORDER &&
+    while ((pce = iter.nextProcessed(NULL, NULL, status)) != UCOL_PROCESSED_NULLORDER &&
            U_SUCCESS(*status)) {
         int64_t *temp = addTouint64_tArray(pcetable, offset, &pcetablesize,
                               pce,
                               patternlength - ucol_getOffset(coleiter) + 1,
                               status);
 
         if (U_FAILURE(*status)) {
             return 0;
         }
 
         offset += 1;
 
-        if (pcetable != temp && pcetable != pattern->PCEBuffer) {
+        if (pcetable != temp && pcetable != pattern->pcesBuffer) {
             uprv_free(pcetable);
         }
 
         pcetable = temp;
         //result += (uint16_t)(ucol_getMaxExpansion(coleiter, ce) - 1);
     }
 
     pcetable[offset]   = 0;
-    pattern->PCE       = pcetable;
-    pattern->PCELength = offset;
+    pattern->pces       = pcetable;
+    pattern->pcesLength = offset;
 
     return result;
 }
 
 /**
 * Initializes the pattern struct.
 * Internal method, status assumed to be success.
 * @param strsrch UStringSearch data storage
 * @param status output error if any, caller to check status before calling
 *               method, status assumed to be success when passed in.
 * @return expansionsize the total expansion size of the pattern
 */
 static
 inline int16_t initializePattern(UStringSearch *strsrch, UErrorCode *status)
 {
+    if (U_FAILURE(*status)) { return 0; }
           UPattern   *pattern     = &(strsrch->pattern);
     const UChar      *patterntext = pattern->text;
           int32_t     length      = pattern->textLength;
           int32_t index       = 0;
 
     // Since the strength is primary, accents are ignored in the pattern.
     if (strsrch->strength == UCOL_PRIMARY) {
         pattern->hasPrefixAccents = 0;
         pattern->hasSuffixAccents = 0;
     } else {
         pattern->hasPrefixAccents = getFCD(patterntext, &index, length) >>
                                                          SECOND_LAST_BYTE_SHIFT_;
         index = length;
         U16_BACK_1(patterntext, 0, index);
         pattern->hasSuffixAccents = getFCD(patterntext, &index, length) &
                                                                  LAST_BYTE_MASK_;
     }
 
     // ** HACK **
-    if (strsrch->pattern.PCE != NULL) {
-        if (strsrch->pattern.PCE != strsrch->pattern.PCEBuffer) {
-            uprv_free(strsrch->pattern.PCE);
+    if (strsrch->pattern.pces != NULL) {
+        if (strsrch->pattern.pces != strsrch->pattern.pcesBuffer) {
+            uprv_free(strsrch->pattern.pces);
         }
 
-        strsrch->pattern.PCE = NULL;
+        strsrch->pattern.pces = NULL;
     }
 
     // since intializePattern is an internal method status is a success.
     return initializePatternCETable(strsrch, status);
 }
 
 /**
 * Initializing shift tables, with the default values.
 * If a corresponding default value is 0, the shift table is not set.
 * @param shift table for forwards shift
@@ skipping 66 matching lines @@
 * If pattern has no non-ignorable ce, we return a illegal argument error.
 * Internal method, status assumed to be success.
 * @param strsrch UStringSearch data storage
 * @param status  for output errors if it occurs, status is assumed to be a
 *                success when it is passed in.
 */
 static
 inline void initialize(UStringSearch *strsrch, UErrorCode *status)
 {
     int16_t expandlength  = initializePattern(strsrch, status);
-    if (U_SUCCESS(*status) && strsrch->pattern.CELength > 0) {
+    if (U_SUCCESS(*status) && strsrch->pattern.cesLength > 0) {
         UPattern *pattern = &strsrch->pattern;
-        int32_t   cesize  = pattern->CELength;
+        int32_t   cesize  = pattern->cesLength;
 
         int16_t minlength = cesize > expandlength
                             ? (int16_t)cesize - expandlength : 1;
         pattern->defaultShiftSize    = minlength;
-        setShiftTable(pattern->shift, pattern->backShift, pattern->CE,
+        setShiftTable(pattern->shift, pattern->backShift, pattern->ces,
                       cesize, expandlength, minlength, minlength);
         return;
     }
     strsrch->pattern.defaultShiftSize = 0;
 }
 
 #if BOYER_MOORE
 /**
 * Check to make sure that the match length is at the end of the character by
 * using the breakiterator.
@@ skipping 55 matching lines @@
                 ubrk_following(breakiterator, start - 1) == start) &&
                (end == endindex ||
                 ubrk_following(breakiterator, end - 1) == end);
         if (result) {
             // iterates the individual ces
                   UCollationElements *coleiter  = strsrch->utilIter;
             const UChar              *text      = strsrch->search->text +
                                                                       start;
                   UErrorCode          status    = U_ZERO_ERROR;
             ucol_setText(coleiter, text, end - start, &status);
-            for (int32_t count = 0; count < strsrch->pattern.CELength;
+            for (int32_t count = 0; count < strsrch->pattern.cesLength;
                  count ++) {
                 int32_t ce = getCE(strsrch, ucol_next(coleiter, &status));
                 if (ce == UCOL_IGNORABLE) {
                     count --;
                     continue;
                 }
-                if (U_FAILURE(status) || ce != strsrch->pattern.CE[count]) {
+                if (U_FAILURE(status) || ce != strsrch->pattern.ces[count]) {
                     return FALSE;
                 }
             }
             int32_t nextce = ucol_next(coleiter, &status);
             while (ucol_getOffset(coleiter) == (end - start)
                    && getCE(strsrch, nextce) == UCOL_IGNORABLE) {
                 nextce = ucol_next(coleiter, &status);
             }
             if (ucol_getOffset(coleiter) == (end - start)
                 && nextce != UCOL_NULLORDER) {
@@ skipping 80 matching lines @@
 inline int32_t shiftForward(UStringSearch *strsrch,
                                 int32_t    textoffset,
                                 int32_t       ce,
                                 int32_t        patternceindex)
 {
     UPattern *pattern = &(strsrch->pattern);
     if (ce != UCOL_NULLORDER) {
         int32_t shift = pattern->shift[hash(ce)];
         // this is to adjust for characters in the middle of the
         // substring for matching that failed.
-        int32_t adjust = pattern->CELength - patternceindex;
+        int32_t adjust = pattern->cesLength - patternceindex;
         if (adjust > 1 && shift >= adjust) {
             shift -= adjust - 1;
         }
         textoffset += shift;
     }
     else {
         textoffset += pattern->defaultShiftSize;
     }
 
     textoffset = getNextUStringSearchBaseOffset(strsrch, textoffset);
@@ skipping 113 matching lines @@
                     uprv_free(norm);
                     return FALSE;
                 }
             }
             else {
                 norm = buffer;
             }
 
             UCollationElements *coleiter  = strsrch->utilIter;
             ucol_setText(coleiter, norm, size, status);
-            uint32_t            firstce   = strsrch->pattern.CE[0];
+            uint32_t            firstce   = strsrch->pattern.ces[0];
             UBool               ignorable = TRUE;
             uint32_t            ce        = UCOL_IGNORABLE;
             while (U_SUCCESS(*status) && ce != firstce && ce != (uint32_t)UCOL_NULLORDER) {
                 offset = ucol_getOffset(coleiter);
                 if (ce != firstce && ce != UCOL_IGNORABLE) {
                     ignorable = FALSE;
                 }
                 ce = ucol_next(coleiter, status);
             }
             UChar32 codepoint;
@@ skipping 32 matching lines @@
 */
 static
 UBool hasAccentsBeforeMatch(const UStringSearch *strsrch, int32_t start,
                                   int32_t    end)
 {
     if (strsrch->pattern.hasPrefixAccents) {
         UCollationElements *coleiter  = strsrch->textIter;
         UErrorCode          status    = U_ZERO_ERROR;
         // we have been iterating forwards previously
         uint32_t            ignorable = TRUE;
-        int32_t             firstce   = strsrch->pattern.CE[0];
+        int32_t             firstce   = strsrch->pattern.ces[0];
 
         setColEIterOffset(coleiter, start);
         int32_t ce  = getCE(strsrch, ucol_next(coleiter, &status));
         if (U_FAILURE(status)) {
             return TRUE;
         }
         while (ce != firstce) {
             if (ce != UCOL_IGNORABLE) {
                 ignorable = FALSE;
             }
@@ skipping 61 matching lines @@
 static
 UBool hasAccentsAfterMatch(const UStringSearch *strsrch, int32_t start,
                                  int32_t    end)
 {
     if (strsrch->pattern.hasSuffixAccents) {
         const UChar       *text       = strsrch->search->text;
               int32_t  temp       = end;
               int32_t      textlength = strsrch->search->textLength;
         U16_BACK_1(text, 0, temp);
         if (getFCD(text, &temp, textlength) & LAST_BYTE_MASK_) {
-            int32_t             firstce  = strsrch->pattern.CE[0];
+            int32_t             firstce  = strsrch->pattern.ces[0];
             UCollationElements *coleiter = strsrch->textIter;
             UErrorCode          status   = U_ZERO_ERROR;
             int32_t ce;
             setColEIterOffset(coleiter, start);
             while ((ce = getCE(strsrch, ucol_next(coleiter, &status))) != firstce) {
                 if (U_FAILURE(status) || ce == UCOL_NULLORDER) {
                     return TRUE;
                 }
             }
             int32_t count = 1;
-            while (count < strsrch->pattern.CELength) {
+            while (count < strsrch->pattern.cesLength) {
                 if (getCE(strsrch, ucol_next(coleiter, &status))
                     == UCOL_IGNORABLE) {
                     // Thai can give an ignorable here.
                     count --;
                 }
                 if (U_FAILURE(status)) {
                     return TRUE;
                 }
                 count ++;
             }
@@ skipping 163 matching lines @@
             if (U_FAILURE(*status)) {
                 return FALSE;
             }
             if (ucol_getOffset(coleiter) != temp) {
                 *start = temp;
                 temp  = ucol_getOffset(coleiter);
             }
             expansion --;
         }
 
-        int32_t  *patternce       = strsrch->pattern.CE;
-        int32_t   patterncelength = strsrch->pattern.CELength;
+        int32_t  *patternce       = strsrch->pattern.ces;
+        int32_t   patterncelength = strsrch->pattern.cesLength;
         int32_t   count           = 0;
         while (count < patterncelength) {
             int32_t ce = getCE(strsrch, ucol_next(coleiter, status));
             if (ce == UCOL_IGNORABLE) {
                 continue;
             }
             if (expandflag && count == 0 && ucol_getOffset(coleiter) != temp) {
                 *start = temp;
                 temp   = ucol_getOffset(coleiter);
             }
@@ skipping 181 matching lines @@
 * Running through a collation element iterator to see if the contents matches
 * pattern in string search data
 * @param strsrch string search data
 * @param coleiter collation element iterator
 * @return TRUE if a match if found, FALSE otherwise
 */
 static
 inline UBool checkCollationMatch(const UStringSearch      *strsrch,
                                        UCollationElements *coleiter)
 {
-    int         patternceindex = strsrch->pattern.CELength;
-    int32_t    *patternce      = strsrch->pattern.CE;
+    int         patternceindex = strsrch->pattern.cesLength;
+    int32_t    *patternce      = strsrch->pattern.ces;
     UErrorCode  status = U_ZERO_ERROR;
     while (patternceindex > 0) {
         int32_t ce = getCE(strsrch, ucol_next(coleiter, &status));
         if (ce == UCOL_IGNORABLE) {
             continue;
         }
         if (U_FAILURE(status) || ce != *patternce) {
             return FALSE;
         }
         patternce ++;
@@ skipping 178 matching lines @@
     }
     else {
         safetextlength = u_strlen(strsrch->canonicalSuffixAccents);
         safetext       = strsrch->canonicalSuffixAccents;
     }
 
     // if status is a failure, ucol_setText does nothing
     ucol_setText(coleiter, safetext, safetextlength, status);
     // status checked in loop below
 
-    int32_t  *ce        = strsrch->pattern.CE;
-    int32_t   celength  = strsrch->pattern.CELength;
+    int32_t  *ce        = strsrch->pattern.ces;
+    int32_t   celength  = strsrch->pattern.cesLength;
     int       ceindex   = celength - 1;
     UBool     isSafe    = TRUE; // indication flag for position in safe zone
 
     while (ceindex >= 0) {
         int32_t textce = ucol_previous(coleiter, status);
         if (U_FAILURE(*status)) {
             if (isSafe) {
                 cleanUpSafeText(strsrch, safetext, safebuffer);
             }
             return USEARCH_DONE;
@@ skipping 218 matching lines @@
             if (U_FAILURE(*status)) {
                 return FALSE;
             }
             if (ucol_getOffset(coleiter) != temp) {
                 *start = temp;
                 temp  = ucol_getOffset(coleiter);
             }
             expansion --;
         }
 
-        int32_t  *patternce       = strsrch->pattern.CE;
-        int32_t   patterncelength = strsrch->pattern.CELength;
+        int32_t  *patternce       = strsrch->pattern.ces;
+        int32_t   patterncelength = strsrch->pattern.cesLength;
         int32_t   count           = 0;
         int32_t   textlength      = strsrch->search->textLength;
         while (count < patterncelength) {
             int32_t ce = getCE(strsrch, ucol_next(coleiter, status));
             // status checked below, note that if status is a failure
             // ucol_next returns UCOL_NULLORDER
             if (ce == UCOL_IGNORABLE) {
                 continue;
             }
             if (expandflag && count == 0 && ucol_getOffset(coleiter) != temp) {
@@ skipping 176 matching lines @@
             if (U_FAILURE(*status)) {
                 return FALSE;
             }
             if (ucol_getOffset(coleiter) != temp) {
                 *end = temp;
                 temp  = ucol_getOffset(coleiter);
             }
             expansion --;
         }
 
-        int32_t  *patternce       = strsrch->pattern.CE;
-        int32_t   patterncelength = strsrch->pattern.CELength;
+        int32_t  *patternce       = strsrch->pattern.ces;
+        int32_t   patterncelength = strsrch->pattern.cesLength;
         int32_t   count           = patterncelength;
         while (count > 0) {
             int32_t ce = getCE(strsrch, ucol_previous(coleiter, status));
             // status checked below, note that if status is a failure
             // ucol_previous returns UCOL_NULLORDER
             if (ce == UCOL_IGNORABLE) {
                 continue;
             }
             if (expandflag && count == 0 &&
                 getColElemIterOffset(coleiter, FALSE) != temp) {
@@ skipping 203 matching lines @@
     else {
         safetextlength = u_strlen(strsrch->canonicalPrefixAccents);
         safetext       = strsrch->canonicalPrefixAccents;
     }
 
     UCollationElements *coleiter = strsrch->utilIter;
      // if status is a failure, ucol_setText does nothing
     ucol_setText(coleiter, safetext, safetextlength, status);
     // status checked in loop below
 
-    int32_t  *ce           = strsrch->pattern.CE;
-    int32_t   celength     = strsrch->pattern.CELength;
+    int32_t  *ce           = strsrch->pattern.ces;
+    int32_t   celength     = strsrch->pattern.cesLength;
     int       ceindex      = 0;
     UBool     isSafe       = TRUE; // safe zone indication flag for position
     int32_t   prefixlength = u_strlen(strsrch->canonicalPrefixAccents);
 
     while (ceindex < celength) {
         int32_t textce = ucol_next(coleiter, status);
         if (U_FAILURE(*status)) {
             if (isSafe) {
                 cleanUpSafeText(strsrch, safetext, safebuffer);
             }
@@ skipping 193 matching lines @@
             if (U_FAILURE(*status)) {
                 return FALSE;
             }
             if (ucol_getOffset(coleiter) != temp) {
                 *end = temp;
                 temp  = ucol_getOffset(coleiter);
             }
             expansion --;
         }
 
-        int32_t  *patternce       = strsrch->pattern.CE;
-        int32_t   patterncelength = strsrch->pattern.CELength;
+        int32_t  *patternce       = strsrch->pattern.ces;
+        int32_t   patterncelength = strsrch->pattern.cesLength;
         int32_t   count           = patterncelength;
         while (count > 0) {
             int32_t ce = getCE(strsrch, ucol_previous(coleiter, status));
             // status checked below, note that if status is a failure
             // ucol_previous returns UCOL_NULLORDER
             if (ce == UCOL_IGNORABLE) {
                 continue;
             }
             if (expandflag && count == 0 &&
                 getColElemIterOffset(coleiter, FALSE) != temp) {
@@ skipping 185 matching lines @@
         }
 
         result->collator    = collator;
         result->strength    = ucol_getStrength(collator);
         result->ceMask      = getMask(result->strength);
         result->toShift     =
              ucol_getAttribute(collator, UCOL_ALTERNATE_HANDLING, status) ==
                                                             UCOL_SHIFTED;
         result->variableTop = ucol_getVariableTop(collator, status);
 
-        result->nfd         = Normalizer2Factory::getNFDInstance(*status);
+        result->nfd         = Normalizer2::getNFDInstance(*status);
 
         if (U_FAILURE(*status)) {
             uprv_free(result);
             return NULL;
         }
 
         result->search             = (USearch *)uprv_malloc(sizeof(USearch));
         if (result->search == NULL) {
             *status = U_MEMORY_ALLOCATION_ERROR;
             uprv_free(result);
             return NULL;
         }
 
         result->search->text       = text;
         result->search->textLength = textlength;
 
         result->pattern.text       = pattern;
         result->pattern.textLength = patternlength;
-        result->pattern.CE         = NULL;
-        result->pattern.PCE        = NULL;
+        result->pattern.ces         = NULL;
+        result->pattern.pces        = NULL;
 
         result->search->breakIter  = breakiter;
 #if !UCONFIG_NO_BREAK_ITERATION
         result->search->internalBreakIter = ubrk_open(UBRK_CHARACTER, ucol_getLocaleByType(result->collator, ULOC_VALID_LOCALE, status), text, textlength, status);
         if (breakiter) {
             ubrk_setText(breakiter, text, textlength, status);
         }
 #endif
 
         result->ownCollator           = FALSE;
         result->search->matchedLength = 0;
         result->search->matchedIndex  = USEARCH_DONE;
         result->utilIter              = NULL;
         result->textIter              = ucol_openElements(collator, text,
                                                           textlength, status);
+        result->textProcessedIter     = NULL;
         if (U_FAILURE(*status)) {
             usearch_close(result);
             return NULL;
         }
 
         result->search->isOverlap          = FALSE;
         result->search->isCanonicalMatch   = FALSE;
         result->search->elementComparisonType = 0;
         result->search->isForwardSearching = TRUE;
         result->search->reset              = TRUE;
 
         initialize(result, status);
 
         if (U_FAILURE(*status)) {
             usearch_close(result);
             return NULL;
         }
 
         return result;
     }
     return NULL;
 }
 
 U_CAPI void U_EXPORT2 usearch_close(UStringSearch *strsrch)
 {
     if (strsrch) {
-        if (strsrch->pattern.CE != strsrch->pattern.CEBuffer &&
-            strsrch->pattern.CE) {
-            uprv_free(strsrch->pattern.CE);
+        if (strsrch->pattern.ces != strsrch->pattern.cesBuffer &&
+            strsrch->pattern.ces) {
+            uprv_free(strsrch->pattern.ces);
         }
 
-        if (strsrch->pattern.PCE != NULL &&
-            strsrch->pattern.PCE != strsrch->pattern.PCEBuffer) {
-            uprv_free(strsrch->pattern.PCE);
+        if (strsrch->pattern.pces != NULL &&
+            strsrch->pattern.pces != strsrch->pattern.pcesBuffer) {
+            uprv_free(strsrch->pattern.pces);
         }
 
+        delete strsrch->textProcessedIter;
         ucol_closeElements(strsrch->textIter);
         ucol_closeElements(strsrch->utilIter);
 
         if (strsrch->ownCollator && strsrch->collator) {
             ucol_close((UCollator *)strsrch->collator);
         }
 
 #if !UCONFIG_NO_BREAK_ITERATION
         if (strsrch->search->internalBreakIter) {
             ubrk_close(strsrch->search->internalBreakIter);
         }
 #endif
 
         uprv_free(strsrch->search);
         uprv_free(strsrch);
     }
 }
 
+namespace {
+
+UBool initTextProcessedIter(UStringSearch *strsrch, UErrorCode *status) {
+    if (U_FAILURE(*status)) { return FALSE; }
+    if (strsrch->textProcessedIter == NULL) {
+        strsrch->textProcessedIter = new icu::UCollationPCE(strsrch->textIter);
+        if (strsrch->textProcessedIter == NULL) {
+            *status = U_MEMORY_ALLOCATION_ERROR;
+            return FALSE;
+        }
+    } else {
+        strsrch->textProcessedIter->init(strsrch->textIter);
+    }
+    return TRUE;
+}
+
+}
+
 // set and get methods --------------------------------------------------
 
 U_CAPI void U_EXPORT2 usearch_setOffset(UStringSearch *strsrch,
                                         int32_t    position,
                                         UErrorCode    *status)
 {
     if (U_SUCCESS(*status) && strsrch) {
         if (isOutOfBounds(strsrch->search->textLength, position)) {
             *status = U_INDEX_OUTOFBOUNDS_ERROR;
         }
@@ skipping 200 matching lines @@
                                           const UCollator     *collator,
                                                 UErrorCode    *status)
 {
     if (U_SUCCESS(*status)) {
         if (collator == NULL) {
             *status = U_ILLEGAL_ARGUMENT_ERROR;
             return;
         }
 
         if (strsrch) {
+            delete strsrch->textProcessedIter;
+            strsrch->textProcessedIter = NULL;
+            ucol_closeElements(strsrch->textIter);
+            ucol_closeElements(strsrch->utilIter);
+            strsrch->textIter = strsrch->utilIter = NULL;
             if (strsrch->ownCollator && (strsrch->collator != collator)) {
                 ucol_close((UCollator *)strsrch->collator);
                 strsrch->ownCollator = FALSE;
             }
             strsrch->collator    = collator;
             strsrch->strength    = ucol_getStrength(collator);
             strsrch->ceMask      = getMask(strsrch->strength);
 #if !UCONFIG_NO_BREAK_ITERATION
             ubrk_close(strsrch->search->internalBreakIter);
             strsrch->search->internalBreakIter = ubrk_open(UBRK_CHARACTER, ucol_getLocaleByType(collator, ULOC_VALID_LOCALE, status),
                                                      strsrch->search->text, strsrch->search->textLength, status);
 #endif
             // if status is a failure, ucol_getAttribute returns UCOL_DEFAULT
             strsrch->toShift     =
                ucol_getAttribute(collator, UCOL_ALTERNATE_HANDLING, status) ==
                                                                 UCOL_SHIFTED;
             // if status is a failure, ucol_getVariableTop returns 0
             strsrch->variableTop = ucol_getVariableTop(collator, status);
-            if (U_SUCCESS(*status)) {
-                initialize(strsrch, status);
-                if (U_SUCCESS(*status)) {
-                    /* free offset buffer to avoid memory leak before initializing. */
-                    ucol_freeOffsetBuffer(&(strsrch->textIter->iteratordata_));
-                    uprv_init_collIterate(collator, strsrch->search->text,
-                                          strsrch->search->textLength,
-                                          &(strsrch->textIter->iteratordata_),
-                                          status);
-                    strsrch->utilIter->iteratordata_.coll = collator;
-                }
-            }
+            strsrch->textIter = ucol_openElements(collator,
+                                      strsrch->search->text,
+                                      strsrch->search->textLength,
+                                      status);
+            strsrch->utilIter = ucol_openElements(
+                    collator, strsrch->pattern.text, strsrch->pattern.textLength, status);
+            // initialize() _after_ setting the iterators for the new collator.
+            initialize(strsrch, status);
         }
 
         // **** are these calls needed?
         // **** we call uprv_init_pce in initializePatternPCETable
-        // **** and the CEBuffer constructor...
+        // **** and the CEIBuffer constructor...
 #if 0
         uprv_init_pce(strsrch->textIter);
         uprv_init_pce(strsrch->utilIter);
 #endif
     }
 }
 
 U_CAPI UCollator * U_EXPORT2 usearch_getCollator(const UStringSearch *strsrch)
 {
     if (strsrch) {
@@ skipping 157 matching lines @@
             // match is not found.
             search->isForwardSearching = TRUE;
             if (search->matchedIndex != USEARCH_DONE) {
                 // there's no need to set the collation element iterator
                 // the next call to next will set the offset.
                 return search->matchedIndex;
             }
         }
 
         if (U_SUCCESS(*status)) {
-            if (strsrch->pattern.CELength == 0) {
+            if (strsrch->pattern.cesLength == 0) {
                 if (search->matchedIndex == USEARCH_DONE) {
                     search->matchedIndex = offset;
                 }
                 else { // moves by codepoints
                     U16_FWD_1(search->text, search->matchedIndex, textlength);
                 }
 
                 search->matchedLength = 0;
                 setColEIterOffset(strsrch->textIter, search->matchedIndex);
                 // status checked below
@@ skipping 90 matching lines @@
             // Could check pattern length, but the
             // linear search will do the right thing
             if (offset == 0 || matchedindex == 0) {
                 setMatchNotFound(strsrch);
                 return USEARCH_DONE;
             }
 #endif
         }
 
         if (U_SUCCESS(*status)) {
-            if (strsrch->pattern.CELength == 0) {
+            if (strsrch->pattern.cesLength == 0) {
                 search->matchedIndex =
                       (matchedindex == USEARCH_DONE ? offset : matchedindex);
                 if (search->matchedIndex == 0) {
                     setMatchNotFound(strsrch);
                     // status checked below
                 }
                 else { // move by codepoints
                     U16_BACK_1(search->text, 0, search->matchedIndex);
                     setColEIterOffset(strsrch->textIter, search->matchedIndex);
                     // status checked below
@@ skipping 62 matching lines @@
 
         // if status is a failure, ucol_getVariableTop returns 0
         varTop = ucol_getVariableTop(strsrch->collator, &status);
         if (strsrch->variableTop != varTop) {
             strsrch->variableTop = varTop;
             sameCollAttribute    = FALSE;
         }
         if (!sameCollAttribute) {
             initialize(strsrch, &status);
         }
-        /* free offset buffer to avoid memory leak before initializing. */
-        ucol_freeOffsetBuffer(&(strsrch->textIter->iteratordata_));
-        uprv_init_collIterate(strsrch->collator, strsrch->search->text,
+        ucol_setText(strsrch->textIter, strsrch->search->text,
                               strsrch->search->textLength,
-                              &(strsrch->textIter->iteratordata_),
                               &status);
         strsrch->search->matchedLength      = 0;
         strsrch->search->matchedIndex       = USEARCH_DONE;
         strsrch->search->isOverlap          = FALSE;
         strsrch->search->isCanonicalMatch   = FALSE;
         strsrch->search->elementComparisonType = 0;
         strsrch->search->isForwardSearching = TRUE;
         strsrch->search->reset              = TRUE;
     }
 }
 
 //
 //  CEI  Collation Element + source text index.
 //       These structs are kept in the circular buffer.
 //
 struct  CEI {
     int64_t ce;
     int32_t lowIndex;
     int32_t highIndex;
 };
 
 U_NAMESPACE_BEGIN
 
-
+namespace {
 //
-//  CEBuffer   A circular buffer of CEs from the text being searched.
+//  CEIBuffer   A circular buffer of CEs-with-index from the text being searched.
 //
 #define   DEFAULT_CEBUFFER_SIZE 96
 #define   CEBUFFER_EXTRA 32
 // Some typical max values to make buffer size more reasonable for asymmetric search.
 // #8694 is for a better long-term solution to allocation of this buffer.
 #define   MAX_TARGET_IGNORABLES_PER_PAT_JAMO_L 8
 #define   MAX_TARGET_IGNORABLES_PER_PAT_OTHER 3
 #define   MIGHT_BE_JAMO_L(c) ((c >= 0x1100 && c <= 0x115E) || (c >= 0x3131 && c <= 0x314E) || (c >= 0x3165 && c <= 0x3186))
-struct CEBuffer {
+struct CEIBuffer {
     CEI                  defBuf[DEFAULT_CEBUFFER_SIZE];
     CEI                 *buf;
     int32_t              bufSize;
     int32_t              firstIx;
     int32_t              limitIx;
     UCollationElements  *ceIter;
     UStringSearch       *strSearch;
 
 
 
-               CEBuffer(UStringSearch *ss, UErrorCode *status);
-               ~CEBuffer();
+               CEIBuffer(UStringSearch *ss, UErrorCode *status);
+               ~CEIBuffer();
    const CEI   *get(int32_t index);
    const CEI   *getPrevious(int32_t index);
 };
 
 
-CEBuffer::CEBuffer(UStringSearch *ss, UErrorCode *status) {
+CEIBuffer::CEIBuffer(UStringSearch *ss, UErrorCode *status) {
     buf = defBuf;
     strSearch = ss;
-    bufSize = ss->pattern.PCELength + CEBUFFER_EXTRA;
+    bufSize = ss->pattern.pcesLength + CEBUFFER_EXTRA;
     if (ss->search->elementComparisonType != 0) {
         const UChar * patText = ss->pattern.text;
         if (patText) {
             const UChar * patTextLimit = patText + ss->pattern.textLength;
             while ( patText < patTextLimit ) {
                 UChar c = *patText++;
                 if (MIGHT_BE_JAMO_L(c)) {
                     bufSize += MAX_TARGET_IGNORABLES_PER_PAT_JAMO_L;
                 } else {
                     // No check for surrogates, we might allocate slightly more buffer than necessary.
                     bufSize += MAX_TARGET_IGNORABLES_PER_PAT_OTHER;
                 }
             }
         }
     }
     ceIter    = ss->textIter;
     firstIx = 0;
     limitIx = 0;
 
-    uprv_init_pce(ceIter);
+    if (!initTextProcessedIter(ss, status)) { return; }
 
     if (bufSize>DEFAULT_CEBUFFER_SIZE) {
         buf = (CEI *)uprv_malloc(bufSize * sizeof(CEI));
         if (buf == NULL) {
             *status = U_MEMORY_ALLOCATION_ERROR;
         }
     }
 }
 
 // TODO: add a reset or init function so that allocated
 //       buffers can be retained & reused.
 
-CEBuffer::~CEBuffer() {
+CEIBuffer::~CEIBuffer() {
     if (buf != defBuf) {
         uprv_free(buf);
     }
 }
 
 
 // Get the CE with the specified index.
 //   Index must be in the range
 //          n-history_size < index < n+1
 //   where n is the largest index to have been fetched by some previous call to this function.
 //   The CE value will be UCOL__PROCESSED_NULLORDER at end of input.
 //
-const CEI *CEBuffer::get(int32_t index) {
+const CEI *CEIBuffer::get(int32_t index) {
     int i = index % bufSize;
 
     if (index>=firstIx && index<limitIx) {
         // The request was for an entry already in our buffer.
         //  Just return it.
         return &buf[i];
     }
 
     // Caller is requesting a new, never accessed before, CE.
     //   Verify that it is the next one in sequence, which is all
     //   that is allowed.
     if (index != limitIx) {
         U_ASSERT(FALSE);
 
         return NULL;
     }
 
     // Manage the circular CE buffer indexing
     limitIx++;
 
     if (limitIx - firstIx >= bufSize) {
         // The buffer is full, knock out the lowest-indexed entry.
         firstIx++;
     }
 
     UErrorCode status = U_ZERO_ERROR;
 
-    buf[i].ce = ucol_nextProcessed(ceIter, &buf[i].lowIndex, &buf[i].highIndex, &status);
+    buf[i].ce = strSearch->textProcessedIter->nextProcessed(&buf[i].lowIndex, &buf[i].highIndex, &status);
 
     return &buf[i];
 }
 
 // Get the CE with the specified index.
 //   Index must be in the range
 //          n-history_size < index < n+1
 //   where n is the largest index to have been fetched by some previous call to this function.
 //   The CE value will be UCOL__PROCESSED_NULLORDER at end of input.
 //
-const CEI *CEBuffer::getPrevious(int32_t index) {
+const CEI *CEIBuffer::getPrevious(int32_t index) {
     int i = index % bufSize;
 
     if (index>=firstIx && index<limitIx) {
         // The request was for an entry already in our buffer.
         //  Just return it.
         return &buf[i];
     }
 
     // Caller is requesting a new, never accessed before, CE.
     //   Verify that it is the next one in sequence, which is all
     //   that is allowed.
     if (index != limitIx) {
         U_ASSERT(FALSE);
 
         return NULL;
     }
 
     // Manage the circular CE buffer indexing
     limitIx++;
 
     if (limitIx - firstIx >= bufSize) {
         // The buffer is full, knock out the lowest-indexed entry.
         firstIx++;
     }
 
     UErrorCode status = U_ZERO_ERROR;
 
-    buf[i].ce = ucol_previousProcessed(ceIter, &buf[i].lowIndex, &buf[i].highIndex, &status);
+    buf[i].ce = strSearch->textProcessedIter->previousProcessed(&buf[i].lowIndex, &buf[i].highIndex, &status);
 
     return &buf[i];
 }
 
+}
+
 U_NAMESPACE_END
 
 
 // #define USEARCH_DEBUG
 
 #ifdef USEARCH_DEBUG
 #include <stdio.h>
 #include <stdlib.h>
 #endif
 
@@ skipping 201 matching lines @@
 {
     if (U_FAILURE(*status)) {
         return FALSE;
     }
 
     // TODO:  reject search patterns beginning with a combining char.
 
 #ifdef USEARCH_DEBUG
     if (getenv("USEARCH_DEBUG") != NULL) {
         printf("Pattern CEs\n");
-        for (int ii=0; ii<strsrch->pattern.CELength; ii++) {
-            printf(" %8x", strsrch->pattern.CE[ii]);
+        for (int ii=0; ii<strsrch->pattern.cesLength; ii++) {
+            printf(" %8x", strsrch->pattern.ces[ii]);
         }
         printf("\n");
     }
 
 #endif
     // Input parameter sanity check.
     //  TODO:  should input indicies clip to the text length
     //         in the same way that UText does.
-    if(strsrch->pattern.CELength == 0         ||
+    if(strsrch->pattern.cesLength == 0         ||
        startIdx < 0                           ||
        startIdx > strsrch->search->textLength ||
-       strsrch->pattern.CE == NULL) {
+       strsrch->pattern.ces == NULL) {
            *status = U_ILLEGAL_ARGUMENT_ERROR;
            return FALSE;
     }
 
-    if (strsrch->pattern.PCE == NULL) {
+    if (strsrch->pattern.pces == NULL) {
         initializePatternPCETable(strsrch, status);
     }
 
     ucol_setOffset(strsrch->textIter, startIdx, status);
-    CEBuffer ceb(strsrch, status);
+    CEIBuffer ceb(strsrch, status);
 
 
     int32_t    targetIx = 0;
     const CEI *targetCEI = NULL;
     int32_t    patIx;
     UBool      found;
 
     int32_t  mStart = -1;
     int32_t  mLimit = -1;
     int32_t  minLimit;
@@ skipping 25 matching lines @@
         // For targetIx > 0, this ceb.get gets a CE that is as far back in the ring buffer
         // (compared to the last CE fetched for the previous targetIx value) as we need to go
         // for this targetIx value, so if it is non-NULL then other ceb.get calls should be OK.
         const CEI *firstCEI = ceb.get(targetIx);
         if (firstCEI == NULL) {
             *status = U_INTERNAL_PROGRAM_ERROR;
             found = FALSE;
             break;
         }
         
-        for (patIx=0; patIx<strsrch->pattern.PCELength; patIx++) {
-            patCE = strsrch->pattern.PCE[patIx];
+        for (patIx=0; patIx<strsrch->pattern.pcesLength; patIx++) {
+            patCE = strsrch->pattern.pces[patIx];
             targetCEI = ceb.get(targetIx+patIx+targetIxOffset);
             //  Compare CE from target string with CE from the pattern.
             //    Note that the target CE will be UCOL_PROCESSED_NULLORDER if we reach the end of input,
             //    which will fail the compare, below.
             UCompareCEsResult ceMatch = compareCE64s(targetCEI->ce, patCE, strsrch->search->elementComparisonType);
             if ( ceMatch == U_CE_NO_MATCH ) {
                 found = FALSE;
                 break;
             } else if ( ceMatch > U_CE_NO_MATCH ) {
                 if ( ceMatch == U_CE_SKIP_TARG ) {
                     // redo with same patCE, next targCE
                     patIx--;
                     targetIxOffset++;
                 } else { // ceMatch == U_CE_SKIP_PATN
                     // redo with same targCE, next patCE
                     targetIxOffset--;
                 }
             }
         }
-        targetIxOffset += strsrch->pattern.PCELength; // this is now the offset in target CE space to end of the match so far
+        targetIxOffset += strsrch->pattern.pcesLength; // this is now the offset in target CE space to end of the match so far
 
         if (!found && ((targetCEI == NULL) || (targetCEI->ce != UCOL_PROCESSED_NULLORDER))) {
             // No match at this targetIx.  Try again at the next.
             continue;
         }
 
         if (!found) {
             // No match at all, we have run off the end of the target text.
             break;
         }
@@ skipping 156 matching lines @@
 {
     if (U_FAILURE(*status)) {
         return FALSE;
     }
 
     // TODO:  reject search patterns beginning with a combining char.
 
 #ifdef USEARCH_DEBUG
     if (getenv("USEARCH_DEBUG") != NULL) {
         printf("Pattern CEs\n");
-        for (int ii=0; ii<strsrch->pattern.CELength; ii++) {
-            printf(" %8x", strsrch->pattern.CE[ii]);
+        for (int ii=0; ii<strsrch->pattern.cesLength; ii++) {
+            printf(" %8x", strsrch->pattern.ces[ii]);
         }
         printf("\n");
     }
 
 #endif
     // Input parameter sanity check.
     //  TODO:  should input indicies clip to the text length
     //         in the same way that UText does.
-    if(strsrch->pattern.CELength == 0         ||
+    if(strsrch->pattern.cesLength == 0         ||
        startIdx < 0                           ||
        startIdx > strsrch->search->textLength ||
-       strsrch->pattern.CE == NULL) {
+       strsrch->pattern.ces == NULL) {
            *status = U_ILLEGAL_ARGUMENT_ERROR;
            return FALSE;
     }
 
-    if (strsrch->pattern.PCE == NULL) {
+    if (strsrch->pattern.pces == NULL) {
         initializePatternPCETable(strsrch, status);
     }
 
-    CEBuffer ceb(strsrch, status);
+    CEIBuffer ceb(strsrch, status);
     int32_t    targetIx = 0;
 
     /*
      * Pre-load the buffer with the CE's for the grapheme
      * after our starting position so that we're sure that
      * we can look at the CE following the match when we
      * check the match boundaries.
      *
      * This will also pre-fetch the first CE that we'll
      * consider for the match.
@@ skipping 40 matching lines @@
         // for this targetIx value, so if it is non-NULL then other ceb.getPrevious calls should be OK.
         const CEI *lastCEI  = ceb.getPrevious(targetIx);
         if (lastCEI == NULL) {
             *status = U_INTERNAL_PROGRAM_ERROR;
             found = FALSE;
              break;
         }
         //  Inner loop checks for a match beginning at each
         //  position from the outer loop.
         int32_t targetIxOffset = 0;
-        for (patIx = strsrch->pattern.PCELength - 1; patIx >= 0; patIx -= 1) {
-            int64_t patCE = strsrch->pattern.PCE[patIx];
+        for (patIx = strsrch->pattern.pcesLength - 1; patIx >= 0; patIx -= 1) {
+            int64_t patCE = strsrch->pattern.pces[patIx];
 
-            targetCEI = ceb.getPrevious(targetIx + strsrch->pattern.PCELength - 1 - patIx + targetIxOffset);
+            targetCEI = ceb.getPrevious(targetIx + strsrch->pattern.pcesLength - 1 - patIx + targetIxOffset);
             //  Compare CE from target string with CE from the pattern.
             //    Note that the target CE will be UCOL_NULLORDER if we reach the end of input,
             //    which will fail the compare, below.
             UCompareCEsResult ceMatch = compareCE64s(targetCEI->ce, patCE, strsrch->search->elementComparisonType);
             if ( ceMatch == U_CE_NO_MATCH ) {
                 found = FALSE;
                 break;
             } else if ( ceMatch > U_CE_NO_MATCH ) {
                 if ( ceMatch == U_CE_SKIP_TARG ) {
                     // redo with same patCE, next targCE
@@ skipping 15 matching lines @@
             // No match at all, we have run off the end of the target text.
             break;
         }
 
 
         // We have found a match in CE space.
         // Now determine the bounds in string index space.
         //  There still is a chance of match failure if the CE range not correspond to
         //     an acceptable character range.
         //
-        const CEI *firstCEI = ceb.getPrevious(targetIx + strsrch->pattern.PCELength - 1 + targetIxOffset);
+        const CEI *firstCEI = ceb.getPrevious(targetIx + strsrch->pattern.pcesLength - 1 + targetIxOffset);
         mStart   = firstCEI->lowIndex;
 
         // Check for the start of the match being within a combining sequence.
         //   This can happen if the pattern itself begins with a combining char, and
         //   the match found combining marks in the target text that were attached
         //    to something else.
         //   This type of match should be rejected for not completely consuming a
         //   combining sequence.
         if (!isBreakBoundary(strsrch, mStart)) {
             found = FALSE;
@@ skipping 105 matching lines @@
 UBool usearch_handleNextExact(UStringSearch *strsrch, UErrorCode *status)
 {
     if (U_FAILURE(*status)) {
         setMatchNotFound(strsrch);
         return FALSE;
     }
 
 #if BOYER_MOORE
     UCollationElements *coleiter        = strsrch->textIter;
     int32_t             textlength      = strsrch->search->textLength;
-    int32_t            *patternce       = strsrch->pattern.CE;
-    int32_t             patterncelength = strsrch->pattern.CELength;
+    int32_t            *patternce       = strsrch->pattern.ces;
+    int32_t             patterncelength = strsrch->pattern.cesLength;
     int32_t             textoffset      = ucol_getOffset(coleiter);
 
     // status used in setting coleiter offset, since offset is checked in
     // shiftForward before setting the coleiter offset, status never
     // a failure
     textoffset = shiftForward(strsrch, textoffset, UCOL_NULLORDER,
                               patterncelength);
     while (textoffset <= textlength)
     {
         uint32_t    patternceindex = patterncelength - 1;
@@ skipping 92 matching lines @@
 UBool usearch_handleNextCanonical(UStringSearch *strsrch, UErrorCode *status)
 {
     if (U_FAILURE(*status)) {
         setMatchNotFound(strsrch);
         return FALSE;
     }
 
 #if BOYER_MOORE
     UCollationElements *coleiter        = strsrch->textIter;
     int32_t             textlength      = strsrch->search->textLength;
-    int32_t            *patternce       = strsrch->pattern.CE;
-    int32_t             patterncelength = strsrch->pattern.CELength;
+    int32_t            *patternce       = strsrch->pattern.ces;
+    int32_t             patterncelength = strsrch->pattern.cesLength;
     int32_t             textoffset      = ucol_getOffset(coleiter);
     UBool               hasPatternAccents =
        strsrch->pattern.hasSuffixAccents || strsrch->pattern.hasPrefixAccents;
 
     textoffset = shiftForward(strsrch, textoffset, UCOL_NULLORDER,
                               patterncelength);
     strsrch->canonicalPrefixAccents[0] = 0;
     strsrch->canonicalSuffixAccents[0] = 0;
 
     while (textoffset <= textlength)
@@ skipping 92 matching lines @@
 
 UBool usearch_handlePreviousExact(UStringSearch *strsrch, UErrorCode *status)
 {
     if (U_FAILURE(*status)) {
         setMatchNotFound(strsrch);
         return FALSE;
     }
 
 #if BOYER_MOORE
     UCollationElements *coleiter        = strsrch->textIter;
-    int32_t            *patternce       = strsrch->pattern.CE;
-    int32_t             patterncelength = strsrch->pattern.CELength;
+    int32_t            *patternce       = strsrch->pattern.ces;
+    int32_t             patterncelength = strsrch->pattern.cesLength;
     int32_t             textoffset      = ucol_getOffset(coleiter);
 
     // shifting it check for setting offset
     // if setOffset is called previously or there was no previous match, we
     // leave the offset as it is.
     if (strsrch->search->matchedIndex != USEARCH_DONE) {
         textoffset = strsrch->search->matchedIndex;
     }
 
     textoffset = reverseShift(strsrch, textoffset, UCOL_NULLORDER,
@@ skipping 79 matching lines @@
     return FALSE;
 #else
     int32_t textOffset;
 
     if (strsrch->search->isOverlap) {
         if (strsrch->search->matchedIndex != USEARCH_DONE) {
             textOffset = strsrch->search->matchedIndex + strsrch->search->matchedLength - 1;
         } else {
             // move the start position at the end of possible match
             initializePatternPCETable(strsrch, status);
-            for (int32_t nPCEs = 0; nPCEs < strsrch->pattern.PCELength - 1; nPCEs++) {
-                int64_t pce = ucol_nextProcessed(strsrch->textIter, NULL, NULL, status);
+            if (!initTextProcessedIter(strsrch, status)) {
+                setMatchNotFound(strsrch);
+                return FALSE;
+            }
+            for (int32_t nPCEs = 0; nPCEs < strsrch->pattern.pcesLength - 1; nPCEs++) {
+                int64_t pce = strsrch->textProcessedIter->nextProcessed(NULL, NULL, status);
                 if (pce == UCOL_PROCESSED_NULLORDER) {
                     // at the end of the text
                     break;
                 }
             }
             if (U_FAILURE(*status)) {
                 setMatchNotFound(strsrch);
                 return FALSE;
             }
             textOffset = ucol_getOffset(strsrch->textIter);
@@ skipping 19 matching lines @@
 UBool usearch_handlePreviousCanonical(UStringSearch *strsrch,
                                       UErrorCode    *status)
 {
     if (U_FAILURE(*status)) {
         setMatchNotFound(strsrch);
         return FALSE;
     }
 
 #if BOYER_MOORE
     UCollationElements *coleiter        = strsrch->textIter;
-    int32_t            *patternce       = strsrch->pattern.CE;
-    int32_t             patterncelength = strsrch->pattern.CELength;
+    int32_t            *patternce       = strsrch->pattern.ces;
+    int32_t             patterncelength = strsrch->pattern.cesLength;
     int32_t             textoffset      = ucol_getOffset(coleiter);
     UBool               hasPatternAccents =
        strsrch->pattern.hasSuffixAccents || strsrch->pattern.hasPrefixAccents;
 
     // shifting it check for setting offset
     // if setOffset is called previously or there was no previous match, we
     // leave the offset as it is.
     if (strsrch->search->matchedIndex != USEARCH_DONE) {
         textoffset = strsrch->search->matchedIndex;
     }
@@ skipping 86 matching lines @@
     return FALSE;
 #else
     int32_t textOffset;
 
     if (strsrch->search->isOverlap) {
         if (strsrch->search->matchedIndex != USEARCH_DONE) {
             textOffset = strsrch->search->matchedIndex + strsrch->search->matchedLength - 1;
         } else {
             // move the start position at the end of possible match
             initializePatternPCETable(strsrch, status);
-            for (int32_t nPCEs = 0; nPCEs < strsrch->pattern.PCELength - 1; nPCEs++) {
-                int64_t pce = ucol_nextProcessed(strsrch->textIter, NULL, NULL, status);
+            if (!initTextProcessedIter(strsrch, status)) {
+                setMatchNotFound(strsrch);
+                return FALSE;
+            }
+            for (int32_t nPCEs = 0; nPCEs < strsrch->pattern.pcesLength - 1; nPCEs++) {
+                int64_t pce = strsrch->textProcessedIter->nextProcessed(NULL, NULL, status);
                 if (pce == UCOL_PROCESSED_NULLORDER) {
                     // at the end of the text
                     break;
                 }
             }
             if (U_FAILURE(*status)) {
                 setMatchNotFound(strsrch);
                 return FALSE;
             }
             textOffset = ucol_getOffset(strsrch->textIter);
@@ skipping 10 matching lines @@
         strsrch->search->matchedLength = end - start;
         return TRUE;
     } else {
         setMatchNotFound(strsrch);
         return FALSE;
     }
 #endif
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */