Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-04 07:10:57 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibJS/Runtime/PrimitiveString.h

99 lines
2.6 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
/*
LibJS: Remove ByteString internals from PrimitiveString PrimitiveString is now internally either UTF-8, UTF-16, or both. We no longer convert them to/from ByteString anywhere, nor does VM have a ByteString cache.
2025-03-28 13:55:39 +00:00
* Copyright (c) 2020-2025, Andreas Kling <andreas@ladybird.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
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>
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
#include <LibGC/CellAllocator.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 {
LibWeb: Make RopeString subclass so PrimitiveString can be smaller By moving the LHS and RHS pointers used by rope strings into a RopeString subclass, we shrink PrimitiveString by 16 bytes. Most strings are not rope strings, so this ends up saving quite a bit of memory.
2025-03-30 00:08:39 +00:00
class PrimitiveString : public Cell {
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_CELL(PrimitiveString, Cell);
GC_DECLARE_ALLOCATOR(PrimitiveString);
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
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 18:55:01 +01:00
public:
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
[[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, Utf16String);
[[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, String);
[[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, FlyString const&);
[[nodiscard]] static GC::Ref<PrimitiveString> create(VM&, PrimitiveString&, PrimitiveString&);
[[nodiscard]] static GC::Ref<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: Make PrimitiveString::utf8_string() infallible Work towards #20449.
2023-08-08 19:17:55 +02:00
[[nodiscard]] String utf8_string() const;
[[nodiscard]] 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: Make Utf16String & related APIs infallible Work towards #20449.
2023-08-08 18:54:20 +02:00
[[nodiscard]] Utf16String utf16_string() const;
[[nodiscard]] Utf16View utf16_string_view() 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
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: Don't convert to UTF-8 in order to compare two UTF-16 strings If we have two PrimitiveString objects that are both backed by UTF-16 data, we don't have to convert them to UTF-8 for equality checking. Just compare the underlying UTF-16 data. :^)
2025-04-10 12:18:08 +02:00
[[nodiscard]] bool operator==(PrimitiveString const&) const;
LibWeb: Make RopeString subclass so PrimitiveString can be smaller By moving the LHS and RHS pointers used by rope strings into a RopeString subclass, we shrink PrimitiveString by 16 bytes. Most strings are not rope strings, so this ends up saving quite a bit of memory.
2025-03-30 00:08:39 +00:00
protected:
enum class RopeTag { Rope };
explicit PrimitiveString(RopeTag)
: m_is_rope(true)
{
}
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
LibWeb: Make RopeString subclass so PrimitiveString can be smaller By moving the LHS and RHS pointers used by rope strings into a RopeString subclass, we shrink PrimitiveString by 16 bytes. Most strings are not rope strings, so this ends up saving quite a bit of memory.
2025-03-30 00:08:39 +00:00
mutable bool m_is_rope { false };
mutable Optional<String> m_utf8_string;
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
LibJS: Resolve rope strings directly to UTF-16 when preferable When someone calls PrimitiveString::utf16_string() on a rope string, we know for sure that the client wants a UTF-16 string and may not be interested in a UTF-8 version at all. To avoid round-tripping through UTF-8 in this scenario, callers can now inform resolve_rope_if_needed() about their preferred encoding, should rope resolution take place. The UTF-16 case is actually a lot simpler than the UTF-8 case, since we can simply ask for UTF-16 data for each fiber of the rope, and then concatenate all the fibers. Since LibJS always uses UTF-16 for regular expression matching, this avoids round-tripping through UTF-8 whenever the input to a regex test is already UTF-16. :^)
2023-07-13 15:10:57 +02:00
enum class EncodingPreference {
UTF8,
UTF16,
};
LibWeb: Make RopeString subclass so PrimitiveString can be smaller By moving the LHS and RHS pointers used by rope strings into a RopeString subclass, we shrink PrimitiveString by 16 bytes. Most strings are not rope strings, so this ends up saving quite a bit of memory.
2025-03-30 00:08:39 +00:00
private:
friend class RopeString;
explicit PrimitiveString(String);
explicit PrimitiveString(Utf16String);
LibJS: Make PrimitiveString::resolve_rope_if_needed() infallible Work towards #20449.
2023-08-08 18:34:19 +02:00
void resolve_rope_if_needed(EncodingPreference) const;
LibWeb: Make RopeString subclass so PrimitiveString can be smaller By moving the LHS and RHS pointers used by rope strings into a RopeString subclass, we shrink PrimitiveString by 16 bytes. Most strings are not rope strings, so this ends up saving quite a bit of memory.
2025-03-30 00:08:39 +00:00
};
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
LibWeb: Make RopeString subclass so PrimitiveString can be smaller By moving the LHS and RHS pointers used by rope strings into a RopeString subclass, we shrink PrimitiveString by 16 bytes. Most strings are not rope strings, so this ends up saving quite a bit of memory.
2025-03-30 00:08:39 +00:00
class RopeString final : public PrimitiveString {
GC_CELL(RopeString, PrimitiveString);
GC_DECLARE_ALLOCATOR(RopeString);
public:
virtual ~RopeString() override;
private:
friend class PrimitiveString;
explicit RopeString(GC::Ref<PrimitiveString>, GC::Ref<PrimitiveString>);
virtual void visit_edges(Visitor&) override;
void resolve(EncodingPreference) 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
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
mutable GC::Ptr<PrimitiveString> m_lhs;
mutable GC::Ptr<PrimitiveString> m_rhs;
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