path: root/contrib/libs/icu/i18n/uregex.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html 
/* 
******************************************************************************* 
*   Copyright (C) 2004-2015, International Business Machines 
*   Corporation and others.  All Rights Reserved. 
******************************************************************************* 
*   file name:  uregex.cpp 
*/ 
 
#include "unicode/utypes.h" 
 
#if !UCONFIG_NO_REGULAR_EXPRESSIONS 
 
#include "unicode/regex.h" 
#include "unicode/uregex.h" 
#include "unicode/unistr.h" 
#include "unicode/ustring.h" 
#include "unicode/uchar.h" 
#include "unicode/uobject.h" 
#include "unicode/utf16.h" 
#include "cmemory.h" 
#include "uassert.h" 
#include "uhash.h" 
#include "umutex.h" 
#include "uvectr32.h" 
 
#include "regextxt.h" 
 
U_NAMESPACE_BEGIN 
 
#define REMAINING_CAPACITY(idx,len) ((((len)-(idx))>0)?((len)-(idx)):0) 
 
struct RegularExpression: public UMemory { 
public: 
    RegularExpression(); 
    ~RegularExpression(); 
    int32_t           fMagic; 
    RegexPattern     *fPat; 
    u_atomic_int32_t *fPatRefCount; 
    UChar            *fPatString; 
    int32_t           fPatStringLen; 
    RegexMatcher     *fMatcher; 
    const UChar      *fText;         // Text from setText() 
    int32_t           fTextLength;   // Length provided by user with setText(), which 
                                     //  may be -1. 
    UBool             fOwnsText; 
}; 
 
static const int32_t REXP_MAGIC = 0x72657870; // "rexp" in ASCII 
 
RegularExpression::RegularExpression() { 
    fMagic        = REXP_MAGIC; 
    fPat          = NULL; 
    fPatRefCount  = NULL; 
    fPatString    = NULL; 
    fPatStringLen = 0; 
    fMatcher      = NULL; 
    fText         = NULL; 
    fTextLength   = 0; 
    fOwnsText     = FALSE; 
} 
 
RegularExpression::~RegularExpression() { 
    delete fMatcher; 
    fMatcher = NULL; 
    if (fPatRefCount!=NULL && umtx_atomic_dec(fPatRefCount)==0) { 
        delete fPat; 
        uprv_free(fPatString); 
        uprv_free((void *)fPatRefCount); 
    } 
    if (fOwnsText && fText!=NULL) { 
        uprv_free((void *)fText); 
    } 
    fMagic = 0; 
} 
 
U_NAMESPACE_END 
 
U_NAMESPACE_USE 
 
//---------------------------------------------------------------------------------------- 
// 
//   validateRE    Do boilerplate style checks on API function parameters. 
//                 Return TRUE if they look OK. 
//---------------------------------------------------------------------------------------- 
static UBool validateRE(const RegularExpression *re, UBool requiresText, UErrorCode *status) { 
    if (U_FAILURE(*status)) { 
        return FALSE; 
    } 
    if (re == NULL || re->fMagic != REXP_MAGIC) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return FALSE; 
    } 
    // !!! Not sure how to update this with the new UText backing, which is stored in re->fMatcher anyway 
    if (requiresText && re->fText == NULL && !re->fOwnsText) { 
        *status = U_REGEX_INVALID_STATE; 
        return FALSE; 
    } 
    return TRUE; 
} 
 
//---------------------------------------------------------------------------------------- 
// 
//    uregex_open 
// 
//---------------------------------------------------------------------------------------- 
U_CAPI URegularExpression *  U_EXPORT2 
uregex_open( const  UChar          *pattern, 
                    int32_t         patternLength, 
                    uint32_t        flags, 
                    UParseError    *pe, 
                    UErrorCode     *status) { 
 
    if (U_FAILURE(*status)) { 
        return NULL; 
    } 
    if (pattern == NULL || patternLength < -1 || patternLength == 0) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return NULL; 
    } 
    int32_t actualPatLen = patternLength; 
    if (actualPatLen == -1) { 
        actualPatLen = u_strlen(pattern); 
    } 
 
    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; 
        uprv_free((void *)refC); 
        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 UText wrapper around 
    //    this local copy, to avoid making even more copies. 
    // 
    re->fPatString    = patBuf; 
    re->fPatStringLen = patternLength; 
    u_memcpy(patBuf, pattern, actualPatLen); 
    patBuf[actualPatLen] = 0; 
 
    UText patText = UTEXT_INITIALIZER; 
    utext_openUChars(&patText, patBuf, patternLength, status); 
 
    // 
    // Compile the pattern 
    // 
    if (pe != NULL) { 
        re->fPat = RegexPattern::compile(&patText, flags, *pe, *status); 
    } else { 
        re->fPat = RegexPattern::compile(&patText, flags, *status); 
    } 
    utext_close(&patText); 
 
    if (U_FAILURE(*status)) { 
        goto ErrorExit; 
    } 
 
    // 
    // Create the matcher object 
    // 
    re->fMatcher = re->fPat->matcher(*status); 
    if (U_SUCCESS(*status)) { 
        return (URegularExpression*)re; 
    } 
 
ErrorExit: 
    delete re; 
    return NULL; 
 
} 
 
//---------------------------------------------------------------------------------------- 
// 
//    uregex_openUText 
// 
//---------------------------------------------------------------------------------------- 
U_CAPI URegularExpression *  U_EXPORT2 
uregex_openUText(UText          *pattern, 
                 uint32_t        flags, 
                 UParseError    *pe, 
                 UErrorCode     *status) { 
 
    if (U_FAILURE(*status)) { 
        return NULL; 
    } 
    if (pattern == NULL) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return NULL; 
    } 
 
    int64_t patternNativeLength = utext_nativeLength(pattern); 
 
    if (patternNativeLength == 0) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return NULL; 
    } 
 
    RegularExpression *re     = new RegularExpression; 
 
    UErrorCode lengthStatus = U_ZERO_ERROR; 
    int32_t pattern16Length = utext_extract(pattern, 0, patternNativeLength, NULL, 0, &lengthStatus); 
 
    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; 
        uprv_free((void *)refC); 
        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 
    //    around this local copy, to avoid making even more copies. 
    // 
    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); 
 
    // 
    // Compile the pattern 
    // 
    if (pe != NULL) { 
        re->fPat = RegexPattern::compile(&patText, flags, *pe, *status); 
    } else { 
        re->fPat = RegexPattern::compile(&patText, flags, *status); 
    } 
    utext_close(&patText); 
 
    if (U_FAILURE(*status)) { 
        goto ErrorExit; 
    } 
 
    // 
    // Create the matcher object 
    // 
    re->fMatcher = re->fPat->matcher(*status); 
    if (U_SUCCESS(*status)) { 
        return (URegularExpression*)re; 
    } 
 
ErrorExit: 
    delete re; 
    return NULL; 
 
} 
 
//---------------------------------------------------------------------------------------- 
// 
//    uregex_close 
// 
//---------------------------------------------------------------------------------------- 
U_CAPI void  U_EXPORT2 
uregex_close(URegularExpression  *re2) { 
    RegularExpression *re = (RegularExpression*)re2; 
    UErrorCode  status = U_ZERO_ERROR; 
    if (validateRE(re, FALSE, &status) == FALSE) { 
        return; 
    } 
    delete re; 
} 
 
 
//---------------------------------------------------------------------------------------- 
// 
//    uregex_clone 
// 
//---------------------------------------------------------------------------------------- 
U_CAPI URegularExpression * U_EXPORT2 
uregex_clone(const URegularExpression *source2, UErrorCode *status)  { 
    RegularExpression *source = (RegularExpression*)source2; 
    if (validateRE(source, FALSE, status) == FALSE) { 
        return NULL; 
    } 
 
    RegularExpression *clone = new RegularExpression; 
    if (clone == NULL) { 
        *status = U_MEMORY_ALLOCATION_ERROR; 
        return NULL; 
    } 
 
    clone->fMatcher = source->fPat->matcher(*status); 
    if (U_FAILURE(*status)) { 
        delete clone; 
        return NULL; 
    } 
 
    clone->fPat          = source->fPat; 
    clone->fPatRefCount  = source->fPatRefCount; 
    clone->fPatString    = source->fPatString; 
    clone->fPatStringLen = source->fPatStringLen; 
    umtx_atomic_inc(source->fPatRefCount); 
    // Note:  fText is not cloned. 
 
    return (URegularExpression*)clone; 
} 
 
 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_pattern 
// 
//------------------------------------------------------------------------------ 
U_CAPI const UChar * U_EXPORT2 
uregex_pattern(const  URegularExpression *regexp2, 
                      int32_t            *patLength, 
                      UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return NULL; 
    } 
    if (patLength != NULL) { 
        *patLength = regexp->fPatStringLen; 
    } 
    return regexp->fPatString; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_patternUText 
// 
//------------------------------------------------------------------------------ 
U_CAPI UText * U_EXPORT2 
uregex_patternUText(const URegularExpression *regexp2, 
                          UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    return regexp->fPat->patternText(*status); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_flags 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_flags(const URegularExpression *regexp2, UErrorCode *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return 0; 
    } 
    int32_t flags = regexp->fPat->flags(); 
    return flags; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setText 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setText(URegularExpression *regexp2, 
               const UChar        *text, 
               int32_t             textLength, 
               UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return; 
    } 
    if (text == NULL || textLength < -1) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return; 
    } 
 
    if (regexp->fOwnsText && regexp->fText != NULL) { 
        uprv_free((void *)regexp->fText); 
    } 
 
    regexp->fText       = text; 
    regexp->fTextLength = textLength; 
    regexp->fOwnsText   = FALSE; 
 
    UText input = UTEXT_INITIALIZER; 
    utext_openUChars(&input, text, textLength, status); 
    regexp->fMatcher->reset(&input); 
    utext_close(&input); // reset() made a shallow clone, so we don't need this copy 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setUText 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setUText(URegularExpression *regexp2, 
                UText              *text, 
                UErrorCode         *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return; 
    } 
    if (text == NULL) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return; 
    } 
 
    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->fMatcher->reset(text); 
} 
 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_getText 
// 
//------------------------------------------------------------------------------ 
U_CAPI const UChar * U_EXPORT2 
uregex_getText(URegularExpression *regexp2, 
               int32_t            *textLength, 
               UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return NULL; 
    } 
 
    if (regexp->fText == NULL) { 
        // need to fill in the text 
        UText *inputText = regexp->fMatcher->inputText(); 
        int64_t inputNativeLength = utext_nativeLength(inputText); 
        if (UTEXT_FULL_TEXT_IN_CHUNK(inputText, inputNativeLength)) { 
            regexp->fText = inputText->chunkContents; 
            regexp->fTextLength = (int32_t)inputNativeLength; 
            regexp->fOwnsText = FALSE; // because the UText owns it 
        } else { 
            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 
        } 
    } 
 
    if (textLength != NULL) { 
        *textLength = regexp->fTextLength; 
    } 
    return regexp->fText; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_getUText 
// 
//------------------------------------------------------------------------------ 
U_CAPI UText * U_EXPORT2 
uregex_getUText(URegularExpression *regexp2, 
                UText              *dest, 
                UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return dest; 
    } 
    return regexp->fMatcher->getInput(dest, *status); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_refreshUText 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_refreshUText(URegularExpression *regexp2, 
                    UText              *text, 
                    UErrorCode         *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return; 
    } 
    regexp->fMatcher->refreshInputText(text, *status); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_matches 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_matches(URegularExpression *regexp2, 
               int32_t            startIndex, 
               UErrorCode        *status)  { 
    return uregex_matches64( regexp2, (int64_t)startIndex, status); 
} 
 
U_CAPI UBool U_EXPORT2 
uregex_matches64(URegularExpression *regexp2, 
                 int64_t            startIndex, 
                 UErrorCode        *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    UBool result = FALSE; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return result; 
    } 
    if (startIndex == -1) { 
        result = regexp->fMatcher->matches(*status); 
    } else { 
        result = regexp->fMatcher->matches(startIndex, *status); 
    } 
    return result; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_lookingAt 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_lookingAt(URegularExpression *regexp2, 
                 int32_t             startIndex, 
                 UErrorCode         *status)  { 
    return uregex_lookingAt64( regexp2, (int64_t)startIndex, status); 
} 
 
U_CAPI UBool U_EXPORT2 
uregex_lookingAt64(URegularExpression *regexp2, 
                   int64_t             startIndex, 
                   UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    UBool result = FALSE; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return result; 
    } 
    if (startIndex == -1) { 
        result = regexp->fMatcher->lookingAt(*status); 
    } else { 
        result = regexp->fMatcher->lookingAt(startIndex, *status); 
    } 
    return result; 
} 
 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_find 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_find(URegularExpression *regexp2, 
            int32_t             startIndex, 
            UErrorCode         *status)  { 
    return uregex_find64( regexp2, (int64_t)startIndex, status); 
} 
 
U_CAPI UBool U_EXPORT2 
uregex_find64(URegularExpression *regexp2, 
              int64_t             startIndex, 
              UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    UBool result = FALSE; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return result; 
    } 
    if (startIndex == -1) { 
        regexp->fMatcher->resetPreserveRegion(); 
        result = regexp->fMatcher->find(*status); 
    } else { 
        result = regexp->fMatcher->find(startIndex, *status); 
    } 
    return result; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_findNext 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_findNext(URegularExpression *regexp2, 
                UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return FALSE; 
    } 
    UBool result = regexp->fMatcher->find(*status); 
    return result; 
} 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_groupCount 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_groupCount(URegularExpression *regexp2, 
                  UErrorCode         *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return 0; 
    } 
    int32_t  result = regexp->fMatcher->groupCount(); 
    return result; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    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 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_group(URegularExpression *regexp2, 
             int32_t             groupNum, 
             UChar              *dest, 
             int32_t             destCapacity, 
             UErrorCode          *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    if (destCapacity < 0 || (destCapacity > 0 && dest == NULL)) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    if (destCapacity == 0 || regexp->fText != NULL) { 
        // If preflighting or if we already have the text as UChars, 
        // this is a little cheaper than extracting from the UText 
 
        // 
        // Pick up the range of characters from the matcher 
        // 
        int32_t  startIx = regexp->fMatcher->start(groupNum, *status); 
        int32_t  endIx   = regexp->fMatcher->end  (groupNum, *status); 
        if (U_FAILURE(*status)) { 
            return 0; 
        } 
 
        // 
        // Trim length based on buffer capacity 
        // 
        int32_t fullLength = endIx - startIx; 
        int32_t copyLength = fullLength; 
        if (copyLength < destCapacity) { 
            dest[copyLength] = 0; 
        } else if (copyLength == destCapacity) { 
            *status = U_STRING_NOT_TERMINATED_WARNING; 
        } else { 
            copyLength = destCapacity; 
            *status = U_BUFFER_OVERFLOW_ERROR; 
        } 
 
        // 
        // Copy capture group to user's buffer 
        // 
        if (copyLength > 0) { 
            u_memcpy(dest, &regexp->fText[startIx], copyLength); 
        } 
        return fullLength; 
    } else { 
        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; 
    } 
 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_groupUText 
// 
//------------------------------------------------------------------------------ 
U_CAPI UText * U_EXPORT2 
uregex_groupUText(URegularExpression *regexp2, 
                  int32_t             groupNum, 
                  UText              *dest, 
                  int64_t            *groupLength, 
                  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)); 
    } 
 
    return regexp->fMatcher->group(groupNum, dest, *groupLength, *status); 
} 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_start 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_start(URegularExpression *regexp2, 
             int32_t             groupNum, 
             UErrorCode          *status)  { 
    return (int32_t)uregex_start64( regexp2, groupNum, status); 
} 
 
U_CAPI int64_t U_EXPORT2 
uregex_start64(URegularExpression *regexp2, 
               int32_t             groupNum, 
               UErrorCode          *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    int64_t result = regexp->fMatcher->start64(groupNum, *status);
    return result; 
} 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_end 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_end(URegularExpression   *regexp2, 
           int32_t               groupNum, 
           UErrorCode           *status)  { 
    return (int32_t)uregex_end64( regexp2, groupNum, status); 
} 
 
U_CAPI int64_t U_EXPORT2 
uregex_end64(URegularExpression   *regexp2, 
             int32_t               groupNum, 
             UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    int64_t result = regexp->fMatcher->end64(groupNum, *status);
    return result; 
} 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_reset 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_reset(URegularExpression    *regexp2, 
             int32_t               index, 
             UErrorCode            *status)  { 
    uregex_reset64( regexp2, (int64_t)index, status); 
} 
 
U_CAPI void U_EXPORT2 
uregex_reset64(URegularExpression    *regexp2, 
               int64_t               index, 
               UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return; 
    } 
    regexp->fMatcher->reset(index, *status); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setRegion 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setRegion(URegularExpression   *regexp2, 
                 int32_t               regionStart, 
                 int32_t               regionLimit, 
                 UErrorCode           *status)  { 
    uregex_setRegion64( regexp2, (int64_t)regionStart, (int64_t)regionLimit, status); 
} 
 
U_CAPI void U_EXPORT2 
uregex_setRegion64(URegularExpression   *regexp2, 
                   int64_t               regionStart, 
                   int64_t               regionLimit, 
                   UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return; 
    } 
    regexp->fMatcher->region(regionStart, regionLimit, *status); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setRegionAndStart 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setRegionAndStart(URegularExpression   *regexp2, 
                 int64_t               regionStart, 
                 int64_t               regionLimit, 
                 int64_t               startIndex, 
                 UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return; 
    } 
    regexp->fMatcher->region(regionStart, regionLimit, startIndex, *status); 
} 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_regionStart 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_regionStart(const  URegularExpression   *regexp2, 
                          UErrorCode           *status)  { 
    return (int32_t)uregex_regionStart64(regexp2, status); 
} 
 
U_CAPI int64_t U_EXPORT2 
uregex_regionStart64(const  URegularExpression   *regexp2, 
                            UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    return regexp->fMatcher->regionStart(); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_regionEnd 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_regionEnd(const  URegularExpression   *regexp2, 
                        UErrorCode           *status)  { 
    return (int32_t)uregex_regionEnd64(regexp2, status); 
} 
 
U_CAPI int64_t U_EXPORT2 
uregex_regionEnd64(const  URegularExpression   *regexp2, 
                          UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    return regexp->fMatcher->regionEnd(); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_hasTransparentBounds 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_hasTransparentBounds(const  URegularExpression   *regexp2, 
                                   UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return FALSE; 
    } 
    return regexp->fMatcher->hasTransparentBounds(); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_useTransparentBounds 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_useTransparentBounds(URegularExpression    *regexp2, 
                            UBool                  b, 
                            UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return; 
    } 
    regexp->fMatcher->useTransparentBounds(b); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_hasAnchoringBounds 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_hasAnchoringBounds(const  URegularExpression   *regexp2, 
                                 UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return FALSE; 
    } 
    return regexp->fMatcher->hasAnchoringBounds(); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_useAnchoringBounds 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_useAnchoringBounds(URegularExpression    *regexp2, 
                          UBool                  b, 
                          UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status) == FALSE) { 
        return; 
    } 
    regexp->fMatcher->useAnchoringBounds(b); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_hitEnd 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_hitEnd(const  URegularExpression   *regexp2, 
                     UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return FALSE; 
    } 
    return regexp->fMatcher->hitEnd(); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_requireEnd 
// 
//------------------------------------------------------------------------------ 
U_CAPI UBool U_EXPORT2 
uregex_requireEnd(const  URegularExpression   *regexp2, 
                         UErrorCode           *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return FALSE; 
    } 
    return regexp->fMatcher->requireEnd(); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setTimeLimit 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setTimeLimit(URegularExpression   *regexp2, 
                    int32_t               limit, 
                    UErrorCode           *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status)) { 
        regexp->fMatcher->setTimeLimit(limit, *status); 
    } 
} 
 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_getTimeLimit 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_getTimeLimit(const  URegularExpression   *regexp2, 
                           UErrorCode           *status) { 
    int32_t retVal = 0; 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status)) { 
        retVal = regexp->fMatcher->getTimeLimit(); 
    } 
    return retVal; 
} 
 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setStackLimit 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setStackLimit(URegularExpression   *regexp2, 
                     int32_t               limit, 
                     UErrorCode           *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status)) { 
        regexp->fMatcher->setStackLimit(limit, *status); 
    } 
} 
 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_getStackLimit 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_getStackLimit(const  URegularExpression   *regexp2, 
                            UErrorCode           *status) { 
    int32_t retVal = 0; 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status)) { 
        retVal = regexp->fMatcher->getStackLimit(); 
    } 
    return retVal; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setMatchCallback 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setMatchCallback(URegularExpression      *regexp2, 
                        URegexMatchCallback     *callback, 
                        const void              *context, 
                        UErrorCode              *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status)) { 
        regexp->fMatcher->setMatchCallback(callback, context, *status); 
    } 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_getMatchCallback 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_getMatchCallback(const URegularExpression    *regexp2, 
                        URegexMatchCallback        **callback, 
                        const void                 **context, 
                        UErrorCode                  *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
     if (validateRE(regexp, FALSE, status)) { 
         regexp->fMatcher->getMatchCallback(*callback, *context, *status); 
     } 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_setMatchProgressCallback 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_setFindProgressCallback(URegularExpression              *regexp2, 
                                URegexFindProgressCallback      *callback, 
                                const void                      *context, 
                                UErrorCode                      *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, FALSE, status)) { 
        regexp->fMatcher->setFindProgressCallback(callback, context, *status); 
    } 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_getMatchCallback 
// 
//------------------------------------------------------------------------------ 
U_CAPI void U_EXPORT2 
uregex_getFindProgressCallback(const URegularExpression          *regexp2, 
                                URegexFindProgressCallback        **callback, 
                                const void                        **context, 
                                UErrorCode                        *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
     if (validateRE(regexp, FALSE, status)) { 
         regexp->fMatcher->getFindProgressCallback(*callback, *context, *status); 
     } 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_replaceAll 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_replaceAll(URegularExpression    *regexp2, 
                  const UChar           *replacementText, 
                  int32_t                replacementLength, 
                  UChar                 *destBuf, 
                  int32_t                destCapacity, 
                  UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    if (replacementText == NULL || replacementLength < -1 || 
        (destBuf == NULL && destCapacity > 0) || 
        destCapacity < 0) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    int32_t   len = 0; 
 
    uregex_reset(regexp2, 0, status); 
 
    // Note: Seperate error code variables for findNext() and appendReplacement() 
    //       are used so that destination buffer overflow errors 
    //       in appendReplacement won't stop findNext() from working. 
    //       appendReplacement() and appendTail() special case incoming buffer 
    //       overflow errors, continuing to return the correct length. 
    UErrorCode  findStatus = *status; 
    while (uregex_findNext(regexp2, &findStatus)) { 
        len += uregex_appendReplacement(regexp2, replacementText, replacementLength, 
                                        &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. 
        //   Errors in findNext() are not expected. 
        *status = findStatus; 
    } 
 
    return len; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_replaceAllUText 
// 
//------------------------------------------------------------------------------ 
U_CAPI UText * U_EXPORT2 
uregex_replaceAllUText(URegularExpression    *regexp2, 
                       UText                 *replacementText, 
                       UText                 *dest, 
                       UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    if (replacementText == NULL) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    dest = regexp->fMatcher->replaceAll(replacementText, dest, *status); 
    return dest; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_replaceFirst 
// 
//------------------------------------------------------------------------------ 
U_CAPI int32_t U_EXPORT2 
uregex_replaceFirst(URegularExpression  *regexp2, 
                    const UChar         *replacementText, 
                    int32_t              replacementLength, 
                    UChar               *destBuf, 
                    int32_t              destCapacity, 
                    UErrorCode          *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    if (replacementText == NULL || replacementLength < -1 || 
        (destBuf == NULL && destCapacity > 0) || 
        destCapacity < 0) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    int32_t   len = 0; 
    UBool     findSucceeded; 
    uregex_reset(regexp2, 0, status); 
    findSucceeded = uregex_find(regexp2, 0, status); 
    if (findSucceeded) { 
        len = uregex_appendReplacement(regexp2, replacementText, replacementLength, 
                                       &destBuf, &destCapacity, status); 
    } 
    len += uregex_appendTail(regexp2, &destBuf, &destCapacity, status); 
 
    return len; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_replaceFirstUText 
// 
//------------------------------------------------------------------------------ 
U_CAPI UText * U_EXPORT2 
uregex_replaceFirstUText(URegularExpression  *regexp2, 
                         UText                 *replacementText, 
                         UText                 *dest, 
                         UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    if (replacementText == NULL) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    dest = regexp->fMatcher->replaceFirst(replacementText, dest, *status); 
    return dest; 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_appendReplacement 
// 
//------------------------------------------------------------------------------ 
 
U_NAMESPACE_BEGIN 
// 
//  Dummy class, because these functions need to be friends of class RegexMatcher, 
//               and stand-alone C functions don't work as friends 
// 
class RegexCImpl { 
 public: 
   inline static  int32_t appendReplacement(RegularExpression    *regexp, 
                      const UChar           *replacementText, 
                      int32_t                replacementLength, 
                      UChar                **destBuf, 
                      int32_t               *destCapacity, 
                      UErrorCode            *status); 
 
   inline static int32_t appendTail(RegularExpression    *regexp, 
        UChar                **destBuf, 
        int32_t               *destCapacity, 
        UErrorCode            *status); 
 
    inline static int32_t split(RegularExpression    *regexp, 
        UChar                 *destBuf, 
        int32_t                destCapacity, 
        int32_t               *requiredCapacity, 
        UChar                 *destFields[], 
        int32_t                destFieldsCapacity, 
        UErrorCode            *status); 
}; 
 
U_NAMESPACE_END 
 
 
 
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. 
//      Index advances even if capacity is exceeded, for preflight size computations. 
//      This little sequence is used a LOT. 
// 
static inline void appendToBuf(UChar c, int32_t *idx, UChar *buf, int32_t bufCapacity) { 
    if (*idx < bufCapacity) { 
        buf[*idx] = c; 
    } 
    (*idx)++; 
} 
 
 
// 
//  appendReplacement, the actual implementation. 
// 
int32_t RegexCImpl::appendReplacement(RegularExpression    *regexp, 
                                      const UChar           *replacementText, 
                                      int32_t                replacementLength, 
                                      UChar                **destBuf, 
                                      int32_t               *destCapacity, 
                                      UErrorCode            *status)  { 
 
    // If we come in with a buffer overflow error, don't suppress the operation. 
    //  A series of appendReplacements, appendTail need to correctly preflight 
    //  the buffer size when an overflow happens somewhere in the middle. 
    UBool pendingBufferOverflow = FALSE; 
    if (*status == U_BUFFER_OVERFLOW_ERROR && destCapacity != NULL && *destCapacity == 0) { 
        pendingBufferOverflow = TRUE; 
        *status = U_ZERO_ERROR; 
    } 
 
    // 
    // Validate all paramters 
    // 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    if (replacementText == NULL || replacementLength < -1 || 
        destCapacity == NULL || destBuf == NULL || 
        (*destBuf == NULL && *destCapacity > 0) || 
        *destCapacity < 0) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    RegexMatcher *m = regexp->fMatcher; 
    if (m->fMatch == FALSE) { 
        *status = U_REGEX_INVALID_STATE; 
        return 0; 
    } 
 
    UChar    *dest             = *destBuf; 
    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 (replacementLength == -1) { 
        replacementLength = u_strlen(replacementText); 
    } 
 
    // Copy input string from the end of previous match to start of current match 
    if (regexp->fText != NULL) { 
        int32_t matchStart; 
        int32_t lastMatchEnd; 
        if (UTEXT_USES_U16(m->fInputText)) { 
            lastMatchEnd = (int32_t)m->fLastMatchEnd; 
            matchStart = (int32_t)m->fMatchStart; 
        } else { 
            // !!!: Would like a better way to do this! 
            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); 
        } 
    } else { 
        UErrorCode possibleOverflowError = U_ZERO_ERROR; // ignore 
        destIdx += utext_extract(m->fInputText, m->fLastMatchEnd, m->fMatchStart, 
                                 dest==NULL?NULL:&dest[destIdx], REMAINING_CAPACITY(destIdx, capacity), 
                                 &possibleOverflowError); 
    } 
    U_ASSERT(destIdx >= 0); 
 
    // scan the replacement text, looking for substitutions ($n) and \escapes. 
    int32_t  replIdx = 0; 
    while (replIdx < replacementLength && U_SUCCESS(*status)) { 
        UChar  c = replacementText[replIdx]; 
        replIdx++; 
        if (c != DOLLARSIGN && c != BACKSLASH) { 
            // Common case, no substitution, no escaping, 
            //  just copy the char to the dest buf. 
            appendToBuf(c, &destIdx, dest, capacity); 
            continue; 
        } 
 
        if (c == BACKSLASH) { 
            // Backslash Escape.  Copy the following char out without further checks. 
            //                    Note:  Surrogate pairs don't need any special handling 
            //                           The second half wont be a '$' or a '\', and 
            //                           will move to the dest normally on the next 
            //                           loop iteration. 
            if (replIdx >= replacementLength) { 
                break; 
            } 
            c = replacementText[replIdx]; 
 
            if (c==0x55/*U*/ || c==0x75/*u*/) { 
                // We have a \udddd or \Udddddddd escape sequence. 
                UChar32 escapedChar = 
                    u_unescapeAt(uregex_ucstr_unescape_charAt, 
                       &replIdx,                   // Index is updated by unescapeAt 
                       replacementLength,          // Length of replacement text 
                       (void *)replacementText); 
 
                if (escapedChar != (UChar32)0xFFFFFFFF) { 
                    if (escapedChar <= 0xffff) { 
                        appendToBuf((UChar)escapedChar, &destIdx, dest, capacity); 
                    } else { 
                        appendToBuf(U16_LEAD(escapedChar), &destIdx, dest, capacity); 
                        appendToBuf(U16_TRAIL(escapedChar), &destIdx, dest, capacity); 
                    } 
                    continue; 
                } 
                // Note:  if the \u escape was invalid, just fall through and 
                //        treat it as a plain \<anything> escape. 
            } 
 
            // Plain backslash escape.  Just put out the escaped character. 
            appendToBuf(c, &destIdx, dest, capacity); 
 
            replIdx++; 
            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. 
 
        int32_t groupNum  = 0; 
        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); 
            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; 
        } 
 
 
        // Finally, append the capture group data to the destination. 
        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)) { 
            // bad group number or name. 
            break; 
        } 
    } 
 
    // 
    //  Nul Terminate the dest buffer if possible. 
    //  Set the appropriate buffer overflow or not terminated error, if needed. 
    // 
    if (destIdx < capacity) { 
        dest[destIdx] = 0; 
    } 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. 
    // 
    if (destIdx > 0 &&  *destCapacity > 0) { 
        if (destIdx < capacity) { 
            *destBuf      += destIdx; 
            *destCapacity -= destIdx; 
        } else { 
            *destBuf      += capacity; 
            *destCapacity =  0; 
        } 
    } 
 
    // If we came in with a buffer overflow, make sure we go out with one also. 
    //   (A zero length match right at the end of the previous match could 
    //    make this function succeed even though a previous call had overflowed the buf) 
    if (pendingBufferOverflow && U_SUCCESS(*status)) { 
        *status = U_BUFFER_OVERFLOW_ERROR; 
    } 
 
    return destIdx; 
} 
 
// 
//   appendReplacement   the actual API function, 
// 
U_CAPI int32_t U_EXPORT2 
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); 
} 
 
// 
//   uregex_appendReplacementUText...can just use the normal C++ method 
// 
U_CAPI void U_EXPORT2 
uregex_appendReplacementUText(URegularExpression    *regexp2, 
                              UText                 *replText, 
                              UText                 *dest, 
                              UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    regexp->fMatcher->appendReplacement(dest, replText, *status); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_appendTail 
// 
//------------------------------------------------------------------------------ 
int32_t RegexCImpl::appendTail(RegularExpression    *regexp, 
                               UChar                **destBuf, 
                               int32_t               *destCapacity, 
                               UErrorCode            *status) 
{ 
 
    // If we come in with a buffer overflow error, don't suppress the operation. 
    //  A series of appendReplacements, appendTail need to correctly preflight 
    //  the buffer size when an overflow happens somewhere in the middle. 
    UBool pendingBufferOverflow = FALSE; 
    if (*status == U_BUFFER_OVERFLOW_ERROR && destCapacity != NULL && *destCapacity == 0) { 
        pendingBufferOverflow = TRUE; 
        *status = U_ZERO_ERROR; 
    } 
 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
 
    if (destCapacity == NULL || destBuf == NULL || 
        (*destBuf == NULL && *destCapacity > 0) || 
        *destCapacity < 0) 
    { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    RegexMatcher *m = regexp->fMatcher; 
 
    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 (nativeIdx == -1) { 
            srcIdx = 0; 
        } else if (UTEXT_USES_U16(m->fInputText)) { 
            srcIdx = (int32_t)nativeIdx; 
        } else { 
            UErrorCode newStatus = U_ZERO_ERROR;
            srcIdx = utext_extract(m->fInputText, 0, nativeIdx, NULL, 0, &newStatus);
        } 
 
        for (;;) { 
            U_ASSERT(destIdx >= 0); 
 
            if (srcIdx == regexp->fTextLength) { 
                break; 
            } 
            UChar c = regexp->fText[srcIdx]; 
            if (c == 0 && regexp->fTextLength == -1) { 
                regexp->fTextLength = srcIdx; 
                break; 
            } 
 
            if (destIdx < destCap) { 
                dest[destIdx] = c; 
            } else { 
                // We've overflowed the dest buffer. 
                //  If the total input string length is known, we can 
                //    compute the total buffer size needed without scanning through the string. 
                if (regexp->fTextLength > 0) { 
                    destIdx += (regexp->fTextLength - srcIdx); 
                    break; 
                } 
            } 
            srcIdx++; 
            destIdx++; 
        } 
    } else { 
        int64_t  srcIdx; 
        if (m->fMatch) { 
            // The most recent call to find() succeeded. 
            srcIdx = m->fMatchEnd; 
        } else { 
            // The last call to find() on this matcher failed(). 
            //   Look back to the end of the last find() that succeeded for src index. 
            srcIdx = m->fLastMatchEnd; 
            if (srcIdx == -1)  { 
                // There has been no successful match with this matcher. 
                //   We want to copy the whole string. 
                srcIdx = 0; 
            } 
        } 
 
        destIdx = utext_extract(m->fInputText, srcIdx, m->fInputLength, dest, destCap, status); 
    } 
 
    // 
    //  NUL terminate the output string, if possible, otherwise issue the 
    //   appropriate error or warning. 
    // 
    if (destIdx < destCap) { 
        dest[destIdx] = 0; 
    } else  if (destIdx == destCap) { 
        *status = U_STRING_NOT_TERMINATED_WARNING; 
    } else { 
        *status = U_BUFFER_OVERFLOW_ERROR; 
    } 
 
    // 
    // Update the user's buffer ptr and capacity vars to reflect the 
    //   amount used. 
    // 
    if (destIdx < destCap) { 
        *destBuf      += destIdx; 
        *destCapacity -= destIdx; 
    } else if (*destBuf != NULL) { 
        *destBuf      += destCap; 
        *destCapacity  = 0; 
    } 
 
    if (pendingBufferOverflow && U_SUCCESS(*status)) { 
        *status = U_BUFFER_OVERFLOW_ERROR; 
    } 
 
    return destIdx; 
} 
 
 
// 
//   appendTail   the actual API function 
// 
U_CAPI int32_t U_EXPORT2 
uregex_appendTail(URegularExpression    *regexp2, 
                  UChar                **destBuf, 
                  int32_t               *destCapacity, 
                  UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    return RegexCImpl::appendTail(regexp, destBuf, destCapacity, status); 
} 
 
 
// 
//   uregex_appendTailUText...can just use the normal C++ method 
// 
U_CAPI UText * U_EXPORT2 
uregex_appendTailUText(URegularExpression    *regexp2, 
                       UText                 *dest, 
                       UErrorCode            *status)  { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    return regexp->fMatcher->appendTail(dest, *status); 
} 
 
 
//------------------------------------------------------------------------------ 
// 
//    copyString     Internal utility to copy a string to an output buffer, 
//                   while managing buffer overflow and preflight size 
//                   computation.  NUL termination is added to destination, 
//                   and the NUL is counted in the output size. 
// 
//------------------------------------------------------------------------------ 
#if 0 
static void copyString(UChar        *destBuffer,    //  Destination buffer. 
                       int32_t       destCapacity,  //  Total capacity of dest buffer 
                       int32_t      *destIndex,     //  Index into dest buffer.  Updated on return. 
                                                    //    Update not clipped to destCapacity. 
                       const UChar  *srcPtr,        //  Pointer to source string 
                       int32_t       srcLen)        //  Source string len. 
{ 
    int32_t  si; 
    int32_t  di = *destIndex; 
    UChar    c; 
 
    for (si=0; si<srcLen;  si++) { 
        c = srcPtr[si]; 
        if (di < destCapacity) { 
            destBuffer[di] = c; 
            di++; 
        } else { 
            di += srcLen - si; 
            break; 
        } 
    } 
    if (di<destCapacity) { 
        destBuffer[di] = 0; 
    } 
    di++; 
    *destIndex = di; 
} 
#endif 
 
//------------------------------------------------------------------------------ 
// 
//    uregex_split 
// 
//------------------------------------------------------------------------------ 
int32_t RegexCImpl::split(RegularExpression     *regexp, 
                          UChar                 *destBuf, 
                          int32_t                destCapacity, 
                          int32_t               *requiredCapacity, 
                          UChar                 *destFields[], 
                          int32_t                destFieldsCapacity, 
                          UErrorCode            *status) { 
    // 
    // Reset for the input text 
    // 
    regexp->fMatcher->reset(); 
    UText *inputText = regexp->fMatcher->fInputText; 
    int64_t   nextOutputStringStart = 0; 
    int64_t   inputLen = regexp->fMatcher->fInputLength; 
    if (inputLen == 0) { 
        return 0; 
    } 
 
    // 
    // Loop through the input text, searching for the delimiter pattern 
    // 
    int32_t   i;             // Index of the field being processed. 
    int32_t   destIdx = 0;   // Next available position in destBuf; 
    int32_t   numCaptureGroups = regexp->fMatcher->groupCount(); 
    UErrorCode  tStatus = U_ZERO_ERROR;   // Want to ignore any buffer overflow errors so that the strings are still counted 
    for (i=0; ; i++) { 
        if (i>=destFieldsCapacity-1) { 
            // There are one or zero output strings left. 
            // Fill the last output string with whatever is left from the input, then exit the loop. 
            //  ( i will be == destFieldsCapacity if we filled the output array while processing 
            //    capture groups of the delimiter expression, in which case we will discard the 
            //    last capture group saved in favor of the unprocessed remainder of the 
            //    input string.) 
            if (inputLen > nextOutputStringStart) { 
                if (i != destFieldsCapacity-1) { 
                    // No fields are left.  Recycle the last one for holding the trailing part of 
                    //   the input string. 
                    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; 
        } 
 
        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) { 
                tStatus = U_ZERO_ERROR; 
            } else { 
                *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; 
            for (groupNum=1; groupNum<=numCaptureGroups; groupNum++) { 
                // If we've run out of output string slots, bail out. 
                if (i==destFieldsCapacity-1) { 
                    break; 
                } 
                i++; 
 
                // 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), 
                                         &tStatus); 
                destIdx += t + 1;    // Record the space used in the output string buffer. 
                                     //  +1 for the NUL that terminates the string. 
                if (tStatus == U_BUFFER_OVERFLOW_ERROR) { 
                    tStatus = U_ZERO_ERROR; 
                } else { 
                    *status = tStatus; 
                } 
            } 
 
            if (nextOutputStringStart == inputLen) { 
                // The delimiter was at the end of the string. 
                // Output an empty string, and then we are done. 
                if (destIdx < destCapacity) { 
                    destBuf[destIdx] = 0; 
                } 
                if (i < destFieldsCapacity-1) { 
                   ++i; 
                } 
                if (destIdx < destCapacity) { 
                    destFields[i] = destBuf + destIdx; 
                } 
                ++destIdx; 
                break; 
            } 
 
        } 
        else 
        { 
            // We ran off the end of the input while looking for the next delimiter. 
            // All the remaining text goes into the current output string. 
            destFields[i] = &destBuf[destIdx]; 
            destIdx += 1 + utext_extract(inputText, nextOutputStringStart, inputLen, 
                                         &destBuf[destIdx], REMAINING_CAPACITY(destIdx, destCapacity), status); 
            break; 
        } 
    } 
 
    // Zero out any unused portion of the destFields array 
    int j; 
    for (j=i+1; j<destFieldsCapacity; j++) { 
        destFields[j] = NULL; 
    } 
 
    if (requiredCapacity != NULL) { 
        *requiredCapacity = destIdx; 
    } 
    if (destIdx > destCapacity) { 
        *status = U_BUFFER_OVERFLOW_ERROR; 
    } 
    return i+1; 
} 
 
// 
//   uregex_split   The actual API function 
// 
U_CAPI int32_t U_EXPORT2 
uregex_split(URegularExpression      *regexp2, 
             UChar                   *destBuf, 
             int32_t                  destCapacity, 
             int32_t                 *requiredCapacity, 
             UChar                   *destFields[], 
             int32_t                  destFieldsCapacity, 
             UErrorCode              *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    if (validateRE(regexp, TRUE, status) == FALSE) { 
        return 0; 
    } 
    if ((destBuf == NULL && destCapacity > 0) || 
        destCapacity < 0 || 
        destFields == NULL || 
        destFieldsCapacity < 1 ) { 
        *status = U_ILLEGAL_ARGUMENT_ERROR; 
        return 0; 
    } 
 
    return RegexCImpl::split(regexp, destBuf, destCapacity, requiredCapacity, destFields, destFieldsCapacity, status); 
} 
 
 
// 
//   uregex_splitUText...can just use the normal C++ method 
// 
U_CAPI int32_t U_EXPORT2 
uregex_splitUText(URegularExpression    *regexp2, 
                  UText                 *destFields[], 
                  int32_t                destFieldsCapacity, 
                  UErrorCode            *status) { 
    RegularExpression *regexp = (RegularExpression*)regexp2; 
    return regexp->fMatcher->split(regexp->fMatcher->inputText(), destFields, destFieldsCapacity, *status); 
} 
 
 
#endif   // !UCONFIG_NO_REGULAR_EXPRESSIONS