Default,

Union,

Intersection,

Subtraction

Parser(Delegate& delegate, std::span<const CharType> pattern, CompileMode compileMode, unsigned backReferenceLimit, bool isNamedForwardReferenceAllowed)

: m_delegate(delegate)

, m_data(pattern.data())

, m_size(pattern.size())

, m_compileMode(compileMode)

, m_backReferenceLimit(backReferenceLimit)

, m_isNamedForwardReferenceAllowed(isNamedForwardReferenceAllowed)

{

}

/*

ErrorCode parse()

{

if (m_size > MAX_PATTERN_SIZE)

return ErrorCode::PatternTooLarge;

parseTokens();

if (!hasError(m_errorCode)) {

ASSERT(atEndOfPattern());

handleIllegalReferences();

ASSERT(atEndOfPattern());

}

return m_errorCode;

}

static constexpr char32_t errorCodePoint = 0xFFFFFFFFu;

template<YarrSyntaxCheckable FriendDelegate>

friend ErrorCode parse(FriendDelegate&, StringView pattern, CompileMode, unsigned backReferenceLimit, bool isNamedForwardReferenceAllowed);

enum class UnicodeParseContext : uint8_t { PatternCodePoint, GroupName };

enum class ParseEscapeMode : uint8_t { Normal, CharacterClass, ClassSet, ClassStringDisjunction };

enum class TokenType : uint8_t {

NotAtom = 0,

Atom = 1,

Lookbehind = 2,

SetDisjunction = 3,

SetDisjunctionMayContainStrings = 4,

};

class NamedCaptureGroups {

typedef UncheckedKeyHashSet<String> GroupNameHashSet;

public:

NamedCaptureGroups()

{

m_nestedCaptureGroupNames.grow(1);

m_activeCaptureGroupNames.grow(1);

}

bool contains(String name)

{

return m_captureGroupNames.contains(name);

}

bool isEmpty()

{

return m_captureGroupNames.isEmpty();

}

void reset()

{

m_captureGroupNames.clear();

m_nestedCaptureGroupNames.clear();

m_nestedCaptureGroupNames.grow(1);

m_activeCaptureGroupNames.clear();

m_activeCaptureGroupNames.grow(1);

}

void nextAlternative()

{

m_nestedCaptureGroupNames.last().addAll(std::exchange(m_activeCaptureGroupNames.last(), { }));

// For nested parenthesis, we need to seed the new alternative with the already seen

// named captures from the containing alternative.

if (m_activeCaptureGroupNames.size() > 1)

m_activeCaptureGroupNames.last().addAll(m_activeCaptureGroupNames[m_activeCaptureGroupNames.size() - 2]);

}

void pushParenthesis()

{

auto currentTop = m_activeCaptureGroupNames.last();

m_nestedCaptureGroupNames.append(GroupNameHashSet());

m_activeCaptureGroupNames.append(currentTop);

}

void popParenthesis()

{

ASSERT(m_nestedCaptureGroupNames.size() > 1);

ASSERT(m_activeCaptureGroupNames.size() > 1);

m_nestedCaptureGroupNames.last().addAll(WTF::move(m_activeCaptureGroupNames.last()));

// Add all the names seen in this parenthesis to the containing alternative.

m_activeCaptureGroupNames[m_activeCaptureGroupNames.size() - 2].addAll(WTF::move(m_nestedCaptureGroupNames.last()));

m_nestedCaptureGroupNames.removeLast();

m_activeCaptureGroupNames.removeLast();

}

GroupNameHashSet::AddResult add(String name)

{

m_captureGroupNames.add(name);

// If the name is not new, the caller should flag a syntax error.

return m_activeCaptureGroupNames.last().add(name);

}

private:

// Names seen in the whole expression up to this point.

GroupNameHashSet m_captureGroupNames;

// All active names from prior alternatives at this nesting level.

Vector<GroupNameHashSet, 1> m_nestedCaptureGroupNames;

// Names seen in containing disjunction / alternative and the current alternative.

Vector<GroupNameHashSet, 1> m_activeCaptureGroupNames;

};

/*

class CharacterClassParserDelegate {

public:

CharacterClassParserDelegate(Delegate& delegate, ErrorCode& err, CompileMode compileMode)

: m_delegate(delegate)

, m_errorCode(err)

, m_isUnicode(compileMode == CompileMode::Unicode)

, m_state(CharacterClassConstructionState::Empty)

, m_character(0)

{

}

/*

void begin(bool invert)

{

m_delegate.atomCharacterClassBegin(invert);

}

/*

void atomPatternCharacter(char32_t ch, bool hyphenIsRange)

{

switch (m_state) {

case CharacterClassConstructionState::AfterCharacterClass:

// Following a built-in character class we need look out for a hyphen.

// We're looking for invalid ranges, such as /[\d-x]/ or /[\d-\d]/.

// If we see a hyphen following a character class then unlike usual

// we'll report it to the delegate immediately, and put ourself into

// a poisoned state. In a unicode pattern, any following calls to add

// another character or character class will result in syntax error.

// A hypen following a character class is itself valid, but only at

// the end of a regex.

if (hyphenIsRange && ch == '-') {

m_delegate.atomCharacterClassAtom('-');

m_state = CharacterClassConstructionState::AfterCharacterClassHyphen;

return;

}

// Otherwise just fall through - cached character so treat this as CharacterClassConstructionState::Empty.

[[fallthrough]];

case CharacterClassConstructionState::Empty:

m_character = ch;

m_state = CharacterClassConstructionState::CachedCharacter;

return;

case CharacterClassConstructionState::CachedCharacter:

if (hyphenIsRange && ch == '-')

m_state = CharacterClassConstructionState::CachedCharacterHyphen;

else {

m_delegate.atomCharacterClassAtom(m_character);

m_character = ch;

}

return;

case CharacterClassConstructionState::CachedCharacterHyphen:

if (ch < m_character) {

m_errorCode = ErrorCode::CharacterClassRangeOutOfOrder;

return;

}

m_delegate.atomCharacterClassRange(m_character, ch);

m_state = CharacterClassConstructionState::Empty;

return;

// If we hit this case, we have an invalid range like /[\d-a]/.

// See coment in atomBuiltInCharacterClass() below.

case CharacterClassConstructionState::AfterCharacterClassHyphen:

if (m_isUnicode) {

m_errorCode = ErrorCode::CharacterClassRangeInvalid;

return;

}

m_delegate.atomCharacterClassAtom(ch);

m_state = CharacterClassConstructionState::Empty;

return;

}

}

/*

void atomBuiltInCharacterClass(BuiltInCharacterClassID classID, bool invert)

{

switch (m_state) {

case CharacterClassConstructionState::CachedCharacter:

// Flush the currently cached character, then fall through.

m_delegate.atomCharacterClassAtom(m_character);

[[fallthrough]];

case CharacterClassConstructionState::Empty:

case CharacterClassConstructionState::AfterCharacterClass:

m_delegate.atomCharacterClassBuiltIn(classID, invert);

m_state = CharacterClassConstructionState::AfterCharacterClass;

return;

// If we hit either of these cases, we have an invalid range that

// looks something like /[a-\d]/ or /[\d-\d]/.

// Since ES2015, this should be syntax error in a unicode pattern,

// yet gracefully handled in a regular regex to avoid breaking the web.

// Effectively we handle the hyphen as if it was (implicitly) escaped,

// e.g. /[\d-a-z]/ is treated as /[\d\-a\-z]/.

// See usages of CharacterRangeOrUnion abstract op in

// https://tc39.es/ecma262/#sec-regular-expression-patterns-semantics

case CharacterClassConstructionState::CachedCharacterHyphen:

m_delegate.atomCharacterClassAtom(m_character);

m_delegate.atomCharacterClassAtom('-');

[[fallthrough]];

case CharacterClassConstructionState::AfterCharacterClassHyphen:

if (m_isUnicode) {

m_errorCode = ErrorCode::CharacterClassRangeInvalid;

return;

}

m_delegate.atomCharacterClassBuiltIn(classID, invert);

m_state = CharacterClassConstructionState::Empty;

return;

}

}

/*

void end()

{

if (m_state == CharacterClassConstructionState::CachedCharacter)

m_delegate.atomCharacterClassAtom(m_character);

else if (m_state == CharacterClassConstructionState::CachedCharacterHyphen) {

m_delegate.atomCharacterClassAtom(m_character);

m_delegate.atomCharacterClassAtom('-');

}

m_delegate.atomCharacterClassEnd();

}

// parseEscape() should never call these delegate methods when

// invoked with inCharacterClass set.

NO_RETURN_DUE_TO_ASSERT void assertionWordBoundary(bool) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomBackReference(unsigned) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomNamedBackReference(const String&) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomNamedForwardReference(const String&) { RELEASE_ASSERT_NOT_REACHED(); }

private:

Delegate& m_delegate;

ErrorCode& m_errorCode;

bool m_isUnicode;

enum class CharacterClassConstructionState {

Empty,

CachedCharacter,

CachedCharacterHyphen,

AfterCharacterClass,

AfterCharacterClassHyphen,

};

CharacterClassConstructionState m_state;

char32_t m_character;

};

/*

class ClassSetParserDelegate {

private:

struct NestingState {

public:

NestingState(CharacterClassSetOp setOp, bool mayContainStrings, bool inverted)

: m_setOp(setOp)

, m_mayContainStrings(mayContainStrings)

, m_inverted(inverted)

{ }

CharacterClassSetOp m_setOp;

bool m_mayContainStrings;

bool m_inverted;

};

public:

ClassSetParserDelegate(Delegate& delegate, ErrorCode& err)

: m_delegate(delegate)

, m_errorCode(err)

, m_state(ClassSetConstructionState::Empty)

, m_setOp(CharacterClassSetOp::Default)

, m_mayContainStrings(false)

, m_inverted(false)

, m_processingEscape(false)

, m_character(0)

{

}

/*

void begin(bool invert)

{

m_inverted = invert;

m_delegate.atomCharacterClassBegin(invert);

}

void nestedClassBegin(bool invert)

{

flushCachedCharacterIfNeeded();

m_delegate.atomCharacterClassPushNested(invert);

nestedParseState.append(NestingState(m_setOp, m_mayContainStrings, m_inverted));

m_setOp = CharacterClassSetOp::Default;

m_mayContainStrings = false;

m_inverted = invert;

}

bool nestedClassEnd()

{

flushCachedCharacterIfNeeded();

if (m_inverted && m_mayContainStrings)

m_errorCode = ErrorCode::NegatedClassSetMayContainStrings;

if (nestedParseState.isEmpty()) {

end();

return true;

}

bool rhsMayContainStrings = m_mayContainStrings;

NestingState lastState = nestedParseState.takeLast();

m_setOp = lastState.m_setOp;

m_inverted = lastState.m_inverted;

m_mayContainStrings = lastState.m_mayContainStrings;

m_delegate.atomCharacterClassPopNested(m_inverted);

m_state = ClassSetConstructionState::AfterSetOperand;

computeMayContainStrings(rhsMayContainStrings);

return false;

}

void setUnionOp()

{

if (m_setOp != CharacterClassSetOp::Default && m_setOp != CharacterClassSetOp::Union) {

m_errorCode = ErrorCode::InvalidClassSetOperation;

return;

}

flushCachedCharacterIfNeeded();

m_setOp = CharacterClassSetOp::Union;

m_delegate.atomCharacterClassSetOp(m_setOp);

}

void switchFromDefaultOpToUnionOpIfNeeded()

{

if (m_setOp == CharacterClassSetOp::Default) {

m_setOp = CharacterClassSetOp::Union;

m_delegate.atomCharacterClassSetOp(m_setOp);

}

}

void setSubtractOp()

{

if (m_state == ClassSetConstructionState::Empty || (m_setOp != CharacterClassSetOp::Default && m_setOp != CharacterClassSetOp::Subtraction)) {

m_errorCode = ErrorCode::InvalidClassSetOperation;

return;

}

flushCachedCharacterIfNeeded();

m_setOp = CharacterClassSetOp::Subtraction;

m_delegate.atomCharacterClassSetOp(m_setOp);

m_state = ClassSetConstructionState::AfterSetOperator;

}

void setIntersectionOp()

{

if (m_state == ClassSetConstructionState::Empty || (m_setOp != CharacterClassSetOp::Default && m_setOp != CharacterClassSetOp::Intersection)) {

m_errorCode = ErrorCode::InvalidClassSetOperation;

return;

}

flushCachedCharacterIfNeeded();

m_setOp = CharacterClassSetOp::Intersection;

m_delegate.atomCharacterClassSetOp(m_setOp);

m_state = ClassSetConstructionState::AfterSetOperator;

}

void computeMayContainStrings(bool rhsMayContainStrings)

{

switch (m_setOp) {

case CharacterClassSetOp::Default:

case CharacterClassSetOp::Union:

m_mayContainStrings |= rhsMayContainStrings;

break;

case CharacterClassSetOp::Intersection:

m_mayContainStrings = m_mayContainStrings && rhsMayContainStrings;

break;

case CharacterClassSetOp::Subtraction:

// Result is the value of the LHS

break;

}

}

void flushCachedCharacterIfNeeded()

{

if (m_state == ClassSetConstructionState::CachedCharacter) {

m_delegate.atomCharacterClassAtom(m_character);

m_state = ClassSetConstructionState::Empty;

}

}

void afterSetOperand()

{

flushCachedCharacterIfNeeded();

m_state = ClassSetConstructionState::AfterSetOperand;

}

bool canTakeSetOperand()

{

bool unionOpActive = m_setOp == CharacterClassSetOp::Default || m_setOp == CharacterClassSetOp::Union;

switch (m_state) {

case ClassSetConstructionState::Empty:

case ClassSetConstructionState::AfterSetOperator:

return true;

case ClassSetConstructionState::CachedCharacter:

if (!unionOpActive)

return false;

flushCachedCharacterIfNeeded();

return true;

case ClassSetConstructionState::CachedCharacterHyphen:

case ClassSetConstructionState::AfterCharacterClassHyphen:

case ClassSetConstructionState::AfterCharacterClass:

case ClassSetConstructionState::AfterSetRange:

case ClassSetConstructionState::AfterSetOperand:

return unionOpActive;

}

return false;

}

void setProcessingEscape()

{

m_processingEscape = true;

}

/*

void atomPatternCharacter(char32_t ch, bool hyphenIsRange)

{

bool unionOpActive = m_setOp == CharacterClassSetOp::Default || m_setOp == CharacterClassSetOp::Union;

bool processingEscape = m_processingEscape;

m_processingEscape = false;

auto processCharacter = [&] () {

m_character = ch;

m_state = ClassSetConstructionState::CachedCharacter;

return;

};

switch (m_state) {

case ClassSetConstructionState::AfterCharacterClass:

// Following a built-in character class we need look out for a hyphen.

// We're looking for invalid ranges, such as /[\d-x]/ or /[\d-\d]/.

// If we see a hyphen following a character class then unlike usual

// we'll report it to the delegate immediately, and put ourself into

// a poisoned state. In a unicode pattern, any following calls to add

// another character or character class will result in syntax error.

// A hypen following a character class is itself valid, but only at

// the end of a regex.

if (hyphenIsRange && unionOpActive && ch == '-') {

m_delegate.atomCharacterClassAtom('-');

m_state = ClassSetConstructionState::AfterCharacterClassHyphen;

return;

}

// Otherwise just fall through - cached character so treat this as ClassSetConstructionState::Empty.

[[fallthrough]];

case ClassSetConstructionState::AfterSetRange:

switchFromDefaultOpToUnionOpIfNeeded();

// Continue processing the current character.

[[fallthrough]];

case ClassSetConstructionState::Empty:

case ClassSetConstructionState::AfterSetOperator:

if (!processingEscape && ch == '-') {

m_errorCode = ErrorCode::InvalidClassSetCharacter;

return;

}

processCharacter();

return;

case ClassSetConstructionState::CachedCharacter:

if (!unionOpActive) {

m_errorCode = ErrorCode::InvalidClassSetOperation;

return;

}

if (ch == '-')

m_state = ClassSetConstructionState::CachedCharacterHyphen;

else {

m_delegate.atomCharacterClassAtom(m_character);

switchFromDefaultOpToUnionOpIfNeeded();

processCharacter();

}

return;

case ClassSetConstructionState::CachedCharacterHyphen:

if (ch < m_character) {

m_errorCode = ErrorCode::CharacterClassRangeOutOfOrder;

return;

}

m_delegate.atomCharacterClassRange(m_character, ch);

switchFromDefaultOpToUnionOpIfNeeded();

m_state = ClassSetConstructionState::AfterSetRange;

return;

// If we hit this case, we have an invalid range like /[\d-a]/.

// See coment in atomBuiltInCharacterClass() below.

case ClassSetConstructionState::AfterCharacterClassHyphen:

m_errorCode = ErrorCode::CharacterClassRangeInvalid;

return;

case ClassSetConstructionState::AfterSetOperand:

if (!unionOpActive)

m_errorCode = ErrorCode::InvalidClassSetOperation;

if (ch == '-')

m_errorCode = ErrorCode::InvalidClassSetOperation;

else {

m_delegate.atomCharacterClassAtom(m_character);

switchFromDefaultOpToUnionOpIfNeeded();

processCharacter();

}

return;

}

}

/*

void atomBuiltInCharacterClass(BuiltInCharacterClassID classID, bool invert)

{

bool unionOpActive = m_setOp == CharacterClassSetOp::Default || m_setOp == CharacterClassSetOp::Union;

auto processBuiltInCharacterClass = [&] () {

computeMayContainStrings(characterClassMayContainStrings(classID));

m_delegate.atomCharacterClassBuiltIn(classID, invert);

m_state = ClassSetConstructionState::AfterCharacterClass;

return;

};

switch (m_state) {

case ClassSetConstructionState::CachedCharacter:

if (!unionOpActive) {

m_errorCode = ErrorCode::InvalidClassSetOperation;

return;

}

// Flush the currently cached character, then fall through.

m_delegate.atomCharacterClassAtom(m_character);

// Yes, we really want to fall through to the AfterSetRange case to switch from Default to Union op

// and then handle the built in class by falling through again.

[[fallthrough]];

case ClassSetConstructionState::AfterSetRange:

switchFromDefaultOpToUnionOpIfNeeded();

// Continue processing the current character.

[[fallthrough]];

case ClassSetConstructionState::Empty:

case ClassSetConstructionState::AfterCharacterClass:

case ClassSetConstructionState::AfterSetOperator:

processBuiltInCharacterClass();

return;

// If we hit either of these cases, we have an invalid range that

// looks something like /[a-\d]/ or /[\d-\d]/.

// Since ES2015, this should be syntax error in a unicode pattern,

// yet gracefully handled in a regular regex to avoid breaking the web.

// Effectively we handle the hyphen as if it was (implicitly) escaped,

// e.g. /[\d-a-z]/ is treated as /[\d\-a\-z]/.

// See usages of CharacterRangeOrUnion abstract op in

// https://tc39.es/ecma262/#sec-regular-expression-patterns-semantics

case ClassSetConstructionState::CachedCharacterHyphen:

m_delegate.atomCharacterClassAtom(m_character);

m_delegate.atomCharacterClassAtom('-');

[[fallthrough]];

case ClassSetConstructionState::AfterCharacterClassHyphen:

m_errorCode = ErrorCode::CharacterClassRangeInvalid;

return;

case ClassSetConstructionState::AfterSetOperand:

if (!unionOpActive)

m_errorCode = ErrorCode::InvalidClassSetOperation;

processBuiltInCharacterClass();

return;

}

}

/*

void end()

{

if (m_state == ClassSetConstructionState::CachedCharacter)

m_delegate.atomCharacterClassAtom(m_character);

else if (m_state == ClassSetConstructionState::CachedCharacterHyphen) {

m_delegate.atomCharacterClassAtom(m_character);

m_delegate.atomCharacterClassAtom('-');

} else if (m_state == ClassSetConstructionState::AfterSetOperator)

m_errorCode = ErrorCode::InvalidClassSetCharacter;

if (isInverted() && m_mayContainStrings)

m_errorCode = ErrorCode::NegatedClassSetMayContainStrings;

m_delegate.atomCharacterClassEnd();

}

bool isInverted() { return m_inverted; }

ErrorCode error() { return m_errorCode; }

// parseEscape() should never call these delegate methods when

// invoked with inCharacterClass set.

NO_RETURN_DUE_TO_ASSERT void assertionWordBoundary(bool) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomBackReference(unsigned) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomNamedBackReference(const String&) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomNamedForwardReference(const String&) { RELEASE_ASSERT_NOT_REACHED(); }

private:

Delegate& m_delegate;

ErrorCode& m_errorCode;

enum class ClassSetConstructionState {

Empty,

CachedCharacter,

CachedCharacterHyphen,

AfterCharacterClass,

AfterCharacterClassHyphen,

AfterSetRange,

AfterSetOperand,

AfterSetOperator,

};

ClassSetConstructionState m_state;

CharacterClassSetOp m_setOp;

bool m_mayContainStrings;

bool m_inverted;

bool m_processingEscape;

char32_t m_character;

Vector<NestingState> nestedParseState;

};

/*

class ClassStringDisjunctionParserDelegate {

public:

ClassStringDisjunctionParserDelegate(Delegate& delegate, ErrorCode& err)

: m_delegate(delegate)

, m_mayContainStrings(false)

, m_errorCode(err)

{

}

void atomPatternCharacter(char32_t ch, bool)

{

m_stringInProgress.append(ch);

if (m_stringInProgress.size() > 1)

m_mayContainStrings = true;

}

void newAlternative()

{

m_strings.append(m_stringInProgress);

m_stringInProgress.clear();

}

/*

void end()

{

newAlternative();

m_delegate.atomClassStringDisjunction(m_strings);

}

bool mayContainStrings() { return m_mayContainStrings; }

// parseEscape() should never call these delegate methods when parsing a class string disjunction.

NO_RETURN_DUE_TO_ASSERT void assertionWordBoundary(bool) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomBackReference(unsigned) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomNamedBackReference(const String&) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomNamedForwardReference(const String&) { RELEASE_ASSERT_NOT_REACHED(); }

NO_RETURN_DUE_TO_ASSERT void atomBuiltInCharacterClass(BuiltInCharacterClassID, bool) { RELEASE_ASSERT_NOT_REACHED(); }

private:

Delegate& m_delegate;

bool m_mayContainStrings;

ErrorCode& m_errorCode;

Vector<char32_t> m_stringInProgress;

Vector<Vector<char32_t>> m_strings;

};

// The handling of IdentityEscapes is different depending on which unicode flag if any is active.

// For both Unicode and UnicodeSet patterns, IdentityEscapes only include SyntaxCharacters or '/'.

// For UnicodeSet patterns when parsing ClassSet expressions and ClassStringDisjunctions, escapes include SyntaxCharacters, '/'

// and ClassSetReservedPunctionation, which is any of &-!#%,:;<=>@`~

// For non-unicode patterns, most any character can be escaped.

template<ParseEscapeMode parseEscapeMode>

bool isIdentityEscapeAnError(char32_t ch)

{

if (isEitherUnicodeCompilation()

&& ((isASCII(ch) && !strchr((parseEscapeMode == ParseEscapeMode::ClassSet || parseEscapeMode == ParseEscapeMode::ClassStringDisjunction) ? "^$\\.*+?()[]{}|/&-!#%,:;<=>@`~" : "^$\\.*+?()[]{}|/", ch)) || !ch)) {

m_errorCode = ErrorCode::InvalidIdentityEscape;

return true;

}

return false;

}

/*

template<ParseEscapeMode parseEscapeMode, class EscapeDelegate>

TokenType parseEscape(EscapeDelegate& delegate)

{

ASSERT(!hasError(m_errorCode));

ASSERT(peek() == '\\');

consume();

if (atEndOfPattern()) {

m_errorCode = ErrorCode::EscapeUnterminated;

return TokenType::NotAtom;

}

switch (peek()) {

// Assertions

case 'b':

consume();

if (parseEscapeMode != ParseEscapeMode::Normal)

delegate.atomPatternCharacter('\b', /* hyphenIsRange */ false);

else {

delegate.assertionWordBoundary(false);

return TokenType::NotAtom;

}

break;

case 'B':

consume();

if (parseEscapeMode != ParseEscapeMode::Normal) {

if (isIdentityEscapeAnError<parseEscapeMode>('B'))

break;

delegate.atomPatternCharacter('B', /* hyphenIsRange */ false);

} else {

delegate.assertionWordBoundary(true);

return TokenType::NotAtom;

}

break;

// CharacterClassEscape

case 'd':

consume();

if (parseEscapeMode == ParseEscapeMode::ClassStringDisjunction) {

delegate.atomPatternCharacter('d', /* hyphenIsRange */ false);

break;

}

delegate.atomBuiltInCharacterClass(BuiltInCharacterClassID::DigitClassID, false);

break;

case 's':

consume();

if (parseEscapeMode == ParseEscapeMode::ClassStringDisjunction) {

delegate.atomPatternCharacter('s', /* hyphenIsRange */ false);

break;

}

delegate.atomBuiltInCharacterClass(BuiltInCharacterClassID::SpaceClassID, false);

break;

case 'w':

consume();

if (parseEscapeMode == ParseEscapeMode::ClassStringDisjunction) {

delegate.atomPatternCharacter('w', /* hyphenIsRange */ false);

break;

}

delegate.atomBuiltInCharacterClass(BuiltInCharacterClassID::WordClassID, false);

break;

case 'D':

consume();

if (parseEscapeMode == ParseEscapeMode::ClassStringDisjunction) {

delegate.atomPatternCharacter('D', /* hyphenIsRange */ false);

break;

}

delegate.atomBuiltInCharacterClass(BuiltInCharacterClassID::DigitClassID, true);

break;

case 'S':

consume();

if (parseEscapeMode == ParseEscapeMode::ClassStringDisjunction) {

delegate.atomPatternCharacter('S', /* hyphenIsRange */ false);

break;

}

delegate.atomBuiltInCharacterClass(BuiltInCharacterClassID::SpaceClassID, true);

break;

case 'W':

consume();

if (parseEscapeMode == ParseEscapeMode::ClassStringDisjunction) {

delegate.atomPatternCharacter('W', /* hyphenIsRange */ false);

break;

}

delegate.atomBuiltInCharacterClass(BuiltInCharacterClassID::WordClassID, true);

break;

case '0': {

consume();

if (!peekIsDigit()) {

delegate.atomPatternCharacter(0, /* hyphenIsRange */ false);

break;

}