mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-11-30 03:20:28 +00:00
98a9a1d7f9
We already do this in most places, so the style should be consistent. Also, Clang does not like it, as this could cause an unexpected compile error if some statements are added to the default label or a new label is added above it.
1126 lines
40 KiB
C++
1126 lines
40 KiB
C++
/*
|
|
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2020-2021, Linus Groh <linusg@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/Assertions.h>
|
|
#include <AK/ByteBuffer.h>
|
|
#include <AK/Format.h>
|
|
#include <AK/NonnullOwnPtr.h>
|
|
#include <AK/StringBuilder.h>
|
|
#include <LibCore/ArgsParser.h>
|
|
#include <LibCore/File.h>
|
|
#include <LibCore/StandardPaths.h>
|
|
#include <LibJS/AST.h>
|
|
#include <LibJS/Bytecode/BasicBlock.h>
|
|
#include <LibJS/Bytecode/Generator.h>
|
|
#include <LibJS/Bytecode/Interpreter.h>
|
|
#include <LibJS/Bytecode/PassManager.h>
|
|
#include <LibJS/Console.h>
|
|
#include <LibJS/Interpreter.h>
|
|
#include <LibJS/Parser.h>
|
|
#include <LibJS/Runtime/Array.h>
|
|
#include <LibJS/Runtime/ArrayBuffer.h>
|
|
#include <LibJS/Runtime/BooleanObject.h>
|
|
#include <LibJS/Runtime/DataView.h>
|
|
#include <LibJS/Runtime/Date.h>
|
|
#include <LibJS/Runtime/Error.h>
|
|
#include <LibJS/Runtime/FunctionObject.h>
|
|
#include <LibJS/Runtime/GlobalObject.h>
|
|
#include <LibJS/Runtime/Map.h>
|
|
#include <LibJS/Runtime/NativeFunction.h>
|
|
#include <LibJS/Runtime/NumberObject.h>
|
|
#include <LibJS/Runtime/Object.h>
|
|
#include <LibJS/Runtime/OrdinaryFunctionObject.h>
|
|
#include <LibJS/Runtime/PrimitiveString.h>
|
|
#include <LibJS/Runtime/Promise.h>
|
|
#include <LibJS/Runtime/ProxyObject.h>
|
|
#include <LibJS/Runtime/RegExpObject.h>
|
|
#include <LibJS/Runtime/Set.h>
|
|
#include <LibJS/Runtime/Shape.h>
|
|
#include <LibJS/Runtime/StringObject.h>
|
|
#include <LibJS/Runtime/Temporal/Instant.h>
|
|
#include <LibJS/Runtime/Temporal/TimeZone.h>
|
|
#include <LibJS/Runtime/TypedArray.h>
|
|
#include <LibJS/Runtime/Value.h>
|
|
#include <LibLine/Editor.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
RefPtr<JS::VM> vm;
|
|
Vector<String> repl_statements;
|
|
|
|
class ReplObject final : public JS::GlobalObject {
|
|
JS_OBJECT(ReplObject, JS::GlobalObject);
|
|
|
|
public:
|
|
ReplObject() = default;
|
|
virtual void initialize_global_object() override;
|
|
virtual ~ReplObject() override = default;
|
|
|
|
private:
|
|
JS_DECLARE_NATIVE_FUNCTION(exit_interpreter);
|
|
JS_DECLARE_NATIVE_FUNCTION(repl_help);
|
|
JS_DECLARE_NATIVE_FUNCTION(load_file);
|
|
JS_DECLARE_NATIVE_FUNCTION(save_to_file);
|
|
};
|
|
|
|
class ScriptObject final : public JS::GlobalObject {
|
|
JS_OBJECT(ScriptObject, JS::GlobalObject);
|
|
|
|
public:
|
|
ScriptObject() = default;
|
|
virtual void initialize_global_object() override;
|
|
virtual ~ScriptObject() override = default;
|
|
|
|
private:
|
|
JS_DECLARE_NATIVE_FUNCTION(load_file);
|
|
};
|
|
|
|
static bool s_dump_ast = false;
|
|
static bool s_dump_bytecode = false;
|
|
static bool s_run_bytecode = false;
|
|
static bool s_opt_bytecode = false;
|
|
static bool s_print_last_result = false;
|
|
static RefPtr<Line::Editor> s_editor;
|
|
static String s_history_path = String::formatted("{}/.js-history", Core::StandardPaths::home_directory());
|
|
static int s_repl_line_level = 0;
|
|
static bool s_fail_repl = false;
|
|
|
|
static String prompt_for_level(int level)
|
|
{
|
|
static StringBuilder prompt_builder;
|
|
prompt_builder.clear();
|
|
prompt_builder.append("> ");
|
|
|
|
for (auto i = 0; i < level; ++i)
|
|
prompt_builder.append(" ");
|
|
|
|
return prompt_builder.build();
|
|
}
|
|
|
|
static String read_next_piece()
|
|
{
|
|
StringBuilder piece;
|
|
|
|
auto line_level_delta_for_next_line { 0 };
|
|
|
|
do {
|
|
auto line_result = s_editor->get_line(prompt_for_level(s_repl_line_level));
|
|
|
|
line_level_delta_for_next_line = 0;
|
|
|
|
if (line_result.is_error()) {
|
|
s_fail_repl = true;
|
|
return "";
|
|
}
|
|
|
|
auto& line = line_result.value();
|
|
s_editor->add_to_history(line);
|
|
|
|
piece.append(line);
|
|
piece.append('\n');
|
|
auto lexer = JS::Lexer(line);
|
|
|
|
enum {
|
|
NotInLabelOrObjectKey,
|
|
InLabelOrObjectKeyIdentifier,
|
|
InLabelOrObjectKey
|
|
} label_state { NotInLabelOrObjectKey };
|
|
|
|
for (JS::Token token = lexer.next(); token.type() != JS::TokenType::Eof; token = lexer.next()) {
|
|
switch (token.type()) {
|
|
case JS::TokenType::BracketOpen:
|
|
case JS::TokenType::CurlyOpen:
|
|
case JS::TokenType::ParenOpen:
|
|
label_state = NotInLabelOrObjectKey;
|
|
s_repl_line_level++;
|
|
break;
|
|
case JS::TokenType::BracketClose:
|
|
case JS::TokenType::CurlyClose:
|
|
case JS::TokenType::ParenClose:
|
|
label_state = NotInLabelOrObjectKey;
|
|
s_repl_line_level--;
|
|
break;
|
|
|
|
case JS::TokenType::Identifier:
|
|
case JS::TokenType::StringLiteral:
|
|
if (label_state == NotInLabelOrObjectKey)
|
|
label_state = InLabelOrObjectKeyIdentifier;
|
|
else
|
|
label_state = NotInLabelOrObjectKey;
|
|
break;
|
|
case JS::TokenType::Colon:
|
|
if (label_state == InLabelOrObjectKeyIdentifier)
|
|
label_state = InLabelOrObjectKey;
|
|
else
|
|
label_state = NotInLabelOrObjectKey;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (label_state == InLabelOrObjectKey) {
|
|
// If there's a label or object literal key at the end of this line,
|
|
// prompt for more lines but do not change the line level.
|
|
line_level_delta_for_next_line += 1;
|
|
}
|
|
} while (s_repl_line_level + line_level_delta_for_next_line > 0);
|
|
|
|
return piece.to_string();
|
|
}
|
|
|
|
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects);
|
|
|
|
static void print_type(FlyString const& name)
|
|
{
|
|
out("[\033[36;1m{}\033[0m]", name);
|
|
}
|
|
|
|
static void print_separator(bool& first)
|
|
{
|
|
out(first ? " " : ", ");
|
|
first = false;
|
|
}
|
|
|
|
static void print_array(JS::Array& array, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
out("[");
|
|
bool first = true;
|
|
for (auto it = array.indexed_properties().begin(false); it != array.indexed_properties().end(); ++it) {
|
|
print_separator(first);
|
|
auto value = array.get(it.index());
|
|
// The V8 repl doesn't throw an exception here, and instead just
|
|
// prints 'undefined'. We may choose to replicate that behavior in
|
|
// the future, but for now lets just catch the error
|
|
if (vm->exception())
|
|
return;
|
|
print_value(value, seen_objects);
|
|
}
|
|
if (!first)
|
|
out(" ");
|
|
out("]");
|
|
}
|
|
|
|
static void print_object(JS::Object& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
out("{{");
|
|
bool first = true;
|
|
for (auto& entry : object.indexed_properties()) {
|
|
print_separator(first);
|
|
out("\"\033[33;1m{}\033[0m\": ", entry.index());
|
|
auto value = object.get(entry.index());
|
|
// The V8 repl doesn't throw an exception here, and instead just
|
|
// prints 'undefined'. We may choose to replicate that behavior in
|
|
// the future, but for now lets just catch the error
|
|
if (vm->exception())
|
|
return;
|
|
print_value(value, seen_objects);
|
|
}
|
|
for (auto& it : object.shape().property_table_ordered()) {
|
|
print_separator(first);
|
|
if (it.key.is_string()) {
|
|
out("\"\033[33;1m{}\033[0m\": ", it.key.to_display_string());
|
|
} else {
|
|
out("[\033[33;1m{}\033[0m]: ", it.key.to_display_string());
|
|
}
|
|
print_value(object.get_direct(it.value.offset), seen_objects);
|
|
}
|
|
if (!first)
|
|
out(" ");
|
|
out("}}");
|
|
}
|
|
|
|
static void print_function(JS::Object const& object, HashTable<JS::Object*>&)
|
|
{
|
|
print_type(object.class_name());
|
|
if (is<JS::OrdinaryFunctionObject>(object))
|
|
out(" {}", static_cast<JS::OrdinaryFunctionObject const&>(object).name());
|
|
else if (is<JS::NativeFunction>(object))
|
|
out(" {}", static_cast<JS::NativeFunction const&>(object).name());
|
|
}
|
|
|
|
static void print_date(JS::Object const& object, HashTable<JS::Object*>&)
|
|
{
|
|
print_type("Date");
|
|
out(" \033[34;1m{}\033[0m", static_cast<JS::Date const&>(object).string());
|
|
}
|
|
|
|
static void print_error(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto name = object.get_without_side_effects(vm->names.name).value_or(JS::js_undefined());
|
|
auto message = object.get_without_side_effects(vm->names.message).value_or(JS::js_undefined());
|
|
if (name.is_accessor() || message.is_accessor()) {
|
|
print_value(&object, seen_objects);
|
|
} else {
|
|
auto name_string = name.to_string_without_side_effects();
|
|
auto message_string = message.to_string_without_side_effects();
|
|
print_type(name_string);
|
|
if (!message_string.is_empty())
|
|
out(" \033[31;1m{}\033[0m", message_string);
|
|
}
|
|
}
|
|
|
|
static void print_regexp_object(JS::Object const& object, HashTable<JS::Object*>&)
|
|
{
|
|
auto& regexp_object = static_cast<JS::RegExpObject const&>(object);
|
|
// Use RegExp.prototype.source rather than RegExpObject::pattern() so we get proper escaping
|
|
auto source = regexp_object.get("source").to_primitive_string(object.global_object())->string();
|
|
print_type("RegExp");
|
|
out(" \033[34;1m/{}/{}\033[0m", source, regexp_object.flags());
|
|
}
|
|
|
|
static void print_proxy_object(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& proxy_object = static_cast<JS::ProxyObject const&>(object);
|
|
print_type("Proxy");
|
|
out("\n target: ");
|
|
print_value(&proxy_object.target(), seen_objects);
|
|
out("\n handler: ");
|
|
print_value(&proxy_object.handler(), seen_objects);
|
|
}
|
|
|
|
static void print_map(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& map = static_cast<JS::Map const&>(object);
|
|
auto& entries = map.entries();
|
|
print_type("Map");
|
|
out(" {{");
|
|
bool first = true;
|
|
for (auto& entry : entries) {
|
|
print_separator(first);
|
|
print_value(entry.key, seen_objects);
|
|
out(" => ");
|
|
print_value(entry.value, seen_objects);
|
|
}
|
|
if (!first)
|
|
out(" ");
|
|
out("}}");
|
|
}
|
|
|
|
static void print_set(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& set = static_cast<JS::Set const&>(object);
|
|
auto& values = set.values();
|
|
print_type("Set");
|
|
out(" {{");
|
|
bool first = true;
|
|
for (auto& value : values) {
|
|
print_separator(first);
|
|
print_value(value, seen_objects);
|
|
}
|
|
if (!first)
|
|
out(" ");
|
|
out("}}");
|
|
}
|
|
|
|
static void print_promise(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& promise = static_cast<JS::Promise const&>(object);
|
|
print_type("Promise");
|
|
switch (promise.state()) {
|
|
case JS::Promise::State::Pending:
|
|
out("\n state: ");
|
|
out("\033[36;1mPending\033[0m");
|
|
break;
|
|
case JS::Promise::State::Fulfilled:
|
|
out("\n state: ");
|
|
out("\033[32;1mFulfilled\033[0m");
|
|
out("\n result: ");
|
|
print_value(promise.result(), seen_objects);
|
|
break;
|
|
case JS::Promise::State::Rejected:
|
|
out("\n state: ");
|
|
out("\033[31;1mRejected\033[0m");
|
|
out("\n result: ");
|
|
print_value(promise.result(), seen_objects);
|
|
break;
|
|
default:
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
}
|
|
|
|
static void print_array_buffer(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& array_buffer = static_cast<JS::ArrayBuffer const&>(object);
|
|
auto& buffer = array_buffer.buffer();
|
|
auto byte_length = array_buffer.byte_length();
|
|
print_type("ArrayBuffer");
|
|
out("\n byteLength: ");
|
|
print_value(JS::Value((double)byte_length), seen_objects);
|
|
if (!byte_length)
|
|
return;
|
|
outln();
|
|
for (size_t i = 0; i < byte_length; ++i) {
|
|
out("{:02x}", buffer[i]);
|
|
if (i + 1 < byte_length) {
|
|
if ((i + 1) % 32 == 0)
|
|
outln();
|
|
else if ((i + 1) % 16 == 0)
|
|
out(" ");
|
|
else
|
|
out(" ");
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
static void print_number(T number) requires IsArithmetic<T>
|
|
{
|
|
out("\033[35;1m");
|
|
out("{}", number);
|
|
out("\033[0m");
|
|
}
|
|
|
|
static void print_typed_array(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& typed_array_base = static_cast<JS::TypedArrayBase const&>(object);
|
|
auto& array_buffer = *typed_array_base.viewed_array_buffer();
|
|
auto length = typed_array_base.array_length();
|
|
print_type(object.class_name());
|
|
out("\n length: ");
|
|
print_value(JS::Value(length), seen_objects);
|
|
out("\n byteLength: ");
|
|
print_value(JS::Value(typed_array_base.byte_length()), seen_objects);
|
|
out("\n buffer: ");
|
|
print_type("ArrayBuffer");
|
|
if (array_buffer.is_detached())
|
|
out(" (detached)");
|
|
out(" @ {:p}", &array_buffer);
|
|
if (!length || array_buffer.is_detached())
|
|
return;
|
|
outln();
|
|
// FIXME: This kinda sucks.
|
|
#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType) \
|
|
if (is<JS::ClassName>(object)) { \
|
|
out("[ "); \
|
|
auto& typed_array = static_cast<JS::ClassName const&>(typed_array_base); \
|
|
auto data = typed_array.data(); \
|
|
for (size_t i = 0; i < length; ++i) { \
|
|
if (i > 0) \
|
|
out(", "); \
|
|
print_number(data[i]); \
|
|
} \
|
|
out(" ]"); \
|
|
return; \
|
|
}
|
|
JS_ENUMERATE_TYPED_ARRAYS
|
|
#undef __JS_ENUMERATE
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
|
|
static void print_data_view(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& data_view = static_cast<JS::DataView const&>(object);
|
|
print_type("DataView");
|
|
out("\n byteLength: ");
|
|
print_value(JS::Value(data_view.byte_length()), seen_objects);
|
|
out("\n byteOffset: ");
|
|
print_value(JS::Value(data_view.byte_offset()), seen_objects);
|
|
out("\n buffer: ");
|
|
print_type("ArrayBuffer");
|
|
out(" @ {:p}", data_view.viewed_array_buffer());
|
|
}
|
|
|
|
static void print_temporal_instant(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& instant = static_cast<JS::Temporal::Instant const&>(object);
|
|
print_type("Temporal.Instant");
|
|
// FIXME: Print human readable date and time, like in print_date() - ideally handling arbitrarily large values since we get a bigint.
|
|
out("\n nanoseconds: ");
|
|
print_value(&instant.nanoseconds(), seen_objects);
|
|
}
|
|
|
|
static void print_temporal_time_zone(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
auto& time_zone = static_cast<JS::Temporal::TimeZone const&>(object);
|
|
print_type("Temporal.TimeZone");
|
|
out("\n identifier: ");
|
|
print_value(JS::js_string(object.vm(), time_zone.identifier()), seen_objects);
|
|
if (time_zone.offset_nanoseconds().has_value()) {
|
|
out("\n offset (ns): ");
|
|
print_value(JS::Value(*time_zone.offset_nanoseconds()), seen_objects);
|
|
}
|
|
}
|
|
|
|
static void print_primitive_wrapper_object(FlyString const& name, JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
// BooleanObject, NumberObject, StringObject
|
|
print_type(name);
|
|
out(" ");
|
|
print_value(object.value_of(), seen_objects);
|
|
}
|
|
|
|
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects)
|
|
{
|
|
if (value.is_empty()) {
|
|
out("\033[34;1m<empty>\033[0m");
|
|
return;
|
|
}
|
|
|
|
if (value.is_object()) {
|
|
if (seen_objects.contains(&value.as_object())) {
|
|
// FIXME: Maybe we should only do this for circular references,
|
|
// not for all reoccurring objects.
|
|
out("<already printed Object {}>", &value.as_object());
|
|
return;
|
|
}
|
|
seen_objects.set(&value.as_object());
|
|
}
|
|
|
|
if (value.is_object()) {
|
|
auto& object = value.as_object();
|
|
if (is<JS::Array>(object))
|
|
return print_array(static_cast<JS::Array&>(object), seen_objects);
|
|
if (object.is_function())
|
|
return print_function(object, seen_objects);
|
|
if (is<JS::Date>(object))
|
|
return print_date(object, seen_objects);
|
|
if (is<JS::Error>(object))
|
|
return print_error(object, seen_objects);
|
|
if (is<JS::RegExpObject>(object))
|
|
return print_regexp_object(object, seen_objects);
|
|
if (is<JS::Map>(object))
|
|
return print_map(object, seen_objects);
|
|
if (is<JS::Set>(object))
|
|
return print_set(object, seen_objects);
|
|
if (is<JS::DataView>(object))
|
|
return print_data_view(object, seen_objects);
|
|
if (is<JS::ProxyObject>(object))
|
|
return print_proxy_object(object, seen_objects);
|
|
if (is<JS::Promise>(object))
|
|
return print_promise(object, seen_objects);
|
|
if (is<JS::ArrayBuffer>(object))
|
|
return print_array_buffer(object, seen_objects);
|
|
if (object.is_typed_array())
|
|
return print_typed_array(object, seen_objects);
|
|
if (is<JS::StringObject>(object))
|
|
return print_primitive_wrapper_object("String", object, seen_objects);
|
|
if (is<JS::NumberObject>(object))
|
|
return print_primitive_wrapper_object("Number", object, seen_objects);
|
|
if (is<JS::BooleanObject>(object))
|
|
return print_primitive_wrapper_object("Boolean", object, seen_objects);
|
|
if (is<JS::Temporal::Instant>(object))
|
|
return print_temporal_instant(object, seen_objects);
|
|
if (is<JS::Temporal::TimeZone>(object))
|
|
return print_temporal_time_zone(object, seen_objects);
|
|
return print_object(object, seen_objects);
|
|
}
|
|
|
|
if (value.is_string())
|
|
out("\033[32;1m");
|
|
else if (value.is_number() || value.is_bigint())
|
|
out("\033[35;1m");
|
|
else if (value.is_boolean())
|
|
out("\033[33;1m");
|
|
else if (value.is_null())
|
|
out("\033[33;1m");
|
|
else if (value.is_undefined())
|
|
out("\033[34;1m");
|
|
if (value.is_string())
|
|
out("\"");
|
|
else if (value.is_negative_zero())
|
|
out("-");
|
|
out("{}", value.to_string_without_side_effects());
|
|
if (value.is_string())
|
|
out("\"");
|
|
out("\033[0m");
|
|
}
|
|
|
|
static void print(JS::Value value)
|
|
{
|
|
HashTable<JS::Object*> seen_objects;
|
|
print_value(value, seen_objects);
|
|
outln();
|
|
}
|
|
|
|
static bool write_to_file(String const& path)
|
|
{
|
|
int fd = open(path.characters(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
|
for (size_t i = 0; i < repl_statements.size(); i++) {
|
|
auto line = repl_statements[i];
|
|
if (line.length() && i != repl_statements.size() - 1) {
|
|
ssize_t nwritten = write(fd, line.characters(), line.length());
|
|
if (nwritten < 0) {
|
|
close(fd);
|
|
return false;
|
|
}
|
|
}
|
|
if (i != repl_statements.size() - 1) {
|
|
char ch = '\n';
|
|
ssize_t nwritten = write(fd, &ch, 1);
|
|
if (nwritten != 1) {
|
|
perror("write");
|
|
close(fd);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
close(fd);
|
|
return true;
|
|
}
|
|
|
|
static bool parse_and_run(JS::Interpreter& interpreter, StringView const& source)
|
|
{
|
|
auto parser = JS::Parser(JS::Lexer(source));
|
|
auto program = parser.parse_program();
|
|
|
|
if (s_dump_ast)
|
|
program->dump(0);
|
|
|
|
if (parser.has_errors()) {
|
|
auto error = parser.errors()[0];
|
|
auto hint = error.source_location_hint(source);
|
|
if (!hint.is_empty())
|
|
outln("{}", hint);
|
|
vm->throw_exception<JS::SyntaxError>(interpreter.global_object(), error.to_string());
|
|
} else {
|
|
if (s_dump_bytecode || s_run_bytecode) {
|
|
auto unit = JS::Bytecode::Generator::generate(*program);
|
|
if (s_opt_bytecode) {
|
|
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
|
|
passes.perform(unit);
|
|
dbgln("Optimisation passes took {}us", passes.elapsed());
|
|
}
|
|
|
|
if (s_dump_bytecode) {
|
|
for (auto& block : unit.basic_blocks)
|
|
block.dump(unit);
|
|
if (!unit.string_table->is_empty()) {
|
|
outln();
|
|
unit.string_table->dump();
|
|
}
|
|
}
|
|
|
|
if (s_run_bytecode) {
|
|
JS::Bytecode::Interpreter bytecode_interpreter(interpreter.global_object());
|
|
bytecode_interpreter.run(unit);
|
|
} else {
|
|
return true;
|
|
}
|
|
} else {
|
|
interpreter.run(interpreter.global_object(), *program);
|
|
}
|
|
}
|
|
|
|
auto handle_exception = [&] {
|
|
auto* exception = vm->exception();
|
|
vm->clear_exception();
|
|
out("Uncaught exception: ");
|
|
print(exception->value());
|
|
auto& traceback = exception->traceback();
|
|
if (traceback.size() > 1) {
|
|
unsigned repetitions = 0;
|
|
for (size_t i = 0; i < traceback.size(); ++i) {
|
|
auto& traceback_frame = traceback[i];
|
|
if (i + 1 < traceback.size()) {
|
|
auto& next_traceback_frame = traceback[i + 1];
|
|
if (next_traceback_frame.function_name == traceback_frame.function_name) {
|
|
repetitions++;
|
|
continue;
|
|
}
|
|
}
|
|
if (repetitions > 4) {
|
|
// If more than 5 (1 + >4) consecutive function calls with the same name, print
|
|
// the name only once and show the number of repetitions instead. This prevents
|
|
// printing ridiculously large call stacks of recursive functions.
|
|
outln(" -> {}", traceback_frame.function_name);
|
|
outln(" {} more calls", repetitions);
|
|
} else {
|
|
for (size_t j = 0; j < repetitions + 1; ++j)
|
|
outln(" -> {}", traceback_frame.function_name);
|
|
}
|
|
repetitions = 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
if (vm->exception()) {
|
|
handle_exception();
|
|
return false;
|
|
}
|
|
if (s_print_last_result)
|
|
print(vm->last_value());
|
|
if (vm->exception()) {
|
|
handle_exception();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static JS::Value load_file_impl(JS::VM& vm, JS::GlobalObject& global_object)
|
|
{
|
|
auto filename = vm.argument(0).to_string(global_object);
|
|
if (vm.exception())
|
|
return {};
|
|
auto file = Core::File::construct(filename);
|
|
if (!file->open(Core::OpenMode::ReadOnly)) {
|
|
vm.throw_exception<JS::Error>(global_object, String::formatted("Failed to open '{}': {}", filename, file->error_string()));
|
|
return {};
|
|
}
|
|
auto file_contents = file->read_all();
|
|
auto source = StringView { file_contents };
|
|
auto parser = JS::Parser(JS::Lexer(source));
|
|
auto program = parser.parse_program();
|
|
if (parser.has_errors()) {
|
|
auto& error = parser.errors()[0];
|
|
vm.throw_exception<JS::SyntaxError>(global_object, error.to_string());
|
|
return {};
|
|
}
|
|
// FIXME: Use eval()-like semantics and execute in current scope?
|
|
vm.interpreter().run(global_object, *program);
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
void ReplObject::initialize_global_object()
|
|
{
|
|
Base::initialize_global_object();
|
|
define_direct_property("global", this, JS::Attribute::Enumerable);
|
|
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
|
|
define_native_function("exit", exit_interpreter, 0, attr);
|
|
define_native_function("help", repl_help, 0, attr);
|
|
define_native_function("load", load_file, 1, attr);
|
|
define_native_function("save", save_to_file, 1, attr);
|
|
}
|
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::save_to_file)
|
|
{
|
|
if (!vm.argument_count())
|
|
return JS::Value(false);
|
|
String save_path = vm.argument(0).to_string_without_side_effects();
|
|
StringView path = StringView(save_path.characters());
|
|
if (write_to_file(path)) {
|
|
return JS::Value(true);
|
|
}
|
|
return JS::Value(false);
|
|
}
|
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::exit_interpreter)
|
|
{
|
|
if (!vm.argument_count())
|
|
exit(0);
|
|
auto exit_code = vm.argument(0).to_number(global_object);
|
|
if (::vm->exception())
|
|
return {};
|
|
exit(exit_code.as_double());
|
|
}
|
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::repl_help)
|
|
{
|
|
outln("REPL commands:");
|
|
outln(" exit(code): exit the REPL with specified code. Defaults to 0.");
|
|
outln(" help(): display this menu");
|
|
outln(" load(file): load given JS file into running session. For example: load(\"foo.js\")");
|
|
outln(" save(file): write REPL input history to the given file. For example: save(\"foo.txt\")");
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::load_file)
|
|
{
|
|
return load_file_impl(vm, global_object);
|
|
}
|
|
|
|
void ScriptObject::initialize_global_object()
|
|
{
|
|
Base::initialize_global_object();
|
|
define_direct_property("global", this, JS::Attribute::Enumerable);
|
|
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
|
|
define_native_function("load", load_file, 1, attr);
|
|
}
|
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ScriptObject::load_file)
|
|
{
|
|
return load_file_impl(vm, global_object);
|
|
}
|
|
|
|
static void repl(JS::Interpreter& interpreter)
|
|
{
|
|
while (!s_fail_repl) {
|
|
String piece = read_next_piece();
|
|
if (piece.is_empty())
|
|
continue;
|
|
repl_statements.append(piece);
|
|
parse_and_run(interpreter, piece);
|
|
}
|
|
}
|
|
|
|
static Function<void()> interrupt_interpreter;
|
|
static void sigint_handler()
|
|
{
|
|
interrupt_interpreter();
|
|
}
|
|
|
|
class ReplConsoleClient final : public JS::ConsoleClient {
|
|
public:
|
|
ReplConsoleClient(JS::Console& console)
|
|
: ConsoleClient(console)
|
|
{
|
|
}
|
|
|
|
virtual JS::Value log() override
|
|
{
|
|
outln("{}", vm().join_arguments());
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value info() override
|
|
{
|
|
outln("(i) {}", vm().join_arguments());
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value debug() override
|
|
{
|
|
outln("\033[36;1m{}\033[0m", vm().join_arguments());
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value warn() override
|
|
{
|
|
outln("\033[33;1m{}\033[0m", vm().join_arguments());
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value error() override
|
|
{
|
|
outln("\033[31;1m{}\033[0m", vm().join_arguments());
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value clear() override
|
|
{
|
|
out("\033[3J\033[H\033[2J");
|
|
fflush(stdout);
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value trace() override
|
|
{
|
|
outln("{}", vm().join_arguments());
|
|
auto trace = get_trace();
|
|
for (auto& function_name : trace) {
|
|
if (function_name.is_empty())
|
|
function_name = "<anonymous>";
|
|
outln(" -> {}", function_name);
|
|
}
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value count() override
|
|
{
|
|
auto label = vm().argument_count() ? vm().argument(0).to_string_without_side_effects() : "default";
|
|
auto counter_value = m_console.counter_increment(label);
|
|
outln("{}: {}", label, counter_value);
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value count_reset() override
|
|
{
|
|
auto label = vm().argument_count() ? vm().argument(0).to_string_without_side_effects() : "default";
|
|
if (m_console.counter_reset(label))
|
|
outln("{}: 0", label);
|
|
else
|
|
outln("\033[33;1m\"{}\" doesn't have a count\033[0m", label);
|
|
return JS::js_undefined();
|
|
}
|
|
|
|
virtual JS::Value assert_() override
|
|
{
|
|
auto& vm = this->vm();
|
|
if (!vm.argument(0).to_boolean()) {
|
|
if (vm.argument_count() > 1) {
|
|
out("\033[31;1mAssertion failed:\033[0m");
|
|
outln(" {}", vm.join_arguments(1));
|
|
} else {
|
|
outln("\033[31;1mAssertion failed\033[0m");
|
|
}
|
|
}
|
|
return JS::js_undefined();
|
|
}
|
|
};
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
bool gc_on_every_allocation = false;
|
|
bool disable_syntax_highlight = false;
|
|
Vector<String> script_paths;
|
|
|
|
Core::ArgsParser args_parser;
|
|
args_parser.set_general_help("This is a JavaScript interpreter.");
|
|
args_parser.add_option(s_dump_ast, "Dump the AST", "dump-ast", 'A');
|
|
args_parser.add_option(s_dump_bytecode, "Dump the bytecode", "dump-bytecode", 'd');
|
|
args_parser.add_option(s_run_bytecode, "Run the bytecode", "run-bytecode", 'b');
|
|
args_parser.add_option(s_opt_bytecode, "Optimize the bytecode", "optimize-bytecode", 'p');
|
|
args_parser.add_option(s_print_last_result, "Print last result", "print-last-result", 'l');
|
|
args_parser.add_option(gc_on_every_allocation, "GC on every allocation", "gc-on-every-allocation", 'g');
|
|
args_parser.add_option(disable_syntax_highlight, "Disable live syntax highlighting", "no-syntax-highlight", 's');
|
|
args_parser.add_positional_argument(script_paths, "Path to script files", "scripts", Core::ArgsParser::Required::No);
|
|
args_parser.parse(argc, argv);
|
|
|
|
bool syntax_highlight = !disable_syntax_highlight;
|
|
|
|
vm = JS::VM::create();
|
|
// NOTE: These will print out both warnings when using something like Promise.reject().catch(...) -
|
|
// which is, as far as I can tell, correct - a promise is created, rejected without handler, and a
|
|
// handler then attached to it. The Node.js REPL doesn't warn in this case, so it's something we
|
|
// might want to revisit at a later point and disable warnings for promises created this way.
|
|
vm->on_promise_unhandled_rejection = [](auto& promise) {
|
|
// FIXME: Optionally make print_value() to print to stderr
|
|
out("WARNING: A promise was rejected without any handlers");
|
|
out(" (result: ");
|
|
HashTable<JS::Object*> seen_objects;
|
|
print_value(promise.result(), seen_objects);
|
|
outln(")");
|
|
};
|
|
vm->on_promise_rejection_handled = [](auto& promise) {
|
|
// FIXME: Optionally make print_value() to print to stderr
|
|
out("WARNING: A handler was added to an already rejected promise");
|
|
out(" (result: ");
|
|
HashTable<JS::Object*> seen_objects;
|
|
print_value(promise.result(), seen_objects);
|
|
outln(")");
|
|
};
|
|
OwnPtr<JS::Interpreter> interpreter;
|
|
|
|
interrupt_interpreter = [&] {
|
|
auto error = JS::Error::create(interpreter->global_object(), "Received SIGINT");
|
|
vm->throw_exception(interpreter->global_object(), error);
|
|
};
|
|
|
|
if (script_paths.is_empty()) {
|
|
s_print_last_result = true;
|
|
interpreter = JS::Interpreter::create<ReplObject>(*vm);
|
|
ReplConsoleClient console_client(interpreter->global_object().console());
|
|
interpreter->global_object().console().set_client(console_client);
|
|
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
|
|
interpreter->vm().set_underscore_is_last_value(true);
|
|
|
|
s_editor = Line::Editor::construct();
|
|
s_editor->load_history(s_history_path);
|
|
|
|
signal(SIGINT, [](int) {
|
|
if (!s_editor->is_editing())
|
|
sigint_handler();
|
|
s_editor->save_history(s_history_path);
|
|
});
|
|
|
|
s_editor->on_display_refresh = [syntax_highlight](Line::Editor& editor) {
|
|
auto stylize = [&](Line::Span span, Line::Style styles) {
|
|
if (syntax_highlight)
|
|
editor.stylize(span, styles);
|
|
};
|
|
editor.strip_styles();
|
|
|
|
size_t open_indents = s_repl_line_level;
|
|
|
|
auto line = editor.line();
|
|
JS::Lexer lexer(line);
|
|
bool indenters_starting_line = true;
|
|
for (JS::Token token = lexer.next(); token.type() != JS::TokenType::Eof; token = lexer.next()) {
|
|
auto length = token.value().length();
|
|
auto start = token.line_column() - 1;
|
|
auto end = start + length;
|
|
if (indenters_starting_line) {
|
|
if (token.type() != JS::TokenType::ParenClose && token.type() != JS::TokenType::BracketClose && token.type() != JS::TokenType::CurlyClose) {
|
|
indenters_starting_line = false;
|
|
} else {
|
|
--open_indents;
|
|
}
|
|
}
|
|
|
|
switch (token.category()) {
|
|
case JS::TokenCategory::Invalid:
|
|
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Red), Line::Style::Underline });
|
|
break;
|
|
case JS::TokenCategory::Number:
|
|
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Magenta) });
|
|
break;
|
|
case JS::TokenCategory::String:
|
|
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Green), Line::Style::Bold });
|
|
break;
|
|
case JS::TokenCategory::Punctuation:
|
|
break;
|
|
case JS::TokenCategory::Operator:
|
|
break;
|
|
case JS::TokenCategory::Keyword:
|
|
switch (token.type()) {
|
|
case JS::TokenType::BoolLiteral:
|
|
case JS::TokenType::NullLiteral:
|
|
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow), Line::Style::Bold });
|
|
break;
|
|
default:
|
|
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Bold });
|
|
break;
|
|
}
|
|
break;
|
|
case JS::TokenCategory::ControlKeyword:
|
|
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Cyan), Line::Style::Italic });
|
|
break;
|
|
case JS::TokenCategory::Identifier:
|
|
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::White), Line::Style::Bold });
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
editor.set_prompt(prompt_for_level(open_indents));
|
|
};
|
|
|
|
auto complete = [&interpreter](Line::Editor const& editor) -> Vector<Line::CompletionSuggestion> {
|
|
auto line = editor.line(editor.cursor());
|
|
|
|
JS::Lexer lexer { line };
|
|
enum {
|
|
Initial,
|
|
CompleteVariable,
|
|
CompleteNullProperty,
|
|
CompleteProperty,
|
|
} mode { Initial };
|
|
|
|
StringView variable_name;
|
|
StringView property_name;
|
|
|
|
// we're only going to complete either
|
|
// - <N>
|
|
// where N is part of the name of a variable
|
|
// - <N>.<P>
|
|
// where N is the complete name of a variable and
|
|
// P is part of the name of one of its properties
|
|
auto js_token = lexer.next();
|
|
for (; js_token.type() != JS::TokenType::Eof; js_token = lexer.next()) {
|
|
switch (mode) {
|
|
case CompleteVariable:
|
|
switch (js_token.type()) {
|
|
case JS::TokenType::Period:
|
|
// ...<name> <dot>
|
|
mode = CompleteNullProperty;
|
|
break;
|
|
default:
|
|
// not a dot, reset back to initial
|
|
mode = Initial;
|
|
break;
|
|
}
|
|
break;
|
|
case CompleteNullProperty:
|
|
if (js_token.is_identifier_name()) {
|
|
// ...<name> <dot> <name>
|
|
mode = CompleteProperty;
|
|
property_name = js_token.value();
|
|
} else {
|
|
mode = Initial;
|
|
}
|
|
break;
|
|
case CompleteProperty:
|
|
// something came after the property access, reset to initial
|
|
case Initial:
|
|
if (js_token.is_identifier_name()) {
|
|
// ...<name>...
|
|
mode = CompleteVariable;
|
|
variable_name = js_token.value();
|
|
} else {
|
|
mode = Initial;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool last_token_has_trivia = js_token.trivia().length() > 0;
|
|
|
|
if (mode == CompleteNullProperty) {
|
|
mode = CompleteProperty;
|
|
property_name = "";
|
|
last_token_has_trivia = false; // <name> <dot> [tab] is sensible to complete.
|
|
}
|
|
|
|
if (mode == Initial || last_token_has_trivia)
|
|
return {}; // we do not know how to complete this
|
|
|
|
Vector<Line::CompletionSuggestion> results;
|
|
|
|
Function<void(JS::Shape const&, StringView const&)> list_all_properties = [&results, &list_all_properties](JS::Shape const& shape, auto& property_pattern) {
|
|
for (auto const& descriptor : shape.property_table()) {
|
|
if (!descriptor.key.is_string())
|
|
continue;
|
|
auto key = descriptor.key.as_string();
|
|
if (key.view().starts_with(property_pattern)) {
|
|
Line::CompletionSuggestion completion { key, Line::CompletionSuggestion::ForSearch };
|
|
if (!results.contains_slow(completion)) { // hide duplicates
|
|
results.append(String(key));
|
|
}
|
|
}
|
|
}
|
|
if (auto const* prototype = shape.prototype()) {
|
|
list_all_properties(prototype->shape(), property_pattern);
|
|
}
|
|
};
|
|
|
|
switch (mode) {
|
|
case CompleteProperty: {
|
|
auto maybe_variable = vm->get_variable(variable_name, interpreter->global_object());
|
|
if (maybe_variable.is_empty()) {
|
|
maybe_variable = interpreter->global_object().get(FlyString(variable_name));
|
|
if (maybe_variable.is_empty())
|
|
break;
|
|
}
|
|
|
|
auto variable = maybe_variable;
|
|
if (!variable.is_object())
|
|
break;
|
|
|
|
auto const* object = variable.to_object(interpreter->global_object());
|
|
auto const& shape = object->shape();
|
|
list_all_properties(shape, property_name);
|
|
if (results.size())
|
|
editor.suggest(property_name.length());
|
|
break;
|
|
}
|
|
case CompleteVariable: {
|
|
auto const& variable = interpreter->global_object();
|
|
list_all_properties(variable.shape(), variable_name);
|
|
if (results.size())
|
|
editor.suggest(variable_name.length());
|
|
break;
|
|
}
|
|
default:
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
|
|
return results;
|
|
};
|
|
s_editor->on_tab_complete = move(complete);
|
|
repl(*interpreter);
|
|
s_editor->save_history(s_history_path);
|
|
} else {
|
|
interpreter = JS::Interpreter::create<ScriptObject>(*vm);
|
|
ReplConsoleClient console_client(interpreter->global_object().console());
|
|
interpreter->global_object().console().set_client(console_client);
|
|
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
|
|
|
|
signal(SIGINT, [](int) {
|
|
sigint_handler();
|
|
});
|
|
|
|
StringBuilder builder;
|
|
for (auto& path : script_paths) {
|
|
auto file = Core::File::construct(path);
|
|
if (!file->open(Core::OpenMode::ReadOnly)) {
|
|
warnln("Failed to open {}: {}", path, file->error_string());
|
|
return 1;
|
|
}
|
|
auto file_contents = file->read_all();
|
|
auto source = StringView { file_contents };
|
|
builder.append(source);
|
|
}
|
|
|
|
if (!parse_and_run(*interpreter, builder.to_string()))
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|