diff options
Diffstat (limited to 'deps/node/deps/icu-small/source/i18n/repattrn.cpp')
| -rw-r--r-- | deps/node/deps/icu-small/source/i18n/repattrn.cpp | 864 |
1 files changed, 0 insertions, 864 deletions
diff --git a/deps/node/deps/icu-small/source/i18n/repattrn.cpp b/deps/node/deps/icu-small/source/i18n/repattrn.cpp deleted file mode 100644 index b0387306..00000000 --- a/deps/node/deps/icu-small/source/i18n/repattrn.cpp +++ /dev/null @@ -1,864 +0,0 @@ -// © 2016 and later: Unicode, Inc. and others. -// License & terms of use: http://www.unicode.org/copyright.html -// -// file: repattrn.cpp -// -/* -*************************************************************************** -* Copyright (C) 2002-2016 International Business Machines Corporation -* and others. All rights reserved. -*************************************************************************** -*/ - -#include "unicode/utypes.h" - -#if !UCONFIG_NO_REGULAR_EXPRESSIONS - -#include "unicode/regex.h" -#include "unicode/uclean.h" -#include "cmemory.h" -#include "cstr.h" -#include "uassert.h" -#include "uhash.h" -#include "uvector.h" -#include "uvectr32.h" -#include "uvectr64.h" -#include "regexcmp.h" -#include "regeximp.h" -#include "regexst.h" - -U_NAMESPACE_BEGIN - -//-------------------------------------------------------------------------- -// -// RegexPattern Default Constructor -// -//-------------------------------------------------------------------------- -RegexPattern::RegexPattern() { - // Init all of this instances data. - init(); -} - - -//-------------------------------------------------------------------------- -// -// Copy Constructor Note: This is a rather inefficient implementation, -// but it probably doesn't matter. -// -//-------------------------------------------------------------------------- -RegexPattern::RegexPattern(const RegexPattern &other) : UObject(other) { - init(); - *this = other; -} - - - -//-------------------------------------------------------------------------- -// -// Assignment Operator -// -//-------------------------------------------------------------------------- -RegexPattern &RegexPattern::operator = (const RegexPattern &other) { - if (this == &other) { - // Source and destination are the same. Don't do anything. - return *this; - } - - // Clean out any previous contents of object being assigned to. - zap(); - - // Give target object a default initialization - init(); - - // Copy simple fields - fDeferredStatus = other.fDeferredStatus; - - if (U_FAILURE(fDeferredStatus)) { - return *this; - } - - if (other.fPatternString == NULL) { - fPatternString = NULL; - fPattern = utext_clone(fPattern, other.fPattern, FALSE, TRUE, &fDeferredStatus); - } else { - fPatternString = new UnicodeString(*(other.fPatternString)); - if (fPatternString == NULL) { - fDeferredStatus = U_MEMORY_ALLOCATION_ERROR; - } else { - fPattern = utext_openConstUnicodeString(NULL, fPatternString, &fDeferredStatus); - } - } - if (U_FAILURE(fDeferredStatus)) { - return *this; - } - - fFlags = other.fFlags; - fLiteralText = other.fLiteralText; - fMinMatchLen = other.fMinMatchLen; - fFrameSize = other.fFrameSize; - fDataSize = other.fDataSize; - fStaticSets = other.fStaticSets; - fStaticSets8 = other.fStaticSets8; - - fStartType = other.fStartType; - fInitialStringIdx = other.fInitialStringIdx; - fInitialStringLen = other.fInitialStringLen; - *fInitialChars = *other.fInitialChars; - fInitialChar = other.fInitialChar; - *fInitialChars8 = *other.fInitialChars8; - fNeedsAltInput = other.fNeedsAltInput; - - // Copy the pattern. It's just values, nothing deep to copy. - fCompiledPat->assign(*other.fCompiledPat, fDeferredStatus); - fGroupMap->assign(*other.fGroupMap, fDeferredStatus); - - // Copy the Unicode Sets. - // Could be made more efficient if the sets were reference counted and shared, - // but I doubt that pattern copying will be particularly common. - // Note: init() already added an empty element zero to fSets - int32_t i; - int32_t numSets = other.fSets->size(); - fSets8 = new Regex8BitSet[numSets]; - if (fSets8 == NULL) { - fDeferredStatus = U_MEMORY_ALLOCATION_ERROR; - return *this; - } - for (i=1; i<numSets; i++) { - if (U_FAILURE(fDeferredStatus)) { - return *this; - } - UnicodeSet *sourceSet = (UnicodeSet *)other.fSets->elementAt(i); - UnicodeSet *newSet = new UnicodeSet(*sourceSet); - if (newSet == NULL) { - fDeferredStatus = U_MEMORY_ALLOCATION_ERROR; - break; - } - fSets->addElement(newSet, fDeferredStatus); - fSets8[i] = other.fSets8[i]; - } - - // Copy the named capture group hash map. - int32_t hashPos = UHASH_FIRST; - while (const UHashElement *hashEl = uhash_nextElement(other.fNamedCaptureMap, &hashPos)) { - if (U_FAILURE(fDeferredStatus)) { - break; - } - const UnicodeString *name = (const UnicodeString *)hashEl->key.pointer; - UnicodeString *key = new UnicodeString(*name); - int32_t val = hashEl->value.integer; - if (key == NULL) { - fDeferredStatus = U_MEMORY_ALLOCATION_ERROR; - } else { - uhash_puti(fNamedCaptureMap, key, val, &fDeferredStatus); - } - } - return *this; -} - - -//-------------------------------------------------------------------------- -// -// init Shared initialization for use by constructors. -// Bring an uninitialized RegexPattern up to a default state. -// -//-------------------------------------------------------------------------- -void RegexPattern::init() { - fFlags = 0; - fCompiledPat = 0; - fLiteralText.remove(); - fSets = NULL; - fSets8 = NULL; - fDeferredStatus = U_ZERO_ERROR; - fMinMatchLen = 0; - fFrameSize = 0; - fDataSize = 0; - fGroupMap = NULL; - fStaticSets = NULL; - fStaticSets8 = NULL; - fStartType = START_NO_INFO; - fInitialStringIdx = 0; - fInitialStringLen = 0; - fInitialChars = NULL; - fInitialChar = 0; - fInitialChars8 = NULL; - fNeedsAltInput = FALSE; - fNamedCaptureMap = NULL; - - fPattern = NULL; // will be set later - fPatternString = NULL; // may be set later - fCompiledPat = new UVector64(fDeferredStatus); - fGroupMap = new UVector32(fDeferredStatus); - fSets = new UVector(fDeferredStatus); - fInitialChars = new UnicodeSet; - fInitialChars8 = new Regex8BitSet; - fNamedCaptureMap = uhash_open(uhash_hashUnicodeString, // Key hash function - uhash_compareUnicodeString, // Key comparator function - uhash_compareLong, // Value comparator function - &fDeferredStatus); - if (U_FAILURE(fDeferredStatus)) { - return; - } - if (fCompiledPat == NULL || fGroupMap == NULL || fSets == NULL || - fInitialChars == NULL || fInitialChars8 == NULL || fNamedCaptureMap == NULL) { - fDeferredStatus = U_MEMORY_ALLOCATION_ERROR; - return; - } - - // Slot zero of the vector of sets is reserved. Fill it here. - fSets->addElement((int32_t)0, fDeferredStatus); - - // fNamedCaptureMap owns its key strings, type (UnicodeString *) - uhash_setKeyDeleter(fNamedCaptureMap, uprv_deleteUObject); -} - - -//-------------------------------------------------------------------------- -// -// zap Delete everything owned by this RegexPattern. -// -//-------------------------------------------------------------------------- -void RegexPattern::zap() { - delete fCompiledPat; - fCompiledPat = NULL; - int i; - for (i=1; i<fSets->size(); i++) { - UnicodeSet *s; - s = (UnicodeSet *)fSets->elementAt(i); - if (s != NULL) { - delete s; - } - } - delete fSets; - fSets = NULL; - delete[] fSets8; - fSets8 = NULL; - delete fGroupMap; - fGroupMap = NULL; - delete fInitialChars; - fInitialChars = NULL; - delete fInitialChars8; - fInitialChars8 = NULL; - if (fPattern != NULL) { - utext_close(fPattern); - fPattern = NULL; - } - if (fPatternString != NULL) { - delete fPatternString; - fPatternString = NULL; - } - uhash_close(fNamedCaptureMap); - fNamedCaptureMap = NULL; -} - - -//-------------------------------------------------------------------------- -// -// Destructor -// -//-------------------------------------------------------------------------- -RegexPattern::~RegexPattern() { - zap(); -} - - -//-------------------------------------------------------------------------- -// -// Clone -// -//-------------------------------------------------------------------------- -RegexPattern *RegexPattern::clone() const { - RegexPattern *copy = new RegexPattern(*this); - return copy; -} - - -//-------------------------------------------------------------------------- -// -// operator == (comparison) Consider to patterns to be == if the -// pattern strings and the flags are the same. -// Note that pattern strings with the same -// characters can still be considered different. -// -//-------------------------------------------------------------------------- -UBool RegexPattern::operator ==(const RegexPattern &other) const { - if (this->fFlags == other.fFlags && this->fDeferredStatus == other.fDeferredStatus) { - if (this->fPatternString != NULL && other.fPatternString != NULL) { - return *(this->fPatternString) == *(other.fPatternString); - } else if (this->fPattern == NULL) { - if (other.fPattern == NULL) { - return TRUE; - } - } else if (other.fPattern != NULL) { - UTEXT_SETNATIVEINDEX(this->fPattern, 0); - UTEXT_SETNATIVEINDEX(other.fPattern, 0); - return utext_equals(this->fPattern, other.fPattern); - } - } - return FALSE; -} - -//--------------------------------------------------------------------- -// -// compile -// -//--------------------------------------------------------------------- -RegexPattern * U_EXPORT2 -RegexPattern::compile(const UnicodeString ®ex, - uint32_t flags, - UParseError &pe, - UErrorCode &status) -{ - if (U_FAILURE(status)) { - return NULL; - } - - const uint32_t allFlags = UREGEX_CANON_EQ | UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | - UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD | - UREGEX_ERROR_ON_UNKNOWN_ESCAPES | UREGEX_UNIX_LINES | UREGEX_LITERAL; - - if ((flags & ~allFlags) != 0) { - status = U_REGEX_INVALID_FLAG; - return NULL; - } - - if ((flags & UREGEX_CANON_EQ) != 0) { - status = U_REGEX_UNIMPLEMENTED; - return NULL; - } - - RegexPattern *This = new RegexPattern; - if (This == NULL) { - status = U_MEMORY_ALLOCATION_ERROR; - return NULL; - } - if (U_FAILURE(This->fDeferredStatus)) { - status = This->fDeferredStatus; - delete This; - return NULL; - } - This->fFlags = flags; - - RegexCompile compiler(This, status); - compiler.compile(regex, pe, status); - - if (U_FAILURE(status)) { - delete This; - This = NULL; - } - - return This; -} - - -// -// compile, UText mode -// -RegexPattern * U_EXPORT2 -RegexPattern::compile(UText *regex, - uint32_t flags, - UParseError &pe, - UErrorCode &status) -{ - if (U_FAILURE(status)) { - return NULL; - } - - const uint32_t allFlags = UREGEX_CANON_EQ | UREGEX_CASE_INSENSITIVE | UREGEX_COMMENTS | - UREGEX_DOTALL | UREGEX_MULTILINE | UREGEX_UWORD | - UREGEX_ERROR_ON_UNKNOWN_ESCAPES | UREGEX_UNIX_LINES | UREGEX_LITERAL; - - if ((flags & ~allFlags) != 0) { - status = U_REGEX_INVALID_FLAG; - return NULL; - } - - if ((flags & UREGEX_CANON_EQ) != 0) { - status = U_REGEX_UNIMPLEMENTED; - return NULL; - } - - RegexPattern *This = new RegexPattern; - if (This == NULL) { - status = U_MEMORY_ALLOCATION_ERROR; - return NULL; - } - if (U_FAILURE(This->fDeferredStatus)) { - status = This->fDeferredStatus; - delete This; - return NULL; - } - This->fFlags = flags; - - RegexCompile compiler(This, status); - compiler.compile(regex, pe, status); - - if (U_FAILURE(status)) { - delete This; - This = NULL; - } - - return This; -} - -// -// compile with default flags. -// -RegexPattern * U_EXPORT2 -RegexPattern::compile(const UnicodeString ®ex, - UParseError &pe, - UErrorCode &err) -{ - return compile(regex, 0, pe, err); -} - - -// -// compile with default flags, UText mode -// -RegexPattern * U_EXPORT2 -RegexPattern::compile(UText *regex, - UParseError &pe, - UErrorCode &err) -{ - return compile(regex, 0, pe, err); -} - - -// -// compile with no UParseErr parameter. -// -RegexPattern * U_EXPORT2 -RegexPattern::compile(const UnicodeString ®ex, - uint32_t flags, - UErrorCode &err) -{ - UParseError pe; - return compile(regex, flags, pe, err); -} - - -// -// compile with no UParseErr parameter, UText mode -// -RegexPattern * U_EXPORT2 -RegexPattern::compile(UText *regex, - uint32_t flags, - UErrorCode &err) -{ - UParseError pe; - return compile(regex, flags, pe, err); -} - - -//--------------------------------------------------------------------- -// -// flags -// -//--------------------------------------------------------------------- -uint32_t RegexPattern::flags() const { - return fFlags; -} - - -//--------------------------------------------------------------------- -// -// matcher(UnicodeString, err) -// -//--------------------------------------------------------------------- -RegexMatcher *RegexPattern::matcher(const UnicodeString &input, - UErrorCode &status) const { - RegexMatcher *retMatcher = matcher(status); - if (retMatcher != NULL) { - retMatcher->fDeferredStatus = status; - retMatcher->reset(input); - } - return retMatcher; -} - - -//--------------------------------------------------------------------- -// -// matcher(status) -// -//--------------------------------------------------------------------- -RegexMatcher *RegexPattern::matcher(UErrorCode &status) const { - RegexMatcher *retMatcher = NULL; - - if (U_FAILURE(status)) { - return NULL; - } - if (U_FAILURE(fDeferredStatus)) { - status = fDeferredStatus; - return NULL; - } - - retMatcher = new RegexMatcher(this); - if (retMatcher == NULL) { - status = U_MEMORY_ALLOCATION_ERROR; - return NULL; - } - return retMatcher; -} - - - -//--------------------------------------------------------------------- -// -// matches Convenience function to test for a match, starting -// with a pattern string and a data string. -// -//--------------------------------------------------------------------- -UBool U_EXPORT2 RegexPattern::matches(const UnicodeString ®ex, - const UnicodeString &input, - UParseError &pe, - UErrorCode &status) { - - if (U_FAILURE(status)) {return FALSE;} - - UBool retVal; - RegexPattern *pat = NULL; - RegexMatcher *matcher = NULL; - - pat = RegexPattern::compile(regex, 0, pe, status); - matcher = pat->matcher(input, status); - retVal = matcher->matches(status); - - delete matcher; - delete pat; - return retVal; -} - - -// -// matches, UText mode -// -UBool U_EXPORT2 RegexPattern::matches(UText *regex, - UText *input, - UParseError &pe, - UErrorCode &status) { - - if (U_FAILURE(status)) {return FALSE;} - - UBool retVal = FALSE; - RegexPattern *pat = NULL; - RegexMatcher *matcher = NULL; - - pat = RegexPattern::compile(regex, 0, pe, status); - matcher = pat->matcher(status); - if (U_SUCCESS(status)) { - matcher->reset(input); - retVal = matcher->matches(status); - } - - delete matcher; - delete pat; - return retVal; -} - - - - - -//--------------------------------------------------------------------- -// -// pattern -// -//--------------------------------------------------------------------- -UnicodeString RegexPattern::pattern() const { - if (fPatternString != NULL) { - return *fPatternString; - } else if (fPattern == NULL) { - return UnicodeString(); - } else { - UErrorCode status = U_ZERO_ERROR; - int64_t nativeLen = utext_nativeLength(fPattern); - int32_t len16 = utext_extract(fPattern, 0, nativeLen, NULL, 0, &status); // buffer overflow error - UnicodeString result; - - status = U_ZERO_ERROR; - UChar *resultChars = result.getBuffer(len16); - utext_extract(fPattern, 0, nativeLen, resultChars, len16, &status); // unterminated warning - result.releaseBuffer(len16); - - return result; - } -} - - - - -//--------------------------------------------------------------------- -// -// patternText -// -//--------------------------------------------------------------------- -UText *RegexPattern::patternText(UErrorCode &status) const { - if (U_FAILURE(status)) {return NULL;} - status = U_ZERO_ERROR; - - if (fPattern != NULL) { - return fPattern; - } else { - RegexStaticSets::initGlobals(&status); - return RegexStaticSets::gStaticSets->fEmptyText; - } -} - - -//-------------------------------------------------------------------------------- -// -// groupNumberFromName() -// -//-------------------------------------------------------------------------------- -int32_t RegexPattern::groupNumberFromName(const UnicodeString &groupName, UErrorCode &status) const { - if (U_FAILURE(status)) { - return 0; - } - - // No need to explicitly check for syntactically valid names. - // Invalid ones will never be in the map, and the lookup will fail. - - int32_t number = uhash_geti(fNamedCaptureMap, &groupName); - if (number == 0) { - status = U_REGEX_INVALID_CAPTURE_GROUP_NAME; - } - return number; -} - -int32_t RegexPattern::groupNumberFromName(const char *groupName, int32_t nameLength, UErrorCode &status) const { - if (U_FAILURE(status)) { - return 0; - } - UnicodeString name(groupName, nameLength, US_INV); - return groupNumberFromName(name, status); -} - - -//--------------------------------------------------------------------- -// -// split -// -//--------------------------------------------------------------------- -int32_t RegexPattern::split(const UnicodeString &input, - UnicodeString dest[], - int32_t destCapacity, - UErrorCode &status) const -{ - if (U_FAILURE(status)) { - return 0; - }; - - RegexMatcher m(this); - int32_t r = 0; - // Check m's status to make sure all is ok. - if (U_SUCCESS(m.fDeferredStatus)) { - r = m.split(input, dest, destCapacity, status); - } - return r; -} - -// -// split, UText mode -// -int32_t RegexPattern::split(UText *input, - UText *dest[], - int32_t destCapacity, - UErrorCode &status) const -{ - if (U_FAILURE(status)) { - return 0; - }; - - RegexMatcher m(this); - int32_t r = 0; - // Check m's status to make sure all is ok. - if (U_SUCCESS(m.fDeferredStatus)) { - r = m.split(input, dest, destCapacity, status); - } - return r; -} - - -//--------------------------------------------------------------------- -// -// dump Output the compiled form of the pattern. -// Debugging function only. -// -//--------------------------------------------------------------------- -void RegexPattern::dumpOp(int32_t index) const { - (void)index; // Suppress warnings in non-debug build. -#if defined(REGEX_DEBUG) - static const char * const opNames[] = {URX_OPCODE_NAMES}; - int32_t op = fCompiledPat->elementAti(index); - int32_t val = URX_VAL(op); - int32_t type = URX_TYPE(op); - int32_t pinnedType = type; - if ((uint32_t)pinnedType >= UPRV_LENGTHOF(opNames)) { - pinnedType = 0; - } - - printf("%4d %08x %-15s ", index, op, opNames[pinnedType]); - switch (type) { - case URX_NOP: - case URX_DOTANY: - case URX_DOTANY_ALL: - case URX_FAIL: - case URX_CARET: - case URX_DOLLAR: - case URX_BACKSLASH_G: - case URX_BACKSLASH_X: - case URX_END: - case URX_DOLLAR_M: - case URX_CARET_M: - // Types with no operand field of interest. - break; - - case URX_RESERVED_OP: - case URX_START_CAPTURE: - case URX_END_CAPTURE: - case URX_STATE_SAVE: - case URX_JMP: - case URX_JMP_SAV: - case URX_JMP_SAV_X: - case URX_BACKSLASH_B: - case URX_BACKSLASH_BU: - case URX_BACKSLASH_D: - case URX_BACKSLASH_Z: - case URX_STRING_LEN: - case URX_CTR_INIT: - case URX_CTR_INIT_NG: - case URX_CTR_LOOP: - case URX_CTR_LOOP_NG: - case URX_RELOC_OPRND: - case URX_STO_SP: - case URX_LD_SP: - case URX_BACKREF: - case URX_STO_INP_LOC: - case URX_JMPX: - case URX_LA_START: - case URX_LA_END: - case URX_BACKREF_I: - case URX_LB_START: - case URX_LB_CONT: - case URX_LB_END: - case URX_LBN_CONT: - case URX_LBN_END: - case URX_LOOP_C: - case URX_LOOP_DOT_I: - case URX_BACKSLASH_H: - case URX_BACKSLASH_R: - case URX_BACKSLASH_V: - // types with an integer operand field. - printf("%d", val); - break; - - case URX_ONECHAR: - case URX_ONECHAR_I: - if (val < 0x20) { - printf("%#x", val); - } else { - printf("'%s'", CStr(UnicodeString(val))()); - } - break; - - case URX_STRING: - case URX_STRING_I: - { - int32_t lengthOp = fCompiledPat->elementAti(index+1); - U_ASSERT(URX_TYPE(lengthOp) == URX_STRING_LEN); - int32_t length = URX_VAL(lengthOp); - UnicodeString str(fLiteralText, val, length); - printf("%s", CStr(str)()); - } - break; - - case URX_SETREF: - case URX_LOOP_SR_I: - { - UnicodeString s; - UnicodeSet *set = (UnicodeSet *)fSets->elementAt(val); - set->toPattern(s, TRUE); - printf("%s", CStr(s)()); - } - break; - - case URX_STATIC_SETREF: - case URX_STAT_SETREF_N: - { - UnicodeString s; - if (val & URX_NEG_SET) { - printf("NOT "); - val &= ~URX_NEG_SET; - } - UnicodeSet *set = fStaticSets[val]; - set->toPattern(s, TRUE); - printf("%s", CStr(s)()); - } - break; - - - default: - printf("??????"); - break; - } - printf("\n"); -#endif -} - - -void RegexPattern::dumpPattern() const { -#if defined(REGEX_DEBUG) - int index; - - UnicodeString patStr; - for (UChar32 c = utext_next32From(fPattern, 0); c != U_SENTINEL; c = utext_next32(fPattern)) { - patStr.append(c); - } - printf("Original Pattern: \"%s\"\n", CStr(patStr)()); - printf(" Min Match Length: %d\n", fMinMatchLen); - printf(" Match Start Type: %s\n", START_OF_MATCH_STR(fStartType)); - if (fStartType == START_STRING) { - UnicodeString initialString(fLiteralText,fInitialStringIdx, fInitialStringLen); - printf(" Initial match string: \"%s\"\n", CStr(initialString)()); - } else if (fStartType == START_SET) { - UnicodeString s; - fInitialChars->toPattern(s, TRUE); - printf(" Match First Chars: %s\n", CStr(s)()); - - } else if (fStartType == START_CHAR) { - printf(" First char of Match: "); - if (fInitialChar > 0x20) { - printf("'%s'\n", CStr(UnicodeString(fInitialChar))()); - } else { - printf("%#x\n", fInitialChar); - } - } - - printf("Named Capture Groups:\n"); - if (uhash_count(fNamedCaptureMap) == 0) { - printf(" None\n"); - } else { - int32_t pos = UHASH_FIRST; - const UHashElement *el = NULL; - while ((el = uhash_nextElement(fNamedCaptureMap, &pos))) { - const UnicodeString *name = (const UnicodeString *)el->key.pointer; - int32_t number = el->value.integer; - printf(" %d\t%s\n", number, CStr(*name)()); - } - } - - printf("\nIndex Binary Type Operand\n" \ - "-------------------------------------------\n"); - for (index = 0; index<fCompiledPat->size(); index++) { - dumpOp(index); - } - printf("\n\n"); -#endif -} - - - -UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RegexPattern) - -U_NAMESPACE_END -#endif // !UCONFIG_NO_REGULAR_EXPRESSIONS |