struct ParenthesesDisjunctionContext;

struct BackTrackInfoParentheses {

uintptr_t matchAmount;

ParenthesesDisjunctionContext* lastContext;

};

static inline void appendParenthesesDisjunctionContext(BackTrackInfoParentheses* backTrack, ParenthesesDisjunctionContext* context)

{

context->next = backTrack->lastContext;

backTrack->lastContext = context;

++backTrack->matchAmount;

}

static inline void popParenthesesDisjunctionContext(BackTrackInfoParentheses* backTrack)

{

RELEASE_ASSERT(backTrack->matchAmount);

RELEASE_ASSERT(backTrack->lastContext);

backTrack->lastContext = backTrack->lastContext->next;

--backTrack->matchAmount;

}

struct DisjunctionContext

{

DisjunctionContext() = default;

void* operator new(size_t, void* where)

{

return where;

}

static size_t allocationSize(unsigned numberOfFrames)

{

static_assert(alignof(DisjunctionContext) <= sizeof(void*), "");

size_t rawSize = (sizeof(DisjunctionContext) - sizeof(uintptr_t) + Checked<size_t>(numberOfFrames) * sizeof(uintptr_t)).unsafeGet();

size_t roundedSize = roundUpToMultipleOf<sizeof(void*)>(rawSize);

RELEASE_ASSERT(roundedSize >= rawSize);

return roundedSize;

}

int term { 0 };

unsigned matchBegin;

unsigned matchEnd;

uintptr_t frame[1];

};

DisjunctionContext* allocDisjunctionContext(ByteDisjunction* disjunction)

{

size_t size = DisjunctionContext::allocationSize(disjunction->m_frameSize);

allocatorPool = allocatorPool->ensureCapacity(size);

RELEASE_ASSERT(allocatorPool);

return new (allocatorPool->alloc(size)) DisjunctionContext();

}

void freeDisjunctionContext(DisjunctionContext* context)

{

allocatorPool = allocatorPool->dealloc(context);

}

struct ParenthesesDisjunctionContext

{

ParenthesesDisjunctionContext(unsigned* output, ByteTerm& term)

{

unsigned firstSubpatternId = term.atom.subpatternId;

unsigned numNestedSubpatterns = term.atom.parenthesesDisjunction->m_numSubpatterns;

for (unsigned i = 0; i < (numNestedSubpatterns << 1); ++i) {

subpatternBackup[i] = output[(firstSubpatternId << 1) + i];

output[(firstSubpatternId << 1) + i] = offsetNoMatch;

}

new (getDisjunctionContext(term)) DisjunctionContext();

}

void* operator new(size_t, void* where)

{

return where;

}

void restoreOutput(unsigned* output, unsigned firstSubpatternId, unsigned numNestedSubpatterns)

{

for (unsigned i = 0; i < (numNestedSubpatterns << 1); ++i)

output[(firstSubpatternId << 1) + i] = subpatternBackup[i];

}

DisjunctionContext* getDisjunctionContext(ByteTerm& term)

{

return bitwise_cast<DisjunctionContext*>(bitwise_cast<uintptr_t>(this) + allocationSize(term.atom.parenthesesDisjunction->m_numSubpatterns));

}

static size_t allocationSize(unsigned numberOfSubpatterns)

{

static_assert(alignof(ParenthesesDisjunctionContext) <= sizeof(void*), "");

size_t rawSize = (sizeof(ParenthesesDisjunctionContext) - sizeof(unsigned) + (Checked<size_t>(numberOfSubpatterns) * 2U) * sizeof(unsigned)).unsafeGet();

size_t roundedSize = roundUpToMultipleOf<sizeof(void*)>(rawSize);

RELEASE_ASSERT(roundedSize >= rawSize);

return roundedSize;

}

ParenthesesDisjunctionContext* next { nullptr };

unsigned subpatternBackup[1];

};

ParenthesesDisjunctionContext* allocParenthesesDisjunctionContext(ByteDisjunction* disjunction, unsigned* output, ByteTerm& term)

{

size_t size = (Checked<size_t>(ParenthesesDisjunctionContext::allocationSize(term.atom.parenthesesDisjunction->m_numSubpatterns)) + DisjunctionContext::allocationSize(disjunction->m_frameSize)).unsafeGet();

allocatorPool = allocatorPool->ensureCapacity(size);

RELEASE_ASSERT(allocatorPool);

return new (allocatorPool->alloc(size)) ParenthesesDisjunctionContext(output, term);

}

void freeParenthesesDisjunctionContext(ParenthesesDisjunctionContext* context)

{

allocatorPool = allocatorPool->dealloc(context);

}

class InputStream {

public:

InputStream(const CharType* input, unsigned start, unsigned length, bool decodeSurrogatePairs)

: input(input)

, pos(start)

, length(length)

, decodeSurrogatePairs(decodeSurrogatePairs)

{

}

void next()

{

++pos;

}

void rewind(unsigned amount)

{

ASSERT(pos >= amount);

pos -= amount;

}

int read()

{

ASSERT(pos < length);

if (pos < length)

return input[pos];

return -1;

}

int readPair()

{

ASSERT(pos + 1 < length);

return input[pos] | input[pos + 1] << 16;

}

int readChecked(unsigned negativePositionOffest)

{

RELEASE_ASSERT(pos >= negativePositionOffest);

unsigned p = pos - negativePositionOffest;

ASSERT(p < length);

int result = input[p];

if (U16_IS_LEAD(result) && decodeSurrogatePairs && p + 1 < length && U16_IS_TRAIL(input[p + 1])) {

if (atEnd())

return -1;

result = U16_GET_SUPPLEMENTARY(result, input[p + 1]);

next();

}

return result;

}

int readSurrogatePairChecked(unsigned negativePositionOffset)

{

RELEASE_ASSERT(pos >= negativePositionOffset);

unsigned p = pos - negativePositionOffset;

ASSERT(p < length);

if (p + 1 >= length)

return -1;

int first = input[p];

int second = input[p + 1];

if (U16_IS_LEAD(first) && U16_IS_TRAIL(second))

return U16_GET_SUPPLEMENTARY(first, second);

return -1;

}

int reread(unsigned from)

{

ASSERT(from < length);

int result = input[from];

if (U16_IS_LEAD(result) && decodeSurrogatePairs && from + 1 < length && U16_IS_TRAIL(input[from + 1]))

result = U16_GET_SUPPLEMENTARY(result, input[from + 1]);

return result;

}

int prev()

{

ASSERT(!(pos > length));

if (pos && length)

return input[pos - 1];

return -1;

}

unsigned getPos()

{

return pos;

}

void setPos(unsigned p)

{

pos = p;

}

bool atStart()

{

return pos == 0;

}

bool atEnd()

{

return pos == length;

}

unsigned end()

{

return length;

}

bool checkInput(unsigned count)

{

if (((pos + count) <= length) && ((pos + count) >= pos)) {

pos += count;

return true;

}

return false;

}

void uncheckInput(unsigned count)

{

RELEASE_ASSERT(pos >= count);

pos -= count;

}

bool atStart(unsigned negativePositionOffset)

{

return pos == negativePositionOffset;

}

bool atEnd(unsigned negativePositionOffest)

{

RELEASE_ASSERT(pos >= negativePositionOffest);

return (pos - negativePositionOffest) == length;

}

bool isAvailableInput(unsigned offset)

{

return (((pos + offset) <= length) && ((pos + offset) >= pos));

}

private:

const CharType* input;

unsigned pos;

unsigned length;

bool decodeSurrogatePairs;

};

bool testCharacterClass(CharacterClass* characterClass, int ch)

{

auto linearSearchMatches = [&ch](const Vector<UChar32>& matches) {

for (unsigned i = 0; i < matches.size(); ++i) {

if (ch == matches[i])

return true;

}

return false;

};

auto binarySearchMatches = [&ch](const Vector<UChar32>& matches) {

size_t low = 0;

size_t high = matches.size() - 1;

while (low <= high) {

size_t mid = low + (high - low) / 2;

int diff = ch - matches[mid];

if (!diff)

return true;

if (diff < 0) {

if (mid == low)

return false;

high = mid - 1;

} else

low = mid + 1;

}

return false;

};

auto linearSearchRanges = [&ch](const Vector<CharacterRange>& ranges) {

for (unsigned i = 0; i < ranges.size(); ++i) {

if ((ch >= ranges[i].begin) && (ch <= ranges[i].end))

return true;

}

return false;

};

auto binarySearchRanges = [&ch](const Vector<CharacterRange>& ranges) {

size_t low = 0;

size_t high = ranges.size() - 1;

while (low <= high) {

size_t mid = low + (high - low) / 2;

int rangeBeginDiff = ch - ranges[mid].begin;

if (rangeBeginDiff >= 0 && ch <= ranges[mid].end)

return true;

if (rangeBeginDiff < 0) {

if (mid == low)

return false;

high = mid - 1;

} else

low = mid + 1;

}

return false;

};

if (characterClass->m_anyCharacter)

return true;

const size_t thresholdForBinarySearch = 6;

if (!isASCII(ch)) {

if (characterClass->m_matchesUnicode.size()) {

if (characterClass->m_matchesUnicode.size() > thresholdForBinarySearch) {

if (binarySearchMatches(characterClass->m_matchesUnicode))

return true;

} else if (linearSearchMatches(characterClass->m_matchesUnicode))

return true;

}

if (characterClass->m_rangesUnicode.size()) {

if (characterClass->m_rangesUnicode.size() > thresholdForBinarySearch) {

if (binarySearchRanges(characterClass->m_rangesUnicode))

return true;

} else if (linearSearchRanges(characterClass->m_rangesUnicode))

return true;

}

} else {

if (characterClass->m_matches.size()) {

if (characterClass->m_matches.size() > thresholdForBinarySearch) {

if (binarySearchMatches(characterClass->m_matches))

return true;

} else if (linearSearchMatches(characterClass->m_matches))

return true;

}

if (characterClass->m_ranges.size()) {

if (characterClass->m_ranges.size() > thresholdForBinarySearch) {

if (binarySearchRanges(characterClass->m_ranges))

return true;

} else if (linearSearchRanges(characterClass->m_ranges))

return true;

}

}

return false;

}

bool checkCharacter(int testChar, unsigned negativeInputOffset)

{

return testChar == input.readChecked(negativeInputOffset);

}

bool checkSurrogatePair(int testUnicodeChar, unsigned negativeInputOffset)

{

return testUnicodeChar == input.readSurrogatePairChecked(negativeInputOffset);

}

bool checkCasedCharacter(int loChar, int hiChar, unsigned negativeInputOffset)

{

int ch = input.readChecked(negativeInputOffset);

return (loChar == ch) || (hiChar == ch);

}

bool checkCharacterClass(CharacterClass* characterClass, bool invert, unsigned negativeInputOffset)

{

bool match = testCharacterClass(characterClass, input.readChecked(negativeInputOffset));

return invert ? !match : match;

}

bool checkCharacterClassDontAdvanceInputForNonBMP(CharacterClass* characterClass, unsigned negativeInputOffset)

{

int readCharacter = characterClass->hasOnlyNonBMPCharacters() ? input.readSurrogatePairChecked(negativeInputOffset) : input.readChecked(negativeInputOffset);

return testCharacterClass(characterClass, readCharacter);

}

bool tryConsumeBackReference(int matchBegin, int matchEnd, unsigned negativeInputOffset)

{

unsigned matchSize = (unsigned)(matchEnd - matchBegin);

if (!input.checkInput(matchSize))

return false;

for (unsigned i = 0; i < matchSize; ++i) {

int oldCh = input.reread(matchBegin + i);

int ch;

if (!U_IS_BMP(oldCh)) {

ch = input.readSurrogatePairChecked(negativeInputOffset + matchSize - i);

++i;

} else

ch = input.readChecked(negativeInputOffset + matchSize - i);

if (oldCh == ch)

continue;

if (pattern->ignoreCase()) {

// See ES 6.0, 21.2.2.8.2 for the definition of Canonicalize(). For non-Unicode

// patterns, Unicode values are never allowed to match against ASCII ones.

// For Unicode, we need to check all canonical equivalents of a character.

if (!unicode && (isASCII(oldCh) || isASCII(ch))) {

if (toASCIIUpper(oldCh) == toASCIIUpper(ch))

continue;

} else if (areCanonicallyEquivalent(oldCh, ch, unicode ? CanonicalMode::Unicode : CanonicalMode::UCS2))

continue;

}

input.uncheckInput(matchSize);

return false;

}

return true;

}

bool matchAssertionBOL(ByteTerm& term)

{

return (input.atStart(term.inputPosition)) || (pattern->multiline() && testCharacterClass(pattern->newlineCharacterClass, input.readChecked(term.inputPosition + 1)));

}

bool matchAssertionEOL(ByteTerm& term)

{

if (term.inputPosition)

return (input.atEnd(term.inputPosition)) || (pattern->multiline() && testCharacterClass(pattern->newlineCharacterClass, input.readChecked(term.inputPosition)));

return (input.atEnd()) || (pattern->multiline() && testCharacterClass(pattern->newlineCharacterClass, input.read()));

}

bool matchAssertionWordBoundary(ByteTerm& term)

{

bool prevIsWordchar = !input.atStart(term.inputPosition) && testCharacterClass(pattern->wordcharCharacterClass, input.readChecked(term.inputPosition + 1));

bool readIsWordchar;

if (term.inputPosition)

readIsWordchar = !input.atEnd(term.inputPosition) && testCharacterClass(pattern->wordcharCharacterClass, input.readChecked(term.inputPosition));

else

readIsWordchar = !input.atEnd() && testCharacterClass(pattern->wordcharCharacterClass, input.read());

bool wordBoundary = prevIsWordchar != readIsWordchar;

return term.invert() ? !wordBoundary : wordBoundary;

}

bool backtrackPatternCharacter(ByteTerm& term, DisjunctionContext* context)

{

BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + term.frameLocation);

switch (term.atom.quantityType) {

case QuantifierFixedCount:

break;

case QuantifierGreedy:

if (backTrack->matchAmount) {

--backTrack->matchAmount;

input.uncheckInput(U16_LENGTH(term.atom.patternCharacter));

return true;

}

break;

case QuantifierNonGreedy:

if ((backTrack->matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {

++backTrack->matchAmount;

if (checkCharacter(term.atom.patternCharacter, term.inputPosition + 1))

return true;

}

input.setPos(backTrack->begin);

break;

}

return false;

}

bool backtrackPatternCasedCharacter(ByteTerm& term, DisjunctionContext* context)

{

BackTrackInfoPatternCharacter* backTrack = reinterpret_cast<BackTrackInfoPatternCharacter*>(context->frame + term.frameLocation);

switch (term.atom.quantityType) {

case QuantifierFixedCount:

break;

case QuantifierGreedy:

if (backTrack->matchAmount) {

--backTrack->matchAmount;

input.uncheckInput(1);

return true;

}

break;

case QuantifierNonGreedy:

if ((backTrack->matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {

++backTrack->matchAmount;

if (checkCasedCharacter(term.atom.casedCharacter.lo, term.atom.casedCharacter.hi, term.inputPosition + 1))

return true;

}

input.uncheckInput(backTrack->matchAmount);

break;

}

return false;

}

bool matchCharacterClass(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeCharacterClass);

BackTrackInfoCharacterClass* backTrack = reinterpret_cast<BackTrackInfoCharacterClass*>(context->frame + term.frameLocation);

switch (term.atom.quantityType) {

case QuantifierFixedCount: {

if (unicode) {

CharacterClass* charClass = term.atom.characterClass;

backTrack->begin = input.getPos();

unsigned matchAmount = 0;

for (matchAmount = 0; matchAmount < term.atom.quantityMaxCount; ++matchAmount) {

if (term.invert()) {

if (!checkCharacterClass(charClass, term.invert(), term.inputPosition - matchAmount)) {

input.setPos(backTrack->begin);

return false;

}

} else {

unsigned matchOffset = matchAmount * (charClass->hasOnlyNonBMPCharacters() ? 2 : 1);

if (!checkCharacterClassDontAdvanceInputForNonBMP(charClass, term.inputPosition - matchOffset)) {

input.setPos(backTrack->begin);

return false;

}

}

}

return true;

}

for (unsigned matchAmount = 0; matchAmount < term.atom.quantityMaxCount; ++matchAmount) {

if (!checkCharacterClass(term.atom.characterClass, term.invert(), term.inputPosition - matchAmount))

return false;

}

return true;

}

case QuantifierGreedy: {

unsigned position = input.getPos();

backTrack->begin = position;

unsigned matchAmount = 0;

while ((matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {

if (!checkCharacterClass(term.atom.characterClass, term.invert(), term.inputPosition + 1)) {

input.setPos(position);

break;

}

++matchAmount;

position = input.getPos();

}

backTrack->matchAmount = matchAmount;

return true;

}

case QuantifierNonGreedy:

backTrack->begin = input.getPos();

backTrack->matchAmount = 0;

return true;

}

RELEASE_ASSERT_NOT_REACHED();

return false;

}

bool backtrackCharacterClass(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeCharacterClass);

BackTrackInfoCharacterClass* backTrack = reinterpret_cast<BackTrackInfoCharacterClass*>(context->frame + term.frameLocation);

switch (term.atom.quantityType) {

case QuantifierFixedCount:

if (unicode)

input.setPos(backTrack->begin);

break;

case QuantifierGreedy:

if (backTrack->matchAmount) {

if (unicode) {

// Rematch one less match

input.setPos(backTrack->begin);

--backTrack->matchAmount;

for (unsigned matchAmount = 0; (matchAmount < backTrack->matchAmount) && input.checkInput(1); ++matchAmount) {

if (!checkCharacterClass(term.atom.characterClass, term.invert(), term.inputPosition + 1)) {

input.uncheckInput(1);

break;

}

}

return true;

}

--backTrack->matchAmount;

input.uncheckInput(1);

return true;

}

break;

case QuantifierNonGreedy:

if ((backTrack->matchAmount < term.atom.quantityMaxCount) && input.checkInput(1)) {

++backTrack->matchAmount;

if (checkCharacterClass(term.atom.characterClass, term.invert(), term.inputPosition + 1))

return true;

}

input.setPos(backTrack->begin);

break;

}

return false;

}

bool matchBackReference(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeBackReference);

BackTrackInfoBackReference* backTrack = reinterpret_cast<BackTrackInfoBackReference*>(context->frame + term.frameLocation);

unsigned matchBegin = output[(term.atom.subpatternId << 1)];

unsigned matchEnd = output[(term.atom.subpatternId << 1) + 1];

// If the end position of the referenced match hasn't set yet then the backreference in the same parentheses where it references to that.

// In this case the result of match is empty string like when it references to a parentheses with zero-width match.

// Eg.: /(a\1)/

if (matchEnd == offsetNoMatch)

return true;

if (matchBegin == offsetNoMatch)

return true;

ASSERT(matchBegin <= matchEnd);

if (matchBegin == matchEnd)

return true;

switch (term.atom.quantityType) {

case QuantifierFixedCount: {

backTrack->begin = input.getPos();

for (unsigned matchAmount = 0; matchAmount < term.atom.quantityMaxCount; ++matchAmount) {

if (!tryConsumeBackReference(matchBegin, matchEnd, term.inputPosition)) {

input.setPos(backTrack->begin);

return false;

}

}

return true;

}

case QuantifierGreedy: {

unsigned matchAmount = 0;

while ((matchAmount < term.atom.quantityMaxCount) && tryConsumeBackReference(matchBegin, matchEnd, term.inputPosition))

++matchAmount;

backTrack->matchAmount = matchAmount;

return true;

}

case QuantifierNonGreedy:

backTrack->begin = input.getPos();

backTrack->matchAmount = 0;

return true;

}

RELEASE_ASSERT_NOT_REACHED();

return false;

}

bool backtrackBackReference(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeBackReference);

BackTrackInfoBackReference* backTrack = reinterpret_cast<BackTrackInfoBackReference*>(context->frame + term.frameLocation);

unsigned matchBegin = output[(term.atom.subpatternId << 1)];

unsigned matchEnd = output[(term.atom.subpatternId << 1) + 1];

if (matchBegin == offsetNoMatch)

return false;

ASSERT(matchBegin <= matchEnd);

if (matchBegin == matchEnd)

return false;

switch (term.atom.quantityType) {

case QuantifierFixedCount:

// for quantityMaxCount == 1, could rewind.

input.setPos(backTrack->begin);

break;

case QuantifierGreedy:

if (backTrack->matchAmount) {

--backTrack->matchAmount;

input.rewind(matchEnd - matchBegin);

return true;

}

break;

case QuantifierNonGreedy:

if ((backTrack->matchAmount < term.atom.quantityMaxCount) && tryConsumeBackReference(matchBegin, matchEnd, term.inputPosition)) {

++backTrack->matchAmount;

return true;

}

input.setPos(backTrack->begin);

break;

}

return false;

}

void recordParenthesesMatch(ByteTerm& term, ParenthesesDisjunctionContext* context)

{

if (term.capture()) {

unsigned subpatternId = term.atom.subpatternId;

output[(subpatternId << 1)] = context->getDisjunctionContext(term)->matchBegin - term.inputPosition;

output[(subpatternId << 1) + 1] = context->getDisjunctionContext(term)->matchEnd - term.inputPosition;

}

}

void resetMatches(ByteTerm& term, ParenthesesDisjunctionContext* context)

{

unsigned firstSubpatternId = term.atom.subpatternId;

unsigned count = term.atom.parenthesesDisjunction->m_numSubpatterns;

context->restoreOutput(output, firstSubpatternId, count);

}

JSRegExpResult parenthesesDoBacktrack(ByteTerm& term, BackTrackInfoParentheses* backTrack)

{

while (backTrack->matchAmount) {

ParenthesesDisjunctionContext* context = backTrack->lastContext;

JSRegExpResult result = matchDisjunction(term.atom.parenthesesDisjunction, context->getDisjunctionContext(term), true);

if (result == JSRegExpMatch)

return JSRegExpMatch;

resetMatches(term, context);

popParenthesesDisjunctionContext(backTrack);

freeParenthesesDisjunctionContext(context);

if (result != JSRegExpNoMatch)

return result;

}

return JSRegExpNoMatch;

}

bool matchParenthesesOnceBegin(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceBegin);

ASSERT(term.atom.quantityMaxCount == 1);

BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);

switch (term.atom.quantityType) {

case QuantifierGreedy: {

// set this speculatively; if we get to the parens end this will be true.

backTrack->begin = input.getPos();

break;

}

case QuantifierNonGreedy: {

backTrack->begin = notFound;

context->term += term.atom.parenthesesWidth;

return true;

}

case QuantifierFixedCount:

break;

}

if (term.capture()) {

unsigned subpatternId = term.atom.subpatternId;

output[(subpatternId << 1)] = input.getPos() - term.inputPosition;

}

return true;

}

bool matchParenthesesOnceEnd(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceEnd);

ASSERT(term.atom.quantityMaxCount == 1);

if (term.capture()) {

unsigned subpatternId = term.atom.subpatternId;

output[(subpatternId << 1) + 1] = input.getPos() - term.inputPosition;

}

if (term.atom.quantityType == QuantifierFixedCount)

return true;

BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);

return backTrack->begin != input.getPos();

}

bool backtrackParenthesesOnceBegin(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceBegin);

ASSERT(term.atom.quantityMaxCount == 1);

BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);

if (term.capture()) {

unsigned subpatternId = term.atom.subpatternId;

output[(subpatternId << 1)] = offsetNoMatch;

output[(subpatternId << 1) + 1] = offsetNoMatch;

}

switch (term.atom.quantityType) {

case QuantifierGreedy:

// if we backtrack to this point, there is another chance - try matching nothing.

ASSERT(backTrack->begin != notFound);

backTrack->begin = notFound;

context->term += term.atom.parenthesesWidth;

return true;

case QuantifierNonGreedy:

ASSERT(backTrack->begin != notFound);

FALLTHROUGH;

case QuantifierFixedCount:

break;

}

return false;

}

bool backtrackParenthesesOnceEnd(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternOnceEnd);

ASSERT(term.atom.quantityMaxCount == 1);

BackTrackInfoParenthesesOnce* backTrack = reinterpret_cast<BackTrackInfoParenthesesOnce*>(context->frame + term.frameLocation);

switch (term.atom.quantityType) {

case QuantifierGreedy:

if (backTrack->begin == notFound) {

context->term -= term.atom.parenthesesWidth;

return false;

}

FALLTHROUGH;

case QuantifierNonGreedy:

if (backTrack->begin == notFound) {

backTrack->begin = input.getPos();

if (term.capture()) {

// Technically this access to inputPosition should be accessing the begin term's

// inputPosition, but for repeats other than fixed these values should be

// the same anyway! (We don't pre-check for greedy or non-greedy matches.)

ASSERT((&term - term.atom.parenthesesWidth)->type == ByteTerm::TypeParenthesesSubpatternOnceBegin);

ASSERT((&term - term.atom.parenthesesWidth)->inputPosition == term.inputPosition);

unsigned subpatternId = term.atom.subpatternId;

output[subpatternId << 1] = input.getPos() - term.inputPosition;

}

context->term -= term.atom.parenthesesWidth;

return true;

}

FALLTHROUGH;

case QuantifierFixedCount:

break;

}

return false;

}

bool matchParenthesesTerminalBegin(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternTerminalBegin);

ASSERT(term.atom.quantityType == QuantifierGreedy);

ASSERT(term.atom.quantityMaxCount == quantifyInfinite);

ASSERT(!term.capture());

BackTrackInfoParenthesesTerminal* backTrack = reinterpret_cast<BackTrackInfoParenthesesTerminal*>(context->frame + term.frameLocation);

backTrack->begin = input.getPos();

return true;

}

bool matchParenthesesTerminalEnd(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternTerminalEnd);

BackTrackInfoParenthesesTerminal* backTrack = reinterpret_cast<BackTrackInfoParenthesesTerminal*>(context->frame + term.frameLocation);

// Empty match is a failed match.

if (backTrack->begin == input.getPos())

return false;

// Successful match! Okay, what's next? - loop around and try to match more!

context->term -= (term.atom.parenthesesWidth + 1);

return true;

}

bool backtrackParenthesesTerminalBegin(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParenthesesSubpatternTerminalBegin);

ASSERT(term.atom.quantityType == QuantifierGreedy);

ASSERT(term.atom.quantityMaxCount == quantifyInfinite);

ASSERT(!term.capture());

// If we backtrack to this point, we have failed to match this iteration of the parens.

// Since this is greedy / zero minimum a failed is also accepted as a match!

context->term += term.atom.parenthesesWidth;

return true;

}

bool backtrackParenthesesTerminalEnd(ByteTerm&, DisjunctionContext*)

{

// 'Terminal' parentheses are at the end of the regex, and as such a match past end

// should always be returned as a successful match - we should never backtrack to here.

RELEASE_ASSERT_NOT_REACHED();

return false;

}

bool matchParentheticalAssertionBegin(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParentheticalAssertionBegin);

ASSERT(term.atom.quantityMaxCount == 1);

BackTrackInfoParentheticalAssertion* backTrack = reinterpret_cast<BackTrackInfoParentheticalAssertion*>(context->frame + term.frameLocation);

backTrack->begin = input.getPos();

return true;

}

bool matchParentheticalAssertionEnd(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParentheticalAssertionEnd);

ASSERT(term.atom.quantityMaxCount == 1);

BackTrackInfoParentheticalAssertion* backTrack = reinterpret_cast<BackTrackInfoParentheticalAssertion*>(context->frame + term.frameLocation);

input.setPos(backTrack->begin);

// We've reached the end of the parens; if they are inverted, this is failure.

if (term.invert()) {

context->term -= term.atom.parenthesesWidth;

return false;

}

return true;

}

bool backtrackParentheticalAssertionBegin(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParentheticalAssertionBegin);

ASSERT(term.atom.quantityMaxCount == 1);

// We've failed to match parens; if they are inverted, this is win!

if (term.invert()) {

context->term += term.atom.parenthesesWidth;

return true;

}

return false;

}

bool backtrackParentheticalAssertionEnd(ByteTerm& term, DisjunctionContext* context)

{

ASSERT(term.type == ByteTerm::TypeParentheticalAssertionEnd);