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

421 lines
12 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: 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>
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: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +02:00
NativeProperty,
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: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +02:00
bool is_native_property() const { return m_type == Type::NativeProperty; }
LibJS: Add Value::is_nullish()
2020-10-02 16:00:15 +02:00
bool is_nullish() const { return is_null() || is_undefined(); }
LibJS: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +02:00
bool is_cell() const { return is_string() || is_accessor() || is_object() || is_bigint() || is_symbol() || is_native_property(); }
LibJS: Handle Proxy with Array target in IsArray() abstract operation This was missing from Value::is_array(), which is equivalent to the spec's IsArray() abstract operation - it treats a Proxy value with an Array target object as being an Array. It can throw, so needs both the global object and an exception check now.
2021-06-08 21:53:36 +01:00
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: Handle Proxy with Array target in IsArray() abstract operation This was missing from Value::is_array(), which is equivalent to the spec's IsArray() abstract operation - it treats a Proxy value with an Array target object as being an Array. It can throw, so needs both the global object and an exception check now.
2021-06-08 21:53:36 +01:00
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: Start implementing Date :^) This adds: - A global Date object (with `length` property and `now` function) - The Date constructor (no arguments yet) - The Date prototype (with `get*` functions)
2020-03-30 00:21:56 +01:00
bool is_nan() const { return is_number() && __builtin_isnan(as_double()); }
LibJS: Implement Infinity
2020-04-02 16:59:01 +01:00
bool is_infinity() const { return is_number() && __builtin_isinf(as_double()); }
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
bool is_positive_infinity() const { return is_number() && __builtin_isinf_sign(as_double()) > 0; }
bool is_negative_infinity() const { return is_number() && __builtin_isinf_sign(as_double()) < 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
bool is_positive_zero() const { return is_number() && bit_cast<u64>(as_double()) == 0; }
bool is_negative_zero() const { return is_number() && bit_cast<u64>(as_double()) == NEGATIVE_ZERO_BITS; }
LibJS: Rename Value::{is_integer => is_integral_number} The implementation matches the specification, so lets match the name as well. :^)
2021-06-16 13:17:06 +03:00
bool is_integral_number() const { return is_finite_number() && (i32)as_double() == as_double(); }
LibJS: Implement bitwise left shift operator (<<)
2020-04-23 13:36:14 +01:00
bool is_finite_number() const
{
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: Flesh out JS::Value a little bit more
2020-03-07 23:16:14 +01:00
explicit Value(bool value)
: 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
}
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
Value(const Object* 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
}
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
Value(const 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
: 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
}
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
Value(const 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
: 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
}
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
Value(const 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
: 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
}
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
Value(const BigInt* 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: 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
Value(const NativeProperty* native_property)
LibJS: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +02:00
: m_type(Type::NativeProperty)
{
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_native_property = const_cast<NativeProperty*>(native_property);
LibJS: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +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
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
}
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
const Object& 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
}
LibJS: Make Value::as_string() return a PrimitiveString reference
2020-04-29 12:35:39 +02:00
const PrimitiveString& 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;
}
const Symbol& as_symbol() 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(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: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +02:00
NativeProperty& as_native_property()
{
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_native_property());
LibJS: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +02:00
return *m_value.as_native_property;
}
LibJS: Add JSON.stringify
2020-06-10 11:01:00 -07:00
Array& as_array();
LibJS: Add Value::{is, as}_function()
2020-05-06 11:52:53 +01:00
Function& as_function();
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
i32 as_i32() const;
LibJS: Implement String.prototype.split This adds a String.prototype.split implementation modelled after ECMA262 specification. Additionally, `Value::to_u32` was added as an implementation of the standard `ToUint32` abstract operation. There is a tiny kludge for when the separator is an empty string. Basic tests and visiting google.com prove that this is working.
2021-01-09 21:52:47 +01:00
u32 as_u32() const;
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; }
LibWeb+LibJS: Add [LegacyNullToEmptyString] attribute If specified, to_string() returns an empty string instead of "null" for null values.
2020-11-11 09:44:46 +00:00
String to_string(GlobalObject&, bool legacy_null_to_empty_string = false) const;
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
PrimitiveString* to_primitive_string(GlobalObject&);
LibJS: Support @@toPrimitive in ToPrimitive abstract operation Fixes #3961.
2021-03-02 19:22:36 +01:00
Value to_primitive(GlobalObject&, PreferredType preferred_type = PreferredType::Default) const;
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
Object* to_object(GlobalObject&) const;
Value to_numeric(GlobalObject&) const;
Value to_number(GlobalObject&) const;
LibJS: Make Function::call() not require an Interpreter& This makes a difference inside ScriptFunction::call(), which will now instantiate a temporary Interpreter if one is not attached to the VM.
2020-09-27 17:24:14 +02:00
BigInt* to_bigint(GlobalObject&) const;
LibJS: Add a bunch of numeric conversions to Value Namely: - BigInt64 - BigUint64 - i16 - u16 - i8 - u8 - Clamped u8 These will be used in ArrayBuffer::numeric_to_raw_bytes later.
2021-06-17 00:13:26 +01:00
i64 to_bigint_int64(GlobalObject&) const;
u64 to_bigint_uint64(GlobalObject&) const;
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
double to_double(GlobalObject&) const;
LibJS: Replace StringOrSymbol::from_value with Value::to_property_key This is a more specification compliant implementation of the abstract operation 7.1.19 ToPropertyKey which should handle boxed symbols correctly.
2021-06-05 15:22:11 +03:00
StringOrSymbol to_property_key(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
i32 to_i32(GlobalObject& global_object) const
{
if (m_type == Type::Int32)
return m_value.as_i32;
return to_i32_slow_case(global_object);
}
LibJS: Implement String.prototype.split This adds a String.prototype.split implementation modelled after ECMA262 specification. Additionally, `Value::to_u32` was added as an implementation of the standard `ToUint32` abstract operation. There is a tiny kludge for when the separator is an empty string. Basic tests and visiting google.com prove that this is working.
2021-01-09 21:52:47 +01:00
u32 to_u32(GlobalObject&) const;
LibJS: Add a bunch of numeric conversions to Value Namely: - BigInt64 - BigUint64 - i16 - u16 - i8 - u8 - Clamped u8 These will be used in ArrayBuffer::numeric_to_raw_bytes later.
2021-06-17 00:13:26 +01:00
i16 to_i16(GlobalObject&) const;
u16 to_u16(GlobalObject&) const;
i8 to_i8(GlobalObject&) const;
u8 to_u8(GlobalObject&) const;
u8 to_u8_clamp(GlobalObject&) const;
LibJS: Add Value::to_{index,length,integer_or_infinity} abstract operations We should pay more attention to using the well-defined abstract operations from the spec rather than making up our own, often slightly different rules. This is another step in that direction.
2020-12-02 13:23:51 +00:00
size_t to_length(GlobalObject&) const;
size_t to_index(GlobalObject&) const;
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: Move Value::as_accessor() to Value.h
2020-06-04 22:00:17 +01:00
String to_string_without_side_effects() const;
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: 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: 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 to_i32_slow_case(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
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: Make NativeProperty a plain Cell instead of an Object This removes the need for NativeProperty objects to have a prototype, which just made things confusing.
2020-06-23 17:56:57 +02:00
NativeProperty* as_native_property;
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: Make all the JS::Value binary op helpers take GlobalObject& We don't need the Interpreter& for anything here, the GlobalObject is enough for getting to the VM and possibly throwing exceptions.
2020-09-27 19:52:47 +02:00
Value greater_than(GlobalObject&, Value lhs, Value rhs);
Value greater_than_equals(GlobalObject&, Value lhs, Value rhs);
Value less_than(GlobalObject&, Value lhs, Value rhs);
Value less_than_equals(GlobalObject&, Value lhs, Value rhs);
Value bitwise_and(GlobalObject&, Value lhs, Value rhs);
Value bitwise_or(GlobalObject&, Value lhs, Value rhs);
Value bitwise_xor(GlobalObject&, Value lhs, Value rhs);
Value bitwise_not(GlobalObject&, Value);
Value unary_plus(GlobalObject&, Value);
Value unary_minus(GlobalObject&, Value);
Value left_shift(GlobalObject&, Value lhs, Value rhs);
Value right_shift(GlobalObject&, Value lhs, Value rhs);
Value unsigned_right_shift(GlobalObject&, Value lhs, Value rhs);
Value add(GlobalObject&, Value lhs, Value rhs);
Value sub(GlobalObject&, Value lhs, Value rhs);
Value mul(GlobalObject&, Value lhs, Value rhs);
Value div(GlobalObject&, Value lhs, Value rhs);
Value mod(GlobalObject&, 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
Value exp(GlobalObject&, Value lhs, Value rhs);
LibJS: Make all the JS::Value binary op helpers take GlobalObject& We don't need the Interpreter& for anything here, the GlobalObject is enough for getting to the VM and possibly throwing exceptions.
2020-09-27 19:52:47 +02:00
Value in(GlobalObject&, 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
Value instance_of(GlobalObject&, Value lhs, Value rhs);
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: Make all the JS::Value binary op helpers take GlobalObject& We don't need the Interpreter& for anything here, the GlobalObject is enough for getting to the VM and possibly throwing exceptions.
2020-09-27 19:52:47 +02:00
bool abstract_eq(GlobalObject&, 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 strict_eq(Value lhs, Value rhs);
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: Make all the JS::Value binary op helpers take GlobalObject& We don't need the Interpreter& for anything here, the GlobalObject is enough for getting to the VM and possibly throwing exceptions.
2020-09-27 19:52:47 +02:00
TriState abstract_relation(GlobalObject&, bool left_first, Value lhs, Value rhs);
LibJS: Implement the GetMethod abstract operation https://tc39.es/ecma262/#sec-getmethod We have bunch of duplicated on-demand versions of this, let's do it properly.
2021-03-02 18:04:13 +01:00
Function* get_method(GlobalObject& global_object, Value, const PropertyName&);
LibJS: Make length_of_array_like() take an Object rather than Value The pseudo-code from the spec says "Assert: Type(obj) is Object.", so we can just enforce this at compile time rather than taking it literally and doing "ASSERT(value.is_object())". Also fix an issue where the absence of a "length" property on the object would cause a crash (to_number() on empty value).
2021-01-10 14:08:27 +01:00
size_t length_of_array_like(GlobalObject&, const Object&);
LibJS: Explicitly return and accept a Function* in species_constructor The second argument (the default constructor) and the return value have to be constructors (as a result functions), so we can require that explicitly by using appropriate types.
2021-06-10 23:50:48 +03:00
Function* species_constructor(GlobalObject&, const Object&, Function& default_constructor);
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
Value require_object_coercible(GlobalObject&, Value);
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
MarkedValueList create_list_from_array_like(GlobalObject&, Value, AK::Function<Result<void, ErrorType>(Value)> = {});
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: 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
struct ValueTraits : public Traits<Value> {
static unsigned hash(Value value)
{
VERIFY(!value.is_empty());
if (value.is_string())
return value.as_string().string().hash();
if (value.is_bigint())
return value.as_bigint().big_integer().hash();
if (value.is_negative_zero())
value = Value(0);
return u64_hash(value.encoded()); // FIXME: Is this the best way to hash pointers, doubles & ints?
}
static bool equals(const Value a, const Value b)
{
return same_value_zero(a, b);
}
};
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+Format: Remove TypeErasedFormatParams& from format function.
2020-12-30 12:14:15 +01:00
void format(FormatBuilder& builder, const 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+Format: Remove TypeErasedFormatParams& from format function.
2020-12-30 12:14:15 +01:00
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