beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-26 09:30:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/Libraries/LibJS/Runtime/Value.cpp

1217 lines
42 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 18:42:11 +00:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
* Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
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 18:42:11 +00:00
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
LibJS: Implement the "instanceof" operator This operator walks the prototype chain of the RHS value and looks for a "prototype" property with the same value as the prototype of the LHS. This is pretty cool. :^)
2020-03-28 15:56:54 +00:00
#include <AK/FlyString.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 18:42:11 +00:00
#include <AK/String.h>
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 11:39:24 +00:00
#include <AK/StringBuilder.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 15:19:59 +00:00
#include <AK/Utf8View.h>
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
#include <LibCrypto/BigInt/SignedBigInteger.h>
#include <LibCrypto/NumberTheory/ModularFunctions.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Heap/Heap.h>
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 18:14:23 +00:00
#include <LibJS/Runtime/Accessor.h>
LibJS: Handle empty strings and arrays in Value::to_number() - An empty string is converted to 0 - An empty array is converted to 0 - An array with one item is converted to that item's numeric value - An array with more than one item is converted to NaN
2020-03-29 14:20:09 +00:00
#include <LibJS/Runtime/Array.h>
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
#include <LibJS/Runtime/BigInt.h>
#include <LibJS/Runtime/BigIntObject.h>
LibJS: Add Boolean constructor object
2020-04-07 03:51:16 +00:00
#include <LibJS/Runtime/BooleanObject.h>
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
#include <LibJS/Runtime/BoundFunction.h>
LibJS: Rework how native functions are called to improve |this| value Native functions now only get the Interpreter& as an argument. They can then extract |this| along with any indexed arguments it wants from it. This forces functions that want |this| to actually deal with calling interpreter.this_value().to_object(), and dealing with the possibility of a non-object |this|. This is still not great but let's keep massaging it forward.
2020-03-28 21:48:35 +00:00
#include <LibJS/Runtime/Error.h>
LibJS: Add Value::{is, as}_function()
2020-05-06 10:52:53 +00:00
#include <LibJS/Runtime/Function.h>
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 15:24:14 +00:00
#include <LibJS/Runtime/GlobalObject.h>
LibJS: Add NumberObject and make to_object() on number values create it
2020-04-04 21:13:13 +00:00
#include <LibJS/Runtime/NumberObject.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/Object.h>
#include <LibJS/Runtime/PrimitiveString.h>
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
#include <LibJS/Runtime/RegExpObject.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/StringObject.h>
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-17 23:28:00 +00:00
#include <LibJS/Runtime/Symbol.h>
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-30 06:25:21 +00:00
#include <LibJS/Runtime/SymbolObject.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/Value.h>
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
#include <ctype.h>
LibJS: Implement exponentiation (** operator)
2020-04-05 12:40:00 +00: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 18:42:11 +00:00
namespace JS {
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
// Used in various abstract operations to make it obvious when a non-optional return value must be discarded.
static const double INVALID { 0 };
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
static const Crypto::SignedBigInteger BIGINT_ZERO { 0 };
static bool is_valid_bigint_value(String string)
{
string = string.trim_whitespace();
if (string.length() > 1 && (string[0] == '-' || string[0] == '+'))
string = string.substring_view(1, string.length() - 1);
for (auto& ch : string) {
if (!isdigit(ch))
return false;
}
return true;
}
ALWAYS_INLINE bool both_number(const Value& lhs, const Value& rhs)
{
return lhs.is_number() && rhs.is_number();
}
ALWAYS_INLINE bool both_bigint(const Value& lhs, const Value& rhs)
{
return lhs.is_bigint() && rhs.is_bigint();
}
LibJS: Implement (mostly) spec compliant version of Number.toString()
2020-12-26 10:30:14 +00:00
static String double_to_string(double d)
{
// https://tc39.es/ecma262/#sec-numeric-types-number-tostring
if (isnan(d))
return "NaN";
if (d == +0.0 || d == -0.0)
return "0";
if (d < +0.0) {
StringBuilder builder;
builder.append('-');
builder.append(double_to_string(-d));
return builder.to_string();
}
if (d == INFINITY)
return "Infinity";
StringBuilder number_string_builder;
size_t start_index = 0;
size_t end_index = 0;
size_t intpart_end = 0;
// generate integer part (reversed)
double intPart;
double frac_part;
frac_part = modf(d, &intPart);
while (intPart > 0) {
number_string_builder.append('0' + (int)fmod(intPart, 10));
end_index++;
intPart = floor(intPart / 10);
}
auto reversed_integer_part = number_string_builder.to_string().reverse();
number_string_builder.clear();
number_string_builder.append(reversed_integer_part);
intpart_end = end_index;
int exponent = 0;
// generate fractional part
while (frac_part > 0) {
double old_frac_part = frac_part;
frac_part *= 10;
frac_part = modf(frac_part, &intPart);
if (old_frac_part == frac_part)
break;
number_string_builder.append('0' + (int)intPart);
end_index++;
exponent--;
}
auto number_string = number_string_builder.to_string();
LibJS: Fix old object numeric key test now that toString() is correct
2020-12-27 00:27:10 +00:00
// FIXME: Remove this hack.
// FIXME: Instead find the shortest round-trippable representation.
// Remove decimals after the 15th position
LibJS: Implement (mostly) spec compliant version of Number.toString()
2020-12-26 10:30:14 +00:00
if (end_index > intpart_end + 15) {
exponent += end_index - intpart_end - 15;
end_index = intpart_end + 15;
}
// remove leading zeroes
while (start_index < end_index && number_string[start_index] == '0') {
start_index++;
}
// remove trailing zeroes
while (end_index > 0 && number_string[end_index - 1] == '0') {
end_index--;
exponent++;
}
if (end_index <= start_index)
return "0";
auto digits = number_string.substring_view(start_index, end_index - start_index);
int number_of_digits = end_index - start_index;
exponent += number_of_digits;
StringBuilder builder;
if (number_of_digits <= exponent && exponent <= 21) {
builder.append(digits);
builder.append(String::repeated('0', exponent - number_of_digits));
return builder.to_string();
}
if (0 < exponent && exponent <= 21) {
builder.append(digits.substring_view(0, exponent));
builder.append('.');
builder.append(digits.substring_view(exponent));
return builder.to_string();
}
if (-6 < exponent && exponent <= 0) {
builder.append("0.");
builder.append(String::repeated('0', -exponent));
builder.append(digits);
return builder.to_string();
}
if (number_of_digits == 1) {
builder.append(digits);
builder.append('e');
if (exponent - 1 > 0)
builder.append('+');
else
builder.append('-');
builder.append(String::format("%d", abs(exponent - 1)));
return builder.to_string();
}
builder.append(digits[0]);
builder.append('.');
builder.append(digits.substring_view(1));
builder.append('e');
if (exponent - 1 > 0)
builder.append('+');
else
builder.append('-');
builder.append(String::format("%d", abs(exponent - 1)));
return builder.to_string();
}
LibJS: Add Value::is_array()
2020-03-26 11:02:18 +00:00
bool Value::is_array() const
{
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 20:18:47 +00:00
return is_object() && as_object().is_array();
LibJS: Add Value::is_array()
2020-03-26 11:02:18 +00:00
}
LibJS: Add JSON.stringify
2020-06-10 18:01:00 +00:00
Array& Value::as_array()
{
ASSERT(is_array());
return static_cast<Array&>(*m_value.as_object);
}
LibJS: Add Value::{is, as}_function()
2020-05-06 10:52:53 +00:00
bool Value::is_function() const
{
return is_object() && as_object().is_function();
}
Function& Value::as_function()
{
ASSERT(is_function());
return static_cast<Function&>(as_object());
}
LibJS: Implement IsRegExp abstract operation This is needed by various String.prototype operations, as well as the RegExp constructor.
2020-12-25 01:52:19 +00:00
bool Value::is_regexp(GlobalObject& global_object) const
{
// 7.2.8 IsRegExp, https://tc39.es/ecma262/#sec-isregexp
if (!is_object())
return false;
auto matcher = as_object().get(global_object.vm().well_known_symbol_match());
if (global_object.vm().exception())
return false;
if (!matcher.is_empty() && !matcher.is_undefined())
return matcher.to_boolean();
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
return is<RegExpObject>(as_object());
LibJS: Implement IsRegExp abstract operation This is needed by various String.prototype operations, as well as the RegExp constructor.
2020-12-25 01:52:19 +00:00
}
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 11:39:24 +00:00
String Value::to_string_without_side_effects() 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 18:42:11 +00:00
{
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
switch (m_type) {
case Type::Undefined:
LibJS: Fix string representation for value of type undefined
2020-03-07 22:11:17 +00:00
return "undefined";
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Null:
return "null";
case Type::Boolean:
return m_value.as_bool ? "true" : "false";
case Type::Number:
LibJS: Implement (mostly) spec compliant version of Number.toString()
2020-12-26 10:30:14 +00:00
return double_to_string(m_value.as_double);
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::String:
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 11:39:24 +00:00
return m_value.as_string->string();
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Symbol:
return m_value.as_symbol->to_string();
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
case Type::BigInt:
return m_value.as_bigint->to_string();
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Object:
LibJS: Use string::formatted() in to_string() functions
2020-10-04 14:18:12 +00:00
return String::formatted("[object {}]", as_object().class_name());
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::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 18:14:23 +00:00
return "<accessor>";
LibJS: to_string_without_side_effects() should handle NativeProperty
2020-06-25 20:22:57 +00:00
case Type::NativeProperty:
return "<native-property>";
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
default:
ASSERT_NOT_REACHED();
}
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 11:39:24 +00:00
}
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 16:36:49 +00:00
PrimitiveString* Value::to_primitive_string(GlobalObject& global_object)
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 11:39:24 +00:00
{
if (is_string())
return &as_string();
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 16:36:49 +00:00
auto string = to_string(global_object);
if (global_object.vm().exception())
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 11:39:24 +00:00
return nullptr;
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 16:36:49 +00:00
return js_string(global_object.heap(), string);
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 11:39:24 +00:00
}
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 Value::to_string(GlobalObject& global_object, bool legacy_null_to_empty_string) const
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 11:39:24 +00:00
{
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
switch (m_type) {
case Type::Undefined:
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 11:39:24 +00:00
return "undefined";
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Null:
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
return !legacy_null_to_empty_string ? "null" : String::empty();
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Boolean:
return m_value.as_bool ? "true" : "false";
case Type::Number:
LibJS: Implement (mostly) spec compliant version of Number.toString()
2020-12-26 10:30:14 +00:00
return double_to_string(m_value.as_double);
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::String:
return m_value.as_string->string();
case Type::Symbol:
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 16:36:49 +00:00
global_object.vm().throw_exception<TypeError>(global_object, ErrorType::Convert, "symbol", "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-30 06:25:21 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
case Type::BigInt:
return m_value.as_bigint->big_integer().to_base10();
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Object: {
LibJS: Implement spec-compliant OrdinaryToPrimitive This renames Object::to_primitive() to Object::ordinary_to_primitive() for two reasons: - No confusion with Value::to_primitive() - To match the spec's name Also change existing uses of Object::to_primitive() to Value::to_primitive() when the spec uses the latter (which will still call Object::ordinary_to_primitive()). Object::to_string() has been removed as it's not needed anymore (and nothing the spec uses). This makes it possible to overwrite an object's toString and valueOf and have them provide results for anything that uses to_primitive() - e.g.: const o = { toString: undefined, valueOf: () => 42 }; Number(o) // 42, previously NaN ["foo", o].toString(); // "foo,42", previously "foo,[object Object]" ++o // 43, previously NaN etc.
2020-11-03 19:52:21 +00:00
auto primitive_value = to_primitive(PreferredType::String);
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 16:36:49 +00:00
if (global_object.vm().exception())
LibJS: Throw error in Object::to_string() if string conversion fails
2020-04-29 15:29:26 +00:00
return {};
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 16:36:49 +00:00
return primitive_value.to_string(global_object);
LibJS: Throw error in Object::to_string() if string conversion fails
2020-04-29 15:29:26 +00:00
}
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
default:
ASSERT_NOT_REACHED();
}
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 18:42:11 +00:00
}
LibJS: Implement basic boolean coercion We can't expect the conditionals in "if" and "while" statements to always return a bool, so we need to know how to boolify a JS::Value.
2020-03-10 07:46:20 +00:00
bool Value::to_boolean() const
{
switch (m_type) {
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Undefined:
case Type::Null:
return false;
LibJS: Implement basic boolean coercion We can't expect the conditionals in "if" and "while" statements to always return a bool, so we need to know how to boolify a JS::Value.
2020-03-10 07:46:20 +00:00
case Type::Boolean:
return m_value.as_bool;
case Type::Number:
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
if (is_nan())
LibJS: Return false for NaN numbers in Value::to_boolean()
2020-04-07 03:48:47 +00:00
return false;
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
return m_value.as_double != 0;
LibJS: Implement basic boolean coercion We can't expect the conditionals in "if" and "while" statements to always return a bool, so we need to know how to boolify a JS::Value.
2020-03-10 07:46:20 +00:00
case Type::String:
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
return !m_value.as_string->string().is_empty();
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-30 06:25:21 +00:00
case Type::Symbol:
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return true;
case Type::BigInt:
return m_value.as_bigint->big_integer() != BIGINT_ZERO;
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Object:
LibJS: Implement basic boolean coercion We can't expect the conditionals in "if" and "while" statements to always return a bool, so we need to know how to boolify a JS::Value.
2020-03-10 07:46:20 +00:00
return true;
default:
ASSERT_NOT_REACHED();
}
}
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 15:24:14 +00:00
Value Value::to_primitive(PreferredType preferred_type) const
LibJS: Adding two values should convert them to primitives first
2020-04-15 07:32:44 +00:00
{
LibJS: Implement spec-compliant OrdinaryToPrimitive This renames Object::to_primitive() to Object::ordinary_to_primitive() for two reasons: - No confusion with Value::to_primitive() - To match the spec's name Also change existing uses of Object::to_primitive() to Value::to_primitive() when the spec uses the latter (which will still call Object::ordinary_to_primitive()). Object::to_string() has been removed as it's not needed anymore (and nothing the spec uses). This makes it possible to overwrite an object's toString and valueOf and have them provide results for anything that uses to_primitive() - e.g.: const o = { toString: undefined, valueOf: () => 42 }; Number(o) // 42, previously NaN ["foo", o].toString(); // "foo,42", previously "foo,[object Object]" ++o // 43, previously NaN etc.
2020-11-03 19:52:21 +00:00
if (is_object()) {
// FIXME: Also support @@toPrimitive
if (preferred_type == PreferredType::Default)
preferred_type = PreferredType::Number;
return as_object().ordinary_to_primitive(preferred_type);
}
LibJS: Adding two values should convert them to primitives first
2020-04-15 07:32:44 +00:00
return *this;
}
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 16:36:49 +00:00
Object* Value::to_object(GlobalObject& global_object) 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 17:58:19 +00:00
{
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
switch (m_type) {
case Type::Undefined:
case Type::Null:
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 16:36:49 +00:00
global_object.vm().throw_exception<TypeError>(global_object, ErrorType::ToObjectNullOrUndef);
LibJS: Rework how native functions are called to improve |this| value Native functions now only get the Interpreter& as an argument. They can then extract |this| along with any indexed arguments it wants from it. This forces functions that want |this| to actually deal with calling interpreter.this_value().to_object(), and dealing with the possibility of a non-object |this|. This is still not great but let's keep massaging it forward.
2020-03-28 21:48:35 +00:00
return nullptr;
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Boolean:
LibJS: Make Value::to_object() take a GlobalObject&
2020-06-20 14:40:30 +00:00
return BooleanObject::create(global_object, m_value.as_bool);
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Number:
LibJS: Make Value::to_object() take a GlobalObject&
2020-06-20 14:40:30 +00:00
return NumberObject::create(global_object, m_value.as_double);
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::String:
LibJS: Make Value::to_object() take a GlobalObject&
2020-06-20 14:40:30 +00:00
return StringObject::create(global_object, *m_value.as_string);
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Symbol:
LibJS: Make Value::to_object() take a GlobalObject&
2020-06-20 14:40:30 +00:00
return SymbolObject::create(global_object, *m_value.as_symbol);
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
case Type::BigInt:
LibJS: Make Value::to_object() take a GlobalObject&
2020-06-20 14:40:30 +00:00
return BigIntObject::create(global_object, *m_value.as_bigint);
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Object:
return &const_cast<Object&>(as_object());
default:
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
dbgln("Dying because I can't to_object() on {}", *this);
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
ASSERT_NOT_REACHED();
LibJS: Rework how native functions are called to improve |this| value Native functions now only get the Interpreter& as an argument. They can then extract |this| along with any indexed arguments it wants from it. This forces functions that want |this| to actually deal with calling interpreter.this_value().to_object(), and dealing with the possibility of a non-object |this|. This is still not great but let's keep massaging it forward.
2020-03-28 21:48:35 +00:00
}
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 17:58:19 +00:00
}
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 16:36:49 +00:00
Value Value::to_numeric(GlobalObject& global_object) const
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
{
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 15:24:14 +00:00
auto primitive = to_primitive(Value::PreferredType::Number);
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 16:36:49 +00:00
if (global_object.vm().exception())
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
if (primitive.is_bigint())
return primitive;
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 16:36:49 +00:00
return primitive.to_number(global_object);
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
}
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 16:36:49 +00:00
Value Value::to_number(GlobalObject& global_object) const
LibJS: Add Value::to_i32() helper function
2020-03-15 14:00:18 +00:00
{
switch (m_type) {
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-08 00:09:00 +00:00
case Type::Undefined:
return js_nan();
case Type::Null:
return Value(0);
LibJS: Add Value::to_i32() helper function
2020-03-15 14:00:18 +00:00
case Type::Boolean:
LibJS: Loosen type system This commits makes effort towards tolerating some of javascript's quirks when it comes to its type system, note that the interpreter's way of handling type coercion is still not mature at all, for example, we still have to implement NaN instead of just crashing when trying to parse a string and failing.
2020-03-15 22:19:41 +00:00
return Value(m_value.as_bool ? 1 : 0);
LibJS: Add Value::to_i32() helper function
2020-03-15 14:00:18 +00:00
case Type::Number:
LibJS: Loosen type system This commits makes effort towards tolerating some of javascript's quirks when it comes to its type system, note that the interpreter's way of handling type coercion is still not mature at all, for example, we still have to implement NaN instead of just crashing when trying to parse a string and failing.
2020-03-15 22:19:41 +00:00
return Value(m_value.as_double);
case Type::String: {
LibJS: Trim whitespace from string before coercing to number
2020-05-12 23:28:42 +00:00
auto string = as_string().string().trim_whitespace();
LibJS: Implement Math.abs()
2020-03-29 12:56:28 +00:00
if (string.is_empty())
return Value(0);
LibJS: Handle Infinity in Value::to_number()
2020-04-12 12:06:34 +00:00
if (string == "Infinity" || string == "+Infinity")
return js_infinity();
if (string == "-Infinity")
LibJS: Add js_negative_infinity() Value(-js_infinity().as_double()) is kind of awkward.
2020-04-12 12:25:42 +00:00
return js_negative_infinity();
LibJS: Make string to number coercion work for doubles
2020-05-12 23:04:52 +00:00
char* endptr;
auto parsed_double = strtod(string.characters(), &endptr);
if (*endptr)
return js_nan();
return Value(parsed_double);
LibJS: Add Value::to_i32() helper function
2020-03-15 14:00:18 +00: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-30 06:25:21 +00:00
case Type::Symbol:
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 16:36:49 +00:00
global_object.vm().throw_exception<TypeError>(global_object, ErrorType::Convert, "symbol", "number");
LibJS: Throw TypeError when coercing symbol to number
2020-05-17 23:54:10 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
case Type::BigInt:
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 16:36:49 +00:00
global_object.vm().throw_exception<TypeError>(global_object, ErrorType::Convert, "BigInt", "number");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
case Type::Object: {
LibJS: Implement spec-compliant OrdinaryToPrimitive This renames Object::to_primitive() to Object::ordinary_to_primitive() for two reasons: - No confusion with Value::to_primitive() - To match the spec's name Also change existing uses of Object::to_primitive() to Value::to_primitive() when the spec uses the latter (which will still call Object::ordinary_to_primitive()). Object::to_string() has been removed as it's not needed anymore (and nothing the spec uses). This makes it possible to overwrite an object's toString and valueOf and have them provide results for anything that uses to_primitive() - e.g.: const o = { toString: undefined, valueOf: () => 42 }; Number(o) // 42, previously NaN ["foo", o].toString(); // "foo,42", previously "foo,[object Object]" ++o // 43, previously NaN etc.
2020-11-03 19:52:21 +00:00
auto primitive = to_primitive(PreferredType::Number);
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 16:36:49 +00:00
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 16:36:49 +00:00
return primitive.to_number(global_object);
LibJS: Loosen type system This commits makes effort towards tolerating some of javascript's quirks when it comes to its type system, note that the interpreter's way of handling type coercion is still not mature at all, for example, we still have to implement NaN instead of just crashing when trying to parse a string and failing.
2020-03-15 22:19:41 +00:00
}
LibJS: Use switch/case for Value::to_{string{_w/o_side_effects},boolean} This makes them a bit more compact and improves consistency as to_boolean() and to_number() already use this style as well. Also re-order the types to match the table in the spec document.
2020-06-04 20:36:52 +00:00
default:
ASSERT_NOT_REACHED();
}
LibJS: Loosen type system This commits makes effort towards tolerating some of javascript's quirks when it comes to its type system, note that the interpreter's way of handling type coercion is still not mature at all, for example, we still have to implement NaN instead of just crashing when trying to parse a string and failing.
2020-03-15 22:19:41 +00:00
}
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 15:24:14 +00:00
BigInt* Value::to_bigint(GlobalObject& global_object) const
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
{
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 15:24:14 +00:00
auto& vm = global_object.vm();
auto primitive = to_primitive(PreferredType::Number);
if (vm.exception())
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return nullptr;
switch (primitive.type()) {
case Type::Undefined:
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 15:24:14 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::Convert, "undefined", "BigInt");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return nullptr;
case Type::Null:
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 15:24:14 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::Convert, "null", "BigInt");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return nullptr;
case Type::Boolean: {
auto value = primitive.as_bool() ? 1 : 0;
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 15:24:14 +00:00
return js_bigint(vm.heap(), Crypto::SignedBigInteger { value });
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
}
case Type::BigInt:
return &primitive.as_bigint();
case Type::Number:
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 15:24:14 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::Convert, "number", "BigInt");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
case Type::String: {
auto& string = primitive.as_string().string();
if (!is_valid_bigint_value(string)) {
LibJS: Use String::formatted() for throw_exception() message
2020-10-04 12:55:20 +00:00
vm.throw_exception<SyntaxError>(global_object, ErrorType::BigIntInvalidValue, string);
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
}
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 15:24:14 +00:00
return js_bigint(vm.heap(), Crypto::SignedBigInteger::from_base10(string.trim_whitespace()));
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
}
case Type::Symbol:
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 15:24:14 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::Convert, "symbol", "BigInt");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
default:
ASSERT_NOT_REACHED();
}
}
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 07:59:35 +00:00
i32 Value::as_i32() 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-17 23:28:00 +00:00
{
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 07:59:35 +00:00
return static_cast<i32>(as_double());
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-17 23:28:00 +00:00
}
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 07:59:35 +00:00
size_t Value::as_size_t() const
LibJS: Loosen type system This commits makes effort towards tolerating some of javascript's quirks when it comes to its type system, note that the interpreter's way of handling type coercion is still not mature at all, for example, we still have to implement NaN instead of just crashing when trying to parse a string and failing.
2020-03-15 22:19:41 +00:00
{
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 07:59:35 +00:00
ASSERT(as_double() >= 0);
LibJS: Make Array.prototype.push() generic
2020-05-22 12:20:53 +00:00
return min((double)as_i32(), MAX_ARRAY_LIKE_INDEX);
LibJS: Add Value::to_i32() helper function
2020-03-15 14:00:18 +00:00
}
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 16:36:49 +00:00
double Value::to_double(GlobalObject& global_object) const
LibJS: Add Value::to_double() for convenience
2020-04-08 09:22:20 +00:00
{
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 16:36:49 +00:00
auto number = to_number(global_object);
if (global_object.vm().exception())
LibJS: Use INVALID some more in abstract operations
2021-01-09 15:32:23 +00:00
return INVALID;
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 07:59:35 +00:00
return number.as_double();
LibJS: Add Value::to_double() for convenience
2020-04-08 09:22:20 +00:00
}
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 16:36:49 +00:00
i32 Value::to_i32(GlobalObject& global_object) 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-17 23:28:00 +00:00
{
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 16:36:49 +00:00
auto number = to_number(global_object);
if (global_object.vm().exception())
LibJS: Use INVALID some more in abstract operations
2021-01-09 15:32:23 +00:00
return INVALID;
LibJS: Implement parseInt() Here's a reasonably faithful implementation of ECMAScript 2021 18.2.5. Some corner cases are not covered, I've left them as FIXME's in the included unit test. Also I had to tweak JS::Value::to_i32() to always convert infinity to zero, which is in accordance with ToInt32 AFAICT.
2020-12-05 12:51:09 +00:00
if (number.is_nan() || number.is_infinity())
LibJS: Treat NaN in Value::to_i32() as zero Let's treat it as zero like the ECMAScript spec does in toInteger(). That way we can use to_i32() and don't have to care about weird input input values where a number is expected, i.e. "foo".charAt() === "f" "foo".charAt("bar") === "f" "foo".charAt(0) === "f"
2020-05-23 14:02:14 +00:00
return 0;
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 07:59:35 +00:00
return number.as_i32();
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-17 23:28:00 +00:00
}
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 16:36:49 +00:00
size_t Value::to_size_t(GlobalObject& global_object) const
LibJS: Add Value::to_size_t()
2020-04-30 21:41:30 +00:00
{
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
// FIXME: Replace uses of this function with to_length/to_index for correct behaviour and remove this eventually.
LibJS: Add Value::to_size_t()
2020-04-30 21:41:30 +00:00
if (is_empty())
return 0;
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 16:36:49 +00:00
auto number = to_number(global_object);
if (global_object.vm().exception())
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
return INVALID;
LibJS: Remove is_nan() check in as_size_t() and fix to_size_t() We need to call as_double() on the freshly converted number, not the value itself.
2020-05-18 09:03:08 +00:00
if (number.is_nan())
return 0;
if (number.as_double() <= 0)
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 07:59:35 +00:00
return 0;
return number.as_size_t();
LibJS: Add Value::to_size_t()
2020-04-30 21:41:30 +00:00
}
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 Value::to_length(GlobalObject& global_object) const
{
// 7.1.20 ToLength, https://tc39.es/ecma262/#sec-tolength
auto& vm = global_object.vm();
auto len = to_integer_or_infinity(global_object);
if (vm.exception())
return INVALID;
if (len <= 0)
return 0;
return min(len, MAX_ARRAY_LIKE_INDEX);
}
size_t Value::to_index(GlobalObject& global_object) const
{
// 7.1.22 ToIndex, https://tc39.es/ecma262/#sec-toindex
auto& vm = global_object.vm();
if (is_undefined())
return 0;
auto integer_index = to_integer_or_infinity(global_object);
if (vm.exception())
return INVALID;
if (integer_index < 0) {
vm.throw_exception<RangeError>(global_object, ErrorType::InvalidIndex);
return INVALID;
}
auto index = Value(integer_index).to_length(global_object);
ASSERT(!vm.exception());
if (integer_index != index) {
vm.throw_exception<RangeError>(global_object, ErrorType::InvalidIndex);
return INVALID;
}
return index;
}
double Value::to_integer_or_infinity(GlobalObject& global_object) const
{
// 7.1.5 ToIntegerOrInfinity, https://tc39.es/ecma262/#sec-tointegerorinfinity
auto& vm = global_object.vm();
auto number = to_number(global_object);
if (vm.exception())
return INVALID;
if (number.is_nan() || number.as_double() == 0)
return 0;
if (number.is_infinity())
return number.as_double();
auto integer = floor(abs(number.as_double()));
if (number.as_double() < 0)
integer = -integer;
return integer;
}
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 17:52:47 +00:00
Value greater_than(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
TriState relation = abstract_relation(global_object, false, lhs, rhs);
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 15:19:59 +00:00
if (relation == TriState::Unknown)
return Value(false);
return Value(relation == TriState::True);
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value greater_than_equals(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Implement <= and >= binary operators
2020-03-12 12:07:08 +00: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 17:52:47 +00:00
TriState relation = abstract_relation(global_object, true, lhs, rhs);
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 15:19:59 +00:00
if (relation == TriState::Unknown || relation == TriState::True)
return Value(false);
return Value(true);
LibJS: Implement <= and >= binary operators
2020-03-12 12:07:08 +00: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 17:52:47 +00:00
Value less_than(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
TriState relation = abstract_relation(global_object, true, lhs, rhs);
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 15:19:59 +00:00
if (relation == TriState::Unknown)
return Value(false);
return Value(relation == TriState::True);
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value less_than_equals(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Implement <= and >= binary operators
2020-03-12 12:07:08 +00: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 17:52:47 +00:00
TriState relation = abstract_relation(global_object, false, lhs, rhs);
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 15:19:59 +00:00
if (relation == TriState::Unknown || relation == TriState::True)
return Value(false);
return Value(true);
LibJS: Implement <= and >= binary operators
2020-03-12 12:07:08 +00: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 17:52:47 +00:00
Value bitwise_and(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add tests for bitwise & and ^ And fix some edge case conversion bugs found by the tests.
2020-07-23 00:27:32 +00:00
if (both_number(lhs_numeric, rhs_numeric)) {
if (!lhs_numeric.is_finite_number() || !rhs_numeric.is_finite_number())
return Value(0);
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return Value((i32)lhs_numeric.as_double() & (i32)rhs_numeric.as_double());
LibJS: Add tests for bitwise & and ^ And fix some edge case conversion bugs found by the tests.
2020-07-23 00:27:32 +00:00
}
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().bitwise_and(rhs_numeric.as_bigint().big_integer()));
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "bitwise AND");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value bitwise_or(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric)) {
if (!lhs_numeric.is_finite_number() && !rhs_numeric.is_finite_number())
return Value(0);
if (!lhs_numeric.is_finite_number())
return rhs_numeric;
if (!rhs_numeric.is_finite_number())
return lhs_numeric;
return Value((i32)lhs_numeric.as_double() | (i32)rhs_numeric.as_double());
}
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().bitwise_or(rhs_numeric.as_bigint().big_integer()));
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "bitwise OR");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value bitwise_xor(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add tests for bitwise & and ^ And fix some edge case conversion bugs found by the tests.
2020-07-23 00:27:32 +00:00
if (both_number(lhs_numeric, rhs_numeric)) {
if (!lhs_numeric.is_finite_number() && !rhs_numeric.is_finite_number())
return Value(0);
if (!lhs_numeric.is_finite_number())
return rhs_numeric;
if (!rhs_numeric.is_finite_number())
return lhs_numeric;
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return Value((i32)lhs_numeric.as_double() ^ (i32)rhs_numeric.as_double());
LibJS: Add tests for bitwise & and ^ And fix some edge case conversion bugs found by the tests.
2020-07-23 00:27:32 +00:00
}
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().bitwise_xor(rhs_numeric.as_bigint().big_integer()));
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "bitwise XOR");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value bitwise_not(GlobalObject& global_object, Value lhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (lhs_numeric.is_number())
return Value(~(i32)lhs_numeric.as_double());
auto big_integer_bitwise_not = lhs_numeric.as_bigint().big_integer();
big_integer_bitwise_not = big_integer_bitwise_not.plus(Crypto::SignedBigInteger { 1 });
big_integer_bitwise_not.negate();
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 17:52:47 +00:00
return js_bigint(global_object.heap(), big_integer_bitwise_not);
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value unary_plus(GlobalObject& global_object, Value lhs)
LibJS: Implement unary plus / minus
2020-04-02 16:58:39 +00: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 17:52:47 +00:00
return lhs.to_number(global_object.global_object());
LibJS: Implement unary plus / minus
2020-04-02 16:58:39 +00: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 17:52:47 +00:00
Value unary_minus(GlobalObject& global_object, Value lhs)
LibJS: Implement unary plus / minus
2020-04-02 16:58:39 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (lhs_numeric.is_number()) {
if (lhs_numeric.is_nan())
return js_nan();
return Value(-lhs_numeric.as_double());
}
if (lhs_numeric.as_bigint().big_integer() == BIGINT_ZERO)
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 17:52:47 +00:00
return js_bigint(global_object.heap(), BIGINT_ZERO);
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
auto big_integer_negated = lhs_numeric.as_bigint().big_integer();
big_integer_negated.negate();
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 17:52:47 +00:00
return js_bigint(global_object.heap(), big_integer_negated);
LibJS: Implement unary plus / minus
2020-04-02 16:58:39 +00: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 17:52:47 +00:00
Value left_shift(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric)) {
if (!lhs_numeric.is_finite_number())
return Value(0);
if (!rhs_numeric.is_finite_number())
return lhs_numeric;
return Value((i32)lhs_numeric.as_double() << (i32)rhs_numeric.as_double());
}
if (both_bigint(lhs_numeric, rhs_numeric))
TODO();
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 17:52:47 +00:00
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "left-shift");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value right_shift(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric)) {
if (!lhs_numeric.is_finite_number())
return Value(0);
if (!rhs_numeric.is_finite_number())
return lhs_numeric;
return Value((i32)lhs_numeric.as_double() >> (i32)rhs_numeric.as_double());
}
if (both_bigint(lhs_numeric, rhs_numeric))
TODO();
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 17:52:47 +00:00
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "right-shift");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Move Value ops into Value.cpp and tweak BinaryOp names
2020-03-10 10:35:05 +00: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 17:52:47 +00:00
Value unsigned_right_shift(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Implement bitwise unsigned right shift operator (>>>)
2020-04-23 14:43:10 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric)) {
if (!lhs_numeric.is_finite_number())
return Value(0);
if (!rhs_numeric.is_finite_number())
return lhs_numeric;
return Value((unsigned)lhs_numeric.as_double() >> (i32)rhs_numeric.as_double());
}
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 17:52:47 +00:00
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperator, "unsigned right-shift");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Implement bitwise unsigned right shift operator (>>>)
2020-04-23 14:43:10 +00: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 17:52:47 +00:00
Value add(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00:00
{
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 15:24:14 +00:00
auto lhs_primitive = lhs.to_primitive();
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 17:52:47 +00:00
if (global_object.vm().exception())
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 11:39:24 +00:00
return {};
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 15:24:14 +00:00
auto rhs_primitive = rhs.to_primitive();
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 17:52:47 +00:00
if (global_object.vm().exception())
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 11:39:24 +00:00
return {};
LibJS: Adding two values should convert them to primitives first
2020-04-15 07:32:44 +00:00
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 11:39:24 +00:00
if (lhs_primitive.is_string() || rhs_primitive.is_string()) {
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 17:52:47 +00:00
auto lhs_string = lhs_primitive.to_string(global_object.global_object());
if (global_object.vm().exception())
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 11:39:24 +00:00
return {};
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 17:52:47 +00:00
auto rhs_string = rhs_primitive.to_string(global_object.global_object());
if (global_object.vm().exception())
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 11:39:24 +00:00
return {};
StringBuilder builder(lhs_string.length() + rhs_string.length());
builder.append(lhs_string);
builder.append(rhs_string);
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 17:52:47 +00:00
return js_string(global_object.heap(), builder.to_string());
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 11:39:24 +00:00
}
LibJS: Loosen type system This commits makes effort towards tolerating some of javascript's quirks when it comes to its type system, note that the interpreter's way of handling type coercion is still not mature at all, for example, we still have to implement NaN instead of just crashing when trying to parse a string and failing.
2020-03-15 22:19:41 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs_primitive.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs_primitive.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric))
return Value(lhs_numeric.as_double() + rhs_numeric.as_double());
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().plus(rhs_numeric.as_bigint().big_integer()));
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "addition");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00: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 17:52:47 +00:00
Value sub(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric))
return Value(lhs_numeric.as_double() - rhs_numeric.as_double());
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().minus(rhs_numeric.as_bigint().big_integer()));
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "subtraction");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00: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 17:52:47 +00:00
Value mul(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Implement multiplication and division operators
2020-03-12 12:04:52 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric))
return Value(lhs_numeric.as_double() * rhs_numeric.as_double());
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().multiplied_by(rhs_numeric.as_bigint().big_integer()));
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "multiplication");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Implement multiplication and division operators
2020-03-12 12:04:52 +00: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 17:52:47 +00:00
Value div(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Implement multiplication and division operators
2020-03-12 12:04:52 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric))
return Value(lhs_numeric.as_double() / rhs_numeric.as_double());
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().divided_by(rhs_numeric.as_bigint().big_integer()).quotient);
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "division");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Implement multiplication and division operators
2020-03-12 12:04:52 +00: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 17:52:47 +00:00
Value mod(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Add basic support for modulo (%) in binary expressions
2020-04-04 19:17:34 +00: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 17:52:47 +00:00
auto lhs_numeric = lhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
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 17:52:47 +00:00
auto rhs_numeric = rhs.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric)) {
if (lhs_numeric.is_nan() || rhs_numeric.is_nan())
return js_nan();
auto index = lhs_numeric.as_double();
auto period = rhs_numeric.as_double();
auto trunc = (double)(i32)(index / period);
return Value(index - trunc * period);
}
if (both_bigint(lhs_numeric, rhs_numeric))
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 17:52:47 +00:00
return js_bigint(global_object.heap(), lhs_numeric.as_bigint().big_integer().divided_by(rhs_numeric.as_bigint().big_integer()).remainder);
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::BigIntBadOperatorOtherType, "modulo");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Add basic support for modulo (%) in binary expressions
2020-04-04 19:17:34 +00:00
}
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 16:36:49 +00:00
Value exp(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Implement exponentiation (** operator)
2020-04-05 12:40:00 +00:00
{
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 16:36:49 +00:00
auto& vm = global_object.vm();
auto lhs_numeric = lhs.to_numeric(global_object);
if (vm.exception())
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-17 23:28:00 +00:00
return {};
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 16:36:49 +00:00
auto rhs_numeric = rhs.to_numeric(global_object);
if (vm.exception())
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-17 23:28:00 +00:00
return {};
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (both_number(lhs_numeric, rhs_numeric))
return Value(pow(lhs_numeric.as_double(), rhs_numeric.as_double()));
if (both_bigint(lhs_numeric, rhs_numeric))
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 16:36:49 +00:00
return js_bigint(vm.heap(), Crypto::NumberTheory::Power(lhs_numeric.as_bigint().big_integer(), rhs_numeric.as_bigint().big_integer()));
vm.throw_exception<TypeError>(global_object, ErrorType::BigIntBadOperatorOtherType, "exponentiation");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
return {};
LibJS: Implement exponentiation (** operator)
2020-04-05 12:40:00 +00: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 17:52:47 +00:00
Value in(GlobalObject& global_object, Value lhs, Value rhs)
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-08 00:09:00 +00:00
{
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
if (!rhs.is_object()) {
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 17:52:47 +00:00
global_object.vm().throw_exception<TypeError>(global_object.global_object(), ErrorType::InOperatorWithObject);
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
return {};
}
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 17:52:47 +00:00
auto lhs_string = lhs.to_string(global_object.global_object());
if (global_object.vm().exception())
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 11:39:24 +00:00
return {};
LibJS: Value.in uses has_property instead of get().is_empty()
2020-06-03 21:27:01 +00:00
return Value(rhs.as_object().has_property(lhs_string));
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-08 00:09:00 +00:00
}
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 16:36:49 +00:00
Value instance_of(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00:00
{
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 16:36:49 +00:00
auto& vm = global_object.vm();
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
if (!rhs.is_object()) {
LibJS: Use String::formatted() for throw_exception() message
2020-10-04 12:55:20 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::NotAnObject, rhs.to_string_without_side_effects());
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
return {};
}
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 16:36:49 +00:00
auto has_instance_method = rhs.as_object().get(vm.well_known_symbol_has_instance());
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
if (!has_instance_method.is_empty()) {
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
if (!has_instance_method.is_function()) {
LibJS: Use String::formatted() for throw_exception() message
2020-10-04 12:55:20 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::NotAFunction, has_instance_method.to_string_without_side_effects());
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
return {};
}
LibJS: Fix crashing exception in Value::ordinary_has_instance() Two issues: - throw_exception() with ErrorType::InstanceOfOperatorBadPrototype would receive rhs_prototype.to_string_without_side_effects(), which would ASSERT_NOT_REACHED() as to_string_without_side_effects() must not be called on an empty value. It should (and now does) receive the RHS value instead as the message is "'prototype' property of {} is not an object". - Value::instance_of() was missing an exception check after calling has_instance_method, to_boolean() on an empty value result would crash as well. Fixes #3930.
2020-11-03 17:54:57 +00:00
auto has_instance_result = vm.call(has_instance_method.as_function(), rhs, lhs);
if (vm.exception())
return {};
return Value(has_instance_result.to_boolean());
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
}
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
if (!rhs.is_function()) {
LibJS: Use String::formatted() for throw_exception() message
2020-10-04 12:55:20 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::NotAFunction, rhs.to_string_without_side_effects());
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
return {};
}
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 16:36:49 +00:00
return ordinary_has_instance(global_object, lhs, rhs);
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
}
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 16:36:49 +00:00
Value ordinary_has_instance(GlobalObject& global_object, Value lhs, Value rhs)
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
{
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 16:36:49 +00:00
auto& vm = global_object.vm();
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
if (!rhs.is_function())
return Value(false);
auto& rhs_function = rhs.as_function();
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<BoundFunction>(rhs_function)) {
auto& bound_target = static_cast<const BoundFunction&>(rhs_function);
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 16:36:49 +00:00
return instance_of(global_object, lhs, Value(&bound_target.target_function()));
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
}
if (!lhs.is_object())
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-08 00:09:00 +00:00
return Value(false);
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
Object* lhs_object = &lhs.as_object();
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
auto rhs_prototype = rhs_function.get(vm.names.prototype);
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 16:36:49 +00:00
if (vm.exception())
LibJS: Add interpreter exception checks
2020-06-07 17:53:14 +00:00
return {};
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
if (!rhs_prototype.is_object()) {
LibJS: Fix crashing exception in Value::ordinary_has_instance() Two issues: - throw_exception() with ErrorType::InstanceOfOperatorBadPrototype would receive rhs_prototype.to_string_without_side_effects(), which would ASSERT_NOT_REACHED() as to_string_without_side_effects() must not be called on an empty value. It should (and now does) receive the RHS value instead as the message is "'prototype' property of {} is not an object". - Value::instance_of() was missing an exception check after calling has_instance_method, to_boolean() on an empty value result would crash as well. Fixes #3930.
2020-11-03 17:54:57 +00:00
vm.throw_exception<TypeError>(global_object, ErrorType::InstanceOfOperatorBadPrototype, rhs.to_string_without_side_effects());
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 10:52:32 +00:00
return {};
}
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
while (true) {
lhs_object = lhs_object->prototype();
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 16:36:49 +00:00
if (vm.exception())
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
return {};
if (!lhs_object)
return Value(false);
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 16:36:49 +00:00
if (same_value(rhs_prototype, lhs_object))
LibJS: Implement spec-complient instance_of operation
2020-07-11 22:27:28 +00:00
return Value(true);
}
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-08 00:09:00 +00:00
}
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 16:36:49 +00:00
bool same_value(Value lhs, Value rhs)
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-08 00:09:00 +00:00
{
if (lhs.type() != rhs.type())
return false;
if (lhs.is_number()) {
if (lhs.is_nan() && rhs.is_nan())
return true;
if (lhs.is_positive_zero() && rhs.is_negative_zero())
return false;
if (lhs.is_negative_zero() && rhs.is_positive_zero())
return false;
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-17 23:28:00 +00:00
return lhs.as_double() == rhs.as_double();
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-08 00:09:00 +00:00
}
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (lhs.is_bigint()) {
auto lhs_big_integer = lhs.as_bigint().big_integer();
auto rhs_big_integer = rhs.as_bigint().big_integer();
if (lhs_big_integer == BIGINT_ZERO && rhs_big_integer == BIGINT_ZERO && lhs_big_integer.is_negative() != rhs_big_integer.is_negative())
return false;
return lhs_big_integer == rhs_big_integer;
}
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 16:36:49 +00:00
return same_value_non_numeric(lhs, rhs);
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-08 00:09:00 +00:00
}
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 16:36:49 +00:00
bool same_value_zero(Value lhs, Value rhs)
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-08 00:09:00 +00:00
{
if (lhs.type() != rhs.type())
return false;
if (lhs.is_number()) {
if (lhs.is_nan() && rhs.is_nan())
return true;
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-17 23:28:00 +00:00
return lhs.as_double() == rhs.as_double();
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-08 00:09:00 +00:00
}
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (lhs.is_bigint())
return lhs.as_bigint().big_integer() == rhs.as_bigint().big_integer();
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 16:36:49 +00:00
return same_value_non_numeric(lhs, rhs);
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-08 00:09:00 +00:00
}
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 16:36:49 +00:00
bool same_value_non_numeric(Value lhs, Value rhs)
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-08 00:09:00 +00:00
{
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
ASSERT(!lhs.is_number() && !lhs.is_bigint());
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-08 00:09:00 +00:00
ASSERT(lhs.type() == rhs.type());
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00:00
switch (lhs.type()) {
case Value::Type::Undefined:
case Value::Type::Null:
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-08 00:09:00 +00:00
return true;
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00:00
case Value::Type::String:
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-08 00:09:00 +00:00
return lhs.as_string().string() == rhs.as_string().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-30 06:25:21 +00:00
case Value::Type::Symbol:
return &lhs.as_symbol() == &rhs.as_symbol();
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00:00
case Value::Type::Boolean:
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-08 00:09:00 +00:00
return lhs.as_bool() == rhs.as_bool();
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00:00
case Value::Type::Object:
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-08 00:09:00 +00:00
return &lhs.as_object() == &rhs.as_object();
default:
ASSERT_NOT_REACHED();
LibJS: Forgot to move add/sub/typed_eq to Value.cpp
2020-03-11 11:16:26 +00:00
}
}
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 16:36:49 +00:00
bool strict_eq(Value lhs, Value rhs)
LibJS: Implement abstract equality and inequality
2020-03-15 22:23:38 +00:00
{
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-08 00:09:00 +00:00
if (lhs.type() != rhs.type())
return false;
LibJS: Implement abstract equality and inequality
2020-03-15 22:23:38 +00:00
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-08 00:09:00 +00:00
if (lhs.is_number()) {
if (lhs.is_nan() || rhs.is_nan())
return false;
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-17 23:28:00 +00:00
if (lhs.as_double() == rhs.as_double())
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-08 00:09:00 +00:00
return true;
return false;
}
LibJS: Implement abstract equality and inequality
2020-03-15 22:23:38 +00:00
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (lhs.is_bigint())
return lhs.as_bigint().big_integer() == rhs.as_bigint().big_integer();
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 16:36:49 +00:00
return same_value_non_numeric(lhs, rhs);
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-08 00:09:00 +00:00
}
LibJS: Implement abstract equality and inequality
2020-03-15 22:23:38 +00: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 17:52:47 +00:00
bool abstract_eq(GlobalObject& global_object, Value lhs, Value rhs)
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-08 00:09:00 +00:00
{
if (lhs.type() == rhs.type())
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 16:36:49 +00:00
return strict_eq(lhs, rhs);
LibJS: Implement abstract equality and inequality
2020-03-15 22:23:38 +00:00
LibJS: Add Value::is_nullish()
2020-10-02 14:00:15 +00:00
if (lhs.is_nullish() && rhs.is_nullish())
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-08 00:09:00 +00:00
return true;
LibJS: Implement abstract equality and inequality
2020-03-15 22:23:38 +00:00
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-08 00:09:00 +00:00
if (lhs.is_number() && rhs.is_string())
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 17:52:47 +00:00
return abstract_eq(global_object, lhs, rhs.to_number(global_object.global_object()));
LibJS: Implement abstract equality and inequality
2020-03-15 22:23:38 +00:00
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-08 00:09:00 +00:00
if (lhs.is_string() && rhs.is_number())
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 17:52:47 +00:00
return abstract_eq(global_object, lhs.to_number(global_object.global_object()), rhs);
LibJS: Implement 'in' operator
2020-04-23 15:06:01 +00:00
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (lhs.is_bigint() && rhs.is_string()) {
auto& rhs_string = rhs.as_string().string();
if (!is_valid_bigint_value(rhs_string))
return false;
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 17:52:47 +00:00
return abstract_eq(global_object, lhs, js_bigint(global_object.heap(), Crypto::SignedBigInteger::from_base10(rhs_string)));
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
}
if (lhs.is_string() && rhs.is_bigint())
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 17:52:47 +00:00
return abstract_eq(global_object, rhs, lhs);
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
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-08 00:09:00 +00:00
if (lhs.is_boolean())
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 17:52:47 +00:00
return abstract_eq(global_object, lhs.to_number(global_object.global_object()), rhs);
LibJS: Implement 'in' operator
2020-04-23 15:06:01 +00:00
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-08 00:09:00 +00:00
if (rhs.is_boolean())
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 17:52:47 +00:00
return abstract_eq(global_object, lhs, rhs.to_number(global_object.global_object()));
LibJS: Implement the "instanceof" operator This operator walks the prototype chain of the RHS value and looks for a "prototype" property with the same value as the prototype of the LHS. This is pretty cool. :^)
2020-03-28 15:56:54 +00:00
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if ((lhs.is_string() || lhs.is_number() || lhs.is_bigint() || lhs.is_symbol()) && rhs.is_object())
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 17:52:47 +00:00
return abstract_eq(global_object, lhs, rhs.to_primitive());
LibJS: Implement the "instanceof" operator This operator walks the prototype chain of the RHS value and looks for a "prototype" property with the same value as the prototype of the LHS. This is pretty cool. :^)
2020-03-28 15:56:54 +00:00
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (lhs.is_object() && (rhs.is_string() || rhs.is_number() || lhs.is_bigint() || rhs.is_symbol()))
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 17:52:47 +00:00
return abstract_eq(global_object, lhs.to_primitive(), rhs);
LibJS: Implement the "instanceof" operator This operator walks the prototype chain of the RHS value and looks for a "prototype" property with the same value as the prototype of the LHS. This is pretty cool. :^)
2020-03-28 15:56:54 +00:00
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if ((lhs.is_bigint() && rhs.is_number()) || (lhs.is_number() && rhs.is_bigint())) {
if (lhs.is_nan() || lhs.is_infinity() || rhs.is_nan() || rhs.is_infinity())
return false;
if ((lhs.is_number() && !lhs.is_integer()) || (rhs.is_number() && !rhs.is_integer()))
return false;
if (lhs.is_number())
return Crypto::SignedBigInteger { lhs.as_i32() } == rhs.as_bigint().big_integer();
else
return Crypto::SignedBigInteger { rhs.as_i32() } == lhs.as_bigint().big_integer();
}
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-08 00:09:00 +00:00
return false;
LibJS: Simplify LogStream::operator<<(JS::Value) and move to .cpp file
2020-03-07 20:43:10 +00: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 17:52:47 +00:00
TriState abstract_relation(GlobalObject& global_object, bool left_first, Value lhs, Value rhs)
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 15:19:59 +00:00
{
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
Value x_primitive;
Value y_primitive;
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 15:19:59 +00:00
if (left_first) {
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 15:24:14 +00:00
x_primitive = lhs.to_primitive(Value::PreferredType::Number);
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 17:52:47 +00:00
if (global_object.vm().exception())
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 15:19:59 +00:00
return {};
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 15:24:14 +00:00
y_primitive = rhs.to_primitive(Value::PreferredType::Number);
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 17:52:47 +00:00
if (global_object.vm().exception())
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 15:19:59 +00:00
return {};
} else {
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 15:24:14 +00:00
y_primitive = lhs.to_primitive(Value::PreferredType::Number);
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 17:52:47 +00:00
if (global_object.vm().exception())
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 15:19:59 +00:00
return {};
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 15:24:14 +00:00
x_primitive = rhs.to_primitive(Value::PreferredType::Number);
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 17:52:47 +00:00
if (global_object.vm().exception())
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 15:19:59 +00:00
return {};
}
if (x_primitive.is_string() && y_primitive.is_string()) {
auto x_string = x_primitive.as_string().string();
auto y_string = y_primitive.as_string().string();
if (x_string.starts_with(y_string))
return TriState::False;
if (y_string.starts_with(x_string))
return TriState::True;
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 20:31:20 +00:00
Utf8View x_code_points { x_string };
Utf8View y_code_points { y_string };
for (auto k = x_code_points.begin(), l = y_code_points.begin();
k != x_code_points.end() && l != y_code_points.end();
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 15:19:59 +00:00
++k, ++l) {
if (*k != *l) {
if (*k < *l) {
return TriState::True;
} else {
return TriState::False;
}
}
}
ASSERT_NOT_REACHED();
}
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (x_primitive.is_bigint() && y_primitive.is_string()) {
auto& y_string = y_primitive.as_string().string();
if (!is_valid_bigint_value(y_string))
return TriState::Unknown;
if (x_primitive.as_bigint().big_integer() < Crypto::SignedBigInteger::from_base10(y_string))
return TriState::True;
else
return TriState::False;
}
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 15:19:59 +00:00
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (x_primitive.is_string() && y_primitive.is_bigint()) {
auto& x_string = x_primitive.as_string().string();
if (!is_valid_bigint_value(x_string))
return TriState::Unknown;
if (Crypto::SignedBigInteger::from_base10(x_string) < y_primitive.as_bigint().big_integer())
return TriState::True;
else
return TriState::False;
}
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 17:52:47 +00:00
auto x_numeric = x_primitive.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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 15:19:59 +00:00
return {};
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 17:52:47 +00:00
auto y_numeric = y_primitive.to_numeric(global_object.global_object());
if (global_object.vm().exception())
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 15:19:59 +00:00
return {};
if (x_numeric.is_nan() || y_numeric.is_nan())
return TriState::Unknown;
if (x_numeric.is_positive_infinity() || y_numeric.is_negative_infinity())
return TriState::False;
if (x_numeric.is_negative_infinity() || y_numeric.is_positive_infinity())
return TriState::True;
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (x_numeric.is_number() && y_numeric.is_number()) {
if (x_numeric.as_double() < y_numeric.as_double())
return TriState::True;
else
return TriState::False;
}
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 15:19:59 +00:00
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
if (x_numeric.is_bigint() && y_numeric.is_bigint()) {
if (x_numeric.as_bigint().big_integer() < y_numeric.as_bigint().big_integer())
return TriState::True;
else
return TriState::False;
}
ASSERT((x_numeric.is_number() && y_numeric.is_bigint()) || (x_numeric.is_bigint() && y_numeric.is_number()));
bool x_lower_than_y;
if (x_numeric.is_number()) {
x_lower_than_y = x_numeric.is_integer()
? Crypto::SignedBigInteger { x_numeric.as_i32() } < y_numeric.as_bigint().big_integer()
: (Crypto::SignedBigInteger { x_numeric.as_i32() } < y_numeric.as_bigint().big_integer() || Crypto::SignedBigInteger { x_numeric.as_i32() + 1 } < y_numeric.as_bigint().big_integer());
} else {
x_lower_than_y = y_numeric.is_integer()
? x_numeric.as_bigint().big_integer() < Crypto::SignedBigInteger { y_numeric.as_i32() }
: (x_numeric.as_bigint().big_integer() < Crypto::SignedBigInteger { y_numeric.as_i32() } || x_numeric.as_bigint().big_integer() < Crypto::SignedBigInteger { y_numeric.as_i32() + 1 });
}
if (x_lower_than_y)
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 15:19:59 +00:00
return TriState::True;
else
return TriState::False;
}
LibJS: Remove use of Interpreter& in JSONObject code
2020-09-27 16:52:42 +00:00
size_t length_of_array_like(GlobalObject& global_object, Value value)
LibJS: Add JSON.stringify
2020-06-10 18:01:00 +00:00
{
ASSERT(value.is_object());
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 21:49:19 +00:00
auto& vm = global_object.vm();
auto result = value.as_object().get(vm.names.length);
if (vm.exception())
LibJS: Add JSON.stringify
2020-06-10 18:01:00 +00:00
return 0;
LibJS: Remove use of Interpreter& in JSONObject code
2020-09-27 16:52:42 +00:00
return result.to_size_t(global_object);
LibJS: Add JSON.stringify
2020-06-10 18:01:00 +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 18:42:11 +00:00
}
Reference in a new issue Copy permalink