dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Userland/Libraries/LibJS/Runtime/PrimitiveString.h

71 lines
1.8 KiB
C
Raw Normal View History

LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
*
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 05:24:48 -03:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03:00
*/
#pragma once
#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 21:26:49 -03: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 05:48:23 -03:00
#include <LibJS/Forward.h>
LibJS: Move Cell.{cpp,h} from Runtime/ to Heap/
2021-05-17 14:50:20 -03:00
#include <LibJS/Heap/Cell.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 10:06:45 -03:00
#include <LibJS/Runtime/Utf16String.h>
LibJS+LibLine: Run clang-format
2022-02-13 10:55:23 -03:00
#include <LibJS/Runtime/Value.h>
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03: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 17:11:20 -03:00
JS_CELL(PrimitiveString, Cell);
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03:00
public:
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 20:02:19 -03: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 16:08:53 -03:00
bool is_empty() const;
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 20:02:19 -03:00
String const& string() const;
LibJS: Reduce UTF-8 to UTF-16 transcoding when only UTF-16 is wanted When appending two strings together to form a new string, if both of the strings are already UTF-16, create the new string as UTF-16 as well. This shaves about 0.5 seconds off the following test262 test: RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js
2021-08-09 19:00:38 -03:00
bool has_utf8_string() const { return m_has_utf8_string; }
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 11:46:53 -03:00
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 10:06:45 -03:00
Utf16String const& utf16_string() const;
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 11:46:53 -03:00
Utf16View utf16_string_view() const;
LibJS: Reduce UTF-8 to UTF-16 transcoding when only UTF-16 is wanted When appending two strings together to form a new string, if both of the strings are already UTF-16, create the new string as UTF-16 as well. This shaves about 0.5 seconds off the following test262 test: RegExp/property-escapes/generated/General_Category_-_Decimal_Number.js
2021-08-09 19:00:38 -03:00
bool has_utf16_string() const { return m_has_utf16_string; }
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03:00
LibJS: Replace GlobalObject with VM in remaining AOs [Part 19/19]
2022-08-21 16:38:35 -03:00
Optional<Value> get(VM&, PropertyKey const&) const;
LibJS+LibLine: Run clang-format
2022-02-13 10:55:23 -03:00
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03: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 18:51:28 -03:00
explicit PrimitiveString(PrimitiveString&, PrimitiveString&);
explicit PrimitiveString(String);
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 18:58:47 -03:00
virtual void visit_edges(Cell::Visitor&) override;
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03: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 18:58:47 -03:00
void resolve_rope_if_needed() const;
mutable bool m_is_rope { false };
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 20:02:19 -03:00
mutable bool m_has_utf8_string { false };
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 18:58:47 -03:00
mutable bool m_has_utf16_string { false };
LibJS: Rename PrimitiveString::m_{left,right} to m_{lhs,rhs} The LHS/RHS naming is already widely used as parameter names and local variables with the same meaning, so let's also use them for the members.
2022-08-05 21:06:02 -03:00
mutable PrimitiveString* m_lhs { nullptr };
mutable PrimitiveString* m_rhs { nullptr };
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 18:58:47 -03:00
mutable String m_utf8_string;
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 20:02:19 -03:00
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 10:06:45 -03:00
mutable Utf16String m_utf16_string;
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03:00
};
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 11:46:53 -03:00
PrimitiveString* js_string(Heap&, Utf16View const&);
PrimitiveString* js_string(VM&, Utf16View const&);
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 10:06:45 -03:00
PrimitiveString* js_string(Heap&, Utf16String);
PrimitiveString* js_string(VM&, Utf16String);
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 20:02:19 -03:00
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03:00
PrimitiveString* js_string(Heap&, String);
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 13:36:49 -03:00
PrimitiveString* js_string(VM&, String);
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03: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 18:58:47 -03:00
PrimitiveString* js_rope_string(VM&, PrimitiveString&, PrimitiveString&);
LibJS: Add a new PrimitiveString class to hold GC-allocated strings
2020-03-11 14:55:01 -03:00
}
Reference in a new issue Copy permalink