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

451 lines
13 KiB
C
Raw Normal View History

LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
/*
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
LibJS: Implement the RequireObjectCoercible abstract operation Throws an exception if the given value is nullish, returns it otherwise. We can now gradually replace such manual checks with this function where applicable. This also has the advantage that the somewhat useless "ToObject on null or undefined" will be replaced with "null cannot be converted to an object" or "undefined cannot be converted to an object". :^)
2021-06-06 16:10:23 +01:00
* Copyright (c) 2020-2021, Linus Groh <linusg@serenityos.org>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +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: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
*/
#pragma once
#include <AK/Assertions.h>
LibJS: Simplify positive/negative zero checks Because both zeroes have unique and distinct bit representations, we can bit_cast value to u64 and check if it's one of them.
2021-03-22 21:26:16 +03:00
#include <AK/BitCast.h>
LibJS: Prevent implicit pointer-to-bool conversion in Value constructor For example, say you try to create a Value from an Array and forgot to include LibJS/Runtime/Array.h. This would cause the boolean constructor to be used instead of a compile error.
2022-01-27 07:45:00 -05:00
#include <AK/Concepts.h>
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
#include <AK/Format.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
#include <AK/Forward.h>
LibJS: Implement the CreateListFromArrayLike() abstract operation We already have two separate implementations of this, so let's do it properly. The optional value type check is done by a callback function that returns Result<void, ErrorType> - value type accepted or message for TypeError, that is.
2021-06-09 23:27:01 +01:00
#include <AK/Function.h>
#include <AK/Result.h>
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
#include <AK/String.h>
LibJS: Implement standard semantics for relational operators (#2417) Previously, the relational operators where casting any value to double and comparing the results according to C++ semantics. This patch makes the relational operators in JS behave according to the standard specification. Since we don't have BigInt yet, the implementation doesn't take it into account. Moved PreferredType from Object to Value. Value::to_primitive now passes preferred_type to Object::to_primitive.
2020-05-28 17:19:59 +02:00
#include <AK/Types.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
#include <LibJS/Forward.h>
LibJS: Move ValueTraits to Value.h and add special case for -0.0 This will allow us to use these traits for other hash-based containers (like Map). This commit also adds a special case for negative zero values, because while the equality check used same_value_zero which is negative/positive zero insensitive, the hash was not.
2021-06-12 23:15:19 +03:00
#include <LibJS/Runtime/BigInt.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>
LibM: Add NAN macro
2020-06-04 13:03:15 +01:00
#include <math.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
LibJS: Make Array.prototype.push() generic
2020-05-22 13:20:53 +01:00
// 2 ** 53 - 1
static constexpr double MAX_ARRAY_LIKE_INDEX = 9007199254740991.0;
LibJS: Simplify positive/negative zero checks Because both zeroes have unique and distinct bit representations, we can bit_cast value to u64 and check if it's one of them.
2021-03-22 21:26:16 +03:00
// Unique bit representation of negative zero (only sign bit set)
static constexpr u64 NEGATIVE_ZERO_BITS = ((u64)1 << 63);
LibJS: Make Array.prototype.push() generic
2020-05-22 13:20:53 +01:00
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
namespace JS {
class Value {
public:
enum class Type {
LibJS: Support array holes, encoded as empty JS::Value This patch adds a new kind of JS::Value, the empty value. It's what you get when you do JSValue() (or most commonly, {} in C++.) An empty Value signifies the absence of a value, and should never be visible to JavaScript itself. As of right now, it's used for array holes and as a return value when an exception has been thrown and we just want to unwind. This patch is a bit of a mess as I had to fix a whole bunch of code that was relying on JSValue() being undefined, etc.
2020-04-06 20:24:45 +02:00
Empty,
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
Undefined,
Null,
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
Int32,
Double,
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
String,
Object,
Boolean,
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
Symbol,
LibJS: Add getter/setter support This patch adds a GetterSetterPair object. Values can now store pointers to objects of this type. These objects are created when using Object.defineProperty and providing an accessor descriptor.
2020-05-21 11:14:23 -07:00
Accessor,
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
BigInt,
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
};
LibJS: Implement standard semantics for relational operators (#2417) Previously, the relational operators where casting any value to double and comparing the results according to C++ semantics. This patch makes the relational operators in JS behave according to the standard specification. Since we don't have BigInt yet, the implementation doesn't take it into account. Moved PreferredType from Object to Value. Value::to_primitive now passes preferred_type to Object::to_primitive.
2020-05-28 17:19:59 +02:00
enum class PreferredType {
Default,
String,
Number,
};
LibJS: Support array holes, encoded as empty JS::Value This patch adds a new kind of JS::Value, the empty value. It's what you get when you do JSValue() (or most commonly, {} in C++.) An empty Value signifies the absence of a value, and should never be visible to JavaScript itself. As of right now, it's used for array holes and as a return value when an exception has been thrown and we just want to unwind. This patch is a bit of a mess as I had to fix a whole bunch of code that was relying on JSValue() being undefined, etc.
2020-04-06 20:24:45 +02:00
bool is_empty() const { return m_type == Type::Empty; }
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
bool is_undefined() const { return m_type == Type::Undefined; }
bool is_null() const { return m_type == Type::Null; }
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
bool is_number() const { return m_type == Type::Int32 || m_type == Type::Double; }
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
bool is_string() const { return m_type == Type::String; }
bool is_object() const { return m_type == Type::Object; }
bool is_boolean() const { return m_type == Type::Boolean; }
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
bool is_symbol() const { return m_type == Type::Symbol; }
LibJS: Add getter/setter support This patch adds a GetterSetterPair object. Values can now store pointers to objects of this type. These objects are created when using Object.defineProperty and providing an accessor descriptor.
2020-05-21 11:14:23 -07:00
bool is_accessor() const { return m_type == Type::Accessor; };
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
bool is_bigint() const { return m_type == Type::BigInt; };
LibJS: Add Value::is_nullish()
2020-10-02 16:00:15 +02:00
bool is_nullish() const { return is_null() || is_undefined(); }
LibJS: Remove the NativeProperty mechanism from LibJS These were an ad-hoc way to implement special behaviour when reading or writing to specific object properties. Because these were effectively replaced by the abillity to override the internal methods of Object, they are no longer needed.
2021-07-07 19:34:26 +03:00
bool is_cell() const { return is_string() || is_accessor() || is_object() || is_bigint() || is_symbol(); }
LibJS: Switch is_array to ThrowCompletionOr
2021-09-23 20:05:34 +03:00
ThrowCompletionOr<bool> is_array(GlobalObject&) const;
LibJS: Add Value::{is, as}_function()
2020-05-06 11:52:53 +01:00
bool is_function() const;
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
bool is_constructor() const;
LibJS: Convert is_regexp to ThrowCompletionOr
2021-09-23 20:10:20 +03:00
ThrowCompletionOr<bool> is_regexp(GlobalObject&) const;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
LibJS: Take advantage of Value::Type::Int32 in a bunch of functions If a JS::Value has type Int32, we know it's a finite, 32-bit integer. Use this information to avoid converting it to a double if possible.
2021-10-07 19:23:56 +02:00
bool is_nan() const
{
if (type() == Type::Int32)
return false;
return is_number() && __builtin_isnan(as_double());
}
bool is_infinity() const
{
if (type() == Type::Int32)
return false;
return is_number() && __builtin_isinf(as_double());
}
bool is_positive_infinity() const
{
if (type() == Type::Int32)
return false;
return is_number() && __builtin_isinf_sign(as_double()) > 0;
}
bool is_negative_infinity() const
{
if (type() == Type::Int32)
return false;
return is_number() && __builtin_isinf_sign(as_double()) < 0;
}
bool is_positive_zero() const
{
if (type() == Type::Int32)
return as_i32() == 0;
return is_number() && bit_cast<u64>(as_double()) == 0;
}
bool is_negative_zero() const
{
if (type() == Type::Int32)
return false;
return is_number() && bit_cast<u64>(as_double()) == NEGATIVE_ZERO_BITS;
}
bool is_integral_number() const
{
if (type() == Type::Int32)
return true;
return is_finite_number() && trunc(as_double()) == as_double();
}
LibJS: Implement bitwise left shift operator (<<)
2020-04-23 13:36:14 +01:00
bool is_finite_number() const
{
LibJS: Take advantage of Value::Type::Int32 in a bunch of functions If a JS::Value has type Int32, we know it's a finite, 32-bit integer. Use this information to avoid converting it to a double if possible.
2021-10-07 19:23:56 +02:00
if (type() == Type::Int32)
return true;
LibJS: Implement bitwise left shift operator (<<)
2020-04-23 13:36:14 +01:00
if (!is_number())
return false;
auto number = as_double();
return !__builtin_isnan(number) && !__builtin_isinf(number);
}
LibJS: Basic NaN support This patch adds js_nan() for constructing a NaN value. You can check if a Value is NaN with Value::is_nan().
2020-03-27 12:26:37 +01:00
LibJS: Inline JS::Value() I had this out of line for debugging reasons. Put it back inline.
2020-04-06 20:30:36 +02:00
Value()
: m_type(Type::Empty)
{
}
LibJS: Allow default-constructing a JS::Value (undefined)
2020-03-20 20:49:48 +01:00
LibJS: Prevent implicit pointer-to-bool conversion in Value constructor For example, say you try to create a Value from an Array and forgot to include LibJS/Runtime/Array.h. This would cause the boolean constructor to be used instead of a compile error.
2022-01-27 07:45:00 -05:00
template<typename T>
requires(SameAs<RemoveCVReference<T>, bool>) explicit Value(T value)
LibJS: Flesh out JS::Value a little bit more
2020-03-07 23:16:14 +01:00
: m_type(Type::Boolean)
{
m_value.as_bool = value;
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
explicit Value(double value)
{
LibJS: Simplify positive/negative zero checks Because both zeroes have unique and distinct bit representations, we can bit_cast value to u64 and check if it's one of them.
2021-03-22 21:26:16 +03:00
bool is_negative_zero = bit_cast<u64>(value) == NEGATIVE_ZERO_BITS;
LibJS: *Actually* check for negative zero in JS::Value(double) As @nico pointed out, 0.0 == -0.0 in C++, even though they are not bitwise identical. Use the same trick as Value::is_negative_zero() to really check for it. This allows JS::Value(0.0) to correctly become an Int32-backed 0 value.
2021-03-22 07:49:08 +01:00
if (value >= NumericLimits<i32>::min() && value <= NumericLimits<i32>::max() && trunc(value) == value && !is_negative_zero) {
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
m_type = Type::Int32;
m_value.as_i32 = static_cast<i32>(value);
} else {
m_type = Type::Double;
m_value.as_double = value;
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
LibJS: Fix two issues with array (length > INT32_MAX) 1. Allow Value(size_t) and use it for array length properties. If an array length can't fit in an Int32 value, we shouldn't go out of or way to force it into one. Instead, for values above INT32_MAX, we simply store them as Double values. 2. Switch to generic indexed property storage for large arrays. Previously we would always allocate array storage eagerly when the length property was set. This meant that "a.length = 0x80000000" would trivially DOS the engine on 32-bit since we don't have that much VM. We now switch to generic storage when changing the length moves us over the 4M entry mark. Fixes #5986.
2021-03-30 13:32:19 +02:00
explicit Value(unsigned long value)
{
if (value > NumericLimits<i32>::max()) {
m_value.as_double = static_cast<double>(value);
m_type = Type::Double;
} else {
m_value.as_i32 = static_cast<i32>(value);
m_type = Type::Int32;
}
}
LibJS: Implement bitwise unsigned right shift operator (>>>)
2020-04-23 15:43:10 +01:00
explicit Value(unsigned value)
{
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
if (value > NumericLimits<i32>::max()) {
m_value.as_double = static_cast<double>(value);
m_type = Type::Double;
} else {
m_value.as_i32 = static_cast<i32>(value);
m_type = Type::Int32;
}
LibJS: Implement bitwise unsigned right shift operator (>>>)
2020-04-23 15:43:10 +01:00
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
explicit Value(i32 value)
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
: m_type(Type::Int32)
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
{
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
m_value.as_i32 = value;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Value(Object const* object)
LibJS: Add a global "Object" constructor This patch adds an "Object" constructor to the global object. The only function it implements so far is Object.getPrototypeOf().
2020-03-28 17:23:54 +01:00
: m_type(object ? Type::Object : Type::Null)
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
{
LibJS: Make JS::Value constructors take const cell pointers Taking non-const cell pointers is asking for trouble, since passing e.g a "const Object*" to Value(Object*) will actually call Value(bool), which is most likely not what you want.
2020-11-28 15:57:25 +01:00
m_value.as_object = const_cast<Object*>(object);
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Value(PrimitiveString const* string)
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
: m_type(Type::String)
{
LibJS: Make JS::Value constructors take const cell pointers Taking non-const cell pointers is asking for trouble, since passing e.g a "const Object*" to Value(Object*) will actually call Value(bool), which is most likely not what you want.
2020-11-28 15:57:25 +01:00
m_value.as_string = const_cast<PrimitiveString*>(string);
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Value(Symbol const* symbol)
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
: m_type(Type::Symbol)
{
LibJS: Make JS::Value constructors take const cell pointers Taking non-const cell pointers is asking for trouble, since passing e.g a "const Object*" to Value(Object*) will actually call Value(bool), which is most likely not what you want.
2020-11-28 15:57:25 +01:00
m_value.as_symbol = const_cast<Symbol*>(symbol);
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Value(Accessor const* accessor)
LibJS: Add getter/setter support This patch adds a GetterSetterPair object. Values can now store pointers to objects of this type. These objects are created when using Object.defineProperty and providing an accessor descriptor.
2020-05-21 11:14:23 -07:00
: m_type(Type::Accessor)
{
LibJS: Make JS::Value constructors take const cell pointers Taking non-const cell pointers is asking for trouble, since passing e.g a "const Object*" to Value(Object*) will actually call Value(bool), which is most likely not what you want.
2020-11-28 15:57:25 +01:00
m_value.as_accessor = const_cast<Accessor*>(accessor);
LibJS: Add getter/setter support This patch adds a GetterSetterPair object. Values can now store pointers to objects of this type. These objects are created when using Object.defineProperty and providing an accessor descriptor.
2020-05-21 11:14:23 -07:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Value(BigInt const* bigint)
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
: m_type(Type::BigInt)
{
LibJS: Make JS::Value constructors take const cell pointers Taking non-const cell pointers is asking for trouble, since passing e.g a "const Object*" to Value(Object*) will actually call Value(bool), which is most likely not what you want.
2020-11-28 15:57:25 +01:00
m_value.as_bigint = const_cast<BigInt*>(bigint);
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
explicit Value(Type type)
: m_type(type)
{
}
Type type() const { return m_type; }
double as_double() const
{
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
VERIFY(is_number());
if (m_type == Type::Int32)
return m_value.as_i32;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
return m_value.as_double;
}
bool as_bool() const
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(type() == Type::Boolean);
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
return m_value.as_bool;
}
LibJS: Make Value::as_object() return Object& Let's move towards using references over pointers in LibJS as well. I had originally steered away from it because that's how I've seen things done in other engines. But this is not the other engines. :^)
2020-04-01 22:18:47 +02:00
Object& as_object()
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(type() == Type::Object);
LibJS: Make Value::as_object() return Object& Let's move towards using references over pointers in LibJS as well. I had originally steered away from it because that's how I've seen things done in other engines. But this is not the other engines. :^)
2020-04-01 22:18:47 +02:00
return *m_value.as_object;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Object const& as_object() const
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(type() == Type::Object);
LibJS: Make Value::as_object() return Object& Let's move towards using references over pointers in LibJS as well. I had originally steered away from it because that's how I've seen things done in other engines. But this is not the other engines. :^)
2020-04-01 22:18:47 +02:00
return *m_value.as_object;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
LibJS: Make Value::as_string() return a PrimitiveString reference
2020-04-29 12:35:39 +02:00
PrimitiveString& as_string()
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(is_string());
LibJS: Make Value::as_string() return a PrimitiveString reference
2020-04-29 12:35:39 +02:00
return *m_value.as_string;
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
PrimitiveString const& as_string() const
LibJS: Flesh out JS::Value a little bit more
2020-03-07 23:16:14 +01:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(is_string());
LibJS: Make Value::as_string() return a PrimitiveString reference
2020-04-29 12:35:39 +02:00
return *m_value.as_string;
LibJS: Flesh out JS::Value a little bit more
2020-03-07 23:16:14 +01:00
}
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
Symbol& as_symbol()
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(is_symbol());
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
return *m_value.as_symbol;
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Symbol const& as_symbol() const
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(is_symbol());
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
return *m_value.as_symbol;
}
LibJS: Make Value::as_cell() return a Cell&
2021-05-25 18:48:11 +02:00
Cell& as_cell()
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(is_cell());
LibJS: Make Value::as_cell() return a Cell&
2021-05-25 18:48:11 +02:00
return *m_value.as_cell;
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
}
LibJS: Move Value::as_accessor() to Value.h
2020-06-04 22:00:17 +01:00
Accessor& as_accessor()
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(is_accessor());
LibJS: Move Value::as_accessor() to Value.h
2020-06-04 22:00:17 +01:00
return *m_value.as_accessor;
}
LibJS: Add side-effect-free version of Value::to_string() There are now two API's on Value: - Value::to_string(Interpreter&) -- may throw. - Value::to_string_without_side_effects() -- will never throw. These are some pretty big sweeping changes, so it's possible that I did some part the wrong way. We'll work it out as we go. :^) Fixes #2123.
2020-05-15 13:39:24 +02:00
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
BigInt& as_bigint()
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(is_bigint());
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
return *m_value.as_bigint;
}
LibJS: Add JSON.stringify
2020-06-10 11:01:00 -07:00
Array& as_array();
LibJS: Rename Function => FunctionObject
2021-06-27 21:48:34 +02:00
FunctionObject& as_function();
LibJS: Add const Value::as_function()
2021-09-25 09:43:34 +02:00
FunctionObject const& as_function() const;
LibJS: Add Value::{is, as}_function()
2020-05-06 11:52:53 +01:00
LibJS: Take advantage of Value::Type::Int32 in a bunch of functions If a JS::Value has type Int32, we know it's a finite, 32-bit integer. Use this information to avoid converting it to a double if possible.
2021-10-07 19:23:56 +02:00
// FIXME: These two conversions are wrong for JS, and seem likely to be footguns
i32 as_i32() const
{
if (m_type == Type::Int32)
return m_value.as_i32;
return static_cast<i32>(as_double());
}
u32 as_u32() const
{
if (m_type == Type::Int32 && m_value.as_i32 >= 0)
return m_value.as_i32;
VERIFY(as_double() >= 0);
return (u32)min(as_double(), (double)NumericLimits<u32>::max());
}
LibJS: Rename to_{i32,size_t}() to as_{i32,size_t}() for clarity As these parameter-less overloads don't change the value's type and just assume Type::Number, naming them as_i32() and as_size_t() is more appropriate.
2020-05-18 08:59:35 +01:00
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
u64 encoded() const { return m_value.encoded; }
LibJS: Convert to_string() to ThrowCompletionOr Also update get_function_name() to use ThrowCompletionOr, but this is not a standard AO and should be refactored out of existence eventually.
2021-10-12 17:49:01 +01:00
ThrowCompletionOr<String> to_string(GlobalObject&) const;
LibJS: Convert to_utf16_string() to ThrowCompletionOr
2021-10-12 18:01:17 +01:00
ThrowCompletionOr<Utf16String> to_utf16_string(GlobalObject&) const;
LibJS: Convert to_primitive_string() to ThrowCompletionOr
2021-10-12 18:05:46 +01:00
ThrowCompletionOr<PrimitiveString*> to_primitive_string(GlobalObject&);
LibJS: Convert to_primitive() to ThrowCompletionOr
2021-10-12 18:09:14 +01:00
ThrowCompletionOr<Value> to_primitive(GlobalObject&, PreferredType preferred_type = PreferredType::Default) const;
LibJS: Convert to_object() to ThrowCompletionOr
2021-10-12 19:24:57 +01:00
ThrowCompletionOr<Object*> to_object(GlobalObject&) const;
LibJS: Convert to_numeric() to ThrowCompletionOr
2021-10-16 21:42:32 +03:00
ThrowCompletionOr<Value> to_numeric(GlobalObject&) const;
LibJS: Convert to_number() to ThrowCompletionOr
2021-10-17 23:20:05 +03:00
ThrowCompletionOr<Value> to_number(GlobalObject&) const;
LibJS: Convert to_bigint() to ThrowCompletionOr
2021-10-16 21:52:16 +03:00
ThrowCompletionOr<BigInt*> to_bigint(GlobalObject&) const;
LibJS: Convert to_bigint_int64() to ThrowCompletionOr
2021-10-16 21:56:14 +03:00
ThrowCompletionOr<i64> to_bigint_int64(GlobalObject&) const;
LibJS: Convert to_bigint_uint64() to ThrowCompletionOr
2021-10-16 22:01:10 +03:00
ThrowCompletionOr<u64> to_bigint_uint64(GlobalObject&) const;
LibJS: Convert to_double() to ThrowCompletionOr
2021-10-16 22:11:08 +03:00
ThrowCompletionOr<double> to_double(GlobalObject&) const;
LibJS: Make Value::to_property_key() return a JS::PropertyKey Instead of returning JS::StringOrSymbol, which is a space-optimized type used in Shape property tables, this now returns JS::PropertyKey which is *not* space-optimized, but has other niceties like optimized storage of numeric ("indexed") properties.
2021-10-24 16:25:39 +02:00
ThrowCompletionOr<PropertyKey> to_property_key(GlobalObject&) const;
LibJS: Convert to_i32() to ThrowCompletionOr
2021-10-17 23:33:35 +03:00
ThrowCompletionOr<i32> to_i32(GlobalObject& global_object) const;
LibJS: Convert to_u32() to ThrowCompletionOr
2021-10-17 23:43:29 +03:00
ThrowCompletionOr<u32> to_u32(GlobalObject&) const;
LibJS: Convert to_i16() to ThrowCompletionOr
2021-10-17 23:44:25 +03:00
ThrowCompletionOr<i16> to_i16(GlobalObject&) const;
LibJS: Convert to_u16() to ThrowCompletionOr
2021-10-17 23:48:24 +03:00
ThrowCompletionOr<u16> to_u16(GlobalObject&) const;
LibJS: Convert to_i8() to ThrowCompletionOr
2021-10-17 23:49:09 +03:00
ThrowCompletionOr<i8> to_i8(GlobalObject&) const;
LibJS: Convert to_u8() to ThrowCompletionOr
2021-10-17 23:49:41 +03:00
ThrowCompletionOr<u8> to_u8(GlobalObject&) const;
LibJS: Convert to_u8_clamp() to ThrowCompletionOr
2021-10-17 23:50:06 +03:00
ThrowCompletionOr<u8> to_u8_clamp(GlobalObject&) const;
LibJS: Convert to_length() to ThrowCompletionOr
2021-10-17 23:57:37 +03:00
ThrowCompletionOr<size_t> to_length(GlobalObject&) const;
LibJS: Convert to_index() to ThrowCompletionOr
2021-10-18 00:05:01 +03:00
ThrowCompletionOr<size_t> to_index(GlobalObject&) const;
LibJS: Convert to_integer_or_infinity() to ThrowCompletionOr
2021-10-18 19:19:57 +01:00
ThrowCompletionOr<double> to_integer_or_infinity(GlobalObject&) const;
LibJS: Pass Interpreter& to Value::to_number() et al. This patch is unfortunately rather large and might make some things feel bloated, but it is necessary to fix a few flaws in LibJS, primarily blindly coercing values to numbers without exception checks - i.e. interpreter.argument(0).to_i32(); // can fail!!! Some examples where the interpreter would actually crash: var o = { toString: () => { throw Error() } }; +o; o - 1; "foo".charAt(o); "bar".repeat(o); To fix this, we now have the following... to_double(Interpreter&) to_i32() to_i32(Interpreter&) to_size_t() to_size_t(Interpreter&) ...and a whole lot of exception checking. There's intentionally no to_double(), use as_double() directly instead. This way we still can use these convenient utility functions but don't need to check for exceptions if we are sure the value already is a number. Fixes #2267.
2020-05-18 00:28:00 +01:00
bool to_boolean() const;
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
ThrowCompletionOr<Value> get(GlobalObject&, PropertyKey const&) const;
ThrowCompletionOr<FunctionObject*> get_method(GlobalObject&, PropertyKey const&) const;
LibJS: Implement the GetV() abstract operation Like Get(), but with any value instead of an object - it's calling ToObject() for us and passes the value to [[Get]]() as the receiver. This will be used in GetMethod() (and a couple of other places, which can be updated over time). I also tried something new here: adding the three steps from the spec as inline comments :^)
2021-06-26 19:17:28 +01:00
LibJS: Move Value::as_accessor() to Value.h
2020-06-04 22:00:17 +01:00
String to_string_without_side_effects() const;
LibJS: Implement conversion of strings to BigInts according to the spec The spec defines a StringToBigInt AO which allows for converting binary, octal, decimal, and hexadecimal strings to a BigInt. Our conversion was only allowing for decimal strings.
2022-01-31 10:23:51 -05:00
Optional<BigInt*> string_to_bigint(GlobalObject& global_object) const;
LibJS: Move Value::as_accessor() to Value.h
2020-06-04 22:00:17 +01:00
LibJS: Stop using Optional<Value> in favor of Value's empty state JS::Value already has the empty state ({} or Value() gives you one.) Use this instead of wrapping Value in Optional in some places. I've also added Value::value_or(Value) so you can easily provide a fallback value when one is not present.
2020-04-25 18:43:34 +02:00
Value value_or(Value fallback) const
{
if (is_empty())
return fallback;
return *this;
}
LibJS: Move 'typeof' string functionality from AST to Value We should be able to get the 'typeof' string for any value directly, so this is now a standalone Value::typeof() method instead of being part of UnaryExpression::execute().
2021-04-02 20:33:03 +02:00
String typeof() const;
LibJS: Add Value::operator==() This is needed for MarkedValueList::contains_slow() to work.
2021-07-04 17:49:54 +01:00
bool operator==(Value const&) const;
LibJS: Move Object::invoke to Value::invoke and fix it for primitives This is a tiny difference and only changes anything for primitives in strict mode. However this is tested in test262 and can be noticed by overriding toString of primitive values. This does now require one to wrap an object in a Value to call invoke but all code using invoke has been migrated.
2021-08-09 16:45:43 +02:00
template<typename... Args>
Everywhere: Rename JS::PropertyKey variables from property_{name => key} PropertyKey used to be called PropertyName, but got renamed. Let's update all the variables of this type as well.
2022-02-06 15:59:04 +00:00
[[nodiscard]] ALWAYS_INLINE ThrowCompletionOr<Value> invoke(GlobalObject& global_object, PropertyKey const& property_key, Args... args);
LibJS: Move Object::invoke to Value::invoke and fix it for primitives This is a tiny difference and only changes anything for primitives in strict mode. However this is tested in test262 and can be noticed by overriding toString of primitive values. This does now require one to wrap an object in a Value to call invoke but all code using invoke has been migrated.
2021-08-09 16:45:43 +02:00
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
private:
LibJS: Make Value::m_type default to Type::Empty This is not effectful since all constructors overwrite the type anyway, but it seems reasonable that the default value of m_type would match what Value() would give you.
2020-04-16 16:11:11 +02:00
Type m_type { Type::Empty };
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
LibJS: Replace uses of MarkedValueList with MarkedVector<Value> This is effectively a drop-in replacement.
2022-02-09 10:06:40 +00:00
[[nodiscard]] ThrowCompletionOr<Value> invoke_internal(GlobalObject& global_object, PropertyKey const&, Optional<MarkedVector<Value>> arguments);
LibJS: Move Object::invoke to Value::invoke and fix it for primitives This is a tiny difference and only changes anything for primitives in strict mode. However this is tested in test262 and can be noticed by overriding toString of primitive values. This does now require one to wrap an object in a Value to call invoke but all code using invoke has been migrated.
2021-08-09 16:45:43 +02:00
LibJS: Convert to_i32() to ThrowCompletionOr
2021-10-17 23:33:35 +03:00
ThrowCompletionOr<i32> to_i32_slow_case(GlobalObject&) const;
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
union {
bool as_bool;
LibJS: Split Value::Type::Number into Int32 and Double We now store 32-bit integers as 32-bit integers directly which avoids having to convert them from doubles when they're only used as 32-bit integers anyway. :^) This patch feels a bit incomplete and there's a lot of opportunities to take advantage of this information. We'll have to find and exploit them eventually.
2021-03-21 18:03:00 +01:00
i32 as_i32;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
double as_double;
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
PrimitiveString* as_string;
LibJS: Add symbol objects This commit adds the following classes: SymbolObject, SymbolConstructor, SymbolPrototype, and Symbol. This commit does not introduce any new functionality to the Object class, so they cannot be used as property keys in objects.
2020-04-29 23:25:21 -07:00
Symbol* as_symbol;
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
Object* as_object;
LibJS: Support "hello friends".length The above snippet is a MemberExpression that necessitates the implicit construction of a StringObject wrapper around a PrimitiveString. We then do a property lookup (a "get") on the StringObject, where we find the "length" property. This is pretty neat! :^)
2020-03-11 18:58:19 +01:00
Cell* as_cell;
LibJS: Add getter/setter support This patch adds a GetterSetterPair object. Values can now store pointers to objects of this type. These objects are created when using Object.defineProperty and providing an accessor descriptor.
2020-05-21 11:14:23 -07:00
Accessor* as_accessor;
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
BigInt* as_bigint;
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
u64 encoded;
} m_value { .encoded = 0 };
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
};
inline Value js_undefined()
{
return Value(Value::Type::Undefined);
}
inline Value js_null()
{
return Value(Value::Type::Null);
}
LibJS: Basic NaN support This patch adds js_nan() for constructing a NaN value. You can check if a Value is NaN with Value::is_nan().
2020-03-27 12:26:37 +01:00
inline Value js_nan()
{
LibM: Add NAN macro
2020-06-04 13:03:15 +01:00
return Value(NAN);
LibJS: Basic NaN support This patch adds js_nan() for constructing a NaN value. You can check if a Value is NaN with Value::is_nan().
2020-03-27 12:26:37 +01:00
}
LibJS: Implement Infinity
2020-04-02 16:59:01 +01:00
inline Value js_infinity()
{
LibM: Add INFINITY macro
2020-06-04 13:05:27 +01:00
return Value(INFINITY);
LibJS: Implement Infinity
2020-04-02 16:59:01 +01:00
}
LibJS: Add js_negative_infinity() Value(-js_infinity().as_double()) is kind of awkward.
2020-04-12 13:25:42 +01:00
inline Value js_negative_infinity()
{
LibM: Add INFINITY macro
2020-06-04 13:05:27 +01:00
return Value(-INFINITY);
LibJS: Add js_negative_infinity() Value(-js_infinity().as_double()) is kind of awkward.
2020-04-12 13:25:42 +01:00
}
LibJS: Inline Cell::Visitor::visit() functions This allows the calls to MarkingVisitor::visit_impl() during GC to be devirtualized in Heap::mark_live_cells().
2021-05-25 18:17:41 +02:00
inline void Cell::Visitor::visit(Value value)
{
if (value.is_cell())
LibJS: Make Value::as_cell() return a Cell&
2021-05-25 18:48:11 +02:00
visit_impl(value.as_cell());
LibJS: Inline Cell::Visitor::visit() functions This allows the calls to MarkingVisitor::visit_impl() during GC to be devirtualized in Heap::mark_live_cells().
2021-05-25 18:17:41 +02:00
}
LibJS: Convert Value operator AOs to ThrowCompletionOr
2021-10-19 00:13:29 +03:00
ThrowCompletionOr<Value> greater_than(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> greater_than_equals(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> less_than(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> less_than_equals(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> bitwise_and(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> bitwise_or(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> bitwise_xor(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> bitwise_not(GlobalObject&, Value);
ThrowCompletionOr<Value> unary_plus(GlobalObject&, Value);
ThrowCompletionOr<Value> unary_minus(GlobalObject&, Value);
ThrowCompletionOr<Value> left_shift(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> right_shift(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> unsigned_right_shift(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> add(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> sub(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> mul(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> div(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> mod(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> exp(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> in(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> instance_of(GlobalObject&, Value lhs, Value rhs);
ThrowCompletionOr<Value> ordinary_has_instance(GlobalObject&, Value lhs, Value rhs);
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 11:35:05 +01:00
LibJS: Convert is_loosely_equal() to ThrowCompletionOr
2021-10-18 23:46:42 +03:00
ThrowCompletionOr<bool> is_loosely_equal(GlobalObject&, Value lhs, Value rhs);
LibJS: Rename strict_eq() to is_strictly_equal() This got turned into a proper AO with a new name recently. See: https://github.com/tc39/ecma262/commit/19d7ca4
2021-09-23 23:43:28 +02:00
bool is_strictly_equal(Value lhs, Value rhs);
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 18:36:49 +02:00
bool same_value(Value lhs, Value rhs);
bool same_value_zero(Value lhs, Value rhs);
bool same_value_non_numeric(Value lhs, Value rhs);
LibJS: Update order of parameters in our is_less_than implementation This change updates the parameter order of the is_less_than function signature and calls to match accordingly with the spec (https://tc39.es/ecma262/#sec-islessthan)
2022-06-13 23:10:12 +01:00
ThrowCompletionOr<TriState> is_less_than(GlobalObject&, Value lhs, Value rhs, bool left_first);
LibJS: Spec-compliant equality comparisons The ECMAScript spec defines multiple equality operations which are used all over the spec; this patch introduces them. Of course, the two primary equality operations are AbtractEquals ('==') and StrictEquals ('==='), which have been renamed to 'abstract_eq' and 'strict_eq' in this patch. In support of the two operations mentioned above, the following have also been added: SameValue, SameValueZero, and SameValueNonNumeric. These are important to have, because they are used elsewhere in the spec aside from the two primary equality comparisons.
2020-05-07 17:09:00 -07:00
LibJS: Add variant of to_integer_or_infinity() for plain doubles In many cases we already know a certain value is a number, or don't have JS values at all and would need to wrap doubles in a value. To optimize these cases and avoid having to pass a global object into functions that won't ever allocate or throw, add a standalone implementation of this function that takes and returns doubles directly.
2022-05-06 20:17:16 +02:00
double to_integer_or_infinity(double);
LibJS: Add Value::operator==() This is needed for MarkedValueList::contains_slow() to work.
2021-07-04 17:49:54 +01:00
inline bool Value::operator==(Value const& value) const { return same_value(*this, value); }
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
}
namespace AK {
template<>
struct Formatter<JS::Value> : Formatter<StringView> {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 01:15:21 +01:00
ErrorOr<void> format(FormatBuilder& builder, JS::Value value)
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
{
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 01:15:21 +01:00
return Formatter<StringView>::format(builder, value.is_empty() ? "<empty>" : value.to_string_without_side_effects());
LibJS: Use new format functions everywhere This changes the remaining uses of the following functions across LibJS: - String::format() => String::formatted() - dbg() => dbgln() - printf() => out(), outln() - fprintf() => warnln() I also removed the relevant 'LogStream& operator<<' overloads as they're not needed anymore.
2020-12-06 16:55:19 +00:00
}
};
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
Reference in a new issue Copy permalink