958 lines
30 KiB
C++
958 lines
30 KiB
C++
//
|
|
// file: rematch.cpp
|
|
//
|
|
// Contains the implementation of class RegexMatcher,
|
|
// which is one of the main API classes for the ICU regular expression package.
|
|
//
|
|
/*
|
|
**********************************************************************
|
|
* Copyright (C) 2002 International Business Machines Corporation *
|
|
* and others. All rights reserved. *
|
|
**********************************************************************
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
#if !UCONFIG_NO_REGULAR_EXPRESSIONS
|
|
|
|
#include "unicode/regex.h"
|
|
#include "unicode/uniset.h"
|
|
#include "unicode/uchar.h"
|
|
#include "uassert.h"
|
|
#include "uvector.h"
|
|
#include "regeximp.h"
|
|
|
|
#include "stdio.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Constructor and Destructor
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
RegexMatcher::RegexMatcher(const RegexPattern *pat) {
|
|
fPattern = pat;
|
|
fInput = NULL;
|
|
fInputLength = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
fBackTrackStack = new UStack(status); // TODO: do something with status.
|
|
fCaptureStarts = new UVector(status);
|
|
fCaptureEnds = new UVector(status);
|
|
int i;
|
|
for (i=0; i<=fPattern->fNumCaptureGroups; i++) {
|
|
fCaptureStarts->addElement(-1, status);
|
|
fCaptureEnds ->addElement(-1, status);
|
|
}
|
|
reset();
|
|
}
|
|
|
|
|
|
|
|
RegexMatcher::~RegexMatcher() {
|
|
delete fBackTrackStack;
|
|
delete fCaptureStarts;
|
|
delete fCaptureEnds;
|
|
}
|
|
|
|
|
|
|
|
static const UChar BACKSLASH = 0x5c;
|
|
static const UChar DOLLARSIGN = 0x24;
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// appendReplacement
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
RegexMatcher &RegexMatcher::appendReplacement(UnicodeString &dest,
|
|
const UnicodeString &replacement,
|
|
UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
return *this;
|
|
}
|
|
if (fMatch == FALSE) {
|
|
status = U_REGEX_INVALID_STATE;
|
|
return *this;
|
|
}
|
|
|
|
// Copy input string from the end of previous match to start of current match
|
|
int32_t len = fMatchStart-fLastMatchEnd;
|
|
if (len > 0) {
|
|
dest.append(*fInput, fLastMatchEnd, len);
|
|
}
|
|
|
|
|
|
// scan the replacement text, looking for substitutions ($n) and \escapes.
|
|
// TODO: optimize this loop by efficiently scanning for '$' or '\'
|
|
int32_t replLen = replacement.length();
|
|
int32_t replIdx = 0;
|
|
while (replIdx<replLen) {
|
|
UChar c = replacement.charAt(replIdx);
|
|
replIdx++;
|
|
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 >= replLen) {
|
|
break;
|
|
}
|
|
c = replacement.charAt(replIdx);
|
|
replIdx++;
|
|
dest.append(c);
|
|
continue;
|
|
}
|
|
|
|
if (c != DOLLARSIGN) {
|
|
// Normal char, not a $. Copy it out without further checks.
|
|
dest.append(c);
|
|
continue;
|
|
}
|
|
|
|
// We've got a $. Pick up a capture group number if one follows.
|
|
// Consume at most the number of digits necessary for the largest capture
|
|
// number that is valid for this pattern.
|
|
|
|
int32_t numDigits = 0;
|
|
int32_t groupNum = 0;
|
|
UChar32 digitC;
|
|
for (;;) {
|
|
if (replIdx >= replLen) {
|
|
break;
|
|
}
|
|
digitC = replacement.char32At(replIdx);
|
|
if (u_isdigit(digitC) == FALSE) {
|
|
break;
|
|
}
|
|
replIdx = replacement.moveIndex32(replIdx, 1);
|
|
groupNum=groupNum*10 + u_charDigitValue(digitC);
|
|
numDigits++;
|
|
if (numDigits >= fPattern->fMaxCaptureDigits) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if (numDigits == 0) {
|
|
// The $ didn't introduce a group number at all.
|
|
// Treat it as just part of the substitution text.
|
|
dest.append(DOLLARSIGN);
|
|
continue;
|
|
}
|
|
|
|
// Finally, append the capture group data to the destination.
|
|
dest.append(group(groupNum, status));
|
|
if (U_FAILURE(status)) {
|
|
// Can fail if group number is out of range.
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// appendTail Intended to be used in conjunction with appendReplacement()
|
|
// To the destination string, append everything following
|
|
// the last match position from the input string.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
UnicodeString &RegexMatcher::appendTail(UnicodeString &dest) {
|
|
int32_t len = fInputLength-fMatchEnd;
|
|
if (len > 0) {
|
|
dest.append(*fInput, fMatchEnd, len);
|
|
}
|
|
return dest;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// end
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
int32_t RegexMatcher::end(UErrorCode &err) const {
|
|
return end(0, err);
|
|
}
|
|
|
|
|
|
|
|
int32_t RegexMatcher::end(int group, UErrorCode &err) const {
|
|
if (U_FAILURE(err)) {
|
|
return -1;
|
|
}
|
|
if (fMatch == FALSE) {
|
|
err = U_REGEX_INVALID_STATE;
|
|
return -1;
|
|
}
|
|
if (group < 0 || group > fPattern->fNumCaptureGroups) {
|
|
err = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return -1;
|
|
}
|
|
int32_t e = -1;
|
|
if (group == 0) {
|
|
e = fMatchEnd;
|
|
} else {
|
|
// Note: When the match engine backs out of a capture group, it sets the
|
|
// group's start position to -1. The end position is left with junk.
|
|
// So, before returning an end position, we must first check that
|
|
// the start position indicates that the group matched something.
|
|
int32_t s = fCaptureStarts->elementAti(group);
|
|
if (s != -1) {
|
|
e = fCaptureEnds->elementAti(group);
|
|
}
|
|
}
|
|
return e;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// find()
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
UBool RegexMatcher::find() {
|
|
// Start at the position of the last match end. (Will be zero if the
|
|
// matcher has been reset.
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
int32_t startPos;
|
|
for (startPos=fMatchEnd; startPos < fInputLength; startPos = fInput->moveIndex32(startPos, 1)) {
|
|
MatchAt(startPos, status);
|
|
if (U_FAILURE(status)) {
|
|
return FALSE;
|
|
}
|
|
if (fMatch) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
UBool RegexMatcher::find(int32_t start, UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
return FALSE;
|
|
}
|
|
if (start < 0 || start >= fInputLength) {
|
|
status = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return FALSE;
|
|
}
|
|
this->reset();
|
|
|
|
// TODO: optimize a search for the first char of a possible match.
|
|
// TODO: optimize the search for a leading literal string.
|
|
// TODO: optimize based on the minimum length of a possible match
|
|
int32_t startPos;
|
|
for (startPos=start; startPos < fInputLength; startPos=fInput->moveIndex32(startPos, 1)) {
|
|
MatchAt(startPos, status);
|
|
if (U_FAILURE(status)) {
|
|
return FALSE;
|
|
}
|
|
if (fMatch) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// group()
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
UnicodeString RegexMatcher::group(UErrorCode &status) const {
|
|
return group(0, status);
|
|
}
|
|
|
|
|
|
|
|
UnicodeString RegexMatcher::group(int32_t groupNum, UErrorCode &status) const {
|
|
int32_t s = start(groupNum, status);
|
|
int32_t e = end(groupNum, status);
|
|
|
|
// Note: calling start() and end() above will do all necessary checking that
|
|
// the group number is OK and that a match exists. status will be set.
|
|
if (U_FAILURE(status)) {
|
|
return UnicodeString();
|
|
}
|
|
|
|
if (s < 0) {
|
|
// A capture group wasn't part of the match
|
|
return UnicodeString();
|
|
}
|
|
U_ASSERT(s <= e);
|
|
return UnicodeString(*fInput, s, e-s);
|
|
}
|
|
|
|
|
|
|
|
|
|
int32_t RegexMatcher::groupCount() const {
|
|
return fPattern->fNumCaptureGroups;
|
|
}
|
|
|
|
|
|
|
|
const UnicodeString &RegexMatcher::input() const {
|
|
return *fInput;
|
|
}
|
|
|
|
|
|
|
|
|
|
UBool RegexMatcher::lookingAt(UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
return FALSE;
|
|
}
|
|
reset();
|
|
MatchAt(0, status);
|
|
return fMatch;
|
|
}
|
|
|
|
|
|
|
|
UBool RegexMatcher::matches(UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
return FALSE;
|
|
}
|
|
reset();
|
|
MatchAt(0, status);
|
|
UBool success = (fMatch && fMatchEnd==fInputLength);
|
|
return success;
|
|
}
|
|
|
|
|
|
|
|
|
|
const RegexPattern &RegexMatcher::pattern() const {
|
|
return *fPattern;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// replaceAll
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
UnicodeString RegexMatcher::replaceAll(const UnicodeString &replacement, UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
return *fInput;
|
|
}
|
|
UnicodeString destString;
|
|
for (reset(); find(); ) {
|
|
appendReplacement(destString, replacement, status);
|
|
if (U_FAILURE(status)) {
|
|
break;
|
|
}
|
|
}
|
|
appendTail(destString);
|
|
return destString;
|
|
}
|
|
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// replaceFirst
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
UnicodeString RegexMatcher::replaceFirst(const UnicodeString &replacement, UErrorCode &status) {
|
|
if (U_FAILURE(status)) {
|
|
return *fInput;
|
|
}
|
|
reset();
|
|
if (!find()) {
|
|
return *fInput;
|
|
}
|
|
|
|
UnicodeString destString;
|
|
appendReplacement(destString, replacement, status);
|
|
appendTail(destString);
|
|
return destString;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// reset
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
RegexMatcher &RegexMatcher::reset() {
|
|
fMatchStart = 0;
|
|
fMatchEnd = 0;
|
|
fLastMatchEnd = 0;
|
|
fMatch = FALSE;
|
|
int i;
|
|
for (i=0; i<=fPattern->fNumCaptureGroups; i++) {
|
|
fCaptureStarts->setElementAt(-1, i);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
RegexMatcher &RegexMatcher::reset(const UnicodeString &input) {
|
|
fInput = &input;
|
|
fInputLength = input.length();
|
|
reset();
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// start
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
int32_t RegexMatcher::start(UErrorCode &err) const {
|
|
return start(0, err);
|
|
}
|
|
|
|
|
|
|
|
|
|
int32_t RegexMatcher::start(int group, UErrorCode &err) const {
|
|
if (U_FAILURE(err)) {
|
|
return -1;
|
|
}
|
|
if (fMatch == FALSE) {
|
|
err = U_REGEX_INVALID_STATE;
|
|
return -1;
|
|
}
|
|
if (group < 0 || group > fPattern->fNumCaptureGroups) {
|
|
err = U_INDEX_OUTOFBOUNDS_ERROR;
|
|
return -1;
|
|
}
|
|
int32_t s;
|
|
if (group == 0) {
|
|
s = fMatchStart;
|
|
} else {
|
|
s = fCaptureStarts->elementAti(group);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// isWordBoundary
|
|
// in perl, "xab..cd..", \b is true at positions 0,3,5,7
|
|
// For us,
|
|
// If the current char is a combining mark,
|
|
// \b is FALSE.
|
|
// Else Scan backwards to the first non-combining char.
|
|
// We are at a boundary if the this char and the original chars are
|
|
// opposite in membership in \w set
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
UBool RegexMatcher::isWordBoundary(int32_t pos) {
|
|
UBool isBoundary = FALSE;
|
|
if (pos >= fInputLength) {
|
|
// off end of string. Not a boundary.
|
|
return FALSE;
|
|
}
|
|
|
|
// Determine whether char c at Pos is a member of the word set of chars.
|
|
UChar32 c = fInput->char32At(pos);
|
|
int8_t ctype = u_charType(c);
|
|
if (ctype==U_NON_SPACING_MARK || ctype==U_ENCLOSING_MARK) {
|
|
// Current char is a combining one. Not a boundary.
|
|
return FALSE;
|
|
}
|
|
UBool cIsWord = fPattern->fStaticSets[URX_ISWORD_SET]->contains(c);
|
|
|
|
// Back up until we come to a non-combining char, determine whether
|
|
// that char is a word char.
|
|
UBool prevCIsWord = FALSE;
|
|
int32_t prevPos = pos;
|
|
for (;;) {
|
|
if (prevPos == 0) {
|
|
break;
|
|
}
|
|
prevPos = fInput->moveIndex32(prevPos, -1);
|
|
UChar32 prevChar = fInput->char32At(prevPos);
|
|
int8_t prevCType = u_charType(prevChar);
|
|
if (!(prevCType==U_NON_SPACING_MARK || prevCType==U_ENCLOSING_MARK)) {
|
|
prevCIsWord = fPattern->fStaticSets[URX_ISWORD_SET]->contains(prevChar);
|
|
break;
|
|
}
|
|
}
|
|
isBoundary = cIsWord ^ prevCIsWord;
|
|
return isBoundary;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// backTrack Within the match engine, this function is called when
|
|
// a local match failure occurs, and the match needs to back
|
|
// track and proceed down another path.
|
|
//
|
|
// Note: Inline function. Keep its body above MatchAt().
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
void RegexMatcher::backTrack(int32_t &inputIdx, int32_t &patIdx) {
|
|
inputIdx = fBackTrackStack->popi();
|
|
patIdx = fBackTrackStack->popi();
|
|
int i;
|
|
for (i=1; i<=fPattern->fNumCaptureGroups; i++) {
|
|
int32_t cge = fBackTrackStack->popi();
|
|
fCaptureEnds->setElementAt(cge, i);
|
|
int32_t cgs = fBackTrackStack->popi();
|
|
fCaptureStarts->setElementAt(cgs, i);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------------------
|
|
//
|
|
// MatchAt This is the actual matching engine.
|
|
//
|
|
//--------------------------------------------------------------------------------
|
|
void RegexMatcher::MatchAt(int32_t startIdx, UErrorCode &status) {
|
|
int32_t inputIdx = startIdx; // Current position in the input string.
|
|
int32_t patIdx = 0; // Current position in the compiled pattern.
|
|
UBool isMatch = FALSE; // True if the we have a match.
|
|
|
|
int32_t op; // Operation from the compiled pattern, split into
|
|
int32_t opType; // the opcode
|
|
int32_t opValue; // and the operand value.
|
|
|
|
#ifdef REGEX_RUN_DEBUG
|
|
{
|
|
printf("MatchAt(startIdx=%d)\n", startIdx);
|
|
printf("Original Pattern: ");
|
|
int i;
|
|
for (i=0; i<fPattern->fPattern.length(); i++) {
|
|
printf("%c", fPattern->fPattern.charAt(i));
|
|
}
|
|
printf("\n");
|
|
printf("Input String: ");
|
|
for (i=0; i<fInput->length(); i++) {
|
|
UChar c = fInput->charAt(i);
|
|
if (c<32 || c>256) {
|
|
c = '.';
|
|
}
|
|
printf("%c", c);
|
|
}
|
|
printf("\n");
|
|
printf("\n");
|
|
printf("PatLoc inputIdx char\n");
|
|
}
|
|
#endif
|
|
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
|
|
// Clear out capture results from any previous match.
|
|
// Required for capture groups in patterns with | operations that may not match at all,
|
|
// although the pattern as a whole does match.
|
|
int i;
|
|
for (i=0; i<=fPattern->fNumCaptureGroups; i++) {
|
|
fCaptureStarts->setElementAt(-1, i);
|
|
}
|
|
|
|
// Cache frequently referenced items from the compiled pattern
|
|
// in local variables.
|
|
//
|
|
UVector *pat = fPattern->fCompiledPat;
|
|
const UnicodeString *litText = &fPattern->fLiteralText;
|
|
UVector *sets = fPattern->fSets;
|
|
int32_t inputLen = fInput->length();
|
|
|
|
|
|
//
|
|
// Main loop for interpreting the compiled pattern.
|
|
// One iteration of the loop per pattern operation performed.
|
|
//
|
|
for (;;) {
|
|
op = pat->elementAti(patIdx);
|
|
opType = URX_TYPE(op);
|
|
opValue = URX_VAL(op);
|
|
#ifdef REGEX_RUN_DEBUG
|
|
printf("inputIdx=%d inputChar=%c ", inputIdx, fInput->char32At(inputIdx));
|
|
fPattern->dumpOp(patIdx);
|
|
#endif
|
|
patIdx++;
|
|
|
|
switch (opType) {
|
|
|
|
|
|
case URX_NOP:
|
|
break;
|
|
|
|
|
|
case URX_BACKTRACK:
|
|
// Force a backtrack. In some circumstances, the pattern compiler
|
|
// will notice that the pattern can't possibly match anything, and will
|
|
// emit one of these at that point.
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
|
|
|
|
case URX_ONECHAR:
|
|
{
|
|
UChar32 inputChar = fInput->char32At(inputIdx);
|
|
if (inputChar == opValue && // if (match &&
|
|
!(inputChar == 0xffff && inputIdx >= fInputLength)) // ! end-of-input)
|
|
{
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
} else {
|
|
// No match. Back up to a saved state
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
case URX_STRING:
|
|
{
|
|
// Test input against a literal string.
|
|
// Strings require two slots in the compiled pattern, one for the
|
|
// offset to the string text, and one for the length.
|
|
int32_t stringStartIdx, stringLen;
|
|
stringStartIdx = opValue;
|
|
|
|
op = pat->elementAti(patIdx);
|
|
patIdx++;
|
|
opType = URX_TYPE(op);
|
|
opValue = URX_VAL(op);
|
|
U_ASSERT(opType == URX_STRING_LEN);
|
|
stringLen = opValue;
|
|
|
|
if (fInput->compareBetween(inputIdx,
|
|
inputIdx+stringLen,
|
|
*litText,
|
|
stringStartIdx,
|
|
stringStartIdx+stringLen) == 0)
|
|
{
|
|
// Success. Advance the current input position.
|
|
inputIdx += stringLen;
|
|
} else {
|
|
// No match. Back up matching to a saved state
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
case URX_STATE_SAVE:
|
|
// Save the state of all capture groups, the pattern continuation
|
|
// postion and the input position.
|
|
{
|
|
int i;
|
|
for (i=fPattern->fNumCaptureGroups; i>0; i--) {
|
|
fBackTrackStack->push(fCaptureStarts->elementAt(i), status);
|
|
fBackTrackStack->push(fCaptureEnds->elementAt(i), status);
|
|
}
|
|
fBackTrackStack->push(opValue, status); // pattern continuation position
|
|
fBackTrackStack->push(inputIdx, status); // current input position
|
|
}
|
|
break;
|
|
|
|
|
|
case URX_END:
|
|
// The match loop will exit via this path on a successful match,
|
|
// when we reach the end of the pattern.
|
|
isMatch = TRUE;
|
|
goto breakFromLoop;
|
|
|
|
case URX_START_CAPTURE:
|
|
U_ASSERT(opValue > 0 && opValue <= fPattern->fNumCaptureGroups);
|
|
fCaptureStarts->setElementAt(inputIdx, opValue);
|
|
break;
|
|
|
|
|
|
case URX_END_CAPTURE:
|
|
U_ASSERT(opValue > 0 && opValue <= fPattern->fNumCaptureGroups);
|
|
U_ASSERT(fCaptureStarts->elementAti(opValue) >= 0);
|
|
fCaptureEnds->setElementAt(inputIdx, opValue);
|
|
break;
|
|
|
|
|
|
case URX_DOLLAR: // $, test for End of line
|
|
// or for position before new line at end of input
|
|
if (inputIdx < inputLen-2) {
|
|
// We are no where near the end of input. Fail.
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
}
|
|
if (inputIdx >= inputLen) {
|
|
// We really are at the end of input. Success.
|
|
break;
|
|
}
|
|
// If we are positioned just before a new-line that is located at the
|
|
// end of input, succeed.
|
|
if (inputIdx == inputLen-1) {
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
if (c == 0x0a || c==0x0d || c==0x0c || c==0x85 ||c==0x2028 || c==0x2029) {
|
|
break; // At new-line at end of input. Success
|
|
}
|
|
}
|
|
|
|
if (inputIdx == inputLen-2) {
|
|
if (fInput->char32At(inputIdx) == 0x0d && fInput->char32At(inputIdx+1) == 0x0a) {
|
|
break; // At CR/LF at end of input. Success
|
|
}
|
|
}
|
|
|
|
backTrack(inputIdx, patIdx);
|
|
|
|
// TODO: support for multi-line mode.
|
|
break;
|
|
|
|
|
|
case URX_CARET: // ^, test for start of line
|
|
if (inputIdx != 0) {
|
|
backTrack(inputIdx, patIdx);
|
|
} // TODO: support for multi-line mode.
|
|
break;
|
|
|
|
|
|
case URX_BACKSLASH_A: // Test for start of input
|
|
if (inputIdx != 0) {
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
break;
|
|
|
|
case URX_BACKSLASH_B: // Test for word boundaries
|
|
{
|
|
UBool success = isWordBoundary(inputIdx);
|
|
success ^= (opValue != 0); // flip sense for \B
|
|
if (!success) {
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case URX_BACKSLASH_D: // Test for decimal digit
|
|
{
|
|
if (inputIdx >= fInputLength) {
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
}
|
|
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
int8_t ctype = u_charType(c);
|
|
UBool success = (ctype == U_DECIMAL_DIGIT_NUMBER);
|
|
success ^= (opValue != 0); // flip sense for \D
|
|
if (success) {
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
} else {
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
|
|
case URX_BACKSLASH_G: // Test for position at end of previous match
|
|
if (!((fMatch && inputIdx==fMatchEnd) || fMatch==FALSE && inputIdx==0)) {
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
break;
|
|
|
|
|
|
case URX_BACKSLASH_X: // Match combining character sequence
|
|
{ // Closer to Grapheme cluster than to Perl \X
|
|
// Fail if at end of input
|
|
if (inputIdx >= fInputLength) {
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
}
|
|
|
|
// Always consume one char
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
|
|
// Consume CR/LF as a pair
|
|
if (c == 0x0d) {
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
if (c == 0x0a) {
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Consume any combining marks following a non-control char
|
|
int8_t ctype = u_charType(c);
|
|
if (ctype != U_CONTROL_CHAR) {
|
|
for(;;) {
|
|
c = fInput->char32At(inputIdx);
|
|
ctype = u_charType(c);
|
|
// TODO: make a set and add the "other grapheme extend" chars
|
|
// to the list of stuff to be skipped over.
|
|
if (!(ctype == U_NON_SPACING_MARK || ctype == U_ENCLOSING_MARK)) {
|
|
break;
|
|
}
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
if (inputIdx >= fInputLength) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
case URX_BACKSLASH_Z: // Test for end of line
|
|
if (inputIdx < inputLen) {
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
case URX_STATIC_SETREF:
|
|
{
|
|
// Test input character against one of the predefined sets
|
|
// (Word Characters, for example)
|
|
// The high bit of the op value is a flag for the match polarity.
|
|
// 0: success if input char is in set.
|
|
// 1: success if input char is not in set.
|
|
UBool success = ((opValue & URX_NEG_SET) == URX_NEG_SET);
|
|
opValue &= ~URX_NEG_SET;
|
|
if (inputIdx < fInputLength) {
|
|
// There is input left. Pick up one char and test it for set membership.
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
U_ASSERT(opValue > 0 && opValue < URX_LAST_SET);
|
|
const UnicodeSet *s = fPattern->fStaticSets[opValue];
|
|
if (s->contains(c)) {
|
|
success = !success;
|
|
}
|
|
}
|
|
if (success) {
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
} else {
|
|
backTrack(inputIdx, patIdx);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case URX_SETREF:
|
|
if (inputIdx < fInputLength) {
|
|
// There is input left. Pick up one char and test it for set membership.
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
U_ASSERT(opValue > 0 && opValue < sets->size());
|
|
UnicodeSet *s = (UnicodeSet *)sets->elementAt(opValue);
|
|
if (s->contains(c)) {
|
|
// The character is in the set. A Match.
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
break;
|
|
}
|
|
}
|
|
// Either at end of input, or the character wasn't in the set.
|
|
// Either way, we need to back track out.
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
|
|
|
|
case URX_DOTANY:
|
|
{
|
|
// . matches anything
|
|
if (inputIdx >= fInputLength) {
|
|
// At end of input. Match failed. Backtrack out.
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
}
|
|
// There is input left. Advance over one char, unless we've hit end-of-line
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
if (c == 0x0a || c==0x0d || c==0x0c || c==0x85 ||c==0x2028 || c==0x2029) {
|
|
// End of line in normal mode. . does not match.
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case URX_DOTANY_ALL:
|
|
{
|
|
// ., in dot-matches-all (including new lines) mode
|
|
// . matches anything
|
|
if (inputIdx >= fInputLength) {
|
|
// At end of input. Match failed. Backtrack out.
|
|
backTrack(inputIdx, patIdx);
|
|
break;
|
|
}
|
|
// There is input left. Advance over one char, unless we've hit end-of-line
|
|
UChar32 c = fInput->char32At(inputIdx);
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
if (c == 0x0a || c==0x0d || c==0x0c || c==0x85 ||c==0x2028 || c==0x2029) {
|
|
// In the case of a CR/LF, we need to advance over both.
|
|
UChar32 nextc = fInput->char32At(inputIdx);
|
|
if (c == 0x0d && nextc == 0x0a) {
|
|
inputIdx = fInput->moveIndex32(inputIdx, 1);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case URX_JMP:
|
|
patIdx = opValue;
|
|
break;
|
|
|
|
case URX_FAIL:
|
|
isMatch = FALSE;
|
|
goto breakFromLoop;
|
|
|
|
|
|
default:
|
|
// Trouble. The compiled pattern contains an entry with an
|
|
// unrecognized type tag.
|
|
U_ASSERT(FALSE);
|
|
}
|
|
|
|
if (U_FAILURE(status)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
breakFromLoop:
|
|
fMatch = isMatch;
|
|
if (isMatch) {
|
|
fLastMatchEnd = fMatchEnd;
|
|
fMatchStart = startIdx;
|
|
fMatchEnd = inputIdx;
|
|
REGEX_RUN_DEBUG_PRINTF("Match. start=%d end=%d\n\n", fMatchStart, fMatchEnd);
|
|
}
|
|
else
|
|
{
|
|
REGEX_RUN_DEBUG_PRINTF("No match\n\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
const char RegexMatcher::fgClassID = 0;
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif // !UCONFIG_NO_REGULAR_EXPRESSIONS
|
|
|