Update ICU to 54.1 step 1

source/common/unames.cpp

 /*
 ******************************************************************************
 *
-*   Copyright (C) 1999-2013, International Business Machines
+*   Copyright (C) 1999-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
 *   file name:  unames.c
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 1999oct04
 *   created by: Markus W. Scherer
@@ skipping 11 matching lines @@
 #include "cmemory.h"
 #include "cstring.h"
 #include "ucln_cmn.h"
 #include "udataswp.h"
 #include "uprops.h"
 
 U_NAMESPACE_BEGIN
 
 /* prototypes ------------------------------------------------------------- */
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 static const char DATA_NAME[] = "unames";
 static const char DATA_TYPE[] = "icu";
 
 #define GROUP_SHIFT 5
 #define LINES_PER_GROUP (1L<<GROUP_SHIFT)
 #define GROUP_MASK (LINES_PER_GROUP-1)
 
 /*
  * This struct was replaced by explicitly accessing equivalent
  * fields from triples of uint16_t.
@@ skipping 383 matching lines @@
 
     return cat;
 }
 
 static const char *getCharCatName(UChar32 cp) {
     uint8_t cat = getCharCat(cp);
 
     /* Return unknown if the table of names above is not up to
        date. */
 
-    if (cat >= LENGTHOF(charCatNames)) {
+    if (cat >= UPRV_LENGTHOF(charCatNames)) {
         return "unknown";
     } else {
         return charCatNames[cat];
     }
 }
 
 static uint16_t getExtName(uint32_t code, char *buffer, uint16_t bufferLength) {
     const char *catname = getCharCatName(code);
     uint16_t length = 0;
 
@@ skipping 818 matching lines @@
         range=(AlgorithmicRange *)((uint8_t *)range+range->size);
         --rangeCount;
     }
     return maxNameLength;
 }
 
 static int32_t
 calcExtNameSetsLengths(int32_t maxNameLength) {
     int32_t i, length;
 
-    for(i=0; i<LENGTHOF(charCatNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(charCatNames); ++i) {
         /*
          * for each category, count the length of the category name
          * plus 9=
          * 2 for <>
          * 1 for -
          * 6 for most hex digits per code point
          */
         length=9+calcStringSetLength(gNameSet, charCatNames[i]);
         if(length>maxNameLength) {
             maxNameLength=length;
@@ skipping 142 matching lines @@
 
     /* set sets and lengths from extended names */
     maxNameLength=calcExtNameSetsLengths(maxNameLength);
 
     /* set sets and lengths from group names, set global maximum values */
     calcGroupNameSetsLengths(maxNameLength);
 
     return TRUE;
 }
 
+U_NAMESPACE_END
+
 /* public API --------------------------------------------------------------- */
 
+U_NAMESPACE_USE
+
 U_CAPI int32_t U_EXPORT2
 u_charName(UChar32 code, UCharNameChoice nameChoice,
            char *buffer, int32_t bufferLength,
            UErrorCode *pErrorCode) {
-    AlgorithmicRange *algRange;
+     AlgorithmicRange *algRange;
     uint32_t *p;
     uint32_t i;
     int32_t length;
 
     /* check the argument values */
     if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) {
         return 0;
     } else if(nameChoice>=U_CHAR_NAME_CHOICE_COUNT ||
               bufferLength<0 || (bufferLength>0 && buffer==NULL)
     ) {
@@ skipping 85 matching lines @@
         } else {
             upper[i]=lower[i]=0;
             break;
         }
     }
     if(i==sizeof(upper)) {
         /* name too long, there is no such character */
         *pErrorCode = U_ILLEGAL_CHAR_FOUND;
         return error;
     }
+    // i==strlen(name)==strlen(lower)==strlen(upper)
 
     /* try extended names first */
     if (lower[0] == '<') {
         if (nameChoice == U_EXTENDED_CHAR_NAME) {
-            if (lower[--i] == '>') {
-                for (--i; lower[i] && lower[i] != '-'; --i) {
-                }
+            // Parse a string like "<category-HHHH>" where HHHH is a hex code point.
+            if (lower[--i] == '>' && i >= 3 && lower[--i] != '-') {
+                while (i >= 3 && lower[--i] != '-') {}
 
-                if (lower[i] == '-') { /* We've got a category. */
+                if (i >= 2 && lower[i] == '-') {
                     uint32_t cIdx;
 
                     lower[i] = 0;
 
                     for (++i; lower[i] != '>'; ++i) {
                         if (lower[i] >= '0' && lower[i] <= '9') {
                             cp = (cp << 4) + lower[i] - '0';
                         } else if (lower[i] >= 'a' && lower[i] <= 'f') {
                             cp = (cp << 4) + lower[i] - 'a' + 10;
                         } else {
                             *pErrorCode = U_ILLEGAL_CHAR_FOUND;
                             return error;
                         }
                     }
 
                     /* Now validate the category name.
                        We could use a binary search, or a trie, if
                        we really wanted to. */
 
-                    for (lower[i] = 0, cIdx = 0; cIdx < LENGTHOF(charCatNames); ++cIdx) {
+                    for (lower[i] = 0, cIdx = 0; cIdx < UPRV_LENGTHOF(charCatNames); ++cIdx) {
 
                         if (!uprv_strcmp(lower + 1, charCatNames[cIdx])) {
                             if (getCharCat(cp) == cIdx) {
                                 return cp;
                             }
                             break;
                         }
                     }
                 }
             }
@@ skipping 485 matching lines @@
                                  inRange->type, i);
                 *pErrorCode=U_UNSUPPORTED_ERROR;
                 return 0;
             }
         }
     }
 
     return headerSize+(int32_t)offset;
 }
 
-U_NAMESPACE_END
-
 /*
  * Hey, Emacs, please set the following:
  *
  * Local Variables:
  * indent-tabs-mode: nil
  * End:
  *
  */