ICU-66108.tar.gz

[apple/icu.git] / icuSources / i18n / uregex.cpp

diff --git a/icuSources/i18n/uregex.cpp b/icuSources/i18n/uregex.cpp
index 8618baa936c9b1558f870ffe3cc57474dd9c3919..7f41918cff93a458f220ecf7d1332b35f61aa79a 100644 (file)
--- a/icuSources/i18n/uregex.cpp
+++ b/icuSources/i18n/uregex.cpp
@@ -1,9 +1,11 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /*
 *******************************************************************************
 /*
 *******************************************************************************

-*   Copyright (C) 2004-2011, International Business Machines
+*   Copyright (C) 2004-2015, International Business Machines

 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************

-*   file name:  regex.cpp
+*   file name:  uregex.cpp

 */
 
 #include "unicode/utypes.h"
 */
 
 #include "unicode/utypes.h"


@@ -17,14 +19,14 @@
 #include "unicode/uchar.h"
 #include "unicode/uobject.h"
 #include "unicode/utf16.h"
 #include "unicode/uchar.h"
 #include "unicode/uobject.h"
 #include "unicode/utf16.h"

-#include "umutex.h"
-#include "uassert.h"

 #include "cmemory.h"
 #include "cmemory.h"

+#include "uassert.h"
+#include "uhash.h"
+#include "umutex.h"
+#include "uvectr32.h"

 
 #include "regextxt.h"
 
 
 #include "regextxt.h"
 

-#include <stdio.h>
-

 U_NAMESPACE_BEGIN
 
 #define REMAINING_CAPACITY(idx,len) ((((len)-(idx))>0)?((len)-(idx)):0)
 U_NAMESPACE_BEGIN
 
 #define REMAINING_CAPACITY(idx,len) ((((len)-(idx))>0)?((len)-(idx)):0)


@@ -35,7 +37,7 @@ public:
     ~RegularExpression();
     int32_t           fMagic;
     RegexPattern     *fPat;
     ~RegularExpression();
     int32_t           fMagic;
     RegexPattern     *fPat;

-    int32_t          *fPatRefCount;
+    u_atomic_int32_t *fPatRefCount;

     UChar            *fPatString;
     int32_t           fPatStringLen;
     RegexMatcher     *fMatcher;
     UChar            *fPatString;
     int32_t           fPatStringLen;
     RegexMatcher     *fMatcher;


@@ -65,7 +67,7 @@ RegularExpression::~RegularExpression() {
     if (fPatRefCount!=NULL && umtx_atomic_dec(fPatRefCount)==0) {
         delete fPat;
         uprv_free(fPatString);
     if (fPatRefCount!=NULL && umtx_atomic_dec(fPatRefCount)==0) {
         delete fPat;
         uprv_free(fPatString);

-        uprv_free(fPatRefCount);
+        uprv_free((void *)fPatRefCount);

     }
     if (fOwnsText && fText!=NULL) {
         uprv_free((void *)fText);
     }
     if (fOwnsText && fText!=NULL) {
         uprv_free((void *)fText);


@@ -122,13 +124,13 @@ uregex_open( const  UChar          *pattern,
         actualPatLen = u_strlen(pattern);
     }
 
         actualPatLen = u_strlen(pattern);
     }
 

-    RegularExpression *re     = new RegularExpression;
-    int32_t            *refC   = (int32_t *)uprv_malloc(sizeof(int32_t));
+    RegularExpression  *re     = new RegularExpression;
+    u_atomic_int32_t   *refC   = (u_atomic_int32_t *)uprv_malloc(sizeof(int32_t));

     UChar              *patBuf = (UChar *)uprv_malloc(sizeof(UChar)*(actualPatLen+1));
     if (re == NULL || refC == NULL || patBuf == NULL) {
         *status = U_MEMORY_ALLOCATION_ERROR;
         delete re;
     UChar              *patBuf = (UChar *)uprv_malloc(sizeof(UChar)*(actualPatLen+1));
     if (re == NULL || refC == NULL || patBuf == NULL) {
         *status = U_MEMORY_ALLOCATION_ERROR;
         delete re;

-        uprv_free(refC);
+        uprv_free((void *)refC);

         uprv_free(patBuf);
         return NULL;
     }
         uprv_free(patBuf);
         return NULL;
     }


@@ -144,7 +146,7 @@ uregex_open( const  UChar          *pattern,
     re->fPatStringLen = patternLength;
     u_memcpy(patBuf, pattern, actualPatLen);
     patBuf[actualPatLen] = 0;
     re->fPatStringLen = patternLength;
     u_memcpy(patBuf, pattern, actualPatLen);
     patBuf[actualPatLen] = 0;

-    
+

     UText patText = UTEXT_INITIALIZER;
     utext_openUChars(&patText, patBuf, patternLength, status);
 
     UText patText = UTEXT_INITIALIZER;
     utext_openUChars(&patText, patBuf, patternLength, status);
 


@@ -157,7 +159,7 @@ uregex_open( const  UChar          *pattern,
         re->fPat = RegexPattern::compile(&patText, flags, *status);
     }
     utext_close(&patText);
         re->fPat = RegexPattern::compile(&patText, flags, *status);
     }
     utext_close(&patText);

-    
+

     if (U_FAILURE(*status)) {
         goto ErrorExit;
     }
     if (U_FAILURE(*status)) {
         goto ErrorExit;
     }


@@ -186,7 +188,7 @@ uregex_openUText(UText          *pattern,
                  uint32_t        flags,
                  UParseError    *pe,
                  UErrorCode     *status) {
                  uint32_t        flags,
                  UParseError    *pe,
                  UErrorCode     *status) {

-    
+

     if (U_FAILURE(*status)) {
         return NULL;
     }
     if (U_FAILURE(*status)) {
         return NULL;
     }


@@ -194,31 +196,31 @@ uregex_openUText(UText          *pattern,
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }

-    
+

     int64_t patternNativeLength = utext_nativeLength(pattern);
     int64_t patternNativeLength = utext_nativeLength(pattern);

-    
+

     if (patternNativeLength == 0) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }
     if (patternNativeLength == 0) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return NULL;
     }

-    
+

     RegularExpression *re     = new RegularExpression;
     RegularExpression *re     = new RegularExpression;

-    
+

     UErrorCode lengthStatus = U_ZERO_ERROR;
     int32_t pattern16Length = utext_extract(pattern, 0, patternNativeLength, NULL, 0, &lengthStatus);
     UErrorCode lengthStatus = U_ZERO_ERROR;
     int32_t pattern16Length = utext_extract(pattern, 0, patternNativeLength, NULL, 0, &lengthStatus);

-    
-    int32_t            *refC   = (int32_t *)uprv_malloc(sizeof(int32_t));
+
+    u_atomic_int32_t   *refC   = (u_atomic_int32_t *)uprv_malloc(sizeof(int32_t));

     UChar              *patBuf = (UChar *)uprv_malloc(sizeof(UChar)*(pattern16Length+1));
     if (re == NULL || refC == NULL || patBuf == NULL) {
         *status = U_MEMORY_ALLOCATION_ERROR;
         delete re;
     UChar              *patBuf = (UChar *)uprv_malloc(sizeof(UChar)*(pattern16Length+1));
     if (re == NULL || refC == NULL || patBuf == NULL) {
         *status = U_MEMORY_ALLOCATION_ERROR;
         delete re;

-        uprv_free(refC);
+        uprv_free((void *)refC);

         uprv_free(patBuf);
         return NULL;
     }
     re->fPatRefCount = refC;
     *re->fPatRefCount = 1;
         uprv_free(patBuf);
         return NULL;
     }
     re->fPatRefCount = refC;
     *re->fPatRefCount = 1;

-    
+

     //
     // Make a copy of the pattern string, so we can return it later if asked.
     //    For compiling the pattern, we will use a read-only UText wrapper
     //
     // Make a copy of the pattern string, so we can return it later if asked.
     //    For compiling the pattern, we will use a read-only UText wrapper


@@ -227,10 +229,10 @@ uregex_openUText(UText          *pattern,
     re->fPatString    = patBuf;
     re->fPatStringLen = pattern16Length;
     utext_extract(pattern, 0, patternNativeLength, patBuf, pattern16Length+1, status);
     re->fPatString    = patBuf;
     re->fPatStringLen = pattern16Length;
     utext_extract(pattern, 0, patternNativeLength, patBuf, pattern16Length+1, status);

-    
+

     UText patText = UTEXT_INITIALIZER;
     utext_openUChars(&patText, patBuf, pattern16Length, status);
     UText patText = UTEXT_INITIALIZER;
     utext_openUChars(&patText, patBuf, pattern16Length, status);

-    
+

     //
     // Compile the pattern
     //
     //
     // Compile the pattern
     //


@@ -240,11 +242,11 @@ uregex_openUText(UText          *pattern,
         re->fPat = RegexPattern::compile(&patText, flags, *status);
     }
     utext_close(&patText);
         re->fPat = RegexPattern::compile(&patText, flags, *status);
     }
     utext_close(&patText);

-    
+

     if (U_FAILURE(*status)) {
         goto ErrorExit;
     }
     if (U_FAILURE(*status)) {
         goto ErrorExit;
     }

-    
+

     //
     // Create the matcher object
     //
     //
     // Create the matcher object
     //


@@ -252,11 +254,11 @@ uregex_openUText(UText          *pattern,
     if (U_SUCCESS(*status)) {
         return (URegularExpression*)re;
     }
     if (U_SUCCESS(*status)) {
         return (URegularExpression*)re;
     }

-    
+

 ErrorExit:
     delete re;
     return NULL;
 ErrorExit:
     delete re;
     return NULL;

-    
+

 }
 
 //----------------------------------------------------------------------------------------
 }
 
 //----------------------------------------------------------------------------------------


@@ -280,7 +282,7 @@ uregex_close(URegularExpression  *re2) {
 //    uregex_clone
 //
 //----------------------------------------------------------------------------------------
 //    uregex_clone
 //
 //----------------------------------------------------------------------------------------

-U_CAPI URegularExpression * U_EXPORT2 
+U_CAPI URegularExpression * U_EXPORT2

 uregex_clone(const URegularExpression *source2, UErrorCode *status)  {
     RegularExpression *source = (RegularExpression*)source2;
     if (validateRE(source, FALSE, status) == FALSE) {
 uregex_clone(const URegularExpression *source2, UErrorCode *status)  {
     RegularExpression *source = (RegularExpression*)source2;
     if (validateRE(source, FALSE, status) == FALSE) {


@@ -300,7 +302,7 @@ uregex_clone(const URegularExpression *source2, UErrorCode *status)  {
     }
 
     clone->fPat          = source->fPat;
     }
 
     clone->fPat          = source->fPat;

-    clone->fPatRefCount  = source->fPatRefCount; 
+    clone->fPatRefCount  = source->fPatRefCount;

     clone->fPatString    = source->fPatString;
     clone->fPatStringLen = source->fPatStringLen;
     umtx_atomic_inc(source->fPatRefCount);
     clone->fPatString    = source->fPatString;
     clone->fPatStringLen = source->fPatStringLen;
     umtx_atomic_inc(source->fPatRefCount);


@@ -317,12 +319,12 @@ uregex_clone(const URegularExpression *source2, UErrorCode *status)  {
 //    uregex_pattern
 //
 //------------------------------------------------------------------------------
 //    uregex_pattern
 //
 //------------------------------------------------------------------------------

-U_CAPI const UChar * U_EXPORT2 
+U_CAPI const UChar * U_EXPORT2

 uregex_pattern(const  URegularExpression *regexp2,
                       int32_t            *patLength,
                       UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_pattern(const  URegularExpression *regexp2,
                       int32_t            *patLength,
                       UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;

-    
+

     if (validateRE(regexp, FALSE, status) == FALSE) {
         return NULL;
     }
     if (validateRE(regexp, FALSE, status) == FALSE) {
         return NULL;
     }


@@ -351,7 +353,7 @@ uregex_patternUText(const URegularExpression *regexp2,
 //    uregex_flags
 //
 //------------------------------------------------------------------------------
 //    uregex_flags
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_flags(const URegularExpression *regexp2, UErrorCode *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
     if (validateRE(regexp, FALSE, status) == FALSE) {
 uregex_flags(const URegularExpression *regexp2, UErrorCode *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
     if (validateRE(regexp, FALSE, status) == FALSE) {


@@ -367,7 +369,7 @@ uregex_flags(const URegularExpression *regexp2, UErrorCode *status)  {
 //    uregex_setText
 //
 //------------------------------------------------------------------------------
 //    uregex_setText
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_setText(URegularExpression *regexp2,
                const UChar        *text,
                int32_t             textLength,
 uregex_setText(URegularExpression *regexp2,
                const UChar        *text,
                int32_t             textLength,


@@ -380,15 +382,15 @@ uregex_setText(URegularExpression *regexp2,
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }

-    
+

     if (regexp->fOwnsText && regexp->fText != NULL) {
         uprv_free((void *)regexp->fText);
     }
     if (regexp->fOwnsText && regexp->fText != NULL) {
         uprv_free((void *)regexp->fText);
     }

-    
+

     regexp->fText       = text;
     regexp->fTextLength = textLength;
     regexp->fOwnsText   = FALSE;
     regexp->fText       = text;
     regexp->fTextLength = textLength;
     regexp->fOwnsText   = FALSE;

-    
+

     UText input = UTEXT_INITIALIZER;
     utext_openUChars(&input, text, textLength, status);
     regexp->fMatcher->reset(&input);
     UText input = UTEXT_INITIALIZER;
     utext_openUChars(&input, text, textLength, status);
     regexp->fMatcher->reset(&input);


@@ -401,7 +403,7 @@ uregex_setText(URegularExpression *regexp2,
 //    uregex_setUText
 //
 //------------------------------------------------------------------------------
 //    uregex_setUText
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_setUText(URegularExpression *regexp2,
                 UText              *text,
                 UErrorCode         *status) {
 uregex_setUText(URegularExpression *regexp2,
                 UText              *text,
                 UErrorCode         *status) {


@@ -413,11 +415,11 @@ uregex_setUText(URegularExpression *regexp2,
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }

-    
+

     if (regexp->fOwnsText && regexp->fText != NULL) {
         uprv_free((void *)regexp->fText);
     }
     if (regexp->fOwnsText && regexp->fText != NULL) {
         uprv_free((void *)regexp->fText);
     }

-    
+

     regexp->fText       = NULL; // only fill it in on request
     regexp->fTextLength = -1;
     regexp->fOwnsText   = TRUE;
     regexp->fText       = NULL; // only fill it in on request
     regexp->fTextLength = -1;
     regexp->fOwnsText   = TRUE;


@@ -431,7 +433,7 @@ uregex_setUText(URegularExpression *regexp2,
 //    uregex_getText
 //
 //------------------------------------------------------------------------------
 //    uregex_getText
 //
 //------------------------------------------------------------------------------

-U_CAPI const UChar * U_EXPORT2 
+U_CAPI const UChar * U_EXPORT2

 uregex_getText(URegularExpression *regexp2,
                int32_t            *textLength,
                UErrorCode         *status)  {
 uregex_getText(URegularExpression *regexp2,
                int32_t            *textLength,
                UErrorCode         *status)  {


@@ -439,7 +441,7 @@ uregex_getText(URegularExpression *regexp2,
     if (validateRE(regexp, FALSE, status) == FALSE) {
         return NULL;
     }
     if (validateRE(regexp, FALSE, status) == FALSE) {
         return NULL;
     }

-    
+

     if (regexp->fText == NULL) {
         // need to fill in the text
         UText *inputText = regexp->fMatcher->inputText();
     if (regexp->fText == NULL) {
         // need to fill in the text
         UText *inputText = regexp->fMatcher->inputText();


@@ -452,13 +454,13 @@ uregex_getText(URegularExpression *regexp2,
             UErrorCode lengthStatus = U_ZERO_ERROR;
             regexp->fTextLength = utext_extract(inputText, 0, inputNativeLength, NULL, 0, &lengthStatus); // buffer overflow error
             UChar *inputChars = (UChar *)uprv_malloc(sizeof(UChar)*(regexp->fTextLength+1));
             UErrorCode lengthStatus = U_ZERO_ERROR;
             regexp->fTextLength = utext_extract(inputText, 0, inputNativeLength, NULL, 0, &lengthStatus); // buffer overflow error
             UChar *inputChars = (UChar *)uprv_malloc(sizeof(UChar)*(regexp->fTextLength+1));

-            
+

             utext_extract(inputText, 0, inputNativeLength, inputChars, regexp->fTextLength+1, status);
             regexp->fText = inputChars;
             regexp->fOwnsText = TRUE; // should already be set but just in case
         }
     }
             utext_extract(inputText, 0, inputNativeLength, inputChars, regexp->fTextLength+1, status);
             regexp->fText = inputChars;
             regexp->fOwnsText = TRUE; // should already be set but just in case
         }
     }

-    
+

     if (textLength != NULL) {
         *textLength = regexp->fTextLength;
     }
     if (textLength != NULL) {
         *textLength = regexp->fTextLength;
     }


@@ -471,7 +473,7 @@ uregex_getText(URegularExpression *regexp2,
 //    uregex_getUText
 //
 //------------------------------------------------------------------------------
 //    uregex_getUText
 //
 //------------------------------------------------------------------------------

-U_CAPI UText * U_EXPORT2 
+U_CAPI UText * U_EXPORT2

 uregex_getUText(URegularExpression *regexp2,
                 UText              *dest,
                 UErrorCode         *status)  {
 uregex_getUText(URegularExpression *regexp2,
                 UText              *dest,
                 UErrorCode         *status)  {


@@ -488,7 +490,7 @@ uregex_getUText(URegularExpression *regexp2,
 //    uregex_refreshUText
 //
 //------------------------------------------------------------------------------
 //    uregex_refreshUText
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_refreshUText(URegularExpression *regexp2,
                     UText              *text,
                     UErrorCode         *status) {
 uregex_refreshUText(URegularExpression *regexp2,
                     UText              *text,
                     UErrorCode         *status) {


@@ -505,14 +507,14 @@ uregex_refreshUText(URegularExpression *regexp2,
 //    uregex_matches
 //
 //------------------------------------------------------------------------------
 //    uregex_matches
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_matches(URegularExpression *regexp2,
                int32_t            startIndex,
                UErrorCode        *status)  {
     return uregex_matches64( regexp2, (int64_t)startIndex, status);
 }
 
 uregex_matches(URegularExpression *regexp2,
                int32_t            startIndex,
                UErrorCode        *status)  {
     return uregex_matches64( regexp2, (int64_t)startIndex, status);
 }
 

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_matches64(URegularExpression *regexp2,
                  int64_t            startIndex,
                  UErrorCode        *status)  {
 uregex_matches64(URegularExpression *regexp2,
                  int64_t            startIndex,
                  UErrorCode        *status)  {


@@ -535,14 +537,14 @@ uregex_matches64(URegularExpression *regexp2,
 //    uregex_lookingAt
 //
 //------------------------------------------------------------------------------
 //    uregex_lookingAt
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_lookingAt(URegularExpression *regexp2,
                  int32_t             startIndex,
                  UErrorCode         *status)  {
     return uregex_lookingAt64( regexp2, (int64_t)startIndex, status);
 }
 
 uregex_lookingAt(URegularExpression *regexp2,
                  int32_t             startIndex,
                  UErrorCode         *status)  {
     return uregex_lookingAt64( regexp2, (int64_t)startIndex, status);
 }
 

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_lookingAt64(URegularExpression *regexp2,
                    int64_t             startIndex,
                    UErrorCode         *status)  {
 uregex_lookingAt64(URegularExpression *regexp2,
                    int64_t             startIndex,
                    UErrorCode         *status)  {


@@ -566,16 +568,16 @@ uregex_lookingAt64(URegularExpression *regexp2,
 //    uregex_find
 //
 //------------------------------------------------------------------------------
 //    uregex_find
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_find(URegularExpression *regexp2,
 uregex_find(URegularExpression *regexp2,

-            int32_t             startIndex, 
+            int32_t             startIndex,

             UErrorCode         *status)  {
     return uregex_find64( regexp2, (int64_t)startIndex, status);
 }
 
             UErrorCode         *status)  {
     return uregex_find64( regexp2, (int64_t)startIndex, status);
 }
 

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_find64(URegularExpression *regexp2,
 uregex_find64(URegularExpression *regexp2,

-              int64_t             startIndex, 
+              int64_t             startIndex,

               UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
     UBool result = FALSE;
               UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
     UBool result = FALSE;


@@ -584,7 +586,7 @@ uregex_find64(URegularExpression *regexp2,
     }
     if (startIndex == -1) {
         regexp->fMatcher->resetPreserveRegion();
     }
     if (startIndex == -1) {
         regexp->fMatcher->resetPreserveRegion();

-        result = regexp->fMatcher->find();
+        result = regexp->fMatcher->find(*status);

     } else {
         result = regexp->fMatcher->find(startIndex, *status);
     }
     } else {
         result = regexp->fMatcher->find(startIndex, *status);
     }


@@ -597,14 +599,14 @@ uregex_find64(URegularExpression *regexp2,
 //    uregex_findNext
 //
 //------------------------------------------------------------------------------
 //    uregex_findNext
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_findNext(URegularExpression *regexp2,
                 UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return FALSE;
     }
 uregex_findNext(URegularExpression *regexp2,
                 UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return FALSE;
     }

-    UBool result = regexp->fMatcher->find();
+    UBool result = regexp->fMatcher->find(*status);

     return result;
 }
 
     return result;
 }
 


@@ -613,7 +615,7 @@ uregex_findNext(URegularExpression *regexp2,
 //    uregex_groupCount
 //
 //------------------------------------------------------------------------------
 //    uregex_groupCount
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_groupCount(URegularExpression *regexp2,
                   UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_groupCount(URegularExpression *regexp2,
                   UErrorCode         *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;


@@ -625,12 +627,42 @@ uregex_groupCount(URegularExpression *regexp2,
 }
 
 
 }
 
 

+//------------------------------------------------------------------------------
+//
+//    uregex_groupNumberFromName
+//
+//------------------------------------------------------------------------------
+int32_t
+uregex_groupNumberFromName(URegularExpression *regexp2,
+                           const UChar        *groupName,
+                           int32_t             nameLength,
+                           UErrorCode          *status) {
+    RegularExpression *regexp = (RegularExpression*)regexp2;
+    if (validateRE(regexp, FALSE, status) == FALSE) {
+        return 0;
+    }
+    int32_t  result = regexp->fPat->groupNumberFromName(UnicodeString(groupName, nameLength), *status);
+    return result;
+}
+
+int32_t
+uregex_groupNumberFromCName(URegularExpression *regexp2,
+                            const char         *groupName,
+                            int32_t             nameLength,
+                            UErrorCode          *status) {
+    RegularExpression *regexp = (RegularExpression*)regexp2;
+    if (validateRE(regexp, FALSE, status) == FALSE) {
+        return 0;
+    }
+    return regexp->fPat->groupNumberFromName(groupName, nameLength, *status);
+}
+

 //------------------------------------------------------------------------------
 //
 //    uregex_group
 //
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------------------
 //
 //    uregex_group
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_group(URegularExpression *regexp2,
              int32_t             groupNum,
              UChar              *dest,
 uregex_group(URegularExpression *regexp2,
              int32_t             groupNum,
              UChar              *dest,


@@ -644,11 +676,11 @@ uregex_group(URegularExpression *regexp2,
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }

-    
+

     if (destCapacity == 0 || regexp->fText != NULL) {
         // If preflighting or if we already have the text as UChars,
     if (destCapacity == 0 || regexp->fText != NULL) {
         // If preflighting or if we already have the text as UChars,

-        // this is a little cheaper than going through uregex_groupUTextDeep()
-        
+        // this is a little cheaper than extracting from the UText
+

         //
         // Pick up the range of characters from the matcher
         //
         //
         // Pick up the range of characters from the matcher
         //


@@ -660,7 +692,7 @@ uregex_group(URegularExpression *regexp2,
 
         //
         // Trim length based on buffer capacity
 
         //
         // Trim length based on buffer capacity

-        // 
+        //

         int32_t fullLength = endIx - startIx;
         int32_t copyLength = fullLength;
         if (copyLength < destCapacity) {
         int32_t fullLength = endIx - startIx;
         int32_t copyLength = fullLength;
         if (copyLength < destCapacity) {


@@ -671,7 +703,7 @@ uregex_group(URegularExpression *regexp2,
             copyLength = destCapacity;
             *status = U_BUFFER_OVERFLOW_ERROR;
         }
             copyLength = destCapacity;
             *status = U_BUFFER_OVERFLOW_ERROR;
         }

-        
+

         //
         // Copy capture group to user's buffer
         //
         //
         // Copy capture group to user's buffer
         //


@@ -680,11 +712,18 @@ uregex_group(URegularExpression *regexp2,
         }
         return fullLength;
     } else {
         }
         return fullLength;
     } else {

-        UText *groupText = uregex_groupUTextDeep(regexp2, groupNum, NULL, status);
-        int32_t result = utext_extract(groupText, 0, utext_nativeLength(groupText), dest, destCapacity, status);
-        utext_close(groupText);
-        return result;
+        int64_t  start = regexp->fMatcher->start64(groupNum, *status);
+        int64_t  limit = regexp->fMatcher->end64(groupNum, *status);
+        if (U_FAILURE(*status)) {
+            return 0;
+        }
+        // Note edge cases:
+        //   Group didn't match: start == end == -1. UText trims to 0, UText gives zero length result.
+        //   Zero Length Match: start == end.
+        int32_t length = utext_extract(regexp->fMatcher->inputText(), start, limit, dest, destCapacity, status);
+        return length;

     }
     }

+

 }
 
 
 }
 
 


@@ -693,7 +732,7 @@ uregex_group(URegularExpression *regexp2,
 //    uregex_groupUText
 //
 //------------------------------------------------------------------------------
 //    uregex_groupUText
 //
 //------------------------------------------------------------------------------

-U_CAPI UText * U_EXPORT2 
+U_CAPI UText * U_EXPORT2

 uregex_groupUText(URegularExpression *regexp2,
                   int32_t             groupNum,
                   UText              *dest,
 uregex_groupUText(URegularExpression *regexp2,
                   int32_t             groupNum,
                   UText              *dest,


@@ -708,62 +747,19 @@ uregex_groupUText(URegularExpression *regexp2,
     return regexp->fMatcher->group(groupNum, dest, *groupLength, *status);
 }
 
     return regexp->fMatcher->group(groupNum, dest, *groupLength, *status);
 }
 

-//------------------------------------------------------------------------------
-//
-//    uregex_groupUTextDeep
-//
-//------------------------------------------------------------------------------
-U_CAPI UText * U_EXPORT2 
-uregex_groupUTextDeep(URegularExpression *regexp2,
-                  int32_t             groupNum,
-                  UText              *dest,
-                  UErrorCode         *status)  {
-    RegularExpression *regexp = (RegularExpression*)regexp2;
-    if (validateRE(regexp, TRUE, status) == FALSE) {
-        UErrorCode emptyTextStatus = U_ZERO_ERROR;
-        return (dest ? dest : utext_openUChars(NULL, NULL, 0, &emptyTextStatus));
-    }
-
-    if (regexp->fText != NULL) {
-        //
-        // Pick up the range of characters from the matcher
-        // and use our already-extracted characters
-        //
-        int32_t  startIx = regexp->fMatcher->start(groupNum, *status);
-        int32_t  endIx   = regexp->fMatcher->end  (groupNum, *status);
-        if (U_FAILURE(*status)) {
-            UErrorCode emptyTextStatus = U_ZERO_ERROR;
-            return (dest ? dest : utext_openUChars(NULL, NULL, 0, &emptyTextStatus));
-        }
-        
-        if (dest) {
-            utext_replace(dest, 0, utext_nativeLength(dest), &regexp->fText[startIx], endIx - startIx, status);
-        } else {
-            UText groupText = UTEXT_INITIALIZER;
-            utext_openUChars(&groupText, &regexp->fText[startIx], endIx - startIx, status);
-            dest = utext_clone(NULL, &groupText, TRUE, FALSE, status);
-            utext_close(&groupText);
-        }
-        
-        return dest;
-    } else {
-        return regexp->fMatcher->group(groupNum, dest, *status);
-    }
-}
-

 //------------------------------------------------------------------------------
 //
 //    uregex_start
 //
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------------------
 //
 //    uregex_start
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_start(URegularExpression *regexp2,
              int32_t             groupNum,
              UErrorCode          *status)  {
     return (int32_t)uregex_start64( regexp2, groupNum, status);
 }
 
 uregex_start(URegularExpression *regexp2,
              int32_t             groupNum,
              UErrorCode          *status)  {
     return (int32_t)uregex_start64( regexp2, groupNum, status);
 }
 

-U_CAPI int64_t U_EXPORT2 
+U_CAPI int64_t U_EXPORT2

 uregex_start64(URegularExpression *regexp2,
                int32_t             groupNum,
                UErrorCode          *status)  {
 uregex_start64(URegularExpression *regexp2,
                int32_t             groupNum,
                UErrorCode          *status)  {


@@ -771,7 +767,7 @@ uregex_start64(URegularExpression *regexp2,
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return 0;
     }
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return 0;
     }

-    int32_t result = regexp->fMatcher->start(groupNum, *status);
+    int64_t result = regexp->fMatcher->start64(groupNum, *status);

     return result;
 }
 
     return result;
 }
 


@@ -780,14 +776,14 @@ uregex_start64(URegularExpression *regexp2,
 //    uregex_end
 //
 //------------------------------------------------------------------------------
 //    uregex_end
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_end(URegularExpression   *regexp2,
            int32_t               groupNum,
            UErrorCode           *status)  {
     return (int32_t)uregex_end64( regexp2, groupNum, status);
 }
 
 uregex_end(URegularExpression   *regexp2,
            int32_t               groupNum,
            UErrorCode           *status)  {
     return (int32_t)uregex_end64( regexp2, groupNum, status);
 }
 

-U_CAPI int64_t U_EXPORT2 
+U_CAPI int64_t U_EXPORT2

 uregex_end64(URegularExpression   *regexp2,
              int32_t               groupNum,
              UErrorCode           *status)  {
 uregex_end64(URegularExpression   *regexp2,
              int32_t               groupNum,
              UErrorCode           *status)  {


@@ -795,7 +791,7 @@ uregex_end64(URegularExpression   *regexp2,
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return 0;
     }
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return 0;
     }

-    int32_t result = regexp->fMatcher->end(groupNum, *status);
+    int64_t result = regexp->fMatcher->end64(groupNum, *status);

     return result;
 }
 
     return result;
 }
 


@@ -804,14 +800,14 @@ uregex_end64(URegularExpression   *regexp2,
 //    uregex_reset
 //
 //------------------------------------------------------------------------------
 //    uregex_reset
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_reset(URegularExpression    *regexp2,
              int32_t               index,
              UErrorCode            *status)  {
     uregex_reset64( regexp2, (int64_t)index, status);
 }
 
 uregex_reset(URegularExpression    *regexp2,
              int32_t               index,
              UErrorCode            *status)  {
     uregex_reset64( regexp2, (int64_t)index, status);
 }
 

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_reset64(URegularExpression    *regexp2,
                int64_t               index,
                UErrorCode            *status)  {
 uregex_reset64(URegularExpression    *regexp2,
                int64_t               index,
                UErrorCode            *status)  {


@@ -828,7 +824,7 @@ uregex_reset64(URegularExpression    *regexp2,
 //    uregex_setRegion
 //
 //------------------------------------------------------------------------------
 //    uregex_setRegion
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_setRegion(URegularExpression   *regexp2,
                  int32_t               regionStart,
                  int32_t               regionLimit,
 uregex_setRegion(URegularExpression   *regexp2,
                  int32_t               regionStart,
                  int32_t               regionLimit,


@@ -836,7 +832,7 @@ uregex_setRegion(URegularExpression   *regexp2,
     uregex_setRegion64( regexp2, (int64_t)regionStart, (int64_t)regionLimit, status);
 }
 
     uregex_setRegion64( regexp2, (int64_t)regionStart, (int64_t)regionLimit, status);
 }
 

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_setRegion64(URegularExpression   *regexp2,
                    int64_t               regionStart,
                    int64_t               regionLimit,
 uregex_setRegion64(URegularExpression   *regexp2,
                    int64_t               regionStart,
                    int64_t               regionLimit,


@@ -854,7 +850,7 @@ uregex_setRegion64(URegularExpression   *regexp2,
 //    uregex_setRegionAndStart
 //
 //------------------------------------------------------------------------------
 //    uregex_setRegionAndStart
 //
 //------------------------------------------------------------------------------

-U_DRAFT void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_setRegionAndStart(URegularExpression   *regexp2,
                  int64_t               regionStart,
                  int64_t               regionLimit,
 uregex_setRegionAndStart(URegularExpression   *regexp2,
                  int64_t               regionStart,
                  int64_t               regionLimit,


@@ -872,13 +868,13 @@ uregex_setRegionAndStart(URegularExpression   *regexp2,
 //    uregex_regionStart
 //
 //------------------------------------------------------------------------------
 //    uregex_regionStart
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_regionStart(const  URegularExpression   *regexp2,
                           UErrorCode           *status)  {
     return (int32_t)uregex_regionStart64(regexp2, status);
 }
 
 uregex_regionStart(const  URegularExpression   *regexp2,
                           UErrorCode           *status)  {
     return (int32_t)uregex_regionStart64(regexp2, status);
 }
 

-U_CAPI int64_t U_EXPORT2 
+U_CAPI int64_t U_EXPORT2

 uregex_regionStart64(const  URegularExpression   *regexp2,
                             UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_regionStart64(const  URegularExpression   *regexp2,
                             UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;


@@ -894,13 +890,13 @@ uregex_regionStart64(const  URegularExpression   *regexp2,
 //    uregex_regionEnd
 //
 //------------------------------------------------------------------------------
 //    uregex_regionEnd
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_regionEnd(const  URegularExpression   *regexp2,
                         UErrorCode           *status)  {
     return (int32_t)uregex_regionEnd64(regexp2, status);
 }
 
 uregex_regionEnd(const  URegularExpression   *regexp2,
                         UErrorCode           *status)  {
     return (int32_t)uregex_regionEnd64(regexp2, status);
 }
 

-U_CAPI int64_t U_EXPORT2 
+U_CAPI int64_t U_EXPORT2

 uregex_regionEnd64(const  URegularExpression   *regexp2,
                           UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_regionEnd64(const  URegularExpression   *regexp2,
                           UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;


@@ -916,7 +912,7 @@ uregex_regionEnd64(const  URegularExpression   *regexp2,
 //    uregex_hasTransparentBounds
 //
 //------------------------------------------------------------------------------
 //    uregex_hasTransparentBounds
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_hasTransparentBounds(const  URegularExpression   *regexp2,
                                    UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_hasTransparentBounds(const  URegularExpression   *regexp2,
                                    UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;


@@ -932,7 +928,7 @@ uregex_hasTransparentBounds(const  URegularExpression   *regexp2,
 //    uregex_useTransparentBounds
 //
 //------------------------------------------------------------------------------
 //    uregex_useTransparentBounds
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_useTransparentBounds(URegularExpression    *regexp2,
                             UBool                  b,
                             UErrorCode            *status)  {
 uregex_useTransparentBounds(URegularExpression    *regexp2,
                             UBool                  b,
                             UErrorCode            *status)  {


@@ -949,7 +945,7 @@ uregex_useTransparentBounds(URegularExpression    *regexp2,
 //    uregex_hasAnchoringBounds
 //
 //------------------------------------------------------------------------------
 //    uregex_hasAnchoringBounds
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_hasAnchoringBounds(const  URegularExpression   *regexp2,
                                  UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_hasAnchoringBounds(const  URegularExpression   *regexp2,
                                  UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;


@@ -965,7 +961,7 @@ uregex_hasAnchoringBounds(const  URegularExpression   *regexp2,
 //    uregex_useAnchoringBounds
 //
 //------------------------------------------------------------------------------
 //    uregex_useAnchoringBounds
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_useAnchoringBounds(URegularExpression    *regexp2,
                           UBool                  b,
                           UErrorCode            *status)  {
 uregex_useAnchoringBounds(URegularExpression    *regexp2,
                           UBool                  b,
                           UErrorCode            *status)  {


@@ -982,7 +978,7 @@ uregex_useAnchoringBounds(URegularExpression    *regexp2,
 //    uregex_hitEnd
 //
 //------------------------------------------------------------------------------
 //    uregex_hitEnd
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_hitEnd(const  URegularExpression   *regexp2,
                      UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_hitEnd(const  URegularExpression   *regexp2,
                      UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;


@@ -998,7 +994,7 @@ uregex_hitEnd(const  URegularExpression   *regexp2,
 //    uregex_requireEnd
 //
 //------------------------------------------------------------------------------
 //    uregex_requireEnd
 //
 //------------------------------------------------------------------------------

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uregex_requireEnd(const  URegularExpression   *regexp2,
                          UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;
 uregex_requireEnd(const  URegularExpression   *regexp2,
                          UErrorCode           *status)  {
     RegularExpression *regexp = (RegularExpression*)regexp2;


@@ -1014,7 +1010,7 @@ uregex_requireEnd(const  URegularExpression   *regexp2,
 //    uregex_setTimeLimit
 //
 //------------------------------------------------------------------------------
 //    uregex_setTimeLimit
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_setTimeLimit(URegularExpression   *regexp2,
                     int32_t               limit,
                     UErrorCode           *status) {
 uregex_setTimeLimit(URegularExpression   *regexp2,
                     int32_t               limit,
                     UErrorCode           *status) {


@@ -1031,7 +1027,7 @@ uregex_setTimeLimit(URegularExpression   *regexp2,
 //    uregex_getTimeLimit
 //
 //------------------------------------------------------------------------------
 //    uregex_getTimeLimit
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_getTimeLimit(const  URegularExpression   *regexp2,
                            UErrorCode           *status) {
     int32_t retVal = 0;
 uregex_getTimeLimit(const  URegularExpression   *regexp2,
                            UErrorCode           *status) {
     int32_t retVal = 0;


@@ -1049,7 +1045,7 @@ uregex_getTimeLimit(const  URegularExpression   *regexp2,
 //    uregex_setStackLimit
 //
 //------------------------------------------------------------------------------
 //    uregex_setStackLimit
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_setStackLimit(URegularExpression   *regexp2,
                      int32_t               limit,
                      UErrorCode           *status) {
 uregex_setStackLimit(URegularExpression   *regexp2,
                      int32_t               limit,
                      UErrorCode           *status) {


@@ -1066,7 +1062,7 @@ uregex_setStackLimit(URegularExpression   *regexp2,
 //    uregex_getStackLimit
 //
 //------------------------------------------------------------------------------
 //    uregex_getStackLimit
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_getStackLimit(const  URegularExpression   *regexp2,
                             UErrorCode           *status) {
     int32_t retVal = 0;
 uregex_getStackLimit(const  URegularExpression   *regexp2,
                             UErrorCode           *status) {
     int32_t retVal = 0;


@@ -1100,7 +1096,7 @@ uregex_setMatchCallback(URegularExpression      *regexp2,
 //    uregex_getMatchCallback
 //
 //------------------------------------------------------------------------------
 //    uregex_getMatchCallback
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_getMatchCallback(const URegularExpression    *regexp2,
                         URegexMatchCallback        **callback,
                         const void                 **context,
 uregex_getMatchCallback(const URegularExpression    *regexp2,
                         URegexMatchCallback        **callback,
                         const void                 **context,


@@ -1134,7 +1130,7 @@ uregex_setFindProgressCallback(URegularExpression              *regexp2,
 //    uregex_getMatchCallback
 //
 //------------------------------------------------------------------------------
 //    uregex_getMatchCallback
 //
 //------------------------------------------------------------------------------

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_getFindProgressCallback(const URegularExpression          *regexp2,
                                 URegexFindProgressCallback        **callback,
                                 const void                        **context,
 uregex_getFindProgressCallback(const URegularExpression          *regexp2,
                                 URegexFindProgressCallback        **callback,
                                 const void                        **context,


@@ -1151,7 +1147,7 @@ uregex_getFindProgressCallback(const URegularExpression          *regexp2,
 //    uregex_replaceAll
 //
 //------------------------------------------------------------------------------
 //    uregex_replaceAll
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_replaceAll(URegularExpression    *regexp2,
                   const UChar           *replacementText,
                   int32_t                replacementLength,
 uregex_replaceAll(URegularExpression    *regexp2,
                   const UChar           *replacementText,
                   int32_t                replacementLength,


@@ -1184,7 +1180,7 @@ uregex_replaceAll(URegularExpression    *regexp2,
                                         &destBuf, &destCapacity, status);
     }
     len += uregex_appendTail(regexp2, &destBuf, &destCapacity, status);
                                         &destBuf, &destCapacity, status);
     }
     len += uregex_appendTail(regexp2, &destBuf, &destCapacity, status);

-    
+

     if (U_FAILURE(findStatus)) {
         // If anything went wrong with the findNext(), make that error trump
         //   whatever may have happened with the append() operations.
     if (U_FAILURE(findStatus)) {
         // If anything went wrong with the findNext(), make that error trump
         //   whatever may have happened with the append() operations.


@@ -1201,7 +1197,7 @@ uregex_replaceAll(URegularExpression    *regexp2,
 //    uregex_replaceAllUText
 //
 //------------------------------------------------------------------------------
 //    uregex_replaceAllUText
 //
 //------------------------------------------------------------------------------

-U_CAPI UText * U_EXPORT2 
+U_CAPI UText * U_EXPORT2

 uregex_replaceAllUText(URegularExpression    *regexp2,
                        UText                 *replacementText,
                        UText                 *dest,
 uregex_replaceAllUText(URegularExpression    *regexp2,
                        UText                 *replacementText,
                        UText                 *dest,


@@ -1214,18 +1210,18 @@ uregex_replaceAllUText(URegularExpression    *regexp2,
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }

-    
+

     dest = regexp->fMatcher->replaceAll(replacementText, dest, *status);
     return dest;
 }
     dest = regexp->fMatcher->replaceAll(replacementText, dest, *status);
     return dest;
 }

-    
+

 
 //------------------------------------------------------------------------------
 //
 //    uregex_replaceFirst
 //
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 //
 //    uregex_replaceFirst
 //
 //------------------------------------------------------------------------------

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_replaceFirst(URegularExpression  *regexp2,
                     const UChar         *replacementText,
                     int32_t              replacementLength,
 uregex_replaceFirst(URegularExpression  *regexp2,
                     const UChar         *replacementText,
                     int32_t              replacementLength,


@@ -1248,7 +1244,7 @@ uregex_replaceFirst(URegularExpression  *regexp2,
     uregex_reset(regexp2, 0, status);
     findSucceeded = uregex_find(regexp2, 0, status);
     if (findSucceeded) {
     uregex_reset(regexp2, 0, status);
     findSucceeded = uregex_find(regexp2, 0, status);
     if (findSucceeded) {

-        len = uregex_appendReplacement(regexp2, replacementText, replacementLength, 
+        len = uregex_appendReplacement(regexp2, replacementText, replacementLength,

                                        &destBuf, &destCapacity, status);
     }
     len += uregex_appendTail(regexp2, &destBuf, &destCapacity, status);
                                        &destBuf, &destCapacity, status);
     }
     len += uregex_appendTail(regexp2, &destBuf, &destCapacity, status);


@@ -1262,7 +1258,7 @@ uregex_replaceFirst(URegularExpression  *regexp2,
 //    uregex_replaceFirstUText
 //
 //------------------------------------------------------------------------------
 //    uregex_replaceFirstUText
 //
 //------------------------------------------------------------------------------

-U_CAPI UText * U_EXPORT2 
+U_CAPI UText * U_EXPORT2

 uregex_replaceFirstUText(URegularExpression  *regexp2,
                          UText                 *replacementText,
                          UText                 *dest,
 uregex_replaceFirstUText(URegularExpression  *regexp2,
                          UText                 *replacementText,
                          UText                 *dest,


@@ -1275,7 +1271,7 @@ uregex_replaceFirstUText(URegularExpression  *regexp2,
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }

-    
+

     dest = regexp->fMatcher->replaceFirst(replacementText, dest, *status);
     return dest;
 }
     dest = regexp->fMatcher->replaceFirst(replacementText, dest, *status);
     return dest;
 }


@@ -1305,7 +1301,7 @@ class RegexCImpl {
         UChar                **destBuf,
         int32_t               *destCapacity,
         UErrorCode            *status);
         UChar                **destBuf,
         int32_t               *destCapacity,
         UErrorCode            *status);

-                  
+

     inline static int32_t split(RegularExpression    *regexp,
         UChar                 *destBuf,
         int32_t                destCapacity,
     inline static int32_t split(RegularExpression    *regexp,
         UChar                 *destBuf,
         int32_t                destCapacity,


@@ -1321,6 +1317,8 @@ U_NAMESPACE_END
 
 static const UChar BACKSLASH  = 0x5c;
 static const UChar DOLLARSIGN = 0x24;
 
 static const UChar BACKSLASH  = 0x5c;
 static const UChar DOLLARSIGN = 0x24;

+static const UChar LEFTBRACKET = 0x7b;
+static const UChar RIGHTBRACKET = 0x7d;

 
 //
 //  Move a character to an output buffer, with bounds checking on the index.
 
 //
 //  Move a character to an output buffer, with bounds checking on the index.


@@ -1361,7 +1359,7 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
         return 0;
     }
     if (replacementText == NULL || replacementLength < -1 ||
         return 0;
     }
     if (replacementText == NULL || replacementLength < -1 ||

-        destCapacity == NULL || destBuf == NULL || 
+        destCapacity == NULL || destBuf == NULL ||

         (*destBuf == NULL && *destCapacity > 0) ||
         *destCapacity < 0) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         (*destBuf == NULL && *destCapacity > 0) ||
         *destCapacity < 0) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;


@@ -1378,7 +1376,7 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
     int32_t   capacity         = *destCapacity;
     int32_t   destIdx          =  0;
     int32_t   i;
     int32_t   capacity         = *destCapacity;
     int32_t   destIdx          =  0;
     int32_t   i;

-    
+

     // If it wasn't supplied by the caller,  get the length of the replacement text.
     //   TODO:  slightly smarter logic in the copy loop could watch for the NUL on
     //          the fly and avoid this step.
     // If it wasn't supplied by the caller,  get the length of the replacement text.
     //   TODO:  slightly smarter logic in the copy loop could watch for the NUL on
     //          the fly and avoid this step.


@@ -1395,14 +1393,14 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
             matchStart = (int32_t)m->fMatchStart;
         } else {
             // !!!: Would like a better way to do this!
             matchStart = (int32_t)m->fMatchStart;
         } else {
             // !!!: Would like a better way to do this!

-            UErrorCode status = U_ZERO_ERROR;
-            lastMatchEnd = utext_extract(m->fInputText, 0, m->fLastMatchEnd, NULL, 0, &status);
-            status = U_ZERO_ERROR;
-            matchStart = lastMatchEnd + utext_extract(m->fInputText, m->fLastMatchEnd, m->fMatchStart, NULL, 0, &status);
+            UErrorCode tempStatus = U_ZERO_ERROR;
+            lastMatchEnd = utext_extract(m->fInputText, 0, m->fLastMatchEnd, NULL, 0, &tempStatus);
+            tempStatus = U_ZERO_ERROR;
+            matchStart = lastMatchEnd + utext_extract(m->fInputText, m->fLastMatchEnd, m->fMatchStart, NULL, 0, &tempStatus);

         }
         for (i=lastMatchEnd; i<matchStart; i++) {
             appendToBuf(regexp->fText[i], &destIdx, dest, capacity);
         }
         for (i=lastMatchEnd; i<matchStart; i++) {
             appendToBuf(regexp->fText[i], &destIdx, dest, capacity);

-        }        
+        }

     } else {
         UErrorCode possibleOverflowError = U_ZERO_ERROR; // ignore
         destIdx += utext_extract(m->fInputText, m->fLastMatchEnd, m->fMatchStart,
     } else {
         UErrorCode possibleOverflowError = U_ZERO_ERROR; // ignore
         destIdx += utext_extract(m->fInputText, m->fLastMatchEnd, m->fMatchStart,


@@ -1413,11 +1411,11 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
 
     // scan the replacement text, looking for substitutions ($n) and \escapes.
     int32_t  replIdx = 0;
 
     // scan the replacement text, looking for substitutions ($n) and \escapes.
     int32_t  replIdx = 0;

-    while (replIdx < replacementLength) {
+    while (replIdx < replacementLength && U_SUCCESS(*status)) {

         UChar  c = replacementText[replIdx];
         replIdx++;
         if (c != DOLLARSIGN && c != BACKSLASH) {
         UChar  c = replacementText[replIdx];
         replIdx++;
         if (c != DOLLARSIGN && c != BACKSLASH) {

-            // Common case, no substitution, no escaping, 
+            // Common case, no substitution, no escaping,

             //  just copy the char to the dest buf.
             appendToBuf(c, &destIdx, dest, capacity);
             continue;
             //  just copy the char to the dest buf.
             appendToBuf(c, &destIdx, dest, capacity);
             continue;


@@ -1436,9 +1434,9 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
 
             if (c==0x55/*U*/ || c==0x75/*u*/) {
                 // We have a \udddd or \Udddddddd escape sequence.
 
             if (c==0x55/*U*/ || c==0x75/*u*/) {
                 // We have a \udddd or \Udddddddd escape sequence.

-                UChar32 escapedChar = 
+                UChar32 escapedChar =

                     u_unescapeAt(uregex_ucstr_unescape_charAt,
                     u_unescapeAt(uregex_ucstr_unescape_charAt,

-                       &replIdx,                   // Index is updated by unescapeAt 
+                       &replIdx,                   // Index is updated by unescapeAt

                        replacementLength,          // Length of replacement text
                        (void *)replacementText);
 
                        replacementLength,          // Length of replacement text
                        (void *)replacementText);
 


@@ -1462,55 +1460,87 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
             continue;
         }
 
             continue;
         }
 

+        // We've got a $.  Pick up the following capture group name or number.
+        // For numbers, consume only digits that produce a valid capture group for the pattern.

 
 

-
-        // We've got a $.  Pick up a capture group number if one follows.
-        // Consume at most the number of digits necessary for the largest capture
-        // number that is valid for this pattern.
-
-        int32_t numDigits = 0;

         int32_t groupNum  = 0;
         int32_t groupNum  = 0;

-        UChar32 digitC;
-        for (;;) {
-            if (replIdx >= replacementLength) {
-                break;
-            }
-            U16_GET(replacementText, 0, replIdx, replacementLength, digitC);
-            if (u_isdigit(digitC) == FALSE) {
-                break;
-            }
+        U_ASSERT(c == DOLLARSIGN);
+        UChar32 c32 = -1;
+        if (replIdx < replacementLength) {
+            U16_GET(replacementText, 0, replIdx, replacementLength, c32);
+        }
+        if (u_isdigit(c32)) {
+            int32_t numDigits = 0;
+            int32_t numCaptureGroups = m->fPattern->fGroupMap->size();
+            for (;;) {
+                if (replIdx >= replacementLength) {
+                    break;
+                }
+                U16_GET(replacementText, 0, replIdx, replacementLength, c32);
+                if (u_isdigit(c32) == FALSE) {
+                    break;
+                }

 
 

+                int32_t digitVal = u_charDigitValue(c32);
+                if (groupNum * 10 + digitVal <= numCaptureGroups) {
+                    groupNum = groupNum * 10 + digitVal;
+                    U16_FWD_1(replacementText, replIdx, replacementLength);
+                    numDigits++;
+                } else {
+                    if (numDigits == 0) {
+                        *status = U_INDEX_OUTOFBOUNDS_ERROR;
+                    }
+                    break;
+                }
+            }
+        } else if (c32 == LEFTBRACKET) {
+            // Scan for Named Capture Group, ${name}.
+            UnicodeString groupName;

             U16_FWD_1(replacementText, replIdx, replacementLength);
             U16_FWD_1(replacementText, replIdx, replacementLength);

-            groupNum=groupNum*10 + u_charDigitValue(digitC);
-            numDigits++;
-            if (numDigits >= m->fPattern->fMaxCaptureDigits) {
-                break;
+            while (U_SUCCESS(*status) && c32 != RIGHTBRACKET) { 
+                if (replIdx >= replacementLength) {
+                    *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
+                    break;
+                }
+                U16_NEXT(replacementText, replIdx, replacementLength, c32);
+                if ((c32 >= 0x41 && c32 <= 0x5a) ||           // A..Z
+                        (c32 >= 0x61 && c32 <= 0x7a) ||       // a..z
+                        (c32 >= 0x31 && c32 <= 0x39)) {       // 0..9
+                    groupName.append(c32);
+                } else if (c32 == RIGHTBRACKET) {
+                    groupNum = regexp->fPat->fNamedCaptureMap ?
+                            uhash_geti(regexp->fPat->fNamedCaptureMap, &groupName) : 0;
+                    if (groupNum == 0) {
+                        // Name not defined by pattern.
+                        *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
+                    }
+                } else {
+                    // Character was something other than a name char or a closing '}'
+                    *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;
+                }

             }
             }

+        } else {
+            // $ not followed by {name} or digits.
+            *status = U_REGEX_INVALID_CAPTURE_GROUP_NAME;

         }
 
 
         }
 
 

-        if (numDigits == 0) {
-            // The $ didn't introduce a group number at all.
-            // Treat it as just part of the substitution text.
-            appendToBuf(DOLLARSIGN, &destIdx, dest, capacity);
-            continue;
-        }
-

         // Finally, append the capture group data to the destination.
         // Finally, append the capture group data to the destination.

-        destIdx += uregex_group((URegularExpression*)regexp, groupNum,
-                                dest==NULL?NULL:&dest[destIdx], REMAINING_CAPACITY(destIdx, capacity), status);
-        if (*status == U_BUFFER_OVERFLOW_ERROR) {
-            // Ignore buffer overflow when extracting the group.  We need to
-            //   continue on to get full size of the untruncated result.  We will
-            //   raise our own buffer overflow error at the end.
-            *status = U_ZERO_ERROR;
+        if (U_SUCCESS(*status)) {
+            destIdx += uregex_group((URegularExpression*)regexp, groupNum,
+                                    dest==NULL?NULL:&dest[destIdx], REMAINING_CAPACITY(destIdx, capacity), status);
+            if (*status == U_BUFFER_OVERFLOW_ERROR) {
+                // Ignore buffer overflow when extracting the group.  We need to
+                //   continue on to get full size of the untruncated result.  We will
+                //   raise our own buffer overflow error at the end.
+                *status = U_ZERO_ERROR;
+            }

         }
 
         if (U_FAILURE(*status)) {
         }
 
         if (U_FAILURE(*status)) {

-            // Can fail if group number is out of range.
+            // bad group number or name.

             break;
         }
             break;
         }

-

     }
 
     //
     }
 
     //


@@ -1519,12 +1549,14 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
     //
     if (destIdx < capacity) {
         dest[destIdx] = 0;
     //
     if (destIdx < capacity) {
         dest[destIdx] = 0;

-    } else if (destIdx == *destCapacity) {
-        *status = U_STRING_NOT_TERMINATED_WARNING;
-    } else {
-        *status = U_BUFFER_OVERFLOW_ERROR;
+    } else if (U_SUCCESS(*status)) {
+        if (destIdx == *destCapacity) {
+            *status = U_STRING_NOT_TERMINATED_WARNING;
+        } else {
+            *status = U_BUFFER_OVERFLOW_ERROR;
+        }

     }
     }

-    
+

     //
     // Return an updated dest buffer and capacity to the caller.
     //
     //
     // Return an updated dest buffer and capacity to the caller.
     //


@@ -1551,14 +1583,14 @@ int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp,
 //
 //   appendReplacement   the actual API function,
 //
 //
 //   appendReplacement   the actual API function,
 //

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_appendReplacement(URegularExpression    *regexp2,
                          const UChar           *replacementText,
                          int32_t                replacementLength,
                          UChar                **destBuf,
                          int32_t               *destCapacity,
                          UErrorCode            *status) {
 uregex_appendReplacement(URegularExpression    *regexp2,
                          const UChar           *replacementText,
                          int32_t                replacementLength,
                          UChar                **destBuf,
                          int32_t               *destCapacity,
                          UErrorCode            *status) {

-    
+

     RegularExpression *regexp = (RegularExpression*)regexp2;
     return RegexCImpl::appendReplacement(
         regexp, replacementText, replacementLength,destBuf, destCapacity, status);
     RegularExpression *regexp = (RegularExpression*)regexp2;
     return RegexCImpl::appendReplacement(
         regexp, replacementText, replacementLength,destBuf, destCapacity, status);


@@ -1567,7 +1599,7 @@ uregex_appendReplacement(URegularExpression    *regexp2,
 //
 //   uregex_appendReplacementUText...can just use the normal C++ method
 //
 //
 //   uregex_appendReplacementUText...can just use the normal C++ method
 //

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uregex_appendReplacementUText(URegularExpression    *regexp2,
                               UText                 *replText,
                               UText                 *dest,
 uregex_appendReplacementUText(URegularExpression    *regexp2,
                               UText                 *replText,
                               UText                 *dest,


@@ -1600,8 +1632,8 @@ int32_t RegexCImpl::appendTail(RegularExpression    *regexp,
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return 0;
     }
     if (validateRE(regexp, TRUE, status) == FALSE) {
         return 0;
     }

-    
-    if (destCapacity == NULL || destBuf == NULL || 
+
+    if (destCapacity == NULL || destBuf == NULL ||

         (*destBuf == NULL && *destCapacity > 0) ||
         *destCapacity < 0)
     {
         (*destBuf == NULL && *destCapacity > 0) ||
         *destCapacity < 0)
     {


@@ -1614,7 +1646,7 @@ int32_t RegexCImpl::appendTail(RegularExpression    *regexp,
     int32_t  destIdx     = 0;
     int32_t  destCap     = *destCapacity;
     UChar    *dest       = *destBuf;
     int32_t  destIdx     = 0;
     int32_t  destCap     = *destCapacity;
     UChar    *dest       = *destBuf;

-    
+

     if (regexp->fText != NULL) {
         int32_t srcIdx;
         int64_t nativeIdx = (m->fMatch ? m->fMatchEnd : m->fLastMatchEnd);
     if (regexp->fText != NULL) {
         int32_t srcIdx;
         int64_t nativeIdx = (m->fMatch ? m->fMatchEnd : m->fLastMatchEnd);


@@ -1623,10 +1655,10 @@ int32_t RegexCImpl::appendTail(RegularExpression    *regexp,
         } else if (UTEXT_USES_U16(m->fInputText)) {
             srcIdx = (int32_t)nativeIdx;
         } else {
         } else if (UTEXT_USES_U16(m->fInputText)) {
             srcIdx = (int32_t)nativeIdx;
         } else {

-            UErrorCode status = U_ZERO_ERROR;
-            srcIdx = utext_extract(m->fInputText, 0, nativeIdx, NULL, 0, &status);
+            UErrorCode newStatus = U_ZERO_ERROR;
+            srcIdx = utext_extract(m->fInputText, 0, nativeIdx, NULL, 0, &newStatus);

         }
         }

-            
+

         for (;;) {
             U_ASSERT(destIdx >= 0);
 
         for (;;) {
             U_ASSERT(destIdx >= 0);
 


@@ -1652,11 +1684,11 @@ int32_t RegexCImpl::appendTail(RegularExpression    *regexp,
             }
             srcIdx++;
             destIdx++;
             }
             srcIdx++;
             destIdx++;

-        }            
+        }

     } else {
         int64_t  srcIdx;
         if (m->fMatch) {
     } else {
         int64_t  srcIdx;
         if (m->fMatch) {

-            // The most recent call to find() succeeded.  
+            // The most recent call to find() succeeded.

             srcIdx = m->fMatchEnd;
         } else {
             // The last call to find() on this matcher failed().
             srcIdx = m->fMatchEnd;
         } else {
             // The last call to find() on this matcher failed().


@@ -1707,7 +1739,7 @@ int32_t RegexCImpl::appendTail(RegularExpression    *regexp,
 //
 //   appendTail   the actual API function
 //
 //
 //   appendTail   the actual API function
 //

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_appendTail(URegularExpression    *regexp2,
                   UChar                **destBuf,
                   int32_t               *destCapacity,
 uregex_appendTail(URegularExpression    *regexp2,
                   UChar                **destBuf,
                   int32_t               *destCapacity,


@@ -1720,7 +1752,7 @@ uregex_appendTail(URegularExpression    *regexp2,
 //
 //   uregex_appendTailUText...can just use the normal C++ method
 //
 //
 //   uregex_appendTailUText...can just use the normal C++ method
 //

-U_CAPI UText * U_EXPORT2 
+U_CAPI UText * U_EXPORT2

 uregex_appendTailUText(URegularExpression    *regexp2,
                        UText                 *dest,
                        UErrorCode            *status)  {
 uregex_appendTailUText(URegularExpression    *regexp2,
                        UText                 *dest,
                        UErrorCode            *status)  {


@@ -1812,19 +1844,19 @@ int32_t RegexCImpl::split(RegularExpression     *regexp,
                     i = destFieldsCapacity-1;
                     destIdx = (int32_t)(destFields[i] - destFields[0]);
                 }
                     i = destFieldsCapacity-1;
                     destIdx = (int32_t)(destFields[i] - destFields[0]);
                 }

-                
+

                 destFields[i] = &destBuf[destIdx];
                 destIdx += 1 + utext_extract(inputText, nextOutputStringStart, inputLen,
                                              &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), status);
             }
             break;
         }
                 destFields[i] = &destBuf[destIdx];
                 destIdx += 1 + utext_extract(inputText, nextOutputStringStart, inputLen,
                                              &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), status);
             }
             break;
         }

-        
+

         if (regexp->fMatcher->find()) {
             // We found another delimiter.  Move everything from where we started looking
             //  up until the start of the delimiter into the next output string.
             destFields[i] = &destBuf[destIdx];
         if (regexp->fMatcher->find()) {
             // We found another delimiter.  Move everything from where we started looking
             //  up until the start of the delimiter into the next output string.
             destFields[i] = &destBuf[destIdx];

-            
+

             destIdx += 1 + utext_extract(inputText, nextOutputStringStart, regexp->fMatcher->fMatchStart,
                                          &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), &tStatus);
             if (tStatus == U_BUFFER_OVERFLOW_ERROR) {
             destIdx += 1 + utext_extract(inputText, nextOutputStringStart, regexp->fMatcher->fMatchStart,
                                          &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), &tStatus);
             if (tStatus == U_BUFFER_OVERFLOW_ERROR) {


@@ -1833,7 +1865,7 @@ int32_t RegexCImpl::split(RegularExpression     *regexp,
                 *status = tStatus;
             }
             nextOutputStringStart = regexp->fMatcher->fMatchEnd;
                 *status = tStatus;
             }
             nextOutputStringStart = regexp->fMatcher->fMatchEnd;

-            
+

             // If the delimiter pattern has capturing parentheses, the captured
             //  text goes out into the next n destination strings.
             int32_t groupNum;
             // If the delimiter pattern has capturing parentheses, the captured
             //  text goes out into the next n destination strings.
             int32_t groupNum;


@@ -1843,14 +1875,14 @@ int32_t RegexCImpl::split(RegularExpression     *regexp,
                     break;
                 }
                 i++;
                     break;
                 }
                 i++;

-                
+

                 // Set up to extract the capture group contents into the dest buffer.
                 destFields[i] = &destBuf[destIdx];
                 tStatus = U_ZERO_ERROR;
                 // Set up to extract the capture group contents into the dest buffer.
                 destFields[i] = &destBuf[destIdx];
                 tStatus = U_ZERO_ERROR;

-                int32_t t = uregex_group((URegularExpression*)regexp, 
-                                         groupNum, 
-                                         destFields[i], 
-                                         REMAINING_CAPACITY(destIdx, destCapacity), 
+                int32_t t = uregex_group((URegularExpression*)regexp,
+                                         groupNum,
+                                         destFields[i],
+                                         REMAINING_CAPACITY(destIdx, destCapacity),

                                          &tStatus);
                 destIdx += t + 1;    // Record the space used in the output string buffer.
                                      //  +1 for the NUL that terminates the string.
                                          &tStatus);
                 destIdx += t + 1;    // Record the space used in the output string buffer.
                                      //  +1 for the NUL that terminates the string.


@@ -1862,7 +1894,7 @@ int32_t RegexCImpl::split(RegularExpression     *regexp,
             }
 
             if (nextOutputStringStart == inputLen) {
             }
 
             if (nextOutputStringStart == inputLen) {

-                // The delimiter was at the end of the string. 
+                // The delimiter was at the end of the string.

                 // Output an empty string, and then we are done.
                 if (destIdx < destCapacity) {
                     destBuf[destIdx] = 0;
                 // Output an empty string, and then we are done.
                 if (destIdx < destCapacity) {
                     destBuf[destIdx] = 0;


@@ -1907,7 +1939,7 @@ int32_t RegexCImpl::split(RegularExpression     *regexp,
 //
 //   uregex_split   The actual API function
 //
 //
 //   uregex_split   The actual API function
 //

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_split(URegularExpression      *regexp2,
              UChar                   *destBuf,
              int32_t                  destCapacity,
 uregex_split(URegularExpression      *regexp2,
              UChar                   *destBuf,
              int32_t                  destCapacity,


@@ -1926,15 +1958,15 @@ uregex_split(URegularExpression      *regexp2,
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }

-    
+

     return RegexCImpl::split(regexp, destBuf, destCapacity, requiredCapacity, destFields, destFieldsCapacity, status);
 }
     return RegexCImpl::split(regexp, destBuf, destCapacity, requiredCapacity, destFields, destFieldsCapacity, status);
 }

-    
+

 
 //
 //   uregex_splitUText...can just use the normal C++ method
 //
 
 //
 //   uregex_splitUText...can just use the normal C++ method
 //

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uregex_splitUText(URegularExpression    *regexp2,
                   UText                 *destFields[],
                   int32_t                destFieldsCapacity,
 uregex_splitUText(URegularExpression    *regexp2,
                   UText                 *destFields[],
                   int32_t                destFieldsCapacity,