0ct0pu5/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2
ladybird/Libraries/LibJS/AST.cpp

471 lines
12 KiB
C++
Raw Normal View History

LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* 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.
*/
#include <LibJS/AST.h>
#include <LibJS/Function.h>
#include <LibJS/Interpreter.h>
#include <LibJS/Value.h>
#include <stdio.h>
namespace JS {
Value ScopeNode::execute(Interpreter& interpreter) const
{
return interpreter.run(*this);
}
Value FunctionDeclaration::execute(Interpreter& interpreter) const
{
LibJS: Add a basic mark&sweep garbage collector :^) Objects can now be allocated via the interpreter's heap. Objects that are allocated in this way will need to be provably reachable from at least one of the known object graph roots. The roots are currently determined by Heap::collect_roots(). Anything that wants be collectable garbage should inherit from Cell, the fundamental atom of the GC heap. This is pretty neat! :^)
2020-03-08 19:23:58 +01:00
auto* function = interpreter.heap().allocate<Function>(name(), body());
LibJS: Make FunctionDeclaration and CallExpression scope-aware
2020-03-09 21:53:13 +01:00
interpreter.set_variable(m_name, Value(function));
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
return Value(function);
}
Value CallExpression::execute(Interpreter& interpreter) const
{
LibJS: Add magical "$gc" function that can be called to trigger GC This will be immensely useful for testing.
2020-03-09 21:27:52 +01:00
if (name() == "$gc") {
interpreter.heap().collect_garbage();
return js_undefined();
}
LibJS: Make FunctionDeclaration and CallExpression scope-aware
2020-03-09 21:53:13 +01:00
auto callee = interpreter.get_variable(name());
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
ASSERT(callee.is_object());
auto* callee_object = callee.as_object();
ASSERT(callee_object->is_function());
auto& function = static_cast<Function&>(*callee_object);
return interpreter.run(function.body());
}
Value ReturnStatement::execute(Interpreter& interpreter) const
{
auto value = argument().execute(interpreter);
interpreter.do_return();
return value;
}
LibJS: Implement if statements If statements execute a certain action or an alternative one depending on whether the tested condition is true or false, this commit helps establish basic control flow capabilities in the AST.
2020-03-08 07:58:58 +02:00
Value IfStatement::execute(Interpreter& interpreter) const
{
auto predicate_result = m_predicate->execute(interpreter);
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 08:46:20 +01:00
if (predicate_result.to_boolean())
LibJS: Implement if statements If statements execute a certain action or an alternative one depending on whether the tested condition is true or false, this commit helps establish basic control flow capabilities in the AST.
2020-03-08 07:58:58 +02:00
return interpreter.run(*m_consequent);
else
return interpreter.run(*m_alternate);
}
LibJS: Implement While statements
2020-03-09 03:22:21 +08:00
Value WhileStatement::execute(Interpreter& interpreter) const
{
Value last_value = js_undefined();
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 08:46:20 +01:00
while (m_predicate->execute(interpreter).to_boolean()) {
LibJS: Implement While statements
2020-03-09 03:22:21 +08:00
last_value = interpreter.run(*m_body);
}
return last_value;
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
Value add(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value(lhs.as_double() + rhs.as_double());
}
Value sub(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value(lhs.as_double() - rhs.as_double());
}
LibJS: Add typed comparison operator The `===` operator allows us to compare two values while taking their type into consideration.
2020-03-08 07:53:02 +02:00
const Value typed_eq(const Value lhs, const Value rhs)
{
if (rhs.type() != lhs.type())
return Value(false);
switch (lhs.type()) {
case Value::Type::Undefined:
return Value(true);
case Value::Type::Null:
return Value(true);
case Value::Type::Number:
return Value(lhs.as_double() == rhs.as_double());
case Value::Type::String:
return Value(lhs.as_string() == rhs.as_string());
case Value::Type::Boolean:
return Value(lhs.as_bool() == rhs.as_bool());
case Value::Type::Object:
return Value(lhs.as_object() == rhs.as_object());
}
ASSERT_NOT_REACHED();
}
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
Value greater(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value(lhs.as_double() > rhs.as_double());
}
Value smaller(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value(lhs.as_double() < rhs.as_double());
}
Value bit_and(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value((i32)lhs.as_double() & (i32)rhs.as_double());
}
Value bit_or(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value((i32)lhs.as_double() | (i32)rhs.as_double());
}
Value bit_xor(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value((i32)lhs.as_double() ^ (i32)rhs.as_double());
}
Value bit_not(Value lhs)
{
ASSERT(lhs.is_number());
return Value(~(i32)lhs.as_double());
}
Value bit_left(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value((i32)lhs.as_double() << (i32)rhs.as_double());
}
Value bit_right(Value lhs, Value rhs)
{
ASSERT(lhs.is_number());
ASSERT(rhs.is_number());
return Value((i32)lhs.as_double() >> (i32)rhs.as_double());
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
Value BinaryExpression::execute(Interpreter& interpreter) const
{
auto lhs_result = m_lhs->execute(interpreter);
auto rhs_result = m_rhs->execute(interpreter);
switch (m_op) {
case BinaryOp::Plus:
return add(lhs_result, rhs_result);
case BinaryOp::Minus:
return sub(lhs_result, rhs_result);
LibJS: Add typed comparison operator The `===` operator allows us to compare two values while taking their type into consideration.
2020-03-08 07:53:02 +02:00
case BinaryOp::TypedEquals:
return typed_eq(lhs_result, rhs_result);
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
case BinaryOp::TypedInequals:
LibJS: Use Value::to_boolean() wherever we haven't checked is_boolean() Unless we've verified that a Value is a boolean, we should not be calling as_bool() on it.
2020-03-10 11:08:37 +01:00
return Value(!typed_eq(lhs_result, rhs_result).to_boolean());
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
case BinaryOp::Greater:
return greater(lhs_result, rhs_result);
case BinaryOp::Smaller:
return smaller(lhs_result, rhs_result);
case BinaryOp::BitAnd:
return bit_and(lhs_result, rhs_result);
case BinaryOp::BitOr:
return bit_or(lhs_result, rhs_result);
case BinaryOp::BitXor:
return bit_xor(lhs_result, rhs_result);
case BinaryOp::BitLeftShift:
return bit_left(lhs_result, rhs_result);
case BinaryOp::BitRightShift:
return bit_right(lhs_result, rhs_result);
LibJS: Add typed comparison operator The `===` operator allows us to compare two values while taking their type into consideration.
2020-03-08 07:53:02 +02:00
}
ASSERT_NOT_REACHED();
}
LibJS: Implement logical expressions Logical expressions are expressions which can return either true or false according to a provided condition.
2020-03-08 07:55:44 +02:00
Value LogicalExpression::execute(Interpreter& interpreter) const
{
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 08:46:20 +01:00
auto lhs_result = m_lhs->execute(interpreter).to_boolean();
auto rhs_result = m_rhs->execute(interpreter).to_boolean();
LibJS: Implement logical expressions Logical expressions are expressions which can return either true or false according to a provided condition.
2020-03-08 07:55:44 +02:00
switch (m_op) {
case LogicalOp::And:
return Value(lhs_result && rhs_result);
case LogicalOp::Or:
return Value(lhs_result || rhs_result);
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
ASSERT_NOT_REACHED();
}
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
Value UnaryExpression::execute(Interpreter& interpreter) const
{
auto lhs_result = m_lhs->execute(interpreter);
switch (m_op) {
case UnaryOp::BitNot:
return bit_not(lhs_result);
LibJS: Move logical not operator to new unary expression class
2020-03-09 19:04:44 +02:00
case UnaryOp::Not:
LibJS: Use Value::to_boolean() wherever we haven't checked is_boolean() Unless we've verified that a Value is a boolean, we should not be calling as_bool() on it.
2020-03-10 11:08:37 +01:00
return Value(!lhs_result.to_boolean());
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
}
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 19:42:11 +01:00
static void print_indent(int indent)
{
for (int i = 0; i < indent * 2; ++i)
putchar(' ');
}
void ASTNode::dump(int indent) const
{
print_indent(indent);
printf("%s\n", class_name());
}
void ScopeNode::dump(int indent) const
{
ASTNode::dump(indent);
for (auto& child : children())
child.dump(indent + 1);
}
void BinaryExpression::dump(int indent) const
{
LibJS: Include the operator in BinaryExpression dumps
2020-03-07 23:16:34 +01:00
const char* op_string = nullptr;
switch (m_op) {
case BinaryOp::Plus:
op_string = "+";
break;
case BinaryOp::Minus:
op_string = "-";
break;
LibJS: Add typed comparison operator The `===` operator allows us to compare two values while taking their type into consideration.
2020-03-08 07:53:02 +02:00
case BinaryOp::TypedEquals:
op_string = "===";
break;
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
case BinaryOp::TypedInequals:
op_string = "!==";
break;
case BinaryOp::Greater:
op_string = ">";
break;
case BinaryOp::Smaller:
op_string = "<";
break;
case BinaryOp::BitAnd:
op_string = "&";
break;
case BinaryOp::BitOr:
op_string = "|";
break;
case BinaryOp::BitXor:
op_string = "^";
break;
case BinaryOp::BitLeftShift:
op_string = "<<";
break;
case BinaryOp::BitRightShift:
op_string = ">>";
break;
LibJS: Add typed comparison operator The `===` operator allows us to compare two values while taking their type into consideration.
2020-03-08 07:53:02 +02:00
}
print_indent(indent);
printf("%s\n", class_name());
m_lhs->dump(indent + 1);
print_indent(indent + 1);
printf("%s\n", op_string);
m_rhs->dump(indent + 1);
}
LibJS: Implement logical expressions Logical expressions are expressions which can return either true or false according to a provided condition.
2020-03-08 07:55:44 +02:00
void LogicalExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case LogicalOp::And:
op_string = "&&";
break;
case LogicalOp::Or:
op_string = "||";
break;
LibJS: Include the operator in BinaryExpression dumps
2020-03-07 23:16:34 +01:00
}
print_indent(indent);
printf("%s\n", class_name());
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
m_lhs->dump(indent + 1);
LibJS: Include the operator in BinaryExpression dumps
2020-03-07 23:16:34 +01:00
print_indent(indent + 1);
printf("%s\n", op_string);
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
m_rhs->dump(indent + 1);
}
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
void UnaryExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case UnaryOp::BitNot:
op_string = "~";
break;
LibJS: Move logical not operator to new unary expression class
2020-03-09 19:04:44 +02:00
case UnaryOp::Not:
op_string = "!";
break;
LibJS: Add new bitwise and relational operators Do note that when it comes to evaluating binary expressions, we are asserting in multiple contexts that the values we're operating on are numbers, we should probably handle other value types to be more tolerant in the future, since for example, adding a number and a string, in which case the number is converted to a string implicitly which is then concatenated, although ugly, is valid javascript.
2020-03-08 23:27:18 +02:00
}
print_indent(indent);
printf("%s\n", class_name());
print_indent(indent + 1);
printf("%s\n", op_string);
m_lhs->dump(indent + 1);
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
void CallExpression::dump(int indent) const
{
print_indent(indent);
printf("%s '%s'\n", class_name(), name().characters());
}
void Literal::dump(int indent) const
{
print_indent(indent);
LibJS: Allow the dumping of literals that aren't numbers
2020-03-08 08:00:22 +02:00
if (m_value.is_object())
ASSERT_NOT_REACHED();
if (m_value.is_string())
printf("%s\n", m_value.as_string()->characters());
else
printf("%s\n", m_value.to_string().characters());
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
void FunctionDeclaration::dump(int indent) const
{
print_indent(indent);
printf("%s '%s'\n", class_name(), name().characters());
body().dump(indent + 1);
}
void ReturnStatement::dump(int indent) const
{
ASTNode::dump(indent);
argument().dump(indent + 1);
}
LibJS: Implement if statements If statements execute a certain action or an alternative one depending on whether the tested condition is true or false, this commit helps establish basic control flow capabilities in the AST.
2020-03-08 07:58:58 +02:00
void IfStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
printf("If\n");
predicate().dump(indent + 1);
consequent().dump(indent + 1);
print_indent(indent);
printf("Else\n");
alternate().dump(indent + 1);
}
LibJS: Implement While statements
2020-03-09 03:22:21 +08:00
void WhileStatement::dump(int indent) const
{
ASTNode::dump(indent);
print_indent(indent);
printf("While\n");
predicate().dump(indent + 1);
body().dump(indent + 1);
}
LibJS: Add basic support for (scoped) variables It's now possible to assign expressions to variables. The variables are put into the current scope of the interpreter. Variable lookup follows the scope chain, ending in the global object.
2020-03-09 21:13:55 +01:00
Value Identifier::execute(Interpreter& interpreter) const
{
return interpreter.get_variable(string());
}
void Identifier::dump(int indent) const
{
print_indent(indent);
printf("Identifier \"%s\"\n", m_string.characters());
}
Value AssignmentExpression::execute(Interpreter& interpreter) const
{
ASSERT(m_lhs->is_identifier());
auto name = static_cast<const Identifier&>(*m_lhs).string();
auto rhs_result = m_rhs->execute(interpreter);
switch (m_op) {
case AssignmentOp::Assign:
interpreter.set_variable(name, rhs_result);
break;
}
return rhs_result;
}
void AssignmentExpression::dump(int indent) const
{
const char* op_string = nullptr;
switch (m_op) {
case AssignmentOp::Assign:
op_string = "=";
break;
}
ASTNode::dump(indent);
print_indent(indent + 1);
printf("%s\n", op_string);
m_lhs->dump(indent + 1);
m_rhs->dump(indent + 1);
}
Value VariableDeclaration::execute(Interpreter& interpreter) const
{
interpreter.declare_variable(name().string());
if (m_initializer) {
auto initalizer_result = m_initializer->execute(interpreter);
interpreter.set_variable(name().string(), initalizer_result);
}
return js_undefined();
}
void VariableDeclaration::dump(int indent) const
{
ASTNode::dump(indent);
m_name->dump(indent + 1);
if (m_initializer)
m_initializer->dump(indent + 1);
}
LibJS: Add a very simple ObjectExpression for "var x = {}" This allows us to allocate an empty new Object on the GC heap.
2020-03-09 21:28:31 +01:00
void ObjectExpression::dump(int indent) const
{
ASTNode::dump(indent);
}
Value ObjectExpression::execute(Interpreter& interpreter) const
{
return Value(interpreter.heap().allocate<Object>());
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
}
Reference in a new issue Copy permalink