| /* | |
| ******************************************************************************* | |
| * 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 "starboard/client_porting/poem/assert_poem.h" | |
| #include "starboard/client_porting/poem/string_poem.h" | |
| #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, ®exp->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; | |
| } | |
| int32_t result = regexp->fMatcher->start(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; | |
| } | |
| int32_t result = regexp->fMatcher->end(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; | |
| 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 = uhash_geti(regexp->fPat->fNamedCaptureMap, &groupName); | |
| 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 status = U_ZERO_ERROR; | |
| srcIdx = utext_extract(m->fInputText, 0, nativeIdx, NULL, 0, &status); | |
| } | |
| 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 | |