ICU 56 update step 1

source/common/caniter.cpp

 /*
  *****************************************************************************
- * Copyright (C) 1996-2014, International Business Machines Corporation and
+ * Copyright (C) 1996-2015, International Business Machines Corporation and
  * others. All Rights Reserved.
  *****************************************************************************
  */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_NORMALIZATION
 
 #include "unicode/caniter.h"
 #include "unicode/normalizer2.h"
@@ skipping 273 matching lines @@
     UChar32 cp;
     Hashtable subpermute(status);
     if(U_FAILURE(status)) {
         return;
     }
     subpermute.setValueDeleter(uprv_deleteUObject);
 
     for (i = 0; i < source.length(); i += U16_LENGTH(cp)) {
         cp = source.char32At(i);
         const UHashElement *ne = NULL;
-        int32_t el = -1;
+        int32_t el = UHASH_FIRST;
         UnicodeString subPermuteString = source;
 
         // optimization:
         // if the character is canonical combining class zero,
         // don't permute it
         if (skipZeros && i != 0 && u_getCombiningClass(cp) == 0) {
             //System.out.println("Skipping " + Utility.hex(UTF16.valueOf(source, i)));
             continue;
         }
 
@@ skipping 44 matching lines @@
 
     UChar USeg[256];
     int32_t segLen = segment.extract(USeg, 256, status);
     getEquivalents2(&basic, USeg, segLen, status);
 
     // now get all the permutations
     // add only the ones that are canonically equivalent
     // TODO: optimize by not permuting any class zero.
 
     const UHashElement *ne = NULL;
-    int32_t el = -1;
+    int32_t el = UHASH_FIRST;
     //Iterator it = basic.iterator();
     ne = basic.nextElement(el);
     //while (it.hasNext())
     while (ne != NULL) {
         //String item = (String) it.next();
         UnicodeString item = *((UnicodeString *)(ne->value.pointer));
 
         permutations.removeAll();
         permute(item, CANITER_SKIP_ZEROES, &permutations, status);
         const UHashElement *ne2 = NULL;
-        int32_t el2 = -1;
+        int32_t el2 = UHASH_FIRST;
         //Iterator it2 = permutations.iterator();
         ne2 = permutations.nextElement(el2);
         //while (it2.hasNext())
         while (ne2 != NULL) {
             //String possible = (String) it2.next();
             //UnicodeString *possible = new UnicodeString(*((UnicodeString *)(ne2->value.pointer)));
             UnicodeString possible(*((UnicodeString *)(ne2->value.pointer)));
             UnicodeString attempt;
             nfd.normalize(possible, attempt, status);
 
@@ skipping 25 matching lines @@
             status = U_MEMORY_ALLOCATION_ERROR;
             return NULL;
         }
     }
     else {
         status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
     //result.toArray(finalResult);
     result_len = 0;
-    el = -1;
+    el = UHASH_FIRST;
     ne = result.nextElement(el);
     while(ne != NULL) {
         finalResult[result_len++] = *((UnicodeString *)(ne->value.pointer));
         ne = result.nextElement(el);
     }
 
 
     return finalResult;
 }
 
@@ skipping 26 matching lines @@
             Hashtable remainder(status);
             remainder.setValueDeleter(uprv_deleteUObject);
             if (extract(&remainder, cp2, segment, segLen, i, status) == NULL) {
                 continue;
             }
 
             // there were some matches, so add all the possibilities to the set.
             UnicodeString prefix(segment, i);
             prefix += cp2;
 
-            int32_t el = -1;
+            int32_t el = UHASH_FIRST;
             const UHashElement *ne = remainder.nextElement(el);
             while (ne != NULL) {
                 UnicodeString item = *((UnicodeString *)(ne->value.pointer));
                 UnicodeString *toAdd = new UnicodeString(prefix);
                 /* test for NULL */
                 if (toAdd == 0) {
                     status = U_MEMORY_ALLOCATION_ERROR;
                     return NULL;
                 }
                 *toAdd += item;
@@ skipping 24 matching lines @@
     //if (PROGRESS) printf("%s, %i\n", UToS(Tr(segment)), segmentPos);
 
     if (U_FAILURE(status)) {
         return NULL;
     }
 
     UnicodeString temp(comp);
     int32_t inputLen=temp.length();
     UnicodeString decompString;
     nfd.normalize(temp, decompString, status);
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    if (decompString.isBogus()) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
     const UChar *decomp=decompString.getBuffer();
     int32_t decompLen=decompString.length();
 
     // See if it matches the start of segment (at segmentPos)
     UBool ok = FALSE;
     UChar32 cp;
     int32_t decompPos = 0;
     UChar32 decompCp;
     U16_NEXT(decomp, decompPos, decompLen, decompCp);
 
@@ skipping 47 matching lines @@
     if(U_FAILURE(status) || trial.compare(segment+segmentPos, segLen - segmentPos) != 0) {
         return NULL;
     }
 
     return getEquivalents2(fillinResult, temp.getBuffer()+inputLen, temp.length()-inputLen, status);
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_NORMALIZATION */