Update ICU to 54.1 step 1

source/i18n/repattrn.cpp

 //
 //  file:  repattrn.cpp
 //
 /*
 ***************************************************************************
-*   Copyright (C) 2002-2012 International Business Machines Corporation   *
+*   Copyright (C) 2002-2013 International Business Machines Corporation   *
 *   and others. All rights reserved.                                      *
 ***************************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
 
 #include "unicode/regex.h"
 #include "unicode/uclean.h"
@@ skipping 251 matching lines @@
 //---------------------------------------------------------------------
 RegexPattern * U_EXPORT2
 RegexPattern::compile(const UnicodeString &regex,
                       uint32_t             flags,
                       UParseError          &pe,
                       UErrorCode           &status)
 {
     if (U_FAILURE(status)) {
         return NULL;
     }
-    
+
     const uint32_t allFlags = UREGEX_CANON_EQ | UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS |
     UREGEX_DOTALL   | UREGEX_MULTILINE        | UREGEX_UWORD |
     UREGEX_ERROR_ON_UNKNOWN_ESCAPES           | UREGEX_UNIX_LINES | UREGEX_LITERAL;
-    
+
     if ((flags & ~allFlags) != 0) {
         status = U_REGEX_INVALID_FLAG;
         return NULL;
     }
-    
+
     if ((flags & UREGEX_CANON_EQ) != 0) {
         status = U_REGEX_UNIMPLEMENTED;
         return NULL;
     }
-    
+
     RegexPattern *This = new RegexPattern;
     if (This == NULL) {
         status = U_MEMORY_ALLOCATION_ERROR;
         return NULL;
     }
     if (U_FAILURE(This->fDeferredStatus)) {
         status = This->fDeferredStatus;
         delete This;
         return NULL;
     }
     This->fFlags = flags;
-    
+
     RegexCompile     compiler(This, status);
     compiler.compile(regex, pe, status);
-    
+
     if (U_FAILURE(status)) {
         delete This;
         This = NULL;
     }
-    
+
     return This;
 }
 
 
 //
 //   compile, UText mode
 //
 RegexPattern * U_EXPORT2
 RegexPattern::compile(UText                *regex,
                       uint32_t             flags,
@@ skipping 25 matching lines @@
     }
     if (U_FAILURE(This->fDeferredStatus)) {
         status = This->fDeferredStatus;
         delete This;
         return NULL;
     }
     This->fFlags = flags;
 
     RegexCompile     compiler(This, status);
     compiler.compile(regex, pe, status);
-    
+
     if (U_FAILURE(status)) {
         delete This;
         This = NULL;
     }
 
     return This;
 }
 
 //
 //   compile with default flags.
@@ skipping 162 matching lines @@
 UnicodeString RegexPattern::pattern() const {
     if (fPatternString != NULL) {
         return *fPatternString;
     } else if (fPattern == NULL) {
         return UnicodeString();
     } else {
         UErrorCode status = U_ZERO_ERROR;
         int64_t nativeLen = utext_nativeLength(fPattern);
         int32_t len16 = utext_extract(fPattern, 0, nativeLen, NULL, 0, &status); // buffer overflow error
         UnicodeString result;
-        
+
         status = U_ZERO_ERROR;
         UChar *resultChars = result.getBuffer(len16);
         utext_extract(fPattern, 0, nativeLen, resultChars, len16, &status); // unterminated warning
         result.releaseBuffer(len16);
-        
+
         return result;
     }
 }
 
 
 
 
 //---------------------------------------------------------------------
 //
 //   patternText
@@ skipping 58 matching lines @@
 }
 
 
 
 //---------------------------------------------------------------------
 //
 //   dump    Output the compiled form of the pattern.
 //           Debugging function only.
 //
 //---------------------------------------------------------------------
+void   RegexPattern::dumpOp(int32_t index) const {
+    (void)index;  // Suppress warnings in non-debug build.
 #if defined(REGEX_DEBUG)
-void   RegexPattern::dumpOp(int32_t index) const {
     static const char * const opNames[] = {URX_OPCODE_NAMES};
     int32_t op          = fCompiledPat->elementAti(index);
     int32_t val         = URX_VAL(op);
     int32_t type        = URX_TYPE(op);
     int32_t pinnedType  = type;
     if ((uint32_t)pinnedType >= sizeof(opNames)/sizeof(char *)) {
         pinnedType = 0;
     }
 
-    REGEX_DUMP_DEBUG_PRINTF(("%4d   %08x    %-15s  ", index, op, opNames[pinnedType]));
+    printf("%4d   %08x    %-15s  ", index, op, opNames[pinnedType]);
     switch (type) {
     case URX_NOP:
     case URX_DOTANY:
     case URX_DOTANY_ALL:
     case URX_FAIL:
     case URX_CARET:
     case URX_DOLLAR:
     case URX_BACKSLASH_G:
     case URX_BACKSLASH_X:
     case URX_END:
@@ skipping 28 matching lines @@
     case URX_LA_END:
     case URX_BACKREF_I:
     case URX_LB_START:
     case URX_LB_CONT:
     case URX_LB_END:
     case URX_LBN_CONT:
     case URX_LBN_END:
     case URX_LOOP_C:
     case URX_LOOP_DOT_I:
         // types with an integer operand field.
-        REGEX_DUMP_DEBUG_PRINTF(("%d", val));
+        printf("%d", val);
         break;
 
     case URX_ONECHAR:
     case URX_ONECHAR_I:
-        REGEX_DUMP_DEBUG_PRINTF(("%c", val<256?val:'?'));
+        printf("%c", val<256?val:'?');
         break;
 
     case URX_STRING:
     case URX_STRING_I:
         {
             int32_t lengthOp       = fCompiledPat->elementAti(index+1);
             U_ASSERT(URX_TYPE(lengthOp) == URX_STRING_LEN);
             int32_t length = URX_VAL(lengthOp);
             int32_t i;
             for (i=val; i<val+length; i++) {
                 UChar c = fLiteralText[i];
                 if (c < 32 || c >= 256) {c = '.';}
-                REGEX_DUMP_DEBUG_PRINTF(("%c", c));
+                printf("%c", c);
             }
         }
         break;
 
     case URX_SETREF:
     case URX_LOOP_SR_I:
         {
             UnicodeString s;
             UnicodeSet *set = (UnicodeSet *)fSets->elementAt(val);
             set->toPattern(s, TRUE);
             for (int32_t i=0; i<s.length(); i++) {
-                REGEX_DUMP_DEBUG_PRINTF(("%c", s.charAt(i)));
+                printf("%c", s.charAt(i));
             }
         }
         break;
 
     case URX_STATIC_SETREF:
     case URX_STAT_SETREF_N:
         {
             UnicodeString s;
             if (val & URX_NEG_SET) {
-                REGEX_DUMP_DEBUG_PRINTF(("NOT "));
+                printf("NOT ");
                 val &= ~URX_NEG_SET;
             }
             UnicodeSet *set = fStaticSets[val];
             set->toPattern(s, TRUE);
             for (int32_t i=0; i<s.length(); i++) {
-                REGEX_DUMP_DEBUG_PRINTF(("%c", s.charAt(i)));
+                printf("%c", s.charAt(i));
             }
         }
         break;
 
 
     default:
-        REGEX_DUMP_DEBUG_PRINTF(("??????"));
+        printf("??????");
         break;
     }
-    REGEX_DUMP_DEBUG_PRINTF(("\n"));
+    printf("\n");
+#endif
 }
-#endif
 
 
+void RegexPattern::dumpPattern() const {
 #if defined(REGEX_DEBUG)
-U_CAPI void  U_EXPORT2
-RegexPatternDump(const RegexPattern *This) {
     int      index;
     int      i;
 
-    REGEX_DUMP_DEBUG_PRINTF(("Original Pattern:  "));
-    UChar32 c = utext_next32From(This->fPattern, 0);
+    printf("Original Pattern:  ");
+    UChar32 c = utext_next32From(fPattern, 0);
     while (c != U_SENTINEL) {
         if (c<32 || c>256) {
             c = '.';
         }
-        REGEX_DUMP_DEBUG_PRINTF(("%c", c));
-        
-        c = UTEXT_NEXT32(This->fPattern);
+        printf("%c", c);
+
+        c = UTEXT_NEXT32(fPattern);
     }
-    REGEX_DUMP_DEBUG_PRINTF(("\n"));
-    REGEX_DUMP_DEBUG_PRINTF(("   Min Match Length:  %d\n", This->fMinMatchLen));
-    REGEX_DUMP_DEBUG_PRINTF(("   Match Start Type:  %s\n", START_OF_MATCH_STR(This->fStartType)));
-    if (This->fStartType == START_STRING) {
-        REGEX_DUMP_DEBUG_PRINTF(("    Initial match string: \""));
-        for (i=This->fInitialStringIdx; i<This->fInitialStringIdx+This->fInitialStringLen; i++) {
-            REGEX_DUMP_DEBUG_PRINTF(("%c", This->fLiteralText[i]));   // TODO:  non-printables, surrogates.
+    printf("\n");
+    printf("   Min Match Length:  %d\n", fMinMatchLen);
+    printf("   Match Start Type:  %s\n", START_OF_MATCH_STR(fStartType));
+    if (fStartType == START_STRING) {
+        printf("    Initial match string: \"");
+        for (i=fInitialStringIdx; i<fInitialStringIdx+fInitialStringLen; i++) {
+            printf("%c", fLiteralText[i]);   // TODO:  non-printables, surrogates.
         }
-        REGEX_DUMP_DEBUG_PRINTF(("\"\n"));
+        printf("\"\n");
 
-    } else if (This->fStartType == START_SET) {
-        int32_t numSetChars = This->fInitialChars->size();
+    } else if (fStartType == START_SET) {
+        int32_t numSetChars = fInitialChars->size();
         if (numSetChars > 20) {
             numSetChars = 20;
         }
-        REGEX_DUMP_DEBUG_PRINTF(("     Match First Chars : "));
+        printf("     Match First Chars : ");
         for (i=0; i<numSetChars; i++) {
-            UChar32 c = This->fInitialChars->charAt(i);
+            UChar32 c = fInitialChars->charAt(i);
             if (0x20<c && c <0x7e) {
-                REGEX_DUMP_DEBUG_PRINTF(("%c ", c));
+                printf("%c ", c);
             } else {
-                REGEX_DUMP_DEBUG_PRINTF(("%#x ", c));
+                printf("%#x ", c);
             }
         }
-        if (numSetChars < This->fInitialChars->size()) {
-            REGEX_DUMP_DEBUG_PRINTF((" ..."));
+        if (numSetChars < fInitialChars->size()) {
+            printf(" ...");
         }
-        REGEX_DUMP_DEBUG_PRINTF(("\n"));
+        printf("\n");
 
-    } else if (This->fStartType == START_CHAR) {
-        REGEX_DUMP_DEBUG_PRINTF(("    First char of Match : "));
-        if (0x20 < This->fInitialChar && This->fInitialChar<0x7e) {
-                REGEX_DUMP_DEBUG_PRINTF(("%c\n", This->fInitialChar));
+    } else if (fStartType == START_CHAR) {
+        printf("    First char of Match : ");
+        if (0x20 < fInitialChar && fInitialChar<0x7e) {
+                printf("%c\n", fInitialChar);
             } else {
-                REGEX_DUMP_DEBUG_PRINTF(("%#x\n", This->fInitialChar));
+                printf("%#x\n", fInitialChar);
             }
     }
 
-    REGEX_DUMP_DEBUG_PRINTF(("\nIndex   Binary     Type             Operand\n" \
-           "-------------------------------------------\n"));
-    for (index = 0; index<This->fCompiledPat->size(); index++) {
-        This->dumpOp(index);
+    printf("\nIndex   Binary     Type             Operand\n" \
+           "-------------------------------------------\n");
+    for (index = 0; index<fCompiledPat->size(); index++) {
+        dumpOp(index);
     }
-    REGEX_DUMP_DEBUG_PRINTF(("\n\n"));
+    printf("\n\n");
+#endif
 }
-#endif
 
 
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RegexPattern)
 
 U_NAMESPACE_END
 #endif  // !UCONFIG_NO_REGULAR_EXPRESSIONS