mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-22 15:40:19 +00:00
f1ce998d73
Combining these into one list helps reduce the size of MatchState, and as a result, reduces the amount of memory consumed during execution of very large regex matches. Doing this also allows us to remove a few regex byte code instructions: ClearNamedCaptureGroup, SaveLeftNamedCaptureGroup, and NamedReference. Named groups now behave the same as unnamed groups for these operations. Note that SaveRightNamedCaptureGroup still exists to cache the matched group name. This also removes the recursion level from the MatchState, as it can exist as a local variable in Matcher::execute instead.
2252 lines
80 KiB
C++
2252 lines
80 KiB
C++
/*
|
|
* Copyright (c) 2020, Emanuel Sprung <emanuel.sprung@gmail.com>
|
|
* Copyright (c) 2020-2021, the SerenityOS developers.
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "RegexParser.h"
|
|
#include "RegexDebug.h"
|
|
#include <AK/CharacterTypes.h>
|
|
#include <AK/String.h>
|
|
#include <AK/StringBuilder.h>
|
|
#include <AK/StringUtils.h>
|
|
#include <AK/Utf16View.h>
|
|
#include <LibUnicode/CharacterTypes.h>
|
|
|
|
namespace regex {
|
|
|
|
static constexpr size_t s_maximum_repetition_count = 1024 * 1024;
|
|
static constexpr auto s_alphabetic_characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"sv;
|
|
static constexpr auto s_decimal_characters = "0123456789"sv;
|
|
|
|
static constexpr StringView identity_escape_characters(bool unicode, bool browser_extended)
|
|
{
|
|
if (unicode)
|
|
return "^$\\.*+?()[]{}|/"sv;
|
|
if (browser_extended)
|
|
return "^$\\.*+?()[|"sv;
|
|
return "^$\\.*+?()[]{}|"sv;
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::set_error(Error error)
|
|
{
|
|
if (m_parser_state.error == Error::NoError) {
|
|
m_parser_state.error = error;
|
|
m_parser_state.error_token = m_parser_state.current_token;
|
|
}
|
|
return false; // always return false, that eases the API usage (return set_error(...)) :^)
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::done() const
|
|
{
|
|
return match(TokenType::Eof);
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::match(TokenType type) const
|
|
{
|
|
return m_parser_state.current_token.type() == type;
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::match(char ch) const
|
|
{
|
|
return m_parser_state.current_token.type() == TokenType::Char && m_parser_state.current_token.value().length() == 1 && m_parser_state.current_token.value()[0] == ch;
|
|
}
|
|
|
|
ALWAYS_INLINE Token Parser::consume()
|
|
{
|
|
auto old_token = m_parser_state.current_token;
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
return old_token;
|
|
}
|
|
|
|
ALWAYS_INLINE Token Parser::consume(TokenType type, Error error)
|
|
{
|
|
if (m_parser_state.current_token.type() != type) {
|
|
set_error(error);
|
|
dbgln_if(REGEX_DEBUG, "[PARSER] Error: Unexpected token {}. Expected: {}", m_parser_state.current_token.name(), Token::name(type));
|
|
}
|
|
return consume();
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::consume(String const& str)
|
|
{
|
|
size_t potentially_go_back { 1 };
|
|
for (auto ch : str) {
|
|
if (match(TokenType::Char)) {
|
|
if (m_parser_state.current_token.value()[0] != ch) {
|
|
m_parser_state.lexer.back(potentially_go_back);
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
return false;
|
|
}
|
|
} else {
|
|
m_parser_state.lexer.back(potentially_go_back);
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
return false;
|
|
}
|
|
consume(TokenType::Char, Error::NoError);
|
|
++potentially_go_back;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::try_skip(StringView str)
|
|
{
|
|
if (str.starts_with(m_parser_state.current_token.value()))
|
|
str = str.substring_view(m_parser_state.current_token.value().length(), str.length() - m_parser_state.current_token.value().length());
|
|
else
|
|
return false;
|
|
|
|
size_t potentially_go_back { 0 };
|
|
for (auto ch : str) {
|
|
if (!m_parser_state.lexer.try_skip(ch)) {
|
|
m_parser_state.lexer.back(potentially_go_back);
|
|
return false;
|
|
}
|
|
++potentially_go_back;
|
|
}
|
|
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
return true;
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::lookahead_any(StringView str)
|
|
{
|
|
for (auto ch : str) {
|
|
if (match(ch))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
ALWAYS_INLINE char Parser::skip()
|
|
{
|
|
char ch;
|
|
if (m_parser_state.current_token.value().length() == 1) {
|
|
ch = m_parser_state.current_token.value()[0];
|
|
} else {
|
|
m_parser_state.lexer.back(m_parser_state.current_token.value().length());
|
|
ch = m_parser_state.lexer.skip();
|
|
}
|
|
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
return ch;
|
|
}
|
|
|
|
ALWAYS_INLINE void Parser::back(size_t count)
|
|
{
|
|
m_parser_state.lexer.back(count);
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
}
|
|
|
|
ALWAYS_INLINE void Parser::reset()
|
|
{
|
|
m_parser_state.bytecode.clear();
|
|
m_parser_state.lexer.reset();
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
m_parser_state.error = Error::NoError;
|
|
m_parser_state.error_token = { TokenType::Eof, 0, StringView(nullptr) };
|
|
m_parser_state.capture_group_minimum_lengths.clear();
|
|
m_parser_state.capture_groups_count = 0;
|
|
m_parser_state.named_capture_groups_count = 0;
|
|
m_parser_state.named_capture_groups.clear();
|
|
}
|
|
|
|
Parser::Result Parser::parse(Optional<AllOptions> regex_options)
|
|
{
|
|
reset();
|
|
if (regex_options.has_value())
|
|
m_parser_state.regex_options = regex_options.value();
|
|
if (parse_internal(m_parser_state.bytecode, m_parser_state.match_length_minimum))
|
|
consume(TokenType::Eof, Error::InvalidPattern);
|
|
else
|
|
set_error(Error::InvalidPattern);
|
|
|
|
dbgln_if(REGEX_DEBUG, "[PARSER] Produced bytecode with {} entries (opcodes + arguments)", m_parser_state.bytecode.size());
|
|
return {
|
|
move(m_parser_state.bytecode),
|
|
move(m_parser_state.capture_groups_count),
|
|
move(m_parser_state.named_capture_groups_count),
|
|
move(m_parser_state.match_length_minimum),
|
|
move(m_parser_state.error),
|
|
move(m_parser_state.error_token)
|
|
};
|
|
}
|
|
|
|
ALWAYS_INLINE bool Parser::match_ordinary_characters()
|
|
{
|
|
// NOTE: This method must not be called during bracket and repetition parsing!
|
|
// FIXME: Add assertion for that?
|
|
auto type = m_parser_state.current_token.type();
|
|
return (type == TokenType::Char
|
|
|| type == TokenType::Comma
|
|
|| type == TokenType::Slash
|
|
|| type == TokenType::EqualSign
|
|
|| type == TokenType::HyphenMinus
|
|
|| type == TokenType::Colon);
|
|
}
|
|
|
|
// =============================
|
|
// Abstract Posix Parser
|
|
// =============================
|
|
|
|
ALWAYS_INLINE bool AbstractPosixParser::parse_bracket_expression(Vector<CompareTypeAndValuePair>& values, size_t& match_length_minimum)
|
|
{
|
|
for (; !done();) {
|
|
if (match(TokenType::HyphenMinus)) {
|
|
consume();
|
|
|
|
if (values.is_empty() || (values.size() == 1 && values.last().type == CharacterCompareType::Inverse)) {
|
|
// first in the bracket expression
|
|
values.append({ CharacterCompareType::Char, (ByteCodeValueType)'-' });
|
|
} else if (match(TokenType::RightBracket)) {
|
|
// Last in the bracket expression
|
|
values.append({ CharacterCompareType::Char, (ByteCodeValueType)'-' });
|
|
} else if (values.last().type == CharacterCompareType::Char) {
|
|
values.append({ CharacterCompareType::RangeExpressionDummy, 0 });
|
|
|
|
if (done())
|
|
return set_error(Error::MismatchingBracket);
|
|
|
|
if (match(TokenType::HyphenMinus)) {
|
|
consume();
|
|
// Valid range, add ordinary character
|
|
values.append({ CharacterCompareType::Char, (ByteCodeValueType)'-' });
|
|
}
|
|
} else {
|
|
return set_error(Error::InvalidRange);
|
|
}
|
|
|
|
} else if (match(TokenType::Circumflex)) {
|
|
auto t = consume();
|
|
|
|
if (values.is_empty())
|
|
values.append({ CharacterCompareType::Inverse, 0 });
|
|
else
|
|
values.append({ CharacterCompareType::Char, (ByteCodeValueType)*t.value().characters_without_null_termination() });
|
|
|
|
} else if (match(TokenType::LeftBracket)) {
|
|
consume();
|
|
|
|
if (match(TokenType::Period)) {
|
|
consume();
|
|
|
|
// FIXME: Parse collating element, this is needed when we have locale support
|
|
// This could have impact on length parameter, I guess.
|
|
set_error(Error::InvalidCollationElement);
|
|
|
|
consume(TokenType::Period, Error::InvalidCollationElement);
|
|
consume(TokenType::RightBracket, Error::MismatchingBracket);
|
|
|
|
} else if (match(TokenType::EqualSign)) {
|
|
consume();
|
|
// FIXME: Parse collating element, this is needed when we have locale support
|
|
// This could have impact on length parameter, I guess.
|
|
set_error(Error::InvalidCollationElement);
|
|
|
|
consume(TokenType::EqualSign, Error::InvalidCollationElement);
|
|
consume(TokenType::RightBracket, Error::MismatchingBracket);
|
|
|
|
} else if (match(TokenType::Colon)) {
|
|
consume();
|
|
|
|
CharClass ch_class;
|
|
// parse character class
|
|
if (match(TokenType::Char)) {
|
|
if (consume("alnum"))
|
|
ch_class = CharClass::Alnum;
|
|
else if (consume("alpha"))
|
|
ch_class = CharClass::Alpha;
|
|
else if (consume("blank"))
|
|
ch_class = CharClass::Blank;
|
|
else if (consume("cntrl"))
|
|
ch_class = CharClass::Cntrl;
|
|
else if (consume("digit"))
|
|
ch_class = CharClass::Digit;
|
|
else if (consume("graph"))
|
|
ch_class = CharClass::Graph;
|
|
else if (consume("lower"))
|
|
ch_class = CharClass::Lower;
|
|
else if (consume("print"))
|
|
ch_class = CharClass::Print;
|
|
else if (consume("punct"))
|
|
ch_class = CharClass::Punct;
|
|
else if (consume("space"))
|
|
ch_class = CharClass::Space;
|
|
else if (consume("upper"))
|
|
ch_class = CharClass::Upper;
|
|
else if (consume("xdigit"))
|
|
ch_class = CharClass::Xdigit;
|
|
else
|
|
return set_error(Error::InvalidCharacterClass);
|
|
|
|
values.append({ CharacterCompareType::CharClass, (ByteCodeValueType)ch_class });
|
|
|
|
} else
|
|
return set_error(Error::InvalidCharacterClass);
|
|
|
|
// FIXME: we do not support locale specific character classes until locales are implemented
|
|
|
|
consume(TokenType::Colon, Error::InvalidCharacterClass);
|
|
consume(TokenType::RightBracket, Error::MismatchingBracket);
|
|
} else {
|
|
return set_error(Error::MismatchingBracket);
|
|
}
|
|
|
|
} else if (match(TokenType::RightBracket)) {
|
|
|
|
if (values.is_empty() || (values.size() == 1 && values.last().type == CharacterCompareType::Inverse)) {
|
|
// handle bracket as ordinary character
|
|
values.append({ CharacterCompareType::Char, (ByteCodeValueType)*consume().value().characters_without_null_termination() });
|
|
} else {
|
|
// closing bracket expression
|
|
break;
|
|
}
|
|
} else {
|
|
values.append({ CharacterCompareType::Char, (ByteCodeValueType)skip() });
|
|
}
|
|
|
|
// check if range expression has to be completed...
|
|
if (values.size() >= 3 && values.at(values.size() - 2).type == CharacterCompareType::RangeExpressionDummy) {
|
|
if (values.last().type != CharacterCompareType::Char)
|
|
return set_error(Error::InvalidRange);
|
|
|
|
auto value2 = values.take_last();
|
|
values.take_last(); // RangeExpressionDummy
|
|
auto value1 = values.take_last();
|
|
|
|
values.append({ CharacterCompareType::CharRange, static_cast<ByteCodeValueType>(CharRange { (u32)value1.value, (u32)value2.value }) });
|
|
}
|
|
}
|
|
|
|
if (!values.is_empty()) {
|
|
match_length_minimum = 1;
|
|
if (values.first().type == CharacterCompareType::Inverse)
|
|
match_length_minimum = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// =============================
|
|
// PosixBasic Parser
|
|
// =============================
|
|
|
|
bool PosixBasicParser::parse_internal(ByteCode& stack, size_t& match_length_minimum)
|
|
{
|
|
return parse_root(stack, match_length_minimum);
|
|
}
|
|
|
|
bool PosixBasicParser::parse_root(ByteCode& bytecode, size_t& match_length_minimum)
|
|
{
|
|
// basic_reg_exp : L_ANCHOR? RE_expression R_ANCHOR?
|
|
if (match(TokenType::Circumflex)) {
|
|
consume();
|
|
bytecode.empend((ByteCodeValueType)OpCodeId::CheckBegin);
|
|
}
|
|
|
|
if (!parse_re_expression(bytecode, match_length_minimum))
|
|
return false;
|
|
|
|
if (match(TokenType::Dollar)) {
|
|
consume();
|
|
bytecode.empend((ByteCodeValueType)OpCodeId::CheckEnd);
|
|
}
|
|
|
|
return !has_error();
|
|
}
|
|
|
|
bool PosixBasicParser::parse_re_expression(ByteCode& bytecode, size_t& match_length_minimum)
|
|
{
|
|
// RE_expression : RE_expression? simple_RE
|
|
while (!done()) {
|
|
if (!parse_simple_re(bytecode, match_length_minimum))
|
|
break;
|
|
}
|
|
|
|
return !has_error();
|
|
}
|
|
|
|
bool PosixBasicParser::parse_simple_re(ByteCode& bytecode, size_t& match_length_minimum)
|
|
{
|
|
// simple_RE : nondupl_RE RE_dupl_symbol?
|
|
ByteCode simple_re_bytecode;
|
|
size_t re_match_length_minimum = 0;
|
|
if (!parse_nonduplicating_re(simple_re_bytecode, re_match_length_minimum))
|
|
return false;
|
|
|
|
// RE_dupl_symbol : '*' | Back_open_brace DUP_COUNT (',' DUP_COUNT?)? Back_close_brace
|
|
if (match(TokenType::Asterisk)) {
|
|
consume();
|
|
ByteCode::transform_bytecode_repetition_any(simple_re_bytecode, true);
|
|
} else if (try_skip("\\{")) {
|
|
auto read_number = [&]() -> Optional<size_t> {
|
|
if (!match(TokenType::Char))
|
|
return {};
|
|
size_t value = 0;
|
|
while (match(TokenType::Char)) {
|
|
auto c = m_parser_state.current_token.value().substring_view(0, 1);
|
|
auto c_value = c.to_uint();
|
|
if (!c_value.has_value())
|
|
break;
|
|
value *= 10;
|
|
value += *c_value;
|
|
consume();
|
|
}
|
|
return value;
|
|
};
|
|
|
|
size_t min_limit;
|
|
Optional<size_t> max_limit;
|
|
|
|
if (auto limit = read_number(); !limit.has_value())
|
|
return set_error(Error::InvalidRepetitionMarker);
|
|
else
|
|
min_limit = *limit;
|
|
|
|
if (match(TokenType::Comma)) {
|
|
consume();
|
|
max_limit = read_number();
|
|
}
|
|
|
|
if (!try_skip("\\}"))
|
|
return set_error(Error::MismatchingBrace);
|
|
|
|
if (max_limit.value_or(min_limit) < min_limit)
|
|
return set_error(Error::InvalidBraceContent);
|
|
|
|
if (min_limit > s_maximum_repetition_count || (max_limit.has_value() && *max_limit > s_maximum_repetition_count))
|
|
return set_error(Error::InvalidBraceContent);
|
|
|
|
ByteCode::transform_bytecode_repetition_min_max(simple_re_bytecode, min_limit, max_limit, true);
|
|
match_length_minimum += re_match_length_minimum * min_limit;
|
|
} else {
|
|
match_length_minimum += re_match_length_minimum;
|
|
}
|
|
|
|
bytecode.extend(move(simple_re_bytecode));
|
|
return true;
|
|
}
|
|
|
|
bool PosixBasicParser::parse_nonduplicating_re(ByteCode& bytecode, size_t& match_length_minimum)
|
|
{
|
|
// nondupl_RE : one_char_or_coll_elem_RE | Back_open_paren RE_expression Back_close_paren | BACKREF
|
|
if (try_skip("\\(")) {
|
|
ByteCode capture_bytecode;
|
|
size_t capture_length_minimum = 0;
|
|
auto capture_group_index = ++m_parser_state.capture_groups_count;
|
|
|
|
if (!parse_re_expression(capture_bytecode, capture_length_minimum))
|
|
return false;
|
|
|
|
if (!try_skip("\\)"))
|
|
return set_error(Error::MismatchingParen);
|
|
|
|
match_length_minimum += capture_length_minimum;
|
|
if (capture_group_index <= number_of_addressable_capture_groups) {
|
|
m_capture_group_minimum_lengths[capture_group_index - 1] = capture_length_minimum;
|
|
m_capture_group_seen[capture_group_index - 1] = true;
|
|
bytecode.insert_bytecode_group_capture_left(capture_group_index);
|
|
}
|
|
|
|
bytecode.extend(capture_bytecode);
|
|
|
|
if (capture_group_index <= number_of_addressable_capture_groups)
|
|
bytecode.insert_bytecode_group_capture_right(capture_group_index);
|
|
return true;
|
|
}
|
|
|
|
for (size_t i = 1; i < 10; ++i) {
|
|
char backref_name[2] { '\\', '0' };
|
|
backref_name[1] += i;
|
|
if (try_skip({ backref_name, 2 })) {
|
|
if (!m_capture_group_seen[i - 1])
|
|
return set_error(Error::InvalidNumber);
|
|
match_length_minimum += m_capture_group_minimum_lengths[i - 1];
|
|
bytecode.insert_bytecode_compare_values({ { CharacterCompareType::Reference, (ByteCodeValueType)i } });
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return parse_one_char_or_collation_element(bytecode, match_length_minimum);
|
|
}
|
|
|
|
bool PosixBasicParser::parse_one_char_or_collation_element(ByteCode& bytecode, size_t& match_length_minimum)
|
|
{
|
|
// one_char_or_coll_elem_RE : ORD_CHAR | QUOTED_CHAR | '.' | bracket_expression
|
|
if (match(TokenType::Period)) {
|
|
consume();
|
|
bytecode.insert_bytecode_compare_values({ { CharacterCompareType::AnyChar, 0 } });
|
|
match_length_minimum += 1;
|
|
return true;
|
|
}
|
|
|
|
// None of these are special in BRE.
|
|
if (match(TokenType::Char) || match(TokenType::Questionmark) || match(TokenType::RightParen) || match(TokenType::HyphenMinus)
|
|
|| match(TokenType::Circumflex) || match(TokenType::RightCurly) || match(TokenType::Comma) || match(TokenType::Colon)
|
|
|| match(TokenType::Dollar) || match(TokenType::EqualSign) || match(TokenType::LeftCurly) || match(TokenType::LeftParen)
|
|
|| match(TokenType::Pipe) || match(TokenType::Slash) || match(TokenType::RightBracket) || match(TokenType::RightParen)) {
|
|
|
|
auto ch = consume().value()[0];
|
|
bytecode.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)ch } });
|
|
match_length_minimum += 1;
|
|
return true;
|
|
}
|
|
|
|
if (match(TokenType::EscapeSequence)) {
|
|
if (m_parser_state.current_token.value().is_one_of("\\)"sv, "\\}"sv, "\\("sv, "\\{"sv))
|
|
return false;
|
|
auto ch = consume().value()[1];
|
|
bytecode.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)ch } });
|
|
match_length_minimum += 1;
|
|
return true;
|
|
}
|
|
|
|
Vector<CompareTypeAndValuePair> values;
|
|
size_t bracket_minimum_length = 0;
|
|
|
|
if (match(TokenType::LeftBracket)) {
|
|
consume();
|
|
if (!AbstractPosixParser::parse_bracket_expression(values, bracket_minimum_length))
|
|
return false;
|
|
|
|
consume(TokenType::RightBracket, Error::MismatchingBracket);
|
|
|
|
if (!has_error())
|
|
bytecode.insert_bytecode_compare_values(move(values));
|
|
match_length_minimum += bracket_minimum_length;
|
|
return !has_error();
|
|
}
|
|
|
|
return set_error(Error::InvalidPattern);
|
|
}
|
|
|
|
// =============================
|
|
// PosixExtended Parser
|
|
// =============================
|
|
|
|
bool PosixExtendedParser::parse_internal(ByteCode& stack, size_t& match_length_minimum)
|
|
{
|
|
return parse_root(stack, match_length_minimum);
|
|
}
|
|
|
|
ALWAYS_INLINE bool PosixExtendedParser::match_repetition_symbol()
|
|
{
|
|
auto type = m_parser_state.current_token.type();
|
|
return (type == TokenType::Asterisk
|
|
|| type == TokenType::Plus
|
|
|| type == TokenType::Questionmark
|
|
|| type == TokenType::LeftCurly);
|
|
}
|
|
|
|
ALWAYS_INLINE bool PosixExtendedParser::parse_repetition_symbol(ByteCode& bytecode_to_repeat, size_t& match_length_minimum)
|
|
{
|
|
if (match(TokenType::LeftCurly)) {
|
|
consume();
|
|
|
|
StringBuilder number_builder;
|
|
|
|
while (match(TokenType::Char)) {
|
|
number_builder.append(consume().value());
|
|
}
|
|
|
|
auto maybe_minimum = number_builder.build().to_uint();
|
|
if (!maybe_minimum.has_value())
|
|
return set_error(Error::InvalidBraceContent);
|
|
|
|
auto minimum = maybe_minimum.value();
|
|
match_length_minimum *= minimum;
|
|
|
|
if (minimum > s_maximum_repetition_count)
|
|
return set_error(Error::InvalidBraceContent);
|
|
|
|
if (match(TokenType::Comma)) {
|
|
consume();
|
|
} else {
|
|
ByteCode bytecode;
|
|
bytecode.insert_bytecode_repetition_n(bytecode_to_repeat, minimum);
|
|
bytecode_to_repeat = move(bytecode);
|
|
|
|
consume(TokenType::RightCurly, Error::MismatchingBrace);
|
|
return !has_error();
|
|
}
|
|
|
|
Optional<size_t> maybe_maximum {};
|
|
number_builder.clear();
|
|
while (match(TokenType::Char)) {
|
|
number_builder.append(consume().value());
|
|
}
|
|
if (!number_builder.is_empty()) {
|
|
auto value = number_builder.build().to_uint();
|
|
if (!value.has_value() || minimum > value.value() || *value > s_maximum_repetition_count)
|
|
return set_error(Error::InvalidBraceContent);
|
|
|
|
maybe_maximum = value.value();
|
|
}
|
|
|
|
ByteCode::transform_bytecode_repetition_min_max(bytecode_to_repeat, minimum, maybe_maximum);
|
|
|
|
consume(TokenType::RightCurly, Error::MismatchingBrace);
|
|
return !has_error();
|
|
|
|
} else if (match(TokenType::Plus)) {
|
|
consume();
|
|
|
|
bool nongreedy = match(TokenType::Questionmark);
|
|
if (nongreedy)
|
|
consume();
|
|
|
|
// Note: don't touch match_length_minimum, it's already correct
|
|
ByteCode::transform_bytecode_repetition_min_one(bytecode_to_repeat, !nongreedy);
|
|
return !has_error();
|
|
|
|
} else if (match(TokenType::Asterisk)) {
|
|
consume();
|
|
match_length_minimum = 0;
|
|
|
|
bool nongreedy = match(TokenType::Questionmark);
|
|
if (nongreedy)
|
|
consume();
|
|
|
|
ByteCode::transform_bytecode_repetition_any(bytecode_to_repeat, !nongreedy);
|
|
|
|
return !has_error();
|
|
|
|
} else if (match(TokenType::Questionmark)) {
|
|
consume();
|
|
match_length_minimum = 0;
|
|
|
|
bool nongreedy = match(TokenType::Questionmark);
|
|
if (nongreedy)
|
|
consume();
|
|
|
|
ByteCode::transform_bytecode_repetition_zero_or_one(bytecode_to_repeat, !nongreedy);
|
|
return !has_error();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
ALWAYS_INLINE bool PosixExtendedParser::parse_bracket_expression(ByteCode& stack, size_t& match_length_minimum)
|
|
{
|
|
Vector<CompareTypeAndValuePair> values;
|
|
if (!AbstractPosixParser::parse_bracket_expression(values, match_length_minimum))
|
|
return false;
|
|
|
|
if (!has_error())
|
|
stack.insert_bytecode_compare_values(move(values));
|
|
|
|
return !has_error();
|
|
}
|
|
|
|
ALWAYS_INLINE bool PosixExtendedParser::parse_sub_expression(ByteCode& stack, size_t& match_length_minimum)
|
|
{
|
|
ByteCode bytecode;
|
|
size_t length = 0;
|
|
bool should_parse_repetition_symbol { false };
|
|
|
|
for (;;) {
|
|
if (match_ordinary_characters()) {
|
|
Token start_token = m_parser_state.current_token;
|
|
Token last_token = m_parser_state.current_token;
|
|
for (;;) {
|
|
if (!match_ordinary_characters())
|
|
break;
|
|
++length;
|
|
last_token = consume();
|
|
}
|
|
|
|
if (length > 1) {
|
|
// last character is inserted into 'bytecode' for duplication symbol handling
|
|
auto new_length = length - ((match_repetition_symbol() && length > 1) ? 1 : 0);
|
|
stack.insert_bytecode_compare_string({ start_token.value().characters_without_null_termination(), new_length });
|
|
}
|
|
|
|
if ((match_repetition_symbol() && length > 1) || length == 1) // Create own compare opcode for last character before duplication symbol
|
|
bytecode.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)last_token.value().characters_without_null_termination()[0] } });
|
|
|
|
should_parse_repetition_symbol = true;
|
|
break;
|
|
}
|
|
|
|
if (match_repetition_symbol())
|
|
return set_error(Error::InvalidRepetitionMarker);
|
|
|
|
if (match(TokenType::Period)) {
|
|
length = 1;
|
|
consume();
|
|
bytecode.insert_bytecode_compare_values({ { CharacterCompareType::AnyChar, 0 } });
|
|
should_parse_repetition_symbol = true;
|
|
break;
|
|
}
|
|
|
|
if (match(TokenType::EscapeSequence)) {
|
|
length = 1;
|
|
Token t = consume();
|
|
dbgln_if(REGEX_DEBUG, "[PARSER] EscapeSequence with substring {}", t.value());
|
|
|
|
bytecode.insert_bytecode_compare_values({ { CharacterCompareType::Char, (u32)t.value().characters_without_null_termination()[1] } });
|
|
should_parse_repetition_symbol = true;
|
|
break;
|
|
}
|
|
|
|
if (match(TokenType::LeftBracket)) {
|
|
consume();
|
|
|
|
ByteCode sub_ops;
|
|
if (!parse_bracket_expression(sub_ops, length) || !sub_ops.size())
|
|
return set_error(Error::InvalidBracketContent);
|
|
|
|
bytecode.extend(move(sub_ops));
|
|
|
|
consume(TokenType::RightBracket, Error::MismatchingBracket);
|
|
should_parse_repetition_symbol = true;
|
|
break;
|
|
}
|
|
|
|
if (match(TokenType::RightBracket)) {
|
|
return set_error(Error::MismatchingBracket);
|
|
}
|
|
|
|
if (match(TokenType::RightCurly)) {
|
|
return set_error(Error::MismatchingBrace);
|
|
}
|
|
|
|
if (match(TokenType::Circumflex)) {
|
|
consume();
|
|
bytecode.empend((ByteCodeValueType)OpCodeId::CheckBegin);
|
|
break;
|
|
}
|
|
|
|
if (match(TokenType::Dollar)) {
|
|
consume();
|
|
bytecode.empend((ByteCodeValueType)OpCodeId::CheckEnd);
|
|
break;
|
|
}
|
|
|
|
if (match(TokenType::RightParen))
|
|
return false;
|
|
|
|
if (match(TokenType::LeftParen)) {
|
|
enum GroupMode {
|
|
Normal,
|
|
Lookahead,
|
|
NegativeLookahead,
|
|
Lookbehind,
|
|
NegativeLookbehind,
|
|
} group_mode { Normal };
|
|
consume();
|
|
Optional<StringView> capture_group_name;
|
|
bool prevent_capture_group = false;
|
|
if (match(TokenType::Questionmark)) {
|
|
consume();
|
|
|
|
if (match(TokenType::Colon)) {
|
|
consume();
|
|
prevent_capture_group = true;
|
|
} else if (consume("<")) { // named capturing group
|
|
|
|
Token start_token = m_parser_state.current_token;
|
|
Token last_token = m_parser_state.current_token;
|
|
size_t capture_group_name_length = 0;
|
|
for (;;) {
|
|
if (!match_ordinary_characters())
|
|
return set_error(Error::InvalidNameForCaptureGroup);
|
|
if (match(TokenType::Char) && m_parser_state.current_token.value()[0] == '>') {
|
|
consume();
|
|
break;
|
|
}
|
|
++capture_group_name_length;
|
|
last_token = consume();
|
|
}
|
|
capture_group_name = StringView(start_token.value().characters_without_null_termination(), capture_group_name_length);
|
|
|
|
} else if (match(TokenType::EqualSign)) { // positive lookahead
|
|
consume();
|
|
group_mode = Lookahead;
|
|
} else if (consume("!")) { // negative lookahead
|
|
group_mode = NegativeLookahead;
|
|
} else if (consume("<")) {
|
|
if (match(TokenType::EqualSign)) { // positive lookbehind
|
|
consume();
|
|
group_mode = Lookbehind;
|
|
}
|
|
if (consume("!")) // negative lookbehind
|
|
group_mode = NegativeLookbehind;
|
|
} else {
|
|
return set_error(Error::InvalidRepetitionMarker);
|
|
}
|
|
}
|
|
|
|
if (!(m_parser_state.regex_options & AllFlags::SkipSubExprResults || prevent_capture_group))
|
|
bytecode.insert_bytecode_group_capture_left(m_parser_state.capture_groups_count);
|
|
|
|
ByteCode capture_group_bytecode;
|
|
|
|
if (!parse_root(capture_group_bytecode, length))
|
|
return set_error(Error::InvalidPattern);
|
|
|
|
switch (group_mode) {
|
|
case Normal:
|
|
bytecode.extend(move(capture_group_bytecode));
|
|
break;
|
|
case Lookahead:
|
|
bytecode.insert_bytecode_lookaround(move(capture_group_bytecode), ByteCode::LookAroundType::LookAhead, length);
|
|
break;
|
|
case NegativeLookahead:
|
|
bytecode.insert_bytecode_lookaround(move(capture_group_bytecode), ByteCode::LookAroundType::NegatedLookAhead, length);
|
|
break;
|
|
case Lookbehind:
|
|
bytecode.insert_bytecode_lookaround(move(capture_group_bytecode), ByteCode::LookAroundType::LookBehind, length);
|
|
break;
|
|
case NegativeLookbehind:
|
|
bytecode.insert_bytecode_lookaround(move(capture_group_bytecode), ByteCode::LookAroundType::NegatedLookBehind, length);
|
|
break;
|
|
}
|
|
|
|
consume(TokenType::RightParen, Error::MismatchingParen);
|
|
|
|
if (!(m_parser_state.regex_options & AllFlags::SkipSubExprResults || prevent_capture_group)) {
|
|
if (capture_group_name.has_value()) {
|
|
bytecode.insert_bytecode_group_capture_right(m_parser_state.capture_groups_count, capture_group_name.value());
|
|
++m_parser_state.named_capture_groups_count;
|
|
} else {
|
|
bytecode.insert_bytecode_group_capture_right(m_parser_state.capture_groups_count);
|
|
}
|
|
++m_parser_state.capture_groups_count;
|
|
}
|
|
should_parse_repetition_symbol = true;
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (match_repetition_symbol()) {
|
|
if (should_parse_repetition_symbol)
|
|
parse_repetition_symbol(bytecode, length);
|
|
else
|
|
return set_error(Error::InvalidRepetitionMarker);
|
|
}
|
|
|
|
stack.extend(move(bytecode));
|
|
match_length_minimum += length;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PosixExtendedParser::parse_root(ByteCode& stack, size_t& match_length_minimum)
|
|
{
|
|
ByteCode bytecode_left;
|
|
size_t match_length_minimum_left { 0 };
|
|
|
|
if (match_repetition_symbol())
|
|
return set_error(Error::InvalidRepetitionMarker);
|
|
|
|
for (;;) {
|
|
if (!parse_sub_expression(bytecode_left, match_length_minimum_left))
|
|
break;
|
|
|
|
if (match(TokenType::Pipe)) {
|
|
consume();
|
|
|
|
ByteCode bytecode_right;
|
|
size_t match_length_minimum_right { 0 };
|
|
|
|
if (!parse_root(bytecode_right, match_length_minimum_right) || bytecode_right.is_empty())
|
|
return set_error(Error::InvalidPattern);
|
|
|
|
ByteCode new_bytecode;
|
|
new_bytecode.insert_bytecode_alternation(move(bytecode_left), move(bytecode_right));
|
|
bytecode_left = move(new_bytecode);
|
|
match_length_minimum_left = min(match_length_minimum_right, match_length_minimum_left);
|
|
}
|
|
}
|
|
|
|
if (bytecode_left.is_empty())
|
|
set_error(Error::EmptySubExpression);
|
|
|
|
stack.extend(move(bytecode_left));
|
|
match_length_minimum = match_length_minimum_left;
|
|
return !has_error();
|
|
}
|
|
|
|
// =============================
|
|
// ECMA262 Parser
|
|
// =============================
|
|
|
|
bool ECMA262Parser::parse_internal(ByteCode& stack, size_t& match_length_minimum)
|
|
{
|
|
if (m_parser_state.regex_options.has_flag_set(AllFlags::Unicode)) {
|
|
return parse_pattern(stack, match_length_minimum, true, true);
|
|
} else {
|
|
ByteCode new_stack;
|
|
size_t new_match_length = 0;
|
|
auto res = parse_pattern(new_stack, new_match_length, false, false);
|
|
if (m_parser_state.named_capture_groups_count > 0) {
|
|
reset();
|
|
return parse_pattern(stack, match_length_minimum, false, true);
|
|
}
|
|
|
|
if (!res)
|
|
return false;
|
|
|
|
stack.extend(new_stack);
|
|
match_length_minimum = new_match_length;
|
|
return res;
|
|
}
|
|
}
|
|
|
|
bool ECMA262Parser::parse_pattern(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
return parse_disjunction(stack, match_length_minimum, unicode, named);
|
|
}
|
|
|
|
bool ECMA262Parser::parse_disjunction(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
ByteCode left_alternative_stack;
|
|
size_t left_alternative_min_length = 0;
|
|
auto alt_ok = parse_alternative(left_alternative_stack, left_alternative_min_length, unicode, named);
|
|
if (!alt_ok)
|
|
return false;
|
|
|
|
if (!match(TokenType::Pipe)) {
|
|
stack.extend(left_alternative_stack);
|
|
match_length_minimum = left_alternative_min_length;
|
|
return alt_ok;
|
|
}
|
|
|
|
consume();
|
|
ByteCode right_alternative_stack;
|
|
size_t right_alternative_min_length = 0;
|
|
auto continuation_ok = parse_disjunction(right_alternative_stack, right_alternative_min_length, unicode, named);
|
|
if (!continuation_ok)
|
|
return false;
|
|
|
|
stack.insert_bytecode_alternation(move(left_alternative_stack), move(right_alternative_stack));
|
|
match_length_minimum = min(left_alternative_min_length, right_alternative_min_length);
|
|
return continuation_ok;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_alternative(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
for (;;) {
|
|
if (match(TokenType::Eof))
|
|
return true;
|
|
|
|
if (parse_term(stack, match_length_minimum, unicode, named))
|
|
continue;
|
|
|
|
return !has_error();
|
|
}
|
|
}
|
|
|
|
bool ECMA262Parser::parse_term(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
if (parse_assertion(stack, match_length_minimum, unicode, named))
|
|
return true;
|
|
|
|
ByteCode atom_stack;
|
|
size_t minimum_atom_length = 0;
|
|
auto parse_with_quantifier = [&] {
|
|
bool did_parse_one = false;
|
|
if (m_should_use_browser_extended_grammar)
|
|
did_parse_one = parse_extended_atom(atom_stack, minimum_atom_length, named);
|
|
|
|
if (!did_parse_one)
|
|
did_parse_one = parse_atom(atom_stack, minimum_atom_length, unicode, named);
|
|
|
|
if (!did_parse_one)
|
|
return false;
|
|
|
|
VERIFY(did_parse_one);
|
|
if (!parse_quantifier(atom_stack, minimum_atom_length, unicode, named))
|
|
return false;
|
|
|
|
return true;
|
|
};
|
|
|
|
if (!parse_with_quantifier())
|
|
return false;
|
|
|
|
stack.extend(move(atom_stack));
|
|
match_length_minimum += minimum_atom_length;
|
|
return true;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_assertion(ByteCode& stack, [[maybe_unused]] size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
if (match(TokenType::Circumflex)) {
|
|
consume();
|
|
stack.empend((ByteCodeValueType)OpCodeId::CheckBegin);
|
|
return true;
|
|
}
|
|
|
|
if (match(TokenType::Dollar)) {
|
|
consume();
|
|
stack.empend((ByteCodeValueType)OpCodeId::CheckEnd);
|
|
return true;
|
|
}
|
|
|
|
if (try_skip("\\b")) {
|
|
stack.insert_bytecode_check_boundary(BoundaryCheckType::Word);
|
|
return true;
|
|
}
|
|
|
|
if (try_skip("\\B")) {
|
|
stack.insert_bytecode_check_boundary(BoundaryCheckType::NonWord);
|
|
return true;
|
|
}
|
|
|
|
if (match(TokenType::LeftParen)) {
|
|
if (!try_skip("(?"))
|
|
return false;
|
|
|
|
if (done()) {
|
|
set_error(Error::InvalidCaptureGroup);
|
|
return false;
|
|
}
|
|
|
|
ByteCode assertion_stack;
|
|
size_t length_dummy = 0;
|
|
|
|
bool should_parse_forward_assertion = m_should_use_browser_extended_grammar ? unicode : true;
|
|
if (should_parse_forward_assertion && try_skip("=")) {
|
|
if (!parse_inner_disjunction(assertion_stack, length_dummy, unicode, named))
|
|
return false;
|
|
stack.insert_bytecode_lookaround(move(assertion_stack), ByteCode::LookAroundType::LookAhead);
|
|
return true;
|
|
}
|
|
if (should_parse_forward_assertion && try_skip("!")) {
|
|
if (!parse_inner_disjunction(assertion_stack, length_dummy, unicode, named))
|
|
return false;
|
|
stack.insert_bytecode_lookaround(move(assertion_stack), ByteCode::LookAroundType::NegatedLookAhead);
|
|
return true;
|
|
}
|
|
if (m_should_use_browser_extended_grammar) {
|
|
if (!unicode) {
|
|
if (parse_quantifiable_assertion(assertion_stack, match_length_minimum, named)) {
|
|
stack.extend(move(assertion_stack));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (try_skip("<=")) {
|
|
if (!parse_inner_disjunction(assertion_stack, length_dummy, unicode, named))
|
|
return false;
|
|
// FIXME: Somehow ensure that this assertion regexp has a fixed length.
|
|
stack.insert_bytecode_lookaround(move(assertion_stack), ByteCode::LookAroundType::LookBehind, length_dummy);
|
|
return true;
|
|
}
|
|
if (try_skip("<!")) {
|
|
if (!parse_inner_disjunction(assertion_stack, length_dummy, unicode, named))
|
|
return false;
|
|
stack.insert_bytecode_lookaround(move(assertion_stack), ByteCode::LookAroundType::NegatedLookBehind, length_dummy);
|
|
return true;
|
|
}
|
|
|
|
// If none of these matched, put the '(?' back.
|
|
m_parser_state.lexer.back(3);
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_inner_disjunction(ByteCode& bytecode_stack, size_t& length, bool unicode, bool named)
|
|
{
|
|
auto disjunction_ok = parse_disjunction(bytecode_stack, length, unicode, named);
|
|
if (!disjunction_ok)
|
|
return false;
|
|
consume(TokenType::RightParen, Error::MismatchingParen);
|
|
return true;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_quantifiable_assertion(ByteCode& stack, size_t&, bool named)
|
|
{
|
|
VERIFY(m_should_use_browser_extended_grammar);
|
|
ByteCode assertion_stack;
|
|
size_t match_length_minimum = 0;
|
|
|
|
if (try_skip("=")) {
|
|
if (!parse_inner_disjunction(assertion_stack, match_length_minimum, false, named))
|
|
return false;
|
|
|
|
stack.insert_bytecode_lookaround(move(assertion_stack), ByteCode::LookAroundType::LookAhead);
|
|
return true;
|
|
}
|
|
if (try_skip("!")) {
|
|
if (!parse_inner_disjunction(assertion_stack, match_length_minimum, false, named))
|
|
return false;
|
|
|
|
stack.insert_bytecode_lookaround(move(assertion_stack), ByteCode::LookAroundType::NegatedLookAhead);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
StringView ECMA262Parser::read_digits_as_string(ReadDigitsInitialZeroState initial_zero, bool hex, int max_count, int min_count)
|
|
{
|
|
if (!match(TokenType::Char))
|
|
return {};
|
|
|
|
if (initial_zero == ReadDigitsInitialZeroState::Disallow && m_parser_state.current_token.value() == "0")
|
|
return {};
|
|
|
|
int count = 0;
|
|
size_t offset = 0;
|
|
auto start_token = m_parser_state.current_token;
|
|
while (match(TokenType::Char)) {
|
|
auto& c = m_parser_state.current_token.value();
|
|
|
|
if (max_count > 0 && count >= max_count)
|
|
break;
|
|
|
|
if (hex && !AK::StringUtils::convert_to_uint_from_hex(c).has_value())
|
|
break;
|
|
if (!hex && !c.to_uint().has_value())
|
|
break;
|
|
|
|
offset += consume().value().length();
|
|
++count;
|
|
}
|
|
|
|
if (count < min_count)
|
|
return {};
|
|
|
|
return StringView { start_token.value().characters_without_null_termination(), offset };
|
|
}
|
|
|
|
Optional<unsigned> ECMA262Parser::read_digits(ECMA262Parser::ReadDigitsInitialZeroState initial_zero, bool hex, int max_count, int min_count)
|
|
{
|
|
auto str = read_digits_as_string(initial_zero, hex, max_count, min_count);
|
|
if (str.is_empty())
|
|
return {};
|
|
if (hex)
|
|
return AK::StringUtils::convert_to_uint_from_hex(str);
|
|
return str.to_uint();
|
|
}
|
|
|
|
bool ECMA262Parser::parse_quantifier(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool)
|
|
{
|
|
enum class Repetition {
|
|
OneOrMore,
|
|
ZeroOrMore,
|
|
Optional,
|
|
Explicit,
|
|
None,
|
|
} repetition_mark { Repetition::None };
|
|
|
|
bool ungreedy = false;
|
|
Optional<size_t> repeat_min, repeat_max;
|
|
|
|
if (match(TokenType::Asterisk)) {
|
|
consume();
|
|
repetition_mark = Repetition::ZeroOrMore;
|
|
} else if (match(TokenType::Plus)) {
|
|
consume();
|
|
repetition_mark = Repetition::OneOrMore;
|
|
} else if (match(TokenType::Questionmark)) {
|
|
consume();
|
|
repetition_mark = Repetition::Optional;
|
|
} else if (match(TokenType::LeftCurly)) {
|
|
repetition_mark = Repetition::Explicit;
|
|
if (!parse_interval_quantifier(repeat_min, repeat_max)) {
|
|
if (unicode) {
|
|
// Invalid interval quantifiers are disallowed in Unicode mod - they must be esacped with '\{'.
|
|
set_error(Error::InvalidPattern);
|
|
}
|
|
return !has_error();
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
|
|
if (match(TokenType::Questionmark)) {
|
|
consume();
|
|
ungreedy = true;
|
|
}
|
|
|
|
switch (repetition_mark) {
|
|
case Repetition::OneOrMore:
|
|
ByteCode::transform_bytecode_repetition_min_one(stack, !ungreedy);
|
|
break;
|
|
case Repetition::ZeroOrMore:
|
|
ByteCode::transform_bytecode_repetition_any(stack, !ungreedy);
|
|
match_length_minimum = 0;
|
|
break;
|
|
case Repetition::Optional:
|
|
ByteCode::transform_bytecode_repetition_zero_or_one(stack, !ungreedy);
|
|
match_length_minimum = 0;
|
|
break;
|
|
case Repetition::Explicit:
|
|
ByteCode::transform_bytecode_repetition_min_max(stack, repeat_min.value(), repeat_max, !ungreedy);
|
|
match_length_minimum *= repeat_min.value();
|
|
break;
|
|
case Repetition::None:
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_interval_quantifier(Optional<size_t>& repeat_min, Optional<size_t>& repeat_max)
|
|
{
|
|
VERIFY(match(TokenType::LeftCurly));
|
|
consume();
|
|
auto chars_consumed = 1;
|
|
|
|
auto low_bound_string = read_digits_as_string();
|
|
chars_consumed += low_bound_string.length();
|
|
|
|
auto low_bound = low_bound_string.to_uint();
|
|
|
|
if (!low_bound.has_value()) {
|
|
if (!m_should_use_browser_extended_grammar && done())
|
|
return set_error(Error::MismatchingBrace);
|
|
|
|
back(chars_consumed + !done());
|
|
return false;
|
|
}
|
|
|
|
repeat_min = low_bound.value();
|
|
|
|
if (match(TokenType::Comma)) {
|
|
consume();
|
|
++chars_consumed;
|
|
auto high_bound_string = read_digits_as_string();
|
|
auto high_bound = high_bound_string.to_uint();
|
|
if (high_bound.has_value()) {
|
|
repeat_max = high_bound.value();
|
|
chars_consumed += high_bound_string.length();
|
|
}
|
|
} else {
|
|
repeat_max = repeat_min;
|
|
}
|
|
|
|
if (!match(TokenType::RightCurly)) {
|
|
if (!m_should_use_browser_extended_grammar && done())
|
|
return set_error(Error::MismatchingBrace);
|
|
|
|
back(chars_consumed + !done());
|
|
return false;
|
|
}
|
|
|
|
consume();
|
|
++chars_consumed;
|
|
|
|
if (repeat_max.has_value()) {
|
|
if (repeat_min.value() > repeat_max.value())
|
|
set_error(Error::InvalidBraceContent);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_atom(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
if (match(TokenType::EscapeSequence)) {
|
|
// Also part of AtomEscape.
|
|
auto token = consume();
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)token.value()[1] } });
|
|
return true;
|
|
}
|
|
if (try_skip("\\")) {
|
|
// AtomEscape.
|
|
return parse_atom_escape(stack, match_length_minimum, unicode, named);
|
|
}
|
|
|
|
if (match(TokenType::LeftBracket)) {
|
|
// Character class.
|
|
return parse_character_class(stack, match_length_minimum, unicode, named);
|
|
}
|
|
|
|
if (match(TokenType::LeftParen)) {
|
|
// Non-capturing group, or a capture group.
|
|
return parse_capture_group(stack, match_length_minimum, unicode, named);
|
|
}
|
|
|
|
if (match(TokenType::Period)) {
|
|
consume();
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::AnyChar, 0 } });
|
|
return true;
|
|
}
|
|
|
|
if (match(TokenType::Circumflex) || match(TokenType::Dollar) || match(TokenType::RightParen)
|
|
|| match(TokenType::Pipe) || match(TokenType::Plus) || match(TokenType::Asterisk)
|
|
|| match(TokenType::Questionmark)) {
|
|
|
|
return false;
|
|
}
|
|
|
|
if (match(TokenType::RightBracket) || match(TokenType::RightCurly) || match(TokenType::LeftCurly)) {
|
|
if (unicode)
|
|
return set_error(Error::InvalidPattern);
|
|
|
|
if (m_should_use_browser_extended_grammar) {
|
|
auto token = consume();
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)token.value()[0] } });
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (match_ordinary_characters()) {
|
|
auto token = consume().value();
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)token[0] } });
|
|
return true;
|
|
}
|
|
|
|
set_error(Error::InvalidPattern);
|
|
return false;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_extended_atom(ByteCode&, size_t&, bool)
|
|
{
|
|
// Note: This includes only rules *not* present in parse_atom()
|
|
VERIFY(m_should_use_browser_extended_grammar);
|
|
|
|
if (parse_invalid_braced_quantifier())
|
|
return true; // FAIL FAIL FAIL
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_invalid_braced_quantifier()
|
|
{
|
|
if (!match(TokenType::LeftCurly))
|
|
return false;
|
|
consume();
|
|
size_t chars_consumed = 1;
|
|
auto low_bound = read_digits_as_string();
|
|
StringView high_bound;
|
|
|
|
if (low_bound.is_empty()) {
|
|
back(chars_consumed + !done());
|
|
return false;
|
|
}
|
|
chars_consumed += low_bound.length();
|
|
if (match(TokenType::Comma)) {
|
|
consume();
|
|
++chars_consumed;
|
|
|
|
high_bound = read_digits_as_string();
|
|
chars_consumed += high_bound.length();
|
|
}
|
|
|
|
if (!match(TokenType::RightCurly)) {
|
|
back(chars_consumed + !done());
|
|
return false;
|
|
}
|
|
|
|
consume();
|
|
set_error(Error::InvalidPattern);
|
|
return true;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_atom_escape(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
if (auto escape_str = read_digits_as_string(ReadDigitsInitialZeroState::Disallow); !escape_str.is_empty()) {
|
|
if (auto escape = escape_str.to_uint(); escape.has_value()) {
|
|
// See if this is a "back"-reference (we've already parsed the group it refers to)
|
|
auto maybe_length = m_parser_state.capture_group_minimum_lengths.get(escape.value());
|
|
if (maybe_length.has_value()) {
|
|
match_length_minimum += maybe_length.value();
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Reference, (ByteCodeValueType)escape.value() } });
|
|
return true;
|
|
}
|
|
// It's not a pattern seen before, so we have to see if it's a valid reference to a future group.
|
|
if (escape.value() <= ensure_total_number_of_capturing_parenthesis()) {
|
|
// This refers to a future group, and it will _always_ be matching an empty string
|
|
// So just match nothing and move on.
|
|
return true;
|
|
}
|
|
if (!m_should_use_browser_extended_grammar) {
|
|
set_error(Error::InvalidNumber);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If not, put the characters back.
|
|
back(escape_str.length());
|
|
}
|
|
|
|
// CharacterEscape > ControlEscape
|
|
if (try_skip("f")) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'\f' } });
|
|
return true;
|
|
}
|
|
|
|
if (try_skip("n")) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'\n' } });
|
|
return true;
|
|
}
|
|
|
|
if (try_skip("r")) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'\r' } });
|
|
return true;
|
|
}
|
|
|
|
if (try_skip("t")) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'\t' } });
|
|
return true;
|
|
}
|
|
|
|
if (try_skip("v")) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'\v' } });
|
|
return true;
|
|
}
|
|
|
|
// CharacterEscape > ControlLetter
|
|
if (try_skip("c")) {
|
|
for (auto c : s_alphabetic_characters) {
|
|
if (try_skip({ &c, 1 })) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)(c % 32) } });
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (unicode) {
|
|
set_error(Error::InvalidPattern);
|
|
return false;
|
|
}
|
|
|
|
if (m_should_use_browser_extended_grammar) {
|
|
back(1 + !done());
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'\\' } });
|
|
match_length_minimum += 1;
|
|
return true;
|
|
}
|
|
|
|
// Allow '\c' in non-unicode mode, just matches 'c'.
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'c' } });
|
|
return true;
|
|
}
|
|
|
|
// '\0'
|
|
if (try_skip("0")) {
|
|
if (!lookahead_any(s_decimal_characters)) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)0 } });
|
|
return true;
|
|
}
|
|
|
|
back();
|
|
}
|
|
|
|
// LegacyOctalEscapeSequence
|
|
if (m_should_use_browser_extended_grammar) {
|
|
if (!unicode) {
|
|
if (auto escape = parse_legacy_octal_escape(); escape.has_value()) {
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)escape.value() } });
|
|
match_length_minimum += 1;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// HexEscape
|
|
if (try_skip("x")) {
|
|
if (auto hex_escape = read_digits(ReadDigitsInitialZeroState::Allow, true, 2, 2); hex_escape.has_value()) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)hex_escape.value() } });
|
|
return true;
|
|
} else if (!unicode) {
|
|
// '\x' is allowed in non-unicode mode, just matches 'x'.
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'x' } });
|
|
return true;
|
|
} else {
|
|
set_error(Error::InvalidPattern);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (try_skip("u")) {
|
|
if (match(TokenType::LeftCurly)) {
|
|
consume();
|
|
|
|
if (!unicode) {
|
|
// FIXME: In non-Unicode mode, this should be parsed as a repetition symbol (repeating the 'u').
|
|
TODO();
|
|
}
|
|
|
|
auto code_point = read_digits(ReadDigitsInitialZeroState::Allow, true, 6);
|
|
if (code_point.has_value() && is_unicode(*code_point) && match(TokenType::RightCurly)) {
|
|
consume();
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)code_point.value() } });
|
|
return true;
|
|
}
|
|
|
|
set_error(Error::InvalidPattern);
|
|
return false;
|
|
}
|
|
|
|
if (auto code_point = read_digits(ReadDigitsInitialZeroState::Allow, true, 4, 4); code_point.has_value()) {
|
|
// In Unicode mode, we need to combine surrogate pairs into a single code point. But we also need to be
|
|
// rather forgiving if the surrogate pairs are invalid. So if a second code unit follows this code unit,
|
|
// but doesn't form a valid surrogate pair, insert bytecode for both code units individually.
|
|
Optional<u32> low_surrogate;
|
|
if (unicode && Utf16View::is_high_surrogate(*code_point) && try_skip("\\u")) {
|
|
low_surrogate = read_digits(ReadDigitsInitialZeroState::Allow, true, 4);
|
|
if (!low_surrogate.has_value()) {
|
|
set_error(Error::InvalidPattern);
|
|
return false;
|
|
}
|
|
|
|
if (Utf16View::is_low_surrogate(*low_surrogate)) {
|
|
*code_point = Utf16View::decode_surrogate_pair(*code_point, *low_surrogate);
|
|
low_surrogate.clear();
|
|
}
|
|
}
|
|
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)code_point.value() } });
|
|
|
|
if (low_surrogate.has_value()) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)low_surrogate.value() } });
|
|
}
|
|
|
|
return true;
|
|
} else if (!unicode) {
|
|
// '\u' is allowed in non-unicode mode, just matches 'u'.
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'u' } });
|
|
return true;
|
|
} else {
|
|
set_error(Error::InvalidPattern);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// IdentityEscape
|
|
for (auto ch : identity_escape_characters(unicode, m_should_use_browser_extended_grammar)) {
|
|
if (try_skip({ &ch, 1 })) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)ch } });
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (unicode) {
|
|
if (try_skip("/")) {
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)'/' } });
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (named && try_skip("k")) {
|
|
auto name = read_capture_group_specifier(true);
|
|
if (name.is_empty()) {
|
|
set_error(Error::InvalidNameForCaptureGroup);
|
|
return false;
|
|
}
|
|
auto maybe_capture_group = m_parser_state.named_capture_groups.get(name);
|
|
if (!maybe_capture_group.has_value()) {
|
|
set_error(Error::InvalidNameForCaptureGroup);
|
|
return false;
|
|
}
|
|
match_length_minimum += maybe_capture_group->minimum_length;
|
|
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Reference, (ByteCodeValueType)maybe_capture_group->group_index } });
|
|
return true;
|
|
}
|
|
|
|
if (unicode) {
|
|
PropertyEscape property { Empty {} };
|
|
bool negated = false;
|
|
|
|
if (parse_unicode_property_escape(property, negated)) {
|
|
Vector<CompareTypeAndValuePair> compares;
|
|
if (negated)
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::Inverse, 0 });
|
|
property.visit(
|
|
[&](Unicode::Property property) {
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::Property, (ByteCodeValueType)property });
|
|
},
|
|
[&](Unicode::GeneralCategory general_category) {
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::GeneralCategory, (ByteCodeValueType)general_category });
|
|
},
|
|
[&](Script script) {
|
|
if (script.is_extension)
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::ScriptExtension, (ByteCodeValueType)script.script });
|
|
else
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::Script, (ByteCodeValueType)script.script });
|
|
},
|
|
[](Empty&) { VERIFY_NOT_REACHED(); });
|
|
stack.insert_bytecode_compare_values(move(compares));
|
|
match_length_minimum += 1;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (done())
|
|
return set_error(Error::InvalidTrailingEscape);
|
|
|
|
bool negate = false;
|
|
auto ch = parse_character_class_escape(negate);
|
|
if (!ch.has_value()) {
|
|
if (!unicode) {
|
|
// Allow all SourceCharacter's as escapes here.
|
|
auto token = consume();
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values({ { CharacterCompareType::Char, (ByteCodeValueType)token.value()[0] } });
|
|
return true;
|
|
}
|
|
|
|
set_error(Error::InvalidCharacterClass);
|
|
return false;
|
|
}
|
|
|
|
Vector<CompareTypeAndValuePair> compares;
|
|
if (negate)
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::Inverse, 0 });
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::CharClass, (ByteCodeValueType)ch.value() });
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values(move(compares));
|
|
return true;
|
|
}
|
|
Optional<u8> ECMA262Parser::parse_legacy_octal_escape()
|
|
{
|
|
constexpr auto all_octal_digits = "01234567";
|
|
auto read_octal_digit = [&](auto start, auto end, bool should_ensure_no_following_octal_digit) -> Optional<u8> {
|
|
for (char c = '0' + start; c <= '0' + end; ++c) {
|
|
if (try_skip({ &c, 1 })) {
|
|
if (!should_ensure_no_following_octal_digit || !lookahead_any(all_octal_digits))
|
|
return c - '0';
|
|
back(2);
|
|
return {};
|
|
}
|
|
}
|
|
return {};
|
|
};
|
|
|
|
// OctalDigit(1)
|
|
if (auto digit = read_octal_digit(0, 7, true); digit.has_value()) {
|
|
return digit.value();
|
|
}
|
|
|
|
// OctalDigit(2)
|
|
if (auto left_digit = read_octal_digit(0, 3, false); left_digit.has_value()) {
|
|
if (auto right_digit = read_octal_digit(0, 7, true); right_digit.has_value()) {
|
|
return left_digit.value() * 8 + right_digit.value();
|
|
}
|
|
|
|
back(2);
|
|
}
|
|
|
|
// OctalDigit(2)
|
|
if (auto left_digit = read_octal_digit(4, 7, false); left_digit.has_value()) {
|
|
if (auto right_digit = read_octal_digit(0, 7, false); right_digit.has_value()) {
|
|
return left_digit.value() * 8 + right_digit.value();
|
|
}
|
|
|
|
back(2);
|
|
}
|
|
|
|
// OctalDigit(3)
|
|
if (auto left_digit = read_octal_digit(0, 3, false); left_digit.has_value()) {
|
|
size_t chars_consumed = 1;
|
|
if (auto mid_digit = read_octal_digit(0, 7, false); mid_digit.has_value()) {
|
|
++chars_consumed;
|
|
if (auto right_digit = read_octal_digit(0, 7, false); right_digit.has_value()) {
|
|
return left_digit.value() * 64 + mid_digit.value() * 8 + right_digit.value();
|
|
}
|
|
}
|
|
|
|
back(chars_consumed);
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
Optional<CharClass> ECMA262Parser::parse_character_class_escape(bool& negate, bool expect_backslash)
|
|
{
|
|
if (expect_backslash && !try_skip("\\"))
|
|
return {};
|
|
|
|
// CharacterClassEscape
|
|
CharClass ch_class;
|
|
if (try_skip("d")) {
|
|
ch_class = CharClass::Digit;
|
|
} else if (try_skip("D")) {
|
|
ch_class = CharClass::Digit;
|
|
negate = true;
|
|
} else if (try_skip("s")) {
|
|
ch_class = CharClass::Space;
|
|
} else if (try_skip("S")) {
|
|
ch_class = CharClass::Space;
|
|
negate = true;
|
|
} else if (try_skip("w")) {
|
|
ch_class = CharClass::Word;
|
|
} else if (try_skip("W")) {
|
|
ch_class = CharClass::Word;
|
|
negate = true;
|
|
} else {
|
|
return {};
|
|
}
|
|
|
|
return ch_class;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_character_class(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool)
|
|
{
|
|
consume(TokenType::LeftBracket, Error::InvalidPattern);
|
|
|
|
Vector<CompareTypeAndValuePair> compares;
|
|
|
|
if (match(TokenType::Circumflex)) {
|
|
// Negated charclass
|
|
consume();
|
|
compares.empend(CompareTypeAndValuePair { CharacterCompareType::Inverse, 0 });
|
|
}
|
|
|
|
if (match(TokenType::RightBracket)) {
|
|
consume();
|
|
// Should only have at most an 'Inverse'
|
|
VERIFY(compares.size() <= 1);
|
|
stack.insert_bytecode_compare_values(move(compares));
|
|
return true;
|
|
}
|
|
|
|
if (!parse_nonempty_class_ranges(compares, unicode))
|
|
return false;
|
|
|
|
match_length_minimum += 1;
|
|
stack.insert_bytecode_compare_values(move(compares));
|
|
return true;
|
|
}
|
|
|
|
struct CharClassRangeElement {
|
|
union {
|
|
CharClass character_class;
|
|
u32 code_point { 0 };
|
|
Unicode::Property property;
|
|
Unicode::GeneralCategory general_category;
|
|
Unicode::Script script;
|
|
};
|
|
|
|
bool is_negated { false };
|
|
bool is_character_class { false };
|
|
bool is_property { false };
|
|
bool is_general_category { false };
|
|
bool is_script { false };
|
|
bool is_script_extension { false };
|
|
};
|
|
|
|
bool ECMA262Parser::parse_nonempty_class_ranges(Vector<CompareTypeAndValuePair>& ranges, bool unicode)
|
|
{
|
|
auto read_class_atom_no_dash = [&]() -> Optional<CharClassRangeElement> {
|
|
if (match(TokenType::EscapeSequence)) {
|
|
auto token = consume().value();
|
|
return { CharClassRangeElement { .code_point = (u32)token[1], .is_character_class = false } };
|
|
}
|
|
|
|
if (try_skip("\\")) {
|
|
if (done()) {
|
|
set_error(Error::InvalidTrailingEscape);
|
|
return {};
|
|
}
|
|
|
|
if (try_skip("f"))
|
|
return { CharClassRangeElement { .code_point = '\f', .is_character_class = false } };
|
|
if (try_skip("n"))
|
|
return { CharClassRangeElement { .code_point = '\n', .is_character_class = false } };
|
|
if (try_skip("r"))
|
|
return { CharClassRangeElement { .code_point = '\r', .is_character_class = false } };
|
|
if (try_skip("t"))
|
|
return { CharClassRangeElement { .code_point = '\t', .is_character_class = false } };
|
|
if (try_skip("v"))
|
|
return { CharClassRangeElement { .code_point = '\v', .is_character_class = false } };
|
|
if (try_skip("b"))
|
|
return { CharClassRangeElement { .code_point = '\b', .is_character_class = false } };
|
|
if (try_skip("/"))
|
|
return { CharClassRangeElement { .code_point = '/', .is_character_class = false } };
|
|
|
|
// CharacterEscape > ControlLetter
|
|
if (try_skip("c")) {
|
|
for (auto c : s_alphabetic_characters) {
|
|
if (try_skip({ &c, 1 })) {
|
|
return { CharClassRangeElement { .code_point = (u32)(c % 32), .is_character_class = false } };
|
|
}
|
|
}
|
|
|
|
if (unicode) {
|
|
set_error(Error::InvalidPattern);
|
|
return {};
|
|
}
|
|
|
|
if (m_should_use_browser_extended_grammar) {
|
|
for (auto c = '0'; c <= '9'; ++c) {
|
|
if (try_skip({ &c, 1 }))
|
|
return { CharClassRangeElement { .code_point = (u32)(c % 32), .is_character_class = false } };
|
|
}
|
|
if (try_skip("_"))
|
|
return { CharClassRangeElement { .code_point = (u32)('_' % 32), .is_character_class = false } };
|
|
|
|
back(1 + !done());
|
|
return { CharClassRangeElement { .code_point = '\\', .is_character_class = false } };
|
|
}
|
|
}
|
|
|
|
// '\0'
|
|
if (try_skip("0")) {
|
|
if (!lookahead_any(s_decimal_characters))
|
|
return { CharClassRangeElement { .code_point = 0, .is_character_class = false } };
|
|
back();
|
|
}
|
|
|
|
// LegacyOctalEscapeSequence
|
|
if (m_should_use_browser_extended_grammar && !unicode) {
|
|
if (auto escape = parse_legacy_octal_escape(); escape.has_value())
|
|
return { CharClassRangeElement { .code_point = escape.value(), .is_character_class = false } };
|
|
}
|
|
|
|
// HexEscape
|
|
if (try_skip("x")) {
|
|
if (auto hex_escape = read_digits(ReadDigitsInitialZeroState::Allow, true, 2, 2); hex_escape.has_value()) {
|
|
return { CharClassRangeElement { .code_point = hex_escape.value(), .is_character_class = false } };
|
|
} else if (!unicode) {
|
|
// '\x' is allowed in non-unicode mode, just matches 'x'.
|
|
return { CharClassRangeElement { .code_point = 'x', .is_character_class = false } };
|
|
} else {
|
|
set_error(Error::InvalidPattern);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
if (try_skip("u")) {
|
|
if (auto code_point = read_digits(ReadDigitsInitialZeroState::Allow, true, 4, 4); code_point.has_value()) {
|
|
// FIXME: While code point ranges are supported, code point matches as "Char" are not!
|
|
return { CharClassRangeElement { .code_point = code_point.value(), .is_character_class = false } };
|
|
} else if (!unicode) {
|
|
// '\u' is allowed in non-unicode mode, just matches 'u'.
|
|
return { CharClassRangeElement { .code_point = 'u', .is_character_class = false } };
|
|
} else {
|
|
set_error(Error::InvalidPattern);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
// IdentityEscape
|
|
for (auto ch : identity_escape_characters(unicode, m_should_use_browser_extended_grammar)) {
|
|
if (try_skip({ &ch, 1 }))
|
|
return { CharClassRangeElement { .code_point = (u32)ch, .is_character_class = false } };
|
|
}
|
|
|
|
if (unicode) {
|
|
if (try_skip("-"))
|
|
return { CharClassRangeElement { .code_point = '-', .is_character_class = false } };
|
|
|
|
PropertyEscape property { Empty {} };
|
|
bool negated = false;
|
|
if (parse_unicode_property_escape(property, negated)) {
|
|
return property.visit(
|
|
[&](Unicode::Property property) {
|
|
return CharClassRangeElement { .property = property, .is_negated = negated, .is_character_class = true, .is_property = true };
|
|
},
|
|
[&](Unicode::GeneralCategory general_category) {
|
|
return CharClassRangeElement { .general_category = general_category, .is_negated = negated, .is_character_class = true, .is_general_category = true };
|
|
},
|
|
[&](Script script) {
|
|
if (script.is_extension)
|
|
return CharClassRangeElement { .script = script.script, .is_negated = negated, .is_character_class = true, .is_script_extension = true };
|
|
else
|
|
return CharClassRangeElement { .script = script.script, .is_negated = negated, .is_character_class = true, .is_script = true };
|
|
},
|
|
[](Empty&) -> CharClassRangeElement { VERIFY_NOT_REACHED(); });
|
|
}
|
|
}
|
|
|
|
if (try_skip("d"))
|
|
return { CharClassRangeElement { .character_class = CharClass::Digit, .is_character_class = true } };
|
|
if (try_skip("s"))
|
|
return { CharClassRangeElement { .character_class = CharClass::Space, .is_character_class = true } };
|
|
if (try_skip("w"))
|
|
return { CharClassRangeElement { .character_class = CharClass::Word, .is_character_class = true } };
|
|
if (try_skip("D"))
|
|
return { CharClassRangeElement { .character_class = CharClass::Digit, .is_negated = true, .is_character_class = true } };
|
|
if (try_skip("S"))
|
|
return { CharClassRangeElement { .character_class = CharClass::Space, .is_negated = true, .is_character_class = true } };
|
|
if (try_skip("W"))
|
|
return { CharClassRangeElement { .character_class = CharClass::Word, .is_negated = true, .is_character_class = true } };
|
|
|
|
if (!unicode) {
|
|
// Any unrecognised escape is allowed in non-unicode mode.
|
|
return { CharClassRangeElement { .code_point = (u32)skip(), .is_character_class = false } };
|
|
}
|
|
|
|
set_error(Error::InvalidPattern);
|
|
return {};
|
|
}
|
|
|
|
if (match(TokenType::RightBracket) || match(TokenType::HyphenMinus))
|
|
return {};
|
|
|
|
// Allow any (other) SourceCharacter.
|
|
return { CharClassRangeElement { .code_point = (u32)skip(), .is_character_class = false } };
|
|
};
|
|
auto read_class_atom = [&]() -> Optional<CharClassRangeElement> {
|
|
if (match(TokenType::HyphenMinus)) {
|
|
consume();
|
|
return { CharClassRangeElement { .code_point = '-', .is_character_class = false } };
|
|
}
|
|
|
|
return read_class_atom_no_dash();
|
|
};
|
|
|
|
auto empend_atom = [&](auto& atom) {
|
|
if (atom.is_character_class) {
|
|
if (atom.is_negated)
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::TemporaryInverse, 0 });
|
|
|
|
if (atom.is_property)
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::Property, (ByteCodeValueType)(atom.property) });
|
|
else if (atom.is_general_category)
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::GeneralCategory, (ByteCodeValueType)(atom.general_category) });
|
|
else if (atom.is_script)
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::Script, (ByteCodeValueType)(atom.script) });
|
|
else if (atom.is_script_extension)
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::ScriptExtension, (ByteCodeValueType)(atom.script) });
|
|
else
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::CharClass, (ByteCodeValueType)atom.character_class });
|
|
} else {
|
|
VERIFY(!atom.is_negated);
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::Char, atom.code_point });
|
|
}
|
|
};
|
|
|
|
while (!match(TokenType::RightBracket)) {
|
|
if (match(TokenType::Eof)) {
|
|
set_error(Error::MismatchingBracket);
|
|
return false;
|
|
}
|
|
|
|
auto first_atom = read_class_atom();
|
|
if (!first_atom.has_value())
|
|
return false;
|
|
|
|
if (match(TokenType::HyphenMinus)) {
|
|
consume();
|
|
if (match(TokenType::RightBracket)) {
|
|
// Allow '-' as the last element in a charclass, even after an atom.
|
|
m_parser_state.lexer.back(2); // -]
|
|
m_parser_state.current_token = m_parser_state.lexer.next();
|
|
goto read_as_single_atom;
|
|
}
|
|
auto second_atom = read_class_atom();
|
|
if (!second_atom.has_value())
|
|
return false;
|
|
|
|
if (first_atom.value().is_character_class || second_atom.value().is_character_class) {
|
|
if (m_should_use_browser_extended_grammar) {
|
|
if (unicode) {
|
|
set_error(Error::InvalidRange);
|
|
return false;
|
|
}
|
|
|
|
// CharacterRangeOrUnion > !Unicode > CharClass
|
|
empend_atom(*first_atom);
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::Char, (ByteCodeValueType)'-' });
|
|
empend_atom(*second_atom);
|
|
continue;
|
|
} else {
|
|
set_error(Error::InvalidRange);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (first_atom.value().code_point > second_atom.value().code_point) {
|
|
set_error(Error::InvalidRange);
|
|
return false;
|
|
}
|
|
|
|
VERIFY(!first_atom.value().is_negated);
|
|
VERIFY(!second_atom.value().is_negated);
|
|
|
|
ranges.empend(CompareTypeAndValuePair { CharacterCompareType::CharRange, CharRange { first_atom.value().code_point, second_atom.value().code_point } });
|
|
continue;
|
|
}
|
|
|
|
read_as_single_atom:;
|
|
|
|
auto atom = first_atom.value();
|
|
empend_atom(atom);
|
|
}
|
|
|
|
consume(TokenType::RightBracket, Error::MismatchingBracket);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ECMA262Parser::parse_unicode_property_escape(PropertyEscape& property, bool& negated)
|
|
{
|
|
negated = false;
|
|
|
|
if (try_skip("p"))
|
|
negated = false;
|
|
else if (try_skip("P"))
|
|
negated = true;
|
|
else
|
|
return false;
|
|
|
|
auto parsed_property = read_unicode_property_escape();
|
|
if (!parsed_property.has_value()) {
|
|
set_error(Error::InvalidNameForProperty);
|
|
return false;
|
|
}
|
|
|
|
property = move(*parsed_property);
|
|
|
|
return property.visit(
|
|
[this](Unicode::Property property) {
|
|
if (!Unicode::is_ecma262_property(property)) {
|
|
set_error(Error::InvalidNameForProperty);
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
[](Unicode::GeneralCategory) { return true; },
|
|
[](Script) { return true; },
|
|
[](Empty&) -> bool { VERIFY_NOT_REACHED(); });
|
|
}
|
|
|
|
StringView ECMA262Parser::read_capture_group_specifier(bool take_starting_angle_bracket)
|
|
{
|
|
if (take_starting_angle_bracket && !consume("<"))
|
|
return {};
|
|
|
|
auto start_token = m_parser_state.current_token;
|
|
size_t offset = 0;
|
|
while (match(TokenType::Char) || match(TokenType::Dollar)) {
|
|
auto c = m_parser_state.current_token.value();
|
|
if (c == ">")
|
|
break;
|
|
offset += consume().value().length();
|
|
}
|
|
|
|
StringView name { start_token.value().characters_without_null_termination(), offset };
|
|
if (!consume(">") || name.is_empty())
|
|
set_error(Error::InvalidNameForCaptureGroup);
|
|
|
|
return name;
|
|
}
|
|
|
|
Optional<ECMA262Parser::PropertyEscape> ECMA262Parser::read_unicode_property_escape()
|
|
{
|
|
consume(TokenType::LeftCurly, Error::InvalidPattern);
|
|
|
|
// Note: clang-format is disabled here because it doesn't handle templated lambdas yet.
|
|
// clang-format off
|
|
auto read_until = [&]<typename... Ts>(Ts&&... terminators) {
|
|
auto start_token = m_parser_state.current_token;
|
|
size_t offset = 0;
|
|
|
|
while (match(TokenType::Char)) {
|
|
if (m_parser_state.current_token.value().is_one_of(forward<Ts>(terminators)...))
|
|
break;
|
|
offset += consume().value().length();
|
|
}
|
|
|
|
return StringView { start_token.value().characters_without_null_termination(), offset };
|
|
};
|
|
// clang-format on
|
|
|
|
StringView property_type;
|
|
StringView property_name = read_until("="sv, "}"sv);
|
|
|
|
if (try_skip("="sv)) {
|
|
if (property_name.is_empty())
|
|
return {};
|
|
property_type = property_name;
|
|
property_name = read_until("}"sv);
|
|
}
|
|
|
|
consume(TokenType::RightCurly, Error::InvalidPattern);
|
|
|
|
if (property_type.is_empty()) {
|
|
if (auto property = Unicode::property_from_string(property_name); property.has_value())
|
|
return { *property };
|
|
if (auto general_category = Unicode::general_category_from_string(property_name); general_category.has_value())
|
|
return { *general_category };
|
|
} else if ((property_type == "General_Category"sv) || (property_type == "gc"sv)) {
|
|
if (auto general_category = Unicode::general_category_from_string(property_name); general_category.has_value())
|
|
return { *general_category };
|
|
} else if ((property_type == "Script"sv) || (property_type == "sc"sv)) {
|
|
if (auto script = Unicode::script_from_string(property_name); script.has_value())
|
|
return Script { *script, false };
|
|
} else if ((property_type == "Script_Extensions"sv) || (property_type == "scx"sv)) {
|
|
if (auto script = Unicode::script_from_string(property_name); script.has_value())
|
|
return Script { *script, true };
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
bool ECMA262Parser::parse_capture_group(ByteCode& stack, size_t& match_length_minimum, bool unicode, bool named)
|
|
{
|
|
consume(TokenType::LeftParen, Error::InvalidPattern);
|
|
|
|
auto enter_capture_group_scope = [&] {
|
|
m_capture_groups_in_scope.empend();
|
|
};
|
|
auto exit_capture_group_scope = [&] {
|
|
auto last = m_capture_groups_in_scope.take_last();
|
|
m_capture_groups_in_scope.last().extend(move(last));
|
|
};
|
|
auto register_capture_group_in_current_scope = [&](auto identifier) {
|
|
m_capture_groups_in_scope.last().empend(identifier);
|
|
};
|
|
auto clear_all_capture_groups_in_scope = [&] {
|
|
for (auto& index : m_capture_groups_in_scope.last())
|
|
stack.insert_bytecode_clear_capture_group(index);
|
|
};
|
|
|
|
if (match(TokenType::Questionmark)) {
|
|
// Non-capturing group or group with specifier.
|
|
consume();
|
|
|
|
if (match(TokenType::Colon)) {
|
|
consume();
|
|
ByteCode noncapture_group_bytecode;
|
|
size_t length = 0;
|
|
|
|
enter_capture_group_scope();
|
|
if (!parse_disjunction(noncapture_group_bytecode, length, unicode, named))
|
|
return set_error(Error::InvalidPattern);
|
|
clear_all_capture_groups_in_scope();
|
|
exit_capture_group_scope();
|
|
|
|
consume(TokenType::RightParen, Error::MismatchingParen);
|
|
|
|
stack.extend(move(noncapture_group_bytecode));
|
|
match_length_minimum += length;
|
|
return true;
|
|
}
|
|
|
|
if (consume("<")) {
|
|
++m_parser_state.named_capture_groups_count;
|
|
auto group_index = ++m_parser_state.capture_groups_count; // Named capture groups count as normal capture groups too.
|
|
auto name = read_capture_group_specifier();
|
|
|
|
if (name.is_empty()) {
|
|
set_error(Error::InvalidNameForCaptureGroup);
|
|
return false;
|
|
}
|
|
|
|
ByteCode capture_group_bytecode;
|
|
size_t length = 0;
|
|
enter_capture_group_scope();
|
|
if (!parse_disjunction(capture_group_bytecode, length, unicode, named))
|
|
return set_error(Error::InvalidPattern);
|
|
clear_all_capture_groups_in_scope();
|
|
exit_capture_group_scope();
|
|
|
|
register_capture_group_in_current_scope(group_index);
|
|
|
|
consume(TokenType::RightParen, Error::MismatchingParen);
|
|
|
|
stack.insert_bytecode_group_capture_left(group_index);
|
|
stack.extend(move(capture_group_bytecode));
|
|
stack.insert_bytecode_group_capture_right(group_index, name);
|
|
|
|
match_length_minimum += length;
|
|
|
|
m_parser_state.capture_group_minimum_lengths.set(group_index, length);
|
|
m_parser_state.named_capture_groups.set(name, { group_index, length });
|
|
return true;
|
|
}
|
|
|
|
set_error(Error::InvalidCaptureGroup);
|
|
return false;
|
|
}
|
|
|
|
auto group_index = ++m_parser_state.capture_groups_count;
|
|
enter_capture_group_scope();
|
|
|
|
ByteCode capture_group_bytecode;
|
|
size_t length = 0;
|
|
|
|
if (!parse_disjunction(capture_group_bytecode, length, unicode, named))
|
|
return set_error(Error::InvalidPattern);
|
|
|
|
clear_all_capture_groups_in_scope();
|
|
exit_capture_group_scope();
|
|
|
|
register_capture_group_in_current_scope(group_index);
|
|
|
|
stack.insert_bytecode_group_capture_left(group_index);
|
|
stack.extend(move(capture_group_bytecode));
|
|
|
|
m_parser_state.capture_group_minimum_lengths.set(group_index, length);
|
|
|
|
consume(TokenType::RightParen, Error::MismatchingParen);
|
|
|
|
stack.insert_bytecode_group_capture_right(group_index);
|
|
|
|
match_length_minimum += length;
|
|
|
|
return true;
|
|
}
|
|
|
|
size_t ECMA262Parser::ensure_total_number_of_capturing_parenthesis()
|
|
{
|
|
if (m_total_number_of_capturing_parenthesis.has_value())
|
|
return m_total_number_of_capturing_parenthesis.value();
|
|
|
|
GenericLexer lexer { m_parser_state.lexer.source() };
|
|
size_t count = 0;
|
|
while (!lexer.is_eof()) {
|
|
switch (lexer.peek()) {
|
|
case '\\':
|
|
lexer.consume(2);
|
|
continue;
|
|
case '[':
|
|
while (!lexer.is_eof()) {
|
|
if (lexer.consume_specific('\\'))
|
|
lexer.consume();
|
|
else if (lexer.consume_specific(']'))
|
|
break;
|
|
lexer.consume();
|
|
}
|
|
break;
|
|
case '(':
|
|
if (lexer.consume_specific('?')) {
|
|
// non-capturing group '(?:', lookaround '(?<='/'(?<!', or named capture '(?<'
|
|
if (!lexer.consume_specific('<'))
|
|
break;
|
|
|
|
if (lexer.next_is(is_any_of("=!")))
|
|
break;
|
|
|
|
++count;
|
|
} else {
|
|
++count;
|
|
}
|
|
break;
|
|
}
|
|
lexer.consume();
|
|
}
|
|
|
|
m_total_number_of_capturing_parenthesis = count;
|
|
return count;
|
|
}
|
|
}
|