ICU 56 update step 1

source/i18n/repattrn.cpp

 //
 //  file:  repattrn.cpp
 //
 /*
 ***************************************************************************
-*   Copyright (C) 2002-2013 International Business Machines Corporation   *
+*   Copyright (C) 2002-2015 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"
 #include "uassert.h"
+#include "uhash.h"
 #include "uvector.h"
 #include "uvectr32.h"
 #include "uvectr64.h"
 #include "regexcmp.h"
 #include "regeximp.h"
 #include "regexst.h"
 
 U_NAMESPACE_BEGIN
 
 //--------------------------------------------------------------------------
@@ skipping 31 matching lines @@
         return *this;
     }
 
     // Clean out any previous contents of object being assigned to.
     zap();
 
     // Give target object a default initialization
     init();
 
     // Copy simple fields
-    if ( other.fPatternString == NULL ) {
+    fDeferredStatus   = other.fDeferredStatus;
+
+    if (U_FAILURE(fDeferredStatus)) {
+        return *this;
+    }
+
+    if (other.fPatternString == NULL) {
         fPatternString = NULL;
-        fPattern      = utext_clone(fPattern, other.fPattern, FALSE, TRUE, &fDeferredStatus);
+        fPattern = utext_clone(fPattern, other.fPattern, FALSE, TRUE, &fDeferredStatus);
     } else {
         fPatternString = new UnicodeString(*(other.fPatternString));
-        UErrorCode status = U_ZERO_ERROR;
-        fPattern      = utext_openConstUnicodeString(NULL, fPatternString, &status);
-        if (U_FAILURE(status)) {
+        if (fPatternString == NULL) {
             fDeferredStatus = U_MEMORY_ALLOCATION_ERROR;
-            return *this;
+        } else {
+            fPattern = utext_openConstUnicodeString(NULL, fPatternString, &fDeferredStatus);
         }
     }
+    if (U_FAILURE(fDeferredStatus)) {
+        return *this;
+    }
+
     fFlags            = other.fFlags;
     fLiteralText      = other.fLiteralText;
-    fDeferredStatus   = other.fDeferredStatus;
     fMinMatchLen      = other.fMinMatchLen;
     fFrameSize        = other.fFrameSize;
     fDataSize         = other.fDataSize;
-    fMaxCaptureDigits = other.fMaxCaptureDigits;
     fStaticSets       = other.fStaticSets;
     fStaticSets8      = other.fStaticSets8;
 
     fStartType        = other.fStartType;
     fInitialStringIdx = other.fInitialStringIdx;
     fInitialStringLen = other.fInitialStringLen;
     *fInitialChars    = *other.fInitialChars;
     fInitialChar      = other.fInitialChar;
     *fInitialChars8   = *other.fInitialChars8;
     fNeedsAltInput    = other.fNeedsAltInput;
@@ skipping 20 matching lines @@
         UnicodeSet *sourceSet = (UnicodeSet *)other.fSets->elementAt(i);
         UnicodeSet *newSet    = new UnicodeSet(*sourceSet);
         if (newSet == NULL) {
             fDeferredStatus = U_MEMORY_ALLOCATION_ERROR;
             break;
         }
         fSets->addElement(newSet, fDeferredStatus);
         fSets8[i] = other.fSets8[i];
     }
 
+    // Copy the named capture group hash map.
+    int32_t hashPos = UHASH_FIRST;
+    while (const UHashElement *hashEl = uhash_nextElement(other.fNamedCaptureMap, &hashPos)) {
+        if (U_FAILURE(fDeferredStatus)) {
+            break;
+        }
+        const UnicodeString *name = (const UnicodeString *)hashEl->key.pointer;
+        UnicodeString *key = new UnicodeString(*name);
+        int32_t val = hashEl->value.integer;
+        if (key == NULL) {
+            fDeferredStatus = U_MEMORY_ALLOCATION_ERROR;
+        } else {
+            uhash_puti(fNamedCaptureMap, key, val, &fDeferredStatus);
+        }
+    }
     return *this;
 }
 
 
 //--------------------------------------------------------------------------
 //
 //    init        Shared initialization for use by constructors.
 //                Bring an uninitialized RegexPattern up to a default state.
 //
 //--------------------------------------------------------------------------
 void RegexPattern::init() {
     fFlags            = 0;
     fCompiledPat      = 0;
     fLiteralText.remove();
     fSets             = NULL;
     fSets8            = NULL;
     fDeferredStatus   = U_ZERO_ERROR;
     fMinMatchLen      = 0;
     fFrameSize        = 0;
     fDataSize         = 0;
     fGroupMap         = NULL;
-    fMaxCaptureDigits = 1;
     fStaticSets       = NULL;
     fStaticSets8      = NULL;
     fStartType        = START_NO_INFO;
     fInitialStringIdx = 0;
     fInitialStringLen = 0;
     fInitialChars     = NULL;
     fInitialChar      = 0;
     fInitialChars8    = NULL;
     fNeedsAltInput    = FALSE;
+    fNamedCaptureMap  = NULL;
 
     fPattern          = NULL; // will be set later
     fPatternString    = NULL; // may be set later
     fCompiledPat      = new UVector64(fDeferredStatus);
     fGroupMap         = new UVector32(fDeferredStatus);
     fSets             = new UVector(fDeferredStatus);
     fInitialChars     = new UnicodeSet;
     fInitialChars8    = new Regex8BitSet;
+    fNamedCaptureMap  = uhash_open(uhash_hashUnicodeString,     // Key hash function
+                                   uhash_compareUnicodeString,  // Key comparator function
+                                   uhash_compareLong,           // Value comparator function
+                                   &fDeferredStatus);
     if (U_FAILURE(fDeferredStatus)) {
         return;
     }
     if (fCompiledPat == NULL  || fGroupMap == NULL || fSets == NULL ||
-        fInitialChars == NULL || fInitialChars8 == NULL) {
+            fInitialChars == NULL || fInitialChars8 == NULL || fNamedCaptureMap == NULL) {
         fDeferredStatus = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
 
     // Slot zero of the vector of sets is reserved.  Fill it here.
     fSets->addElement((int32_t)0, fDeferredStatus);
+
+    // fNamedCaptureMap owns its key strings, type (UnicodeString *)
+    uhash_setKeyDeleter(fNamedCaptureMap, uprv_deleteUObject);
 }
 
 
 //--------------------------------------------------------------------------
 //
 //   zap            Delete everything owned by this RegexPattern.
 //
 //--------------------------------------------------------------------------
 void RegexPattern::zap() {
     delete fCompiledPat;
@@ skipping 17 matching lines @@
     delete fInitialChars8;
     fInitialChars8 = NULL;
     if (fPattern != NULL) {
         utext_close(fPattern);
         fPattern = NULL;
     }
     if (fPatternString != NULL) {
         delete fPatternString;
         fPatternString = NULL;
     }
+    uhash_close(fNamedCaptureMap);
+    fNamedCaptureMap = NULL;
 }
 
 
 //--------------------------------------------------------------------------
 //
 //   Destructor
 //
 //--------------------------------------------------------------------------
 RegexPattern::~RegexPattern() {
     zap();
@@ skipping 337 matching lines @@
 
     if (fPattern != NULL) {
         return fPattern;
     } else {
         RegexStaticSets::initGlobals(&status);
         return RegexStaticSets::gStaticSets->fEmptyText;
     }
 }
 
 
+//--------------------------------------------------------------------------------
+//
+//  groupNumberFromName()
+//
+//--------------------------------------------------------------------------------
+int32_t RegexPattern::groupNumberFromName(const UnicodeString &groupName, UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return 0;
+    }
+
+    // No need to explicitly check for syntactically valid names.
+    // Invalid ones will never be in the map, and the lookup will fail.
+
+    int32_t number = uhash_geti(fNamedCaptureMap, &groupName);
+    if (number == 0) {
+        status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
+    }
+    return number;
+}
+
+int32_t RegexPattern::groupNumberFromName(const char *groupName, int32_t nameLength, UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return 0;
+    }
+    UnicodeString name(groupName, nameLength, US_INV);
+    return groupNumberFromName(name, status);
+}
+
 
 //---------------------------------------------------------------------
 //
 //   split
 //
 //---------------------------------------------------------------------
 int32_t  RegexPattern::split(const UnicodeString &input,
         UnicodeString    dest[],
         int32_t          destCapacity,
         UErrorCode      &status) const
@@ skipping 93 matching lines @@
     case URX_LA_START:
     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:
+    case URX_BACKSLASH_H:
+    case URX_BACKSLASH_R:
+    case URX_BACKSLASH_V:
         // types with an integer operand field.
         printf("%d", val);
         break;
 
     case URX_ONECHAR:
     case URX_ONECHAR_I:
         printf("%c", val<256?val:'?');
         break;
 
     case URX_STRING:
@@ skipping 44 matching lines @@
         printf("??????");
         break;
     }
     printf("\n");
 #endif
 }
 
 
 void RegexPattern::dumpPattern() const {
 #if defined(REGEX_DEBUG)
+    // TODO: This function assumes an ASCII based charset.
     int      index;
     int      i;
 
     printf("Original Pattern:  ");
     UChar32 c = utext_next32From(fPattern, 0);
     while (c != U_SENTINEL) {
         if (c<32 || c>256) {
             c = '.';
         }
         printf("%c", c);
@@ skipping 31 matching lines @@
 
     } else if (fStartType == START_CHAR) {
         printf("    First char of Match : ");
         if (0x20 < fInitialChar && fInitialChar<0x7e) {
                 printf("%c\n", fInitialChar);
             } else {
                 printf("%#x\n", fInitialChar);
             }
     }
 
+    printf("Named Capture Groups:\n");
+    if (uhash_count(fNamedCaptureMap) == 0) {
+        printf("   None\n");
+    } else {
+        int32_t pos = UHASH_FIRST;
+        const UHashElement *el = NULL;
+        while ((el = uhash_nextElement(fNamedCaptureMap, &pos))) {
+            const UnicodeString *name = (const UnicodeString *)el->key.pointer;
+            char s[100];
+            name->extract(0, 99, s, sizeof(s), US_INV);  // capture group names are invariant.
+            int32_t number = el->value.integer;
+            printf("   %d\t%s\n", number, s);
+        }
+    }
+
     printf("\nIndex   Binary     Type             Operand\n" \
            "-------------------------------------------\n");
     for (index = 0; index<fCompiledPat->size(); index++) {
         dumpOp(index);
     }
     printf("\n\n");
 #endif
 }
 
 
 
 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RegexPattern)
 
 U_NAMESPACE_END
 #endif  // !UCONFIG_NO_REGULAR_EXPRESSIONS