Update ICU to 54.1 step 1

source/common/uts46.cpp

 /*
 *******************************************************************************
-*   Copyright (C) 2010-2012, International Business Machines
+*   Copyright (C) 2010-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 *   file name:  uts46.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2010mar09
 *   created by: Markus W. Scherer
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_IDNA
 
 #include "unicode/idna.h"
 #include "unicode/normalizer2.h"
 #include "unicode/uscript.h"
 #include "unicode/ustring.h"
 #include "unicode/utf16.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "punycode.h"
 #include "ubidi_props.h"
 #include "ustr_imp.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 // Note about tests for UIDNA_ERROR_DOMAIN_NAME_TOO_LONG:
 //
 // The domain name length limit is 255 octets in an internal DNS representation
 // where the last ("root") label is the empty label
 // represented by length byte 0 alone.
 // In a conventional string, this translates to 253 characters, or 254
 // if there is a trailing dot for the root label.
 
 U_NAMESPACE_BEGIN
 
@@ skipping 272 matching lines @@
     if(&dest==&src || srcArray==NULL) {
         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
         dest.setToBogus();
         return dest;
     }
     // Arguments are fine, reset output values.
     dest.remove();
     info.reset();
     int32_t srcLength=src.length();
     if(srcLength==0) {
-        if(toASCII) {
-            info.errors|=UIDNA_ERROR_EMPTY_LABEL;
-        }
+        info.errors|=UIDNA_ERROR_EMPTY_LABEL;
         return dest;
     }
     UChar *destArray=dest.getBuffer(srcLength);
     if(destArray==NULL) {
         errorCode=U_MEMORY_ALLOCATION_ERROR;
         return dest;
     }
     // ASCII fastpath
     UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
     int32_t labelStart=0;
@@ skipping 37 matching lines @@
                 if((i+1)==srcLength || srcArray[i+1]==0x2e) {
                     // label ends with "-"
                     info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
                 }
             } else if(c==0x2e) {  // dot
                 if(isLabel) {
                     // Replacing with U+FFFD can be complicated for toASCII.
                     ++i;  // '.' was copied to dest already
                     break;
                 }
-                if(toASCII) {
-                    // Permit an empty label at the end but not elsewhere.
-                    if(i==labelStart && i<(srcLength-1)) {
-                        info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
-                    } else if((i-labelStart)>63) {
-                        info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
-                    }
+                if(i==labelStart) {
+                    info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
+                }
+                if(toASCII && (i-labelStart)>63) {
+                    info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
                 }
                 info.errors|=info.labelErrors;
                 info.labelErrors=0;
                 labelStart=i+1;
             }
         }
     }
     info.errors|=info.labelErrors;
     dest.releaseBuffer(i);
     processUnicode(src, labelStart, i, isLabel, toASCII, dest, info, errorCode);
@@ skipping 15 matching lines @@
     }
     const char *srcArray=src.data();
     int32_t srcLength=src.length();
     if(srcArray==NULL && srcLength!=0) {
         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }
     // Arguments are fine, reset output values.
     info.reset();
     if(srcLength==0) {
-        if(toASCII) {
-            info.errors|=UIDNA_ERROR_EMPTY_LABEL;
-        }
+        info.errors|=UIDNA_ERROR_EMPTY_LABEL;
         dest.Flush();
         return;
     }
     UnicodeString destString;
     int32_t labelStart=0;
     if(srcLength<=256) {  // length of stackArray[]
         // ASCII fastpath
         char stackArray[256];
         int32_t destCapacity;
         char *destArray=dest.GetAppendBuffer(srcLength, srcLength+20,
-                                             stackArray, LENGTHOF(stackArray), &destCapacity);
+                                             stackArray, UPRV_LENGTHOF(stackArray), &destCapacity);
         UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
         int32_t i;
         for(i=0;; ++i) {
             if(i==srcLength) {
                 if(toASCII) {
                     if((i-labelStart)>63) {
                         info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
                     }
                     // There is a trailing dot if labelStart==i.
                     if(!isLabel && i>=254 && (i>254 || labelStart<i)) {
@@ skipping 26 matching lines @@
                         info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
                     }
                     if((i+1)==srcLength || srcArray[i+1]==0x2e) {
                         // label ends with "-"
                         info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
                     }
                 } else if(c==0x2e) {  // dot
                     if(isLabel) {
                         break;  // Replacing with U+FFFD can be complicated for toASCII.
                     }
-                    if(toASCII) {
-                        // Permit an empty label at the end but not elsewhere.
-                        if(i==labelStart && i<(srcLength-1)) {
-                            info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
-                        } else if((i-labelStart)>63) {
-                            info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
-                        }
+                    if(i==labelStart) {
+                        info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
+                    }
+                    if(toASCII && (i-labelStart)>63) {
+                        info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
                     }
                     info.errors|=info.labelErrors;
                     info.labelErrors=0;
                     labelStart=i+1;
                 }
             }
         }
         info.errors|=info.labelErrors;
         // Convert the processed ASCII prefix of the current label to UTF-16.
         int32_t mappingStart=i-labelStart;
@@ skipping 238 matching lines @@
         labelString=&fromPunycode;
         label=fromPunycode.getBuffer();
         labelStart=0;
         labelLength=fromPunycode.length();
     } else {
         wasPunycode=FALSE;
         labelString=&dest;
     }
     // Validity check
     if(labelLength==0) {
-        if(toASCII) {
-            info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
-        }
+        info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
         return replaceLabel(dest, destLabelStart, destLabelLength, *labelString, labelLength);
     }
     // labelLength>0
     if(labelLength>=4 && label[2]==0x2d && label[3]==0x2d) {
         // label starts with "??--"
         info.labelErrors|=UIDNA_ERROR_HYPHEN_3_4;
     }
     if(label[0]==0x2d) {
         // label starts with "-"
         info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
@@ skipping 686 matching lines @@
     }
     StringPiece src(name, length<0 ? uprv_strlen(name) : length);
     CheckedArrayByteSink sink(dest, capacity);
     IDNAInfo info;
     reinterpret_cast<const IDNA *>(idna)->nameToUnicodeUTF8(src, sink, info, *pErrorCode);
     idnaInfoToStruct(info, pInfo);
     return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), pErrorCode);
 }
 
 #endif  // UCONFIG_NO_IDNA