865 lines
24 KiB
C++
865 lines
24 KiB
C++
// Copyright (C) 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
|