Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 13:20:59 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibJS/Runtime/PrimitiveString.h

74 lines
2.4 KiB
C
Raw Normal View History

LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
LibJS: Replace standalone js_string() with PrimitiveString::create() Note that js_rope_string() has been folded into this, the old name was misleading - it would not always create a rope string, only if both sides are not empty strings. Use a three-argument create() overload instead.
2022-12-06 22:17:27 +00:00
* Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01: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: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
*/
#pragma once
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
#include <AK/DeprecatedString.h>
LibJS+Everywhere: Make PrimitiveString and Utf16String fallible This makes construction of Utf16String fallible in OOM conditions. The immediate impact is that PrimitiveString must then be fallible as well, as it may either transcode UTF-8 to UTF-16, or create a UTF-16 string from ropes. There are a couple of places where it is very non-trivial to propagate the error further. A FIXME has been added to those locations.
2023-01-07 12:24:05 -05:00
#include <AK/Optional.h>
LibJS: Add initial support for creating PrimitiveStrings with AK::String This will temporarily bloat the size of PrimitiveString as LibJS is transitioned to use String throughout, but will make doing so piecemeal much easier.
2023-01-13 12:24:02 -05:00
#include <AK/String.h>
DevTools+LibJS+LibWeb: Change class_name to use StringView This helps make the overall codebase consistent. `class_name()` in `Kernel` is always `StringView`, but not elsewhere. Additionally, this results in the `strlen` (which needs to be done when printing or other operations) always being computed at compile-time.
2022-03-16 18:26:49 -06:00
#include <AK/StringView.h>
LibJS: Avoid unnecessary ToObject conversion when resolving references When performing GetValue on a primitive type we do not need to perform the ToObject conversion as it will resolve to a property on the prototype object. To avoid this we skip the initial ToObject conversion on the base value as it only serves to get the primitive's boxed prototype. We further specialize on PrimitiveString in order to get efficient behaviour behaviour for the direct properties. Depending on the tests anywhere from 20 to 60%, with significant loop overhead.
2022-02-12 00:48:23 -08:00
#include <LibJS/Forward.h>
LibJS: Move Cell.{cpp,h} from Runtime/ to Heap/
2021-05-17 19:50:20 +02:00
#include <LibJS/Heap/Cell.h>
LibJS+Everywhere: Make PrimitiveString and Utf16String fallible This makes construction of Utf16String fallible in OOM conditions. The immediate impact is that PrimitiveString must then be fallible as well, as it may either transcode UTF-8 to UTF-16, or create a UTF-16 string from ropes. There are a couple of places where it is very non-trivial to propagate the error further. A FIXME has been added to those locations.
2023-01-07 12:24:05 -05:00
#include <LibJS/Runtime/Completion.h>
LibJS: Replace Vector<u16> usage in PrimitiveString wth Utf16String This commit does not go out of its way to reduce copying of the string data yet, but is a minimum set of changes to compile LibJS after making PrimitiveString hold a Utf16String.
2021-08-09 09:06:45 -04:00
#include <LibJS/Runtime/Utf16String.h>
LibJS+LibLine: Run clang-format
2022-02-13 14:55:23 +01:00
#include <LibJS/Runtime/Value.h>
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
namespace JS {
class PrimitiveString final : public Cell {
LibJS: Add JS_CELL macro and use it in all JS::Cell subclasses This is similar to what we already had with JS_OBJECT (and also JS_ENVIRONMENT) but sits at the top of the Cell inheritance hierarchy.
2022-08-28 22:11:20 +02:00
JS_CELL(PrimitiveString, Cell);
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
public:
LibJS: Replace standalone js_string() with PrimitiveString::create() Note that js_rope_string() has been folded into this, the old name was misleading - it would not always create a rope string, only if both sides are not empty strings. Use a three-argument create() overload instead.
2022-12-06 22:17:27 +00:00
[[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, Utf16String);
LibJS: Add initial support for creating PrimitiveStrings with AK::String This will temporarily bloat the size of PrimitiveString as LibJS is transitioned to use String throughout, but will make doing so piecemeal much easier.
2023-01-13 12:24:02 -05:00
[[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, String);
LibJS: Replace standalone js_string() with PrimitiveString::create() Note that js_rope_string() has been folded into this, the old name was misleading - it would not always create a rope string, only if both sides are not empty strings. Use a three-argument create() overload instead.
2022-12-06 22:17:27 +00:00
[[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, DeprecatedString);
LibJS+LibWeb: Convert string view PrimitiveString instances to String First, this adds an overload of PrimitiveString::create for StringView. This overload will throw an OOM completion if creating a String fails. This is not only a bit more convenient, but it also ensures at compile time that all PrimitiveString::create(string_view) invocations will be handled as String and OOM-aware. Next, this wraps all invocations to PrimitiveString::create(string_view) with MUST_OR_THROW_OOM. A small PrimitiveString::create(DeprecatedFlyString) overload also had to be added to disambiguate between the StringView and DeprecatedString overloads.
2023-02-09 09:00:14 -05:00
[[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, DeprecatedFlyString const&);
LibJS: Replace standalone js_string() with PrimitiveString::create() Note that js_rope_string() has been folded into this, the old name was misleading - it would not always create a rope string, only if both sides are not empty strings. Use a three-argument create() overload instead.
2022-12-06 22:17:27 +00:00
[[nodiscard]] static NonnullGCPtr<PrimitiveString> create(VM&, PrimitiveString&, PrimitiveString&);
LibJS+LibWeb: Convert string view PrimitiveString instances to String First, this adds an overload of PrimitiveString::create for StringView. This overload will throw an OOM completion if creating a String fails. This is not only a bit more convenient, but it also ensures at compile time that all PrimitiveString::create(string_view) invocations will be handled as String and OOM-aware. Next, this wraps all invocations to PrimitiveString::create(string_view) with MUST_OR_THROW_OOM. A small PrimitiveString::create(DeprecatedFlyString) overload also had to be added to disambiguate between the StringView and DeprecatedString overloads.
2023-02-09 09:00:14 -05:00
static ThrowCompletionOr<NonnullGCPtr<PrimitiveString>> create(VM&, StringView);
LibJS: Replace standalone js_string() with PrimitiveString::create() Note that js_rope_string() has been folded into this, the old name was misleading - it would not always create a rope string, only if both sides are not empty strings. Use a three-argument create() overload instead.
2022-12-06 22:17:27 +00:00
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
virtual ~PrimitiveString();
LibJS: Allow PrimitiveString to be created with a UTF-16 string PrimitiveString may currently only be created with a UTF-8 string, and it transcodes on the fly when a UTF-16 string is needed. Allow creating a PrimitiveString from a UTF-16 string to avoid unnecessary transcoding when the caller only wants UTF-16.
2021-08-01 19:02:19 -04:00
PrimitiveString(PrimitiveString const&) = delete;
PrimitiveString& operator=(PrimitiveString const&) = delete;
LibJS: Add PrimitiveString::is_empty() and use it If we're only interested in whether the string is empty, we can skip the conversion from UTF-16 to UTF-8.
2022-07-17 21:08:53 +02:00
bool is_empty() const;
LibJS: Add initial support for creating PrimitiveStrings with AK::String This will temporarily bloat the size of PrimitiveString as LibJS is transitioned to use String throughout, but will make doing so piecemeal much easier.
2023-01-13 12:24:02 -05:00
ThrowCompletionOr<String> utf8_string() const;
LibJS: Add a convenience StringView accessor to PrimitiveString
2023-01-15 09:37:32 -05:00
ThrowCompletionOr<StringView> utf8_string_view() const;
LibJS: Add initial support for creating PrimitiveStrings with AK::String This will temporarily bloat the size of PrimitiveString as LibJS is transitioned to use String throughout, but will make doing so piecemeal much easier.
2023-01-13 12:24:02 -05:00
bool has_utf8_string() const { return m_utf8_string.has_value(); }
LibJS+Everywhere: Return strings by value from PrimitiveString It turns out return a ThrowCompletionOr<T const&> is flawed, as the GCC expansion trick used with TRY will always make a copy. PrimitiveString is luckily the only such use case.
2023-01-13 15:33:31 -05:00
ThrowCompletionOr<DeprecatedString> deprecated_string() const;
LibJS: Rename PrimitiveString::has_utf8_string to has_deprecated_string And rename the member variable from m_utf8_string to m_deprecated_string to match.
2023-01-13 09:36:12 -05:00
bool has_deprecated_string() const { return m_deprecated_string.has_value(); }
LibJS: Transcode UTF-8 strings to UTF-16 and add UTF-16 accessors LibJS parses JavaScript as UTF-8, so when creating a string, we must transcode it to UTF-16 to handle encoded surrogate pairs. For example, consider the following string: "\ud83d\ude00" The UTF-8 encoding of this surrogate pair is: 0xf0 0x9f 0x98 0x80 However, LibJS will currently store the two surrogates individually as UTF-8 encoded bytes, rather than combining the pair: 0xed 0xa0 0xb8, 0xed 0xb8 0x80 These are not equivalent. So, as String.prototype becomes UTF-16 aware, this encoding will no longer work for abstractions like strict equality.
2021-07-20 10:46:53 -04:00
LibJS+Everywhere: Return strings by value from PrimitiveString It turns out return a ThrowCompletionOr<T const&> is flawed, as the GCC expansion trick used with TRY will always make a copy. PrimitiveString is luckily the only such use case.
2023-01-13 15:33:31 -05:00
ThrowCompletionOr<Utf16String> utf16_string() const;
LibJS+Everywhere: Make PrimitiveString and Utf16String fallible This makes construction of Utf16String fallible in OOM conditions. The immediate impact is that PrimitiveString must then be fallible as well, as it may either transcode UTF-8 to UTF-16, or create a UTF-16 string from ropes. There are a couple of places where it is very non-trivial to propagate the error further. A FIXME has been added to those locations.
2023-01-07 12:24:05 -05:00
ThrowCompletionOr<Utf16View> utf16_string_view() const;
bool has_utf16_string() const { return m_utf16_string.has_value(); }
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
LibJS+Everywhere: Make PrimitiveString and Utf16String fallible This makes construction of Utf16String fallible in OOM conditions. The immediate impact is that PrimitiveString must then be fallible as well, as it may either transcode UTF-8 to UTF-16, or create a UTF-16 string from ropes. There are a couple of places where it is very non-trivial to propagate the error further. A FIXME has been added to those locations.
2023-01-07 12:24:05 -05:00
ThrowCompletionOr<Optional<Value>> get(VM&, PropertyKey const&) const;
LibJS+LibLine: Run clang-format
2022-02-13 14:55:23 +01:00
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
private:
LibJS: Hide all the constructors! Now that the GC allocator is able to invoke Cell subclass constructors directly via friendship, we no longer need to keep them public. :^)
2022-08-28 23:51:28 +02:00
explicit PrimitiveString(PrimitiveString&, PrimitiveString&);
LibJS: Add initial support for creating PrimitiveStrings with AK::String This will temporarily bloat the size of PrimitiveString as LibJS is transitioned to use String throughout, but will make doing so piecemeal much easier.
2023-01-13 12:24:02 -05:00
explicit PrimitiveString(String);
AK+Everywhere: Rename String to DeprecatedString We have a new, improved string type coming up in AK (OOM aware, no null state), and while it's going to use UTF-8, the name UTF8String is a mouthful - so let's free up the String name by renaming the existing class. Making the old one have an annoying name will hopefully also help with quick adoption :^)
2022-12-04 18:02:33 +00:00
explicit PrimitiveString(DeprecatedString);
LibJS: Hide all the constructors! Now that the GC allocator is able to invoke Cell subclass constructors directly via friendship, we no longer need to keep them public. :^)
2022-08-28 23:51:28 +02:00
explicit PrimitiveString(Utf16String);
LibJS: Implement string concatenation using ropes Instead of concatenating string data every time you add two strings together in JavaScript, we now create a new PrimitiveString that points to the two concatenated strings instead. This turns concatenated strings into a tree structure that doesn't have to be serialized until someone wants the characters in the string. This *dramatically* reduces the peak memory footprint when running the SunSpider benchmark (from ~6G to ~1G on my machine). It's also significantly faster (1.39x) :^)
2022-08-05 23:58:47 +02:00
virtual void visit_edges(Cell::Visitor&) override;
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
LibJS+Everywhere: Make PrimitiveString and Utf16String fallible This makes construction of Utf16String fallible in OOM conditions. The immediate impact is that PrimitiveString must then be fallible as well, as it may either transcode UTF-8 to UTF-16, or create a UTF-16 string from ropes. There are a couple of places where it is very non-trivial to propagate the error further. A FIXME has been added to those locations.
2023-01-07 12:24:05 -05:00
ThrowCompletionOr<void> resolve_rope_if_needed() const;
LibJS: Implement string concatenation using ropes Instead of concatenating string data every time you add two strings together in JavaScript, we now create a new PrimitiveString that points to the two concatenated strings instead. This turns concatenated strings into a tree structure that doesn't have to be serialized until someone wants the characters in the string. This *dramatically* reduces the peak memory footprint when running the SunSpider benchmark (from ~6G to ~1G on my machine). It's also significantly faster (1.39x) :^)
2022-08-05 23:58:47 +02:00
mutable bool m_is_rope { false };
LibJS+LibWeb: Wrap raw JS::Cell*/& fields in GCPtr/NonnullGCPtr
2023-02-26 16:09:02 -07:00
mutable GCPtr<PrimitiveString> m_lhs;
mutable GCPtr<PrimitiveString> m_rhs;
LibJS: Implement string concatenation using ropes Instead of concatenating string data every time you add two strings together in JavaScript, we now create a new PrimitiveString that points to the two concatenated strings instead. This turns concatenated strings into a tree structure that doesn't have to be serialized until someone wants the characters in the string. This *dramatically* reduces the peak memory footprint when running the SunSpider benchmark (from ~6G to ~1G on my machine). It's also significantly faster (1.39x) :^)
2022-08-05 23:58:47 +02:00
LibJS: Add initial support for creating PrimitiveStrings with AK::String This will temporarily bloat the size of PrimitiveString as LibJS is transitioned to use String throughout, but will make doing so piecemeal much easier.
2023-01-13 12:24:02 -05:00
mutable Optional<String> m_utf8_string;
LibJS: Rename PrimitiveString::has_utf8_string to has_deprecated_string And rename the member variable from m_utf8_string to m_deprecated_string to match.
2023-01-13 09:36:12 -05:00
mutable Optional<DeprecatedString> m_deprecated_string;
LibJS+Everywhere: Make PrimitiveString and Utf16String fallible This makes construction of Utf16String fallible in OOM conditions. The immediate impact is that PrimitiveString must then be fallible as well, as it may either transcode UTF-8 to UTF-16, or create a UTF-16 string from ropes. There are a couple of places where it is very non-trivial to propagate the error further. A FIXME has been added to those locations.
2023-01-07 12:24:05 -05:00
mutable Optional<Utf16String> m_utf16_string;
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
};
}
Reference in a new issue Copy permalink