From 63499c2c9f95fac5fb12f727492d64575ef596f1 Mon Sep 17 00:00:00 2001 From: Andreas Kling Date: Wed, 15 Apr 2020 09:28:41 +0200 Subject: [PATCH] LibJS: Pass the Interpreter& to binary/logical/unary helpers --- Libraries/LibJS/AST.cpp | 56 +++++++++++++++---------------- Libraries/LibJS/Runtime/Value.cpp | 54 ++++++++++++++--------------- Libraries/LibJS/Runtime/Value.h | 42 +++++++++++------------ 3 files changed, 76 insertions(+), 76 deletions(-) diff --git a/Libraries/LibJS/AST.cpp b/Libraries/LibJS/AST.cpp index 318d909dfc..8d1fd4a4a0 100644 --- a/Libraries/LibJS/AST.cpp +++ b/Libraries/LibJS/AST.cpp @@ -281,45 +281,45 @@ Value BinaryExpression::execute(Interpreter& interpreter) const switch (m_op) { case BinaryOp::Addition: - return add(lhs_result, rhs_result); + return add(interpreter, lhs_result, rhs_result); case BinaryOp::Subtraction: - return sub(lhs_result, rhs_result); + return sub(interpreter, lhs_result, rhs_result); case BinaryOp::Multiplication: - return mul(lhs_result, rhs_result); + return mul(interpreter, lhs_result, rhs_result); case BinaryOp::Division: - return div(lhs_result, rhs_result); + return div(interpreter, lhs_result, rhs_result); case BinaryOp::Modulo: - return mod(lhs_result, rhs_result); + return mod(interpreter, lhs_result, rhs_result); case BinaryOp::Exponentiation: - return exp(lhs_result, rhs_result); + return exp(interpreter, lhs_result, rhs_result); case BinaryOp::TypedEquals: - return typed_eq(lhs_result, rhs_result); + return typed_eq(interpreter, lhs_result, rhs_result); case BinaryOp::TypedInequals: - return Value(!typed_eq(lhs_result, rhs_result).as_bool()); + return Value(!typed_eq(interpreter, lhs_result, rhs_result).as_bool()); case BinaryOp::AbstractEquals: - return eq(lhs_result, rhs_result); + return eq(interpreter, lhs_result, rhs_result); case BinaryOp::AbstractInequals: - return Value(!eq(lhs_result, rhs_result).as_bool()); + return Value(!eq(interpreter, lhs_result, rhs_result).as_bool()); case BinaryOp::GreaterThan: - return greater_than(lhs_result, rhs_result); + return greater_than(interpreter, lhs_result, rhs_result); case BinaryOp::GreaterThanEquals: - return greater_than_equals(lhs_result, rhs_result); + return greater_than_equals(interpreter, lhs_result, rhs_result); case BinaryOp::LessThan: - return less_than(lhs_result, rhs_result); + return less_than(interpreter, lhs_result, rhs_result); case BinaryOp::LessThanEquals: - return less_than_equals(lhs_result, rhs_result); + return less_than_equals(interpreter, lhs_result, rhs_result); case BinaryOp::BitwiseAnd: - return bitwise_and(lhs_result, rhs_result); + return bitwise_and(interpreter, lhs_result, rhs_result); case BinaryOp::BitwiseOr: - return bitwise_or(lhs_result, rhs_result); + return bitwise_or(interpreter, lhs_result, rhs_result); case BinaryOp::BitwiseXor: - return bitwise_xor(lhs_result, rhs_result); + return bitwise_xor(interpreter, lhs_result, rhs_result); case BinaryOp::LeftShift: - return left_shift(lhs_result, rhs_result); + return left_shift(interpreter, lhs_result, rhs_result); case BinaryOp::RightShift: - return right_shift(lhs_result, rhs_result); + return right_shift(interpreter, lhs_result, rhs_result); case BinaryOp::InstanceOf: - return instance_of(lhs_result, rhs_result); + return instance_of(interpreter, lhs_result, rhs_result); } ASSERT_NOT_REACHED(); @@ -363,13 +363,13 @@ Value UnaryExpression::execute(Interpreter& interpreter) const return {}; switch (m_op) { case UnaryOp::BitwiseNot: - return bitwise_not(lhs_result); + return bitwise_not(interpreter, lhs_result); case UnaryOp::Not: return Value(!lhs_result.to_boolean()); case UnaryOp::Plus: - return unary_plus(lhs_result); + return unary_plus(interpreter, lhs_result); case UnaryOp::Minus: - return unary_minus(lhs_result); + return unary_minus(interpreter, lhs_result); case UnaryOp::Typeof: switch (lhs_result.type()) { case Value::Type::Empty: @@ -704,25 +704,25 @@ Value AssignmentExpression::execute(Interpreter& interpreter) const lhs_result = m_lhs->execute(interpreter); if (interpreter.exception()) return {}; - rhs_result = add(lhs_result, rhs_result); + rhs_result = add(interpreter, lhs_result, rhs_result); break; case AssignmentOp::SubtractionAssignment: lhs_result = m_lhs->execute(interpreter); if (interpreter.exception()) return {}; - rhs_result = sub(lhs_result, rhs_result); + rhs_result = sub(interpreter, lhs_result, rhs_result); break; case AssignmentOp::MultiplicationAssignment: lhs_result = m_lhs->execute(interpreter); if (interpreter.exception()) return {}; - rhs_result = mul(lhs_result, rhs_result); + rhs_result = mul(interpreter, lhs_result, rhs_result); break; case AssignmentOp::DivisionAssignment: lhs_result = m_lhs->execute(interpreter); if (interpreter.exception()) return {}; - rhs_result = div(lhs_result, rhs_result); + rhs_result = div(interpreter, lhs_result, rhs_result); break; } if (interpreter.exception()) @@ -1063,7 +1063,7 @@ Value SwitchStatement::execute(Interpreter& interpreter) const auto test_result = switch_case.test()->execute(interpreter); if (interpreter.exception()) return {}; - if (!eq(discriminant_result, test_result).to_boolean()) + if (!eq(interpreter, discriminant_result, test_result).to_boolean()) continue; } falling_through = true; diff --git a/Libraries/LibJS/Runtime/Value.cpp b/Libraries/LibJS/Runtime/Value.cpp index 1bf14b245b..c003b29485 100644 --- a/Libraries/LibJS/Runtime/Value.cpp +++ b/Libraries/LibJS/Runtime/Value.cpp @@ -180,32 +180,32 @@ double Value::to_double() const return to_number().as_double(); } -Value greater_than(Value lhs, Value rhs) +Value greater_than(Interpreter&, Value lhs, Value rhs) { return Value(lhs.to_number().as_double() > rhs.to_number().as_double()); } -Value greater_than_equals(Value lhs, Value rhs) +Value greater_than_equals(Interpreter&, Value lhs, Value rhs) { return Value(lhs.to_number().as_double() >= rhs.to_number().as_double()); } -Value less_than(Value lhs, Value rhs) +Value less_than(Interpreter&, Value lhs, Value rhs) { return Value(lhs.to_number().as_double() < rhs.to_number().as_double()); } -Value less_than_equals(Value lhs, Value rhs) +Value less_than_equals(Interpreter&, Value lhs, Value rhs) { return Value(lhs.to_number().as_double() <= rhs.to_number().as_double()); } -Value bitwise_and(Value lhs, Value rhs) +Value bitwise_and(Interpreter&, Value lhs, Value rhs) { return Value((i32)lhs.to_number().as_double() & (i32)rhs.to_number().as_double()); } -Value bitwise_or(Value lhs, Value rhs) +Value bitwise_or(Interpreter&, Value lhs, Value rhs) { bool lhs_invalid = lhs.is_undefined() || lhs.is_null() || lhs.is_nan() || lhs.is_infinity(); bool rhs_invalid = rhs.is_undefined() || rhs.is_null() || rhs.is_nan() || rhs.is_infinity(); @@ -222,62 +222,62 @@ Value bitwise_or(Value lhs, Value rhs) return Value((i32)lhs.to_number().as_double() | (i32)rhs.to_number().as_double()); } -Value bitwise_xor(Value lhs, Value rhs) +Value bitwise_xor(Interpreter&, Value lhs, Value rhs) { return Value((i32)lhs.to_number().as_double() ^ (i32)rhs.to_number().as_double()); } -Value bitwise_not(Value lhs) +Value bitwise_not(Interpreter&, Value lhs) { return Value(~(i32)lhs.to_number().as_double()); } -Value unary_plus(Value lhs) +Value unary_plus(Interpreter&, Value lhs) { return lhs.to_number(); } -Value unary_minus(Value lhs) +Value unary_minus(Interpreter&, Value lhs) { if (lhs.to_number().is_nan()) return js_nan(); return Value(-lhs.to_number().as_double()); } -Value left_shift(Value lhs, Value rhs) +Value left_shift(Interpreter&, Value lhs, Value rhs) { return Value((i32)lhs.to_number().as_double() << (i32)rhs.to_number().as_double()); } -Value right_shift(Value lhs, Value rhs) +Value right_shift(Interpreter&, Value lhs, Value rhs) { return Value((i32)lhs.to_number().as_double() >> (i32)rhs.to_number().as_double()); } -Value add(Value lhs, Value rhs) +Value add(Interpreter& interpreter, Value lhs, Value rhs) { if (lhs.is_string() || rhs.is_string()) - return js_string((lhs.is_string() ? lhs : rhs).as_string()->heap(), String::format("%s%s", lhs.to_string().characters(), rhs.to_string().characters())); + return js_string(interpreter.heap(), String::format("%s%s", lhs.to_string().characters(), rhs.to_string().characters())); return Value(lhs.to_number().as_double() + rhs.to_number().as_double()); } -Value sub(Value lhs, Value rhs) +Value sub(Interpreter&, Value lhs, Value rhs) { return Value(lhs.to_number().as_double() - rhs.to_number().as_double()); } -Value mul(Value lhs, Value rhs) +Value mul(Interpreter&, Value lhs, Value rhs) { return Value(lhs.to_number().as_double() * rhs.to_number().as_double()); } -Value div(Value lhs, Value rhs) +Value div(Interpreter&, Value lhs, Value rhs) { return Value(lhs.to_number().as_double() / rhs.to_number().as_double()); } -Value mod(Value lhs, Value rhs) +Value mod(Interpreter&, Value lhs, Value rhs) { if (lhs.to_number().is_nan() || rhs.to_number().is_nan()) return js_nan(); @@ -289,12 +289,12 @@ Value mod(Value lhs, Value rhs) return Value(index - trunc * period); } -Value exp(Value lhs, Value rhs) +Value exp(Interpreter&, Value lhs, Value rhs) { return Value(pow(lhs.to_number().as_double(), rhs.to_number().as_double())); } -Value typed_eq(Value lhs, Value rhs) +Value typed_eq(Interpreter&, Value lhs, Value rhs) { if (rhs.type() != lhs.type()) return Value(false); @@ -320,25 +320,25 @@ Value typed_eq(Value lhs, Value rhs) ASSERT_NOT_REACHED(); } -Value eq(Value lhs, Value rhs) +Value eq(Interpreter& interpreter, Value lhs, Value rhs) { if (lhs.type() == rhs.type()) - return typed_eq(lhs, rhs); + return typed_eq(interpreter, lhs, rhs); if ((lhs.is_undefined() || lhs.is_null()) && (rhs.is_undefined() || rhs.is_null())) return Value(true); if (lhs.is_object() && rhs.is_boolean()) - return eq(lhs.as_object().to_primitive(), rhs.to_number()); + return eq(interpreter, lhs.as_object().to_primitive(), rhs.to_number()); if (lhs.is_boolean() && rhs.is_object()) - return eq(lhs.to_number(), rhs.as_object().to_primitive()); + return eq(interpreter, lhs.to_number(), rhs.as_object().to_primitive()); if (lhs.is_object()) - return eq(lhs.as_object().to_primitive(), rhs); + return eq(interpreter, lhs.as_object().to_primitive(), rhs); if (rhs.is_object()) - return eq(lhs, rhs.as_object().to_primitive()); + return eq(interpreter, lhs, rhs.as_object().to_primitive()); if (lhs.is_number() || rhs.is_number()) return Value(lhs.to_number().as_double() == rhs.to_number().as_double()); @@ -349,7 +349,7 @@ Value eq(Value lhs, Value rhs) return Value(false); } -Value instance_of(Value lhs, Value rhs) +Value instance_of(Interpreter&, Value lhs, Value rhs) { if (!lhs.is_object() || !rhs.is_object()) return Value(false); diff --git a/Libraries/LibJS/Runtime/Value.h b/Libraries/LibJS/Runtime/Value.h index 79ce3bbfc8..c62f5239a9 100644 --- a/Libraries/LibJS/Runtime/Value.h +++ b/Libraries/LibJS/Runtime/Value.h @@ -187,27 +187,27 @@ inline Value js_negative_infinity() return Value(-__builtin_huge_val()); } -Value greater_than(Value lhs, Value rhs); -Value greater_than_equals(Value lhs, Value rhs); -Value less_than(Value lhs, Value rhs); -Value less_than_equals(Value lhs, Value rhs); -Value bitwise_and(Value lhs, Value rhs); -Value bitwise_or(Value lhs, Value rhs); -Value bitwise_xor(Value lhs, Value rhs); -Value bitwise_not(Value); -Value unary_plus(Value); -Value unary_minus(Value); -Value left_shift(Value lhs, Value rhs); -Value right_shift(Value lhs, Value rhs); -Value add(Value lhs, Value rhs); -Value sub(Value lhs, Value rhs); -Value mul(Value lhs, Value rhs); -Value div(Value lhs, Value rhs); -Value mod(Value lhs, Value rhs); -Value exp(Value lhs, Value rhs); -Value eq(Value lhs, Value rhs); -Value typed_eq(Value lhs, Value rhs); -Value instance_of(Value lhs, Value rhs); +Value greater_than(Interpreter&, Value lhs, Value rhs); +Value greater_than_equals(Interpreter&, Value lhs, Value rhs); +Value less_than(Interpreter&, Value lhs, Value rhs); +Value less_than_equals(Interpreter&, Value lhs, Value rhs); +Value bitwise_and(Interpreter&, Value lhs, Value rhs); +Value bitwise_or(Interpreter&, Value lhs, Value rhs); +Value bitwise_xor(Interpreter&, Value lhs, Value rhs); +Value bitwise_not(Interpreter&, Value); +Value unary_plus(Interpreter&, Value); +Value unary_minus(Interpreter&, Value); +Value left_shift(Interpreter&, Value lhs, Value rhs); +Value right_shift(Interpreter&, Value lhs, Value rhs); +Value add(Interpreter&, Value lhs, Value rhs); +Value sub(Interpreter&, Value lhs, Value rhs); +Value mul(Interpreter&, Value lhs, Value rhs); +Value div(Interpreter&, Value lhs, Value rhs); +Value mod(Interpreter&, Value lhs, Value rhs); +Value exp(Interpreter&, Value lhs, Value rhs); +Value eq(Interpreter&, Value lhs, Value rhs); +Value typed_eq(Interpreter&, Value lhs, Value rhs); +Value instance_of(Interpreter&, Value lhs, Value rhs); const LogStream& operator<<(const LogStream&, const Value&);