Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 23:53:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibJS/Runtime/RegExpObject.cpp

181 lines
6.9 KiB
C++
Raw Normal View History

LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
/*
Userland: Use mattco@serenityos.org for my copyright headers
2021-04-22 16:53:07 -07:00
* Copyright (c) 2020, Matthew Olsson <mattco@serenityos.org>
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
*/
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
#include <AK/Function.h>
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
#include <LibJS/Heap/Heap.h>
#include <LibJS/Runtime/GlobalObject.h>
#include <LibJS/Runtime/PrimitiveString.h>
#include <LibJS/Runtime/RegExpObject.h>
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
#include <LibJS/Runtime/StringPrototype.h>
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
#include <LibJS/Runtime/Value.h>
namespace JS {
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
static Flags options_from(GlobalObject& global_object, const String& flags)
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
{
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
auto& vm = global_object.vm();
LibJS: Parse the RegExp.prototype.hasIndices flag
2021-07-09 16:10:17 -04:00
bool d = false, g = false, i = false, m = false, s = false, u = false, y = false;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
Flags options {
LibJS: Enable the BrowserExtended ECMA262 regexp flag by default Fixes #5517.
2021-02-27 00:26:45 +03:30
// JS regexps are all 'global' by default as per our definition, but the "global" flag enables "stateful".
// FIXME: Enable 'BrowserExtended' only if in a browser context.
LibJS: Keep RegExp.exec() results in correct order By using regex::AllFlags::SkipTrimEmptyMatches we get a null string for unmatched capture groups, which we then turn into an undefined entry in the result array instead of putting all matches first and appending undefined for the remaining number of capture groups - e.g. for /foo(ba((r)|(z)))/.exec("foobaz") we now return ["foobaz", "baz", "z", undefined, "z"] and not [ ["foobaz", "baz", "z", "z", undefined] Fixes part of #6042. Also happens to fix selecting an element by ID using jQuery's $("#foo").
2021-04-03 14:54:04 +02:00
.effective_flags = { (regex::ECMAScriptFlags)regex::AllFlags::Global | (regex::ECMAScriptFlags)regex::AllFlags::SkipTrimEmptyMatches | regex::ECMAScriptFlags::BrowserExtended },
.declared_flags = {},
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
};
for (auto ch : flags) {
switch (ch) {
LibJS: Parse the RegExp.prototype.hasIndices flag
2021-07-09 16:10:17 -04:00
case 'd':
if (d)
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectRepeatedFlag, ch);
d = true;
break;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
case 'g':
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
if (g)
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectRepeatedFlag, ch);
g = true;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
options.effective_flags |= regex::ECMAScriptFlags::Global;
options.declared_flags |= regex::ECMAScriptFlags::Global;
break;
case 'i':
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
if (i)
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectRepeatedFlag, ch);
i = true;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
options.effective_flags |= regex::ECMAScriptFlags::Insensitive;
options.declared_flags |= regex::ECMAScriptFlags::Insensitive;
break;
case 'm':
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
if (m)
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectRepeatedFlag, ch);
m = true;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
options.effective_flags |= regex::ECMAScriptFlags::Multiline;
options.declared_flags |= regex::ECMAScriptFlags::Multiline;
break;
case 's':
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
if (s)
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectRepeatedFlag, ch);
s = true;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
options.effective_flags |= regex::ECMAScriptFlags::SingleLine;
options.declared_flags |= regex::ECMAScriptFlags::SingleLine;
break;
case 'u':
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
if (u)
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectRepeatedFlag, ch);
u = true;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
options.effective_flags |= regex::ECMAScriptFlags::Unicode;
options.declared_flags |= regex::ECMAScriptFlags::Unicode;
break;
case 'y':
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
if (y)
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectRepeatedFlag, ch);
y = true;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
// Now for the more interesting flag, 'sticky' actually unsets 'global', part of which is the default.
options.effective_flags.reset_flag(regex::ECMAScriptFlags::Global);
// "What's the difference between sticky and global, then", that's simple.
// all the other flags imply 'global', and the "global" flag implies 'stateful';
// however, the "sticky" flag does *not* imply 'global', only 'stateful'.
options.effective_flags |= (regex::ECMAScriptFlags)regex::AllFlags::Internal_Stateful;
options.effective_flags |= regex::ECMAScriptFlags::Sticky;
options.declared_flags |= regex::ECMAScriptFlags::Sticky;
break;
default:
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
vm.throw_exception<SyntaxError>(global_object, ErrorType::RegExpObjectBadFlag, ch);
return options;
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
}
}
return options;
}
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
RegExpObject* RegExpObject::create(GlobalObject& global_object, String original_pattern, String parsed_pattern, String flags)
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
{
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
return global_object.heap().allocate<RegExpObject>(global_object, move(original_pattern), move(parsed_pattern), move(flags), *global_object.regexp_prototype());
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
}
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
RegExpObject::RegExpObject(String original_pattern, String parsed_pattern, String flags, Object& prototype)
LibJS: Clarify Object (base class) construction somewhat Divide the Object constructor into three variants: - The regular one (takes an Object& prototype) - One for use by GlobalObject - One for use by objects without a prototype (e.g ObjectPrototype)
2020-06-23 17:21:53 +02:00
: Object(prototype)
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
, m_original_pattern(move(original_pattern))
, m_parsed_pattern(move(parsed_pattern))
, m_flags(move(flags))
LibJS: Bring back runtime validation of RegExp flags This is a partial revert of commit 60064e2, which removed the validation of RegExp flags during runtime and expected the parser to do that exclusively - however this was not taking into account the RegExp() constructor, which was subsequently crashing on invalid flags. Also adds test for these constructor error cases, which were obviously missing before. Fixes #7042.
2021-05-11 22:47:14 +01:00
, m_active_flags(options_from(global_object(), m_flags))
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
, m_regex(m_parsed_pattern, m_active_flags.effective_flags)
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
{
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
if (m_regex.parser_result.error != regex::Error::NoError) {
vm().throw_exception<SyntaxError>(global_object(), ErrorType::RegExpCompileError, m_regex.error_string());
}
}
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
RegExpObject::~RegExpObject()
{
}
LibJS: Stop using a native property for RegExp's lastIndex property This is not a functional change, the exposed (incorrect) behaviour is the same as it was before, this simply removes the last user of NativeProperties, allowing us to remove them completely from LibJS.
2021-07-07 19:15:52 +03:00
void RegExpObject::initialize(GlobalObject& global_object)
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
{
LibJS: Stop using a native property for RegExp's lastIndex property This is not a functional change, the exposed (incorrect) behaviour is the same as it was before, this simply removes the last user of NativeProperties, allowing us to remove them completely from LibJS.
2021-07-07 19:15:52 +03:00
auto& vm = this->vm();
Object::initialize(global_object);
define_direct_property(vm.names.lastIndex, {}, Attribute::Writable);
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
}
LibJS: Add ECMA-262 section/title/URL comments almost everywhere As mentioned on Discord earlier, we'll add these to all new functions going forward - this is the backfill. Reasons: - It makes you look at the spec, implementing based on MDN or V8 behavior is a no-go - It makes finding the various functions that are non-compliant easier, in the future everything should either have such a comment or, if it's not from the spec at all, a comment explaining why that is the case - It makes it easier to check whether a certain abstract operation is implemented in LibJS, not all of them use the same name as the spec. E.g. RejectPromise() is Promise::reject() - It makes it easier to reason about vm.arguments(), e.g. when the function has a rest parameter - It makes it easier to see whether a certain function is from a proposal or Annex B Also: - Add arguments to all functions and abstract operations that already had a comment - Fix some outdated section numbers - Replace some ecma-international.org URLs with tc39.es
2021-06-13 00:22:35 +01:00
// 22.2.3.2.4 RegExpCreate ( P, F ), https://tc39.es/ecma262/#sec-regexpcreate
LibJS: Implement (mostly) String.prototype.match JavaScript has a couple of different ways to run a regular expression on a string. This adds support for one more. :^)
2021-03-14 11:03:11 +01:00
RegExpObject* regexp_create(GlobalObject& global_object, Value pattern, Value flags)
{
LibJS: Stop using a native property for RegExp's lastIndex property This is not a functional change, the exposed (incorrect) behaviour is the same as it was before, this simply removes the last user of NativeProperties, allowing us to remove them completely from LibJS.
2021-07-07 19:15:52 +03:00
auto& vm = global_object.vm();
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
LibJS: Implement (mostly) String.prototype.match JavaScript has a couple of different ways to run a regular expression on a string. This adds support for one more. :^)
2021-03-14 11:03:11 +01:00
String f;
LibJS: Fix flags check in regexp_create() We need to check for undefined, not empty - otherwise it will literally use "undefined" as the flags, which will fail (Invalid RegExp flag 'n').
2021-03-14 12:02:53 +01:00
if (flags.is_undefined()) {
LibJS: Implement (mostly) String.prototype.match JavaScript has a couple of different ways to run a regular expression on a string. This adds support for one more. :^)
2021-03-14 11:03:11 +01:00
f = String::empty();
} else {
f = flags.to_string(global_object);
LibJS: Stop using a native property for RegExp's lastIndex property This is not a functional change, the exposed (incorrect) behaviour is the same as it was before, this simply removes the last user of NativeProperties, allowing us to remove them completely from LibJS.
2021-07-07 19:15:52 +03:00
if (vm.exception())
return {};
LibJS: Implement (mostly) String.prototype.match JavaScript has a couple of different ways to run a regular expression on a string. This adds support for one more. :^)
2021-03-14 11:03:11 +01:00
}
LibJS: Implement RegExpCreate/RegExpInitialize closer to the spec RegExpInitialize specifies how the pattern string should be created before passing it to [[RegExpMatcher]]. Rather than passing it as-is, the string should be converted to code points and back to a "List" (if the Unicode flag is present), or as a "List" of UTF-16 code units. Further. the spec requires that we keep both the original pattern string and this parsed string in the RegExp object. The caveat is that the LibRegex parser further requires any multi-byte code units to be escaped (as "\unnnn"). Otherwise, the code unit is recognized as individual UTF-8 bytes.
2021-07-22 08:04:31 -04:00
String original_pattern;
String parsed_pattern;
if (pattern.is_undefined()) {
original_pattern = String::empty();
parsed_pattern = String::empty();
} else {
auto utf16_pattern = pattern.to_utf16_string(global_object);
if (vm.exception())
return {};
Utf16View utf16_pattern_view { utf16_pattern };
bool unicode = f.find('u').has_value();
StringBuilder builder;
// If the Unicode flag is set, append each code point to the pattern. Otherwise, append each
// code unit. But unlike the spec, multi-byte code units must be escaped for LibRegex to parse.
for (size_t i = 0; i < utf16_pattern_view.length_in_code_units();) {
if (unicode) {
auto code_point = code_point_at(utf16_pattern_view, i);
builder.append_code_point(code_point.code_point);
i += code_point.code_unit_count;
continue;
}
u16 code_unit = utf16_pattern_view.code_unit_at(i);
++i;
if (code_unit > 0x7f)
builder.appendff("\\u{:04x}", code_unit);
else
builder.append_code_point(code_unit);
}
original_pattern = utf16_pattern_view.to_utf8(Utf16View::AllowInvalidCodeUnits::Yes);
parsed_pattern = builder.build();
}
auto* object = RegExpObject::create(global_object, move(original_pattern), move(parsed_pattern), move(f));
LibJS: Replace the boolean argument of Object::set with an enum class This is more serenity-esque and also makes pointing out missing exception checks during reviews much easier.
2021-07-16 15:16:27 +03:00
object->set(vm.names.lastIndex, Value(0), Object::ShouldThrowExceptions::Yes);
LibJS: Stop using a native property for RegExp's lastIndex property This is not a functional change, the exposed (incorrect) behaviour is the same as it was before, this simply removes the last user of NativeProperties, allowing us to remove them completely from LibJS.
2021-07-07 19:15:52 +03:00
if (vm.exception())
return {};
return object;
LibJS: Implement (mostly) String.prototype.match JavaScript has a couple of different ways to run a regular expression on a string. This adds support for one more. :^)
2021-03-14 11:03:11 +01:00
}
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 16:05:49 -07:00
}
Reference in a new issue Copy permalink