ICU 56 update step 1

source/i18n/ucoleitr.cpp

 /*
 ******************************************************************************
-*   Copyright (C) 2001-2014, International Business Machines
+*   Copyright (C) 2001-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 *
 * File ucoleitr.cpp
 *
 * Modification History:
 *
 * Date        Name        Description
 * 02/15/2001  synwee      Modified all methods to process its own function 
 *                         instead of calling the equivalent c++ api (coleitr.h)
@@ skipping 13 matching lines @@
 #include "cmemory.h"
 #include "usrchimp.h"
 
 U_NAMESPACE_USE
 
 #define BUFFER_LENGTH             100
 
 #define DEFAULT_BUFFER_SIZE 16
 #define BUFFER_GROW 8
 
-#define ARRAY_SIZE(array) (sizeof array / sizeof array[0])
-
 #define ARRAY_COPY(dst, src, count) uprv_memcpy((void *) (dst), (void *) (src), (count) * sizeof (src)[0])
 
 #define NEW_ARRAY(type, count) (type *) uprv_malloc((count) * sizeof(type))
 
-#define GROW_ARRAY(array, newSize) uprv_realloc((void *) (array), (newSize) * sizeof (array)[0])
-
 #define DELETE_ARRAY(array) uprv_free((void *) (array))
 
 struct RCEI
 {
     uint32_t ce;
     int32_t  low;
     int32_t  high;
 };
 
 U_NAMESPACE_BEGIN
 
 struct RCEBuffer
 {
     RCEI    defaultBuffer[DEFAULT_BUFFER_SIZE];
     RCEI   *buffer;
     int32_t bufferIndex;
     int32_t bufferSize;
 
     RCEBuffer();
     ~RCEBuffer();
 
-    UBool empty() const;
-    void  put(uint32_t ce, int32_t ixLow, int32_t ixHigh);
+    UBool isEmpty() const;
+    void  put(uint32_t ce, int32_t ixLow, int32_t ixHigh, UErrorCode &errorCode);
     const RCEI *get();
 };
 
 RCEBuffer::RCEBuffer()
 {
     buffer = defaultBuffer;
     bufferIndex = 0;
     bufferSize = UPRV_LENGTHOF(defaultBuffer);
 }
 
 RCEBuffer::~RCEBuffer()
 {
     if (buffer != defaultBuffer) {
         DELETE_ARRAY(buffer);
     }
 }
 
-UBool RCEBuffer::empty() const
+UBool RCEBuffer::isEmpty() const
 {
     return bufferIndex <= 0;
 }
 
-void RCEBuffer::put(uint32_t ce, int32_t ixLow, int32_t ixHigh)
+void RCEBuffer::put(uint32_t ce, int32_t ixLow, int32_t ixHigh, UErrorCode &errorCode)
 {
+    if (U_FAILURE(errorCode)) {
+        return;
+    }
     if (bufferIndex >= bufferSize) {
         RCEI *newBuffer = NEW_ARRAY(RCEI, bufferSize + BUFFER_GROW);
+        if (newBuffer == NULL) {
+            errorCode = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
 
         ARRAY_COPY(newBuffer, buffer, bufferSize);
 
         if (buffer != defaultBuffer) {
             DELETE_ARRAY(buffer);
         }
 
         buffer = newBuffer;
         bufferSize += BUFFER_GROW;
     }
@@ skipping 26 matching lines @@
     if (buffer != defaultBuffer) {
         DELETE_ARRAY(buffer);
     }
 }
 
 void PCEBuffer::reset()
 {
     bufferIndex = 0;
 }
 
-UBool PCEBuffer::empty() const
+UBool PCEBuffer::isEmpty() const
 {
     return bufferIndex <= 0;
 }
 
-void PCEBuffer::put(uint64_t ce, int32_t ixLow, int32_t ixHigh)
+void PCEBuffer::put(uint64_t ce, int32_t ixLow, int32_t ixHigh, UErrorCode &errorCode)
 {
+    if (U_FAILURE(errorCode)) {
+        return;
+    }
     if (bufferIndex >= bufferSize) {
         PCEI *newBuffer = NEW_ARRAY(PCEI, bufferSize + BUFFER_GROW);
+        if (newBuffer == NULL) {
+            errorCode = U_MEMORY_ALLOCATION_ERROR;
+            return;
+        }
 
         ARRAY_COPY(newBuffer, buffer, bufferSize);
 
         if (buffer != defaultBuffer) {
             DELETE_ARRAY(buffer);
         }
 
         buffer = newBuffer;
         bufferSize += BUFFER_GROW;
     }
@@ skipping 215 matching lines @@
 {
     int64_t result = UCOL_IGNORABLE;
     int32_t  low = 0, high = 0;
 
     if (U_FAILURE(*status)) {
         return UCOL_PROCESSED_NULLORDER;
     }
 
     // pceBuffer.reset();
 
-    while (pceBuffer.empty()) {
+    while (pceBuffer.isEmpty()) {
         // buffer raw CEs up to non-ignorable primary
         RCEBuffer rceb;
         int32_t ce;
         
         // **** do we need to reset rceb, or will it always be empty at this point ****
         do {
             high = cei->getOffset();
             ce   = cei->previous(*status);
             low  = cei->getOffset();
 
             if (ce == UCOL_NULLORDER) {
-                if (! rceb.empty()) {
+                if (!rceb.isEmpty()) {
                     break;
                 }
 
                 goto finish;
             }
 
-            rceb.put((uint32_t)ce, low, high);
-        } while ((ce & UCOL_PRIMARYORDERMASK) == 0 || isContinuation(ce));
+            rceb.put((uint32_t)ce, low, high, *status);
+        } while (U_SUCCESS(*status) && ((ce & UCOL_PRIMARYORDERMASK) == 0 || isContinuation(ce)));
 
         // process the raw CEs
-        while (! rceb.empty()) {
+        while (U_SUCCESS(*status) && !rceb.isEmpty()) {
             const RCEI *rcei = rceb.get();
 
             result = processCE(rcei->ce);
 
             if (result != UCOL_IGNORABLE) {
-                pceBuffer.put(result, rcei->low, rcei->high);
+                pceBuffer.put(result, rcei->low, rcei->high, *status);
             }
         }
+        if (U_FAILURE(*status)) {
+            return UCOL_PROCESSED_NULLORDER;
+        }
     }
 
 finish:
-    if (pceBuffer.empty()) {
+    if (pceBuffer.isEmpty()) {
         // **** Is -1 the right value for ixLow, ixHigh? ****
         if (ixLow != NULL) {
                 *ixLow = -1;
         }
         
         if (ixHigh != NULL) {
                 *ixHigh = -1
                 ;
         }
         return UCOL_PROCESSED_NULLORDER;
@@ skipping 77 matching lines @@
     return (order >> 8) & 0xff;
 }
 
 U_CAPI int32_t U_EXPORT2
 ucol_tertiaryOrder (int32_t order) 
 {
     return order & 0xff;
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */