2020-03-07 18:42:11 +00:00
|
|
|
/*
|
2021-06-03 08:46:30 +00:00
|
|
|
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
|
2021-04-22 20:51:19 +00:00
|
|
|
* Copyright (c) 2020-2021, Linus Groh <linusg@serenityos.org>
|
2020-03-07 18:42:11 +00:00
|
|
|
*
|
2021-04-22 08:24:48 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2020-03-07 18:42:11 +00:00
|
|
|
*/
|
|
|
|
|
2021-05-15 10:34:40 +00:00
|
|
|
#include <AK/Assertions.h>
|
2020-03-12 09:51:41 +00:00
|
|
|
#include <AK/ByteBuffer.h>
|
2020-11-09 19:10:59 +00:00
|
|
|
#include <AK/Format.h>
|
2020-03-07 18:42:11 +00:00
|
|
|
#include <AK/NonnullOwnPtr.h>
|
2020-03-25 22:10:29 +00:00
|
|
|
#include <AK/StringBuilder.h>
|
2020-03-12 09:51:41 +00:00
|
|
|
#include <LibCore/ArgsParser.h>
|
|
|
|
#include <LibCore/File.h>
|
2020-10-25 23:36:06 +00:00
|
|
|
#include <LibCore/StandardPaths.h>
|
2020-03-07 18:42:11 +00:00
|
|
|
#include <LibJS/AST.h>
|
2021-06-09 02:19:58 +00:00
|
|
|
#include <LibJS/Bytecode/BasicBlock.h>
|
2021-06-03 08:46:30 +00:00
|
|
|
#include <LibJS/Bytecode/Generator.h>
|
|
|
|
#include <LibJS/Bytecode/Interpreter.h>
|
2021-06-13 16:10:20 +00:00
|
|
|
#include <LibJS/Bytecode/PassManager.h>
|
2020-05-04 14:09:05 +00:00
|
|
|
#include <LibJS/Console.h>
|
2020-03-07 18:42:11 +00:00
|
|
|
#include <LibJS/Interpreter.h>
|
2020-03-11 18:27:43 +00:00
|
|
|
#include <LibJS/Parser.h>
|
2020-03-26 11:26:11 +00:00
|
|
|
#include <LibJS/Runtime/Array.h>
|
2020-12-04 22:58:10 +00:00
|
|
|
#include <LibJS/Runtime/ArrayBuffer.h>
|
|
|
|
#include <LibJS/Runtime/BooleanObject.h>
|
2021-06-13 22:47:08 +00:00
|
|
|
#include <LibJS/Runtime/DataView.h>
|
2020-03-31 17:43:45 +00:00
|
|
|
#include <LibJS/Runtime/Date.h>
|
2021-09-24 20:40:38 +00:00
|
|
|
#include <LibJS/Runtime/ECMAScriptFunctionObject.h>
|
2020-04-02 07:54:15 +00:00
|
|
|
#include <LibJS/Runtime/Error.h>
|
2021-06-27 19:48:34 +00:00
|
|
|
#include <LibJS/Runtime/FunctionObject.h>
|
2020-04-01 16:53:28 +00:00
|
|
|
#include <LibJS/Runtime/GlobalObject.h>
|
2021-08-25 02:38:08 +00:00
|
|
|
#include <LibJS/Runtime/Intl/DisplayNames.h>
|
2021-09-06 12:44:54 +00:00
|
|
|
#include <LibJS/Runtime/Intl/ListFormat.h>
|
2021-09-02 12:32:55 +00:00
|
|
|
#include <LibJS/Runtime/Intl/Locale.h>
|
2021-09-10 11:30:45 +00:00
|
|
|
#include <LibJS/Runtime/Intl/NumberFormat.h>
|
2021-09-16 19:48:07 +00:00
|
|
|
#include <LibJS/Runtime/JSONObject.h>
|
2021-06-12 20:54:40 +00:00
|
|
|
#include <LibJS/Runtime/Map.h>
|
2020-12-04 22:58:10 +00:00
|
|
|
#include <LibJS/Runtime/NativeFunction.h>
|
|
|
|
#include <LibJS/Runtime/NumberObject.h>
|
2020-03-16 13:20:30 +00:00
|
|
|
#include <LibJS/Runtime/Object.h>
|
|
|
|
#include <LibJS/Runtime/PrimitiveString.h>
|
2021-04-01 20:14:05 +00:00
|
|
|
#include <LibJS/Runtime/Promise.h>
|
2020-12-04 22:58:10 +00:00
|
|
|
#include <LibJS/Runtime/ProxyObject.h>
|
2020-06-03 23:05:49 +00:00
|
|
|
#include <LibJS/Runtime/RegExpObject.h>
|
2021-06-08 21:08:47 +00:00
|
|
|
#include <LibJS/Runtime/Set.h>
|
2021-10-13 21:05:27 +00:00
|
|
|
#include <LibJS/Runtime/ShadowRealm.h>
|
2020-04-02 17:32:21 +00:00
|
|
|
#include <LibJS/Runtime/Shape.h>
|
2020-12-04 22:58:10 +00:00
|
|
|
#include <LibJS/Runtime/StringObject.h>
|
2021-07-14 20:59:49 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/Calendar.h>
|
2021-07-15 23:17:01 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/Duration.h>
|
2021-07-07 16:43:17 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/Instant.h>
|
2021-07-22 19:06:27 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/PlainDate.h>
|
2021-07-22 19:07:16 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/PlainDateTime.h>
|
2021-09-06 22:02:33 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/PlainMonthDay.h>
|
2021-07-28 18:29:45 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/PlainTime.h>
|
2021-09-06 21:57:25 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/PlainYearMonth.h>
|
2021-07-06 22:56:32 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/TimeZone.h>
|
2021-08-01 17:16:47 +00:00
|
|
|
#include <LibJS/Runtime/Temporal/ZonedDateTime.h>
|
2020-12-04 22:58:10 +00:00
|
|
|
#include <LibJS/Runtime/TypedArray.h>
|
2020-03-16 13:20:30 +00:00
|
|
|
#include <LibJS/Runtime/Value.h>
|
2020-03-31 11:34:57 +00:00
|
|
|
#include <LibLine/Editor.h>
|
2021-11-22 19:25:30 +00:00
|
|
|
#include <LibMain/Main.h>
|
2021-01-12 18:21:59 +00:00
|
|
|
#include <fcntl.h>
|
2020-04-11 09:09:10 +00:00
|
|
|
#include <signal.h>
|
2020-03-07 18:42:11 +00:00
|
|
|
#include <stdio.h>
|
2021-03-12 16:29:37 +00:00
|
|
|
#include <unistd.h>
|
2020-03-07 18:42:11 +00:00
|
|
|
|
2020-09-23 19:29:57 +00:00
|
|
|
RefPtr<JS::VM> vm;
|
2020-04-02 15:52:40 +00:00
|
|
|
Vector<String> repl_statements;
|
|
|
|
|
2021-03-17 15:52:26 +00:00
|
|
|
class ReplObject final : public JS::GlobalObject {
|
|
|
|
JS_OBJECT(ReplObject, JS::GlobalObject);
|
|
|
|
|
2020-04-01 19:20:32 +00:00
|
|
|
public:
|
2021-05-26 00:01:07 +00:00
|
|
|
ReplObject() = default;
|
2021-03-17 15:52:26 +00:00
|
|
|
virtual void initialize_global_object() override;
|
2021-05-26 00:01:07 +00:00
|
|
|
virtual ~ReplObject() override = default;
|
2020-04-01 19:20:32 +00:00
|
|
|
|
|
|
|
private:
|
2021-10-29 21:13:18 +00:00
|
|
|
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);
|
|
|
|
JS_DECLARE_NATIVE_FUNCTION(load_json);
|
2020-04-01 19:20:32 +00:00
|
|
|
};
|
|
|
|
|
2021-05-25 22:50:18 +00:00
|
|
|
class ScriptObject final : public JS::GlobalObject {
|
|
|
|
JS_OBJECT(ScriptObject, JS::GlobalObject);
|
|
|
|
|
|
|
|
public:
|
2021-05-26 00:01:07 +00:00
|
|
|
ScriptObject() = default;
|
2021-05-25 22:50:18 +00:00
|
|
|
virtual void initialize_global_object() override;
|
2021-05-26 00:01:07 +00:00
|
|
|
virtual ~ScriptObject() override = default;
|
2021-05-25 22:50:18 +00:00
|
|
|
|
|
|
|
private:
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DECLARE_NATIVE_FUNCTION(load_file);
|
|
|
|
JS_DECLARE_NATIVE_FUNCTION(load_json);
|
2021-05-25 22:50:18 +00:00
|
|
|
};
|
|
|
|
|
2020-04-26 14:19:30 +00:00
|
|
|
static bool s_dump_ast = false;
|
2021-06-03 08:46:30 +00:00
|
|
|
static bool s_run_bytecode = false;
|
2021-06-13 16:10:20 +00:00
|
|
|
static bool s_opt_bytecode = false;
|
2021-08-14 15:30:37 +00:00
|
|
|
static bool s_as_module = false;
|
2020-04-26 14:19:30 +00:00
|
|
|
static bool s_print_last_result = false;
|
2020-05-26 10:34:39 +00:00
|
|
|
static RefPtr<Line::Editor> s_editor;
|
2020-10-25 23:36:06 +00:00
|
|
|
static String s_history_path = String::formatted("{}/.js-history", Core::StandardPaths::home_directory());
|
2020-04-26 14:19:30 +00:00
|
|
|
static int s_repl_line_level = 0;
|
2020-05-25 12:27:07 +00:00
|
|
|
static bool s_fail_repl = false;
|
2020-04-09 03:30:45 +00:00
|
|
|
|
|
|
|
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();
|
|
|
|
}
|
2020-03-25 22:10:29 +00:00
|
|
|
|
2020-08-10 21:48:37 +00:00
|
|
|
static String read_next_piece()
|
2020-03-25 22:10:29 +00:00
|
|
|
{
|
|
|
|
StringBuilder piece;
|
|
|
|
|
2020-05-30 17:12:11 +00:00
|
|
|
auto line_level_delta_for_next_line { 0 };
|
|
|
|
|
2020-03-25 22:10:29 +00:00
|
|
|
do {
|
2020-05-25 12:27:07 +00:00
|
|
|
auto line_result = s_editor->get_line(prompt_for_level(s_repl_line_level));
|
|
|
|
|
2020-05-30 17:12:11 +00:00
|
|
|
line_level_delta_for_next_line = 0;
|
|
|
|
|
2020-05-25 12:27:07 +00:00
|
|
|
if (line_result.is_error()) {
|
|
|
|
s_fail_repl = true;
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
auto& line = line_result.value();
|
2020-04-26 14:19:30 +00:00
|
|
|
s_editor->add_to_history(line);
|
2020-03-25 22:10:29 +00:00
|
|
|
|
|
|
|
piece.append(line);
|
2021-06-20 20:58:57 +00:00
|
|
|
piece.append('\n');
|
2020-03-25 22:10:29 +00:00
|
|
|
auto lexer = JS::Lexer(line);
|
|
|
|
|
2020-05-30 17:12:11 +00:00
|
|
|
enum {
|
|
|
|
NotInLabelOrObjectKey,
|
|
|
|
InLabelOrObjectKeyIdentifier,
|
|
|
|
InLabelOrObjectKey
|
|
|
|
} label_state { NotInLabelOrObjectKey };
|
|
|
|
|
2020-03-25 22:10:29 +00:00
|
|
|
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:
|
2020-05-30 17:12:11 +00:00
|
|
|
label_state = NotInLabelOrObjectKey;
|
2020-04-26 14:19:30 +00:00
|
|
|
s_repl_line_level++;
|
2020-03-25 22:10:29 +00:00
|
|
|
break;
|
|
|
|
case JS::TokenType::BracketClose:
|
|
|
|
case JS::TokenType::CurlyClose:
|
|
|
|
case JS::TokenType::ParenClose:
|
2020-05-30 17:12:11 +00:00
|
|
|
label_state = NotInLabelOrObjectKey;
|
2020-04-26 14:19:30 +00:00
|
|
|
s_repl_line_level--;
|
2020-03-25 22:10:29 +00:00
|
|
|
break;
|
2020-05-30 17:12:11 +00:00
|
|
|
|
|
|
|
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;
|
2020-03-25 22:10:29 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2020-05-30 17:12:11 +00:00
|
|
|
|
|
|
|
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);
|
2020-03-25 22:10:29 +00:00
|
|
|
|
|
|
|
return piece.to_string();
|
|
|
|
}
|
|
|
|
|
2020-03-26 11:26:11 +00:00
|
|
|
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects);
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_type(FlyString const& name)
|
2020-12-04 22:58:10 +00:00
|
|
|
{
|
|
|
|
out("[\033[36;1m{}\033[0m]", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_separator(bool& first)
|
|
|
|
{
|
|
|
|
out(first ? " " : ", ");
|
|
|
|
first = false;
|
|
|
|
}
|
|
|
|
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
static void print_array(JS::Array& array, HashTable<JS::Object*>& seen_objects)
|
2020-03-26 11:26:11 +00:00
|
|
|
{
|
2020-12-04 22:58:10 +00:00
|
|
|
out("[");
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
bool first = true;
|
|
|
|
for (auto it = array.indexed_properties().begin(false); it != array.indexed_properties().end(); ++it) {
|
2020-12-04 22:58:10 +00:00
|
|
|
print_separator(first);
|
2021-10-02 22:52:27 +00:00
|
|
|
auto value_or_error = array.get(it.index());
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
// 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
|
2021-10-02 22:52:27 +00:00
|
|
|
if (value_or_error.is_error())
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
return;
|
2021-10-02 22:52:27 +00:00
|
|
|
auto value = value_or_error.release_value();
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
print_value(value, seen_objects);
|
2020-03-26 11:26:11 +00:00
|
|
|
}
|
2020-12-04 22:58:10 +00:00
|
|
|
if (!first)
|
|
|
|
out(" ");
|
|
|
|
out("]");
|
2020-03-26 11:26:11 +00:00
|
|
|
}
|
|
|
|
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
static void print_object(JS::Object& object, HashTable<JS::Object*>& seen_objects)
|
2020-03-26 11:26:11 +00:00
|
|
|
{
|
2020-12-04 22:58:10 +00:00
|
|
|
out("{{");
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
bool first = true;
|
|
|
|
for (auto& entry : object.indexed_properties()) {
|
2020-12-04 22:58:10 +00:00
|
|
|
print_separator(first);
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\"\033[33;1m{}\033[0m\": ", entry.index());
|
2021-10-02 22:52:27 +00:00
|
|
|
auto value_or_error = object.get(entry.index());
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
// 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
|
2021-10-02 22:52:27 +00:00
|
|
|
if (value_or_error.is_error())
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
return;
|
2021-10-02 22:52:27 +00:00
|
|
|
auto value = value_or_error.release_value();
|
LibJS: Object index properties have descriptors; Handle sparse indices
This patch adds an IndexedProperties object for storing indexed
properties within an Object. This accomplishes two goals: indexed
properties now have an associated descriptor, and objects now gracefully
handle sparse properties.
The IndexedProperties class is a wrapper around two other classes, one
for simple indexed properties storage, and one for general indexed
property storage. Simple indexed property storage is the common-case,
and is simply a vector of properties which all have attributes of
default_attributes (writable, enumerable, and configurable).
General indexed property storage is for a collection of indexed
properties where EITHER one or more properties have attributes other
than default_attributes OR there is a property with a large index (in
particular, large is '200' or higher).
Indexed properties are now treated relatively the same as storage within
the various Object methods. Additionally, there is a custom iterator
class for IndexedProperties which makes iteration easy. The iterator
skips empty values by default, but can be configured otherwise.
Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
|
|
|
print_value(value, seen_objects);
|
2020-04-06 14:53:02 +00:00
|
|
|
}
|
2020-04-29 02:19:31 +00:00
|
|
|
for (auto& it : object.shape().property_table_ordered()) {
|
2020-12-04 22:58:10 +00:00
|
|
|
print_separator(first);
|
2020-07-08 04:38:46 +00:00
|
|
|
if (it.key.is_string()) {
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\"\033[33;1m{}\033[0m\": ", it.key.to_display_string());
|
2020-07-08 04:38:46 +00:00
|
|
|
} else {
|
2020-12-04 22:58:10 +00:00
|
|
|
out("[\033[33;1m{}\033[0m]: ", it.key.to_display_string());
|
2020-07-08 04:38:46 +00:00
|
|
|
}
|
2020-04-02 17:32:21 +00:00
|
|
|
print_value(object.get_direct(it.value.offset), seen_objects);
|
2020-03-26 11:26:11 +00:00
|
|
|
}
|
2020-12-04 22:58:10 +00:00
|
|
|
if (!first)
|
|
|
|
out(" ");
|
|
|
|
out("}}");
|
2020-03-26 11:26:11 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_function(JS::Object const& object, HashTable<JS::Object*>&)
|
2020-03-26 13:54:43 +00:00
|
|
|
{
|
2020-12-04 22:58:10 +00:00
|
|
|
print_type(object.class_name());
|
2021-09-24 20:40:38 +00:00
|
|
|
if (is<JS::ECMAScriptFunctionObject>(object))
|
|
|
|
out(" {}", static_cast<JS::ECMAScriptFunctionObject const&>(object).name());
|
2021-01-01 16:46:39 +00:00
|
|
|
else if (is<JS::NativeFunction>(object))
|
2021-07-06 22:58:50 +00:00
|
|
|
out(" {}", static_cast<JS::NativeFunction const&>(object).name());
|
2020-03-26 13:54:43 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_date(JS::Object const& object, HashTable<JS::Object*>&)
|
2020-03-31 17:43:45 +00:00
|
|
|
{
|
2020-12-04 22:58:10 +00:00
|
|
|
print_type("Date");
|
2021-07-06 22:58:50 +00:00
|
|
|
out(" \033[34;1m{}\033[0m", static_cast<JS::Date const&>(object).string());
|
2020-03-31 17:43:45 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_error(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2020-04-02 07:54:15 +00:00
|
|
|
{
|
2021-04-11 22:08:28 +00:00
|
|
|
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());
|
2021-07-07 16:34:26 +00:00
|
|
|
if (name.is_accessor() || message.is_accessor()) {
|
2021-04-11 22:08:28 +00:00
|
|
|
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);
|
|
|
|
}
|
2020-12-04 22:58:10 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_regexp_object(JS::Object const& object, HashTable<JS::Object*>&)
|
2020-12-04 22:58:10 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& regexp_object = static_cast<JS::RegExpObject const&>(object);
|
2020-12-04 22:58:10 +00:00
|
|
|
print_type("RegExp");
|
2021-10-05 17:35:34 +00:00
|
|
|
out(" \033[34;1m/{}/{}\033[0m", regexp_object.escape_regexp_pattern(), regexp_object.flags());
|
2020-12-04 22:58:10 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_proxy_object(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2020-12-04 22:58:10 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& proxy_object = static_cast<JS::ProxyObject const&>(object);
|
2020-12-04 22:58:10 +00:00
|
|
|
print_type("Proxy");
|
|
|
|
out("\n target: ");
|
|
|
|
print_value(&proxy_object.target(), seen_objects);
|
|
|
|
out("\n handler: ");
|
|
|
|
print_value(&proxy_object.handler(), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_map(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-06-12 20:54:40 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& map = static_cast<JS::Map const&>(object);
|
2021-06-12 20:54:40 +00:00
|
|
|
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("}}");
|
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_set(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-06-08 21:08:47 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& set = static_cast<JS::Set const&>(object);
|
2021-06-08 21:08:47 +00:00
|
|
|
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("}}");
|
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_promise(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-04-01 20:14:05 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& promise = static_cast<JS::Promise const&>(object);
|
2021-04-01 20:14:05 +00:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_array_buffer(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2020-12-04 22:58:10 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& array_buffer = static_cast<JS::ArrayBuffer const&>(object);
|
2020-12-04 22:58:10 +00:00
|
|
|
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);
|
2021-05-21 18:20:43 +00:00
|
|
|
if (!byte_length)
|
|
|
|
return;
|
2020-12-04 22:58:10 +00:00
|
|
|
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(" ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-13 21:05:27 +00:00
|
|
|
static void print_shadow_realm(JS::Object const&, HashTable<JS::Object*>&)
|
|
|
|
{
|
|
|
|
// Not much we can show here that would be useful. Realm pointer address?!
|
|
|
|
print_type("ShadowRealm");
|
|
|
|
}
|
|
|
|
|
2021-06-17 00:00:12 +00:00
|
|
|
template<typename T>
|
|
|
|
static void print_number(T number) requires IsArithmetic<T>
|
|
|
|
{
|
|
|
|
out("\033[35;1m");
|
|
|
|
out("{}", number);
|
|
|
|
out("\033[0m");
|
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_typed_array(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2020-12-04 22:58:10 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& typed_array_base = static_cast<JS::TypedArrayBase const&>(object);
|
2021-07-04 16:36:10 +00:00
|
|
|
auto& array_buffer = *typed_array_base.viewed_array_buffer();
|
2020-12-04 22:58:10 +00:00
|
|
|
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");
|
2021-07-04 16:36:10 +00:00
|
|
|
if (array_buffer.is_detached())
|
|
|
|
out(" (detached)");
|
|
|
|
out(" @ {:p}", &array_buffer);
|
|
|
|
if (!length || array_buffer.is_detached())
|
2020-12-04 22:58:10 +00:00
|
|
|
return;
|
|
|
|
outln();
|
|
|
|
// FIXME: This kinda sucks.
|
|
|
|
#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType) \
|
2021-03-18 17:34:18 +00:00
|
|
|
if (is<JS::ClassName>(object)) { \
|
2020-12-04 22:58:10 +00:00
|
|
|
out("[ "); \
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& typed_array = static_cast<JS::ClassName const&>(typed_array_base); \
|
2020-12-04 22:58:10 +00:00
|
|
|
auto data = typed_array.data(); \
|
|
|
|
for (size_t i = 0; i < length; ++i) { \
|
|
|
|
if (i > 0) \
|
|
|
|
out(", "); \
|
2021-06-17 00:00:12 +00:00
|
|
|
print_number(data[i]); \
|
2020-12-04 22:58:10 +00:00
|
|
|
} \
|
|
|
|
out(" ]"); \
|
|
|
|
return; \
|
|
|
|
}
|
|
|
|
JS_ENUMERATE_TYPED_ARRAYS
|
|
|
|
#undef __JS_ENUMERATE
|
2021-02-23 19:42:32 +00:00
|
|
|
VERIFY_NOT_REACHED();
|
2020-04-02 07:54:15 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_data_view(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-06-13 22:47:08 +00:00
|
|
|
{
|
2021-07-06 22:58:50 +00:00
|
|
|
auto& data_view = static_cast<JS::DataView const&>(object);
|
2021-06-13 22:47:08 +00:00
|
|
|
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());
|
|
|
|
}
|
|
|
|
|
2021-07-14 20:59:49 +00:00
|
|
|
static void print_temporal_calendar(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
|
|
{
|
|
|
|
auto& calendar = static_cast<JS::Temporal::Calendar const&>(object);
|
|
|
|
print_type("Temporal.Calendar");
|
|
|
|
out(" ");
|
|
|
|
print_value(JS::js_string(object.vm(), calendar.identifier()), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-07-15 23:17:01 +00:00
|
|
|
static void print_temporal_duration(JS::Object const& object, HashTable<JS::Object*>&)
|
|
|
|
{
|
|
|
|
auto& duration = static_cast<JS::Temporal::Duration const&>(object);
|
|
|
|
print_type("Temporal.Duration");
|
|
|
|
out(" \033[34;1m{} y, {} M, {} w, {} d, {} h, {} m, {} s, {} ms, {} us, {} ns\033[0m", duration.years(), duration.months(), duration.weeks(), duration.days(), duration.hours(), duration.minutes(), duration.seconds(), duration.milliseconds(), duration.microseconds(), duration.nanoseconds());
|
|
|
|
}
|
|
|
|
|
2021-07-07 16:43:17 +00:00
|
|
|
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");
|
2021-07-14 20:59:17 +00:00
|
|
|
out(" ");
|
2021-07-07 16:43:17 +00:00
|
|
|
// FIXME: Print human readable date and time, like in print_date() - ideally handling arbitrarily large values since we get a bigint.
|
|
|
|
print_value(&instant.nanoseconds(), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-09-06 22:08:28 +00:00
|
|
|
static void print_temporal_plain_date(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-07-22 19:06:27 +00:00
|
|
|
{
|
|
|
|
auto& plain_date = static_cast<JS::Temporal::PlainDate const&>(object);
|
|
|
|
print_type("Temporal.PlainDate");
|
|
|
|
out(" \033[34;1m{:04}-{:02}-{:02}\033[0m", plain_date.iso_year(), plain_date.iso_month(), plain_date.iso_day());
|
2021-09-06 22:08:28 +00:00
|
|
|
out("\n calendar: ");
|
|
|
|
print_value(&plain_date.calendar(), seen_objects);
|
2021-07-22 19:06:27 +00:00
|
|
|
}
|
|
|
|
|
2021-09-06 22:08:28 +00:00
|
|
|
static void print_temporal_plain_date_time(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-07-22 19:07:16 +00:00
|
|
|
{
|
|
|
|
auto& plain_date_time = static_cast<JS::Temporal::PlainDateTime const&>(object);
|
|
|
|
print_type("Temporal.PlainDateTime");
|
|
|
|
out(" \033[34;1m{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}{:03}{:03}\033[0m", plain_date_time.iso_year(), plain_date_time.iso_month(), plain_date_time.iso_day(), plain_date_time.iso_hour(), plain_date_time.iso_minute(), plain_date_time.iso_second(), plain_date_time.iso_millisecond(), plain_date_time.iso_microsecond(), plain_date_time.iso_nanosecond());
|
2021-09-06 22:08:28 +00:00
|
|
|
out("\n calendar: ");
|
|
|
|
print_value(&plain_date_time.calendar(), seen_objects);
|
2021-07-22 19:07:16 +00:00
|
|
|
}
|
|
|
|
|
2021-09-06 22:08:28 +00:00
|
|
|
static void print_temporal_plain_month_day(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-09-06 22:02:33 +00:00
|
|
|
{
|
|
|
|
auto& plain_month_day = static_cast<JS::Temporal::PlainMonthDay const&>(object);
|
|
|
|
print_type("Temporal.PlainMonthDay");
|
|
|
|
// Also has an [[ISOYear]] internal slot, but showing that here seems rather unexpected.
|
|
|
|
out(" \033[34;1m{:02}-{:02}\033[0m", plain_month_day.iso_month(), plain_month_day.iso_day());
|
2021-09-06 22:08:28 +00:00
|
|
|
out("\n calendar: ");
|
|
|
|
print_value(&plain_month_day.calendar(), seen_objects);
|
2021-09-06 22:02:33 +00:00
|
|
|
}
|
|
|
|
|
2021-09-06 22:08:28 +00:00
|
|
|
static void print_temporal_plain_time(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-07-28 18:29:45 +00:00
|
|
|
{
|
|
|
|
auto& plain_time = static_cast<JS::Temporal::PlainTime const&>(object);
|
|
|
|
print_type("Temporal.PlainTime");
|
|
|
|
out(" \033[34;1m{:02}:{:02}:{:02}.{:03}{:03}{:03}\033[0m", plain_time.iso_hour(), plain_time.iso_minute(), plain_time.iso_second(), plain_time.iso_millisecond(), plain_time.iso_microsecond(), plain_time.iso_nanosecond());
|
2021-09-06 22:08:28 +00:00
|
|
|
out("\n calendar: ");
|
|
|
|
print_value(&plain_time.calendar(), seen_objects);
|
2021-07-28 18:29:45 +00:00
|
|
|
}
|
|
|
|
|
2021-09-06 22:08:28 +00:00
|
|
|
static void print_temporal_plain_year_month(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2021-09-06 21:57:25 +00:00
|
|
|
{
|
|
|
|
auto& plain_year_month = static_cast<JS::Temporal::PlainYearMonth const&>(object);
|
|
|
|
print_type("Temporal.PlainYearMonth");
|
|
|
|
// Also has an [[ISODay]] internal slot, but showing that here seems rather unexpected.
|
|
|
|
out(" \033[34;1m{:04}-{:02}\033[0m", plain_year_month.iso_year(), plain_year_month.iso_month());
|
2021-09-06 22:08:28 +00:00
|
|
|
out("\n calendar: ");
|
|
|
|
print_value(&plain_year_month.calendar(), seen_objects);
|
2021-09-06 21:57:25 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:56:32 +00:00
|
|
|
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");
|
2021-07-14 20:59:17 +00:00
|
|
|
out(" ");
|
2021-07-06 22:56:32 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-01 17:16:47 +00:00
|
|
|
static void print_temporal_zoned_date_time(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
|
|
{
|
|
|
|
auto& zoned_date_time = static_cast<JS::Temporal::ZonedDateTime const&>(object);
|
|
|
|
print_type("Temporal.ZonedDateTime");
|
|
|
|
out("\n epochNanoseconds: ");
|
|
|
|
print_value(&zoned_date_time.nanoseconds(), seen_objects);
|
|
|
|
out("\n timeZone: ");
|
|
|
|
print_value(&zoned_date_time.time_zone(), seen_objects);
|
|
|
|
out("\n calendar: ");
|
|
|
|
print_value(&zoned_date_time.calendar(), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-08-25 02:38:08 +00:00
|
|
|
static void print_intl_display_names(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
|
|
{
|
|
|
|
auto& display_names = static_cast<JS::Intl::DisplayNames const&>(object);
|
|
|
|
print_type("Intl.DisplayNames");
|
|
|
|
out("\n locale: ");
|
|
|
|
print_value(js_string(object.vm(), display_names.locale()), seen_objects);
|
|
|
|
out("\n type: ");
|
|
|
|
print_value(js_string(object.vm(), display_names.type_string()), seen_objects);
|
|
|
|
out("\n style: ");
|
|
|
|
print_value(js_string(object.vm(), display_names.style_string()), seen_objects);
|
|
|
|
out("\n fallback: ");
|
|
|
|
print_value(js_string(object.vm(), display_names.fallback_string()), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-09-02 12:32:55 +00:00
|
|
|
static void print_intl_locale(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
|
|
{
|
|
|
|
auto& locale = static_cast<JS::Intl::Locale const&>(object);
|
|
|
|
print_type("Intl.Locale");
|
|
|
|
out("\n locale: ");
|
|
|
|
print_value(js_string(object.vm(), locale.locale()), seen_objects);
|
|
|
|
if (locale.has_calendar()) {
|
|
|
|
out("\n calendar: ");
|
|
|
|
print_value(js_string(object.vm(), locale.calendar()), seen_objects);
|
|
|
|
}
|
|
|
|
if (locale.has_case_first()) {
|
|
|
|
out("\n caseFirst: ");
|
|
|
|
print_value(js_string(object.vm(), locale.case_first()), seen_objects);
|
|
|
|
}
|
|
|
|
if (locale.has_collation()) {
|
|
|
|
out("\n collation: ");
|
|
|
|
print_value(js_string(object.vm(), locale.collation()), seen_objects);
|
|
|
|
}
|
|
|
|
if (locale.has_hour_cycle()) {
|
|
|
|
out("\n hourCycle: ");
|
|
|
|
print_value(js_string(object.vm(), locale.hour_cycle()), seen_objects);
|
|
|
|
}
|
|
|
|
if (locale.has_numbering_system()) {
|
|
|
|
out("\n numberingSystem: ");
|
|
|
|
print_value(js_string(object.vm(), locale.numbering_system()), seen_objects);
|
|
|
|
}
|
|
|
|
out("\n numeric: ");
|
|
|
|
print_value(JS::Value(locale.numeric()), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-09-06 12:44:54 +00:00
|
|
|
static void print_intl_list_format(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
|
|
{
|
|
|
|
auto& list_format = static_cast<JS::Intl::ListFormat const&>(object);
|
|
|
|
print_type("Intl.ListFormat");
|
|
|
|
out("\n locale: ");
|
|
|
|
print_value(js_string(object.vm(), list_format.locale()), seen_objects);
|
|
|
|
out("\n type: ");
|
|
|
|
print_value(js_string(object.vm(), list_format.type_string()), seen_objects);
|
|
|
|
out("\n style: ");
|
|
|
|
print_value(js_string(object.vm(), list_format.style_string()), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-09-10 11:30:45 +00:00
|
|
|
static void print_intl_number_format(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
|
|
|
{
|
|
|
|
auto& number_format = static_cast<JS::Intl::NumberFormat const&>(object);
|
|
|
|
print_type("Intl.NumberFormat");
|
|
|
|
out("\n locale: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.locale()), seen_objects);
|
|
|
|
out("\n dataLocale: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.data_locale()), seen_objects);
|
|
|
|
out("\n numberingSystem: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.numbering_system()), seen_objects);
|
|
|
|
out("\n style: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.style_string()), seen_objects);
|
|
|
|
if (number_format.has_currency()) {
|
|
|
|
out("\n currency: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.currency()), seen_objects);
|
|
|
|
}
|
|
|
|
if (number_format.has_currency_display()) {
|
|
|
|
out("\n currencyDisplay: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.currency_display_string()), seen_objects);
|
|
|
|
}
|
|
|
|
if (number_format.has_currency_sign()) {
|
|
|
|
out("\n currencySign: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.currency_sign_string()), seen_objects);
|
|
|
|
}
|
|
|
|
if (number_format.has_unit()) {
|
|
|
|
out("\n unit: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.unit()), seen_objects);
|
|
|
|
}
|
|
|
|
if (number_format.has_unit_display()) {
|
|
|
|
out("\n unitDisplay: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.unit_display_string()), seen_objects);
|
|
|
|
}
|
|
|
|
out("\n minimumIntegerDigits: ");
|
|
|
|
print_value(JS::Value(number_format.min_integer_digits()), seen_objects);
|
|
|
|
if (number_format.has_min_fraction_digits()) {
|
|
|
|
out("\n minimumFractionDigits: ");
|
|
|
|
print_value(JS::Value(number_format.min_fraction_digits()), seen_objects);
|
|
|
|
}
|
|
|
|
if (number_format.has_max_fraction_digits()) {
|
|
|
|
out("\n maximumFractionDigits: ");
|
|
|
|
print_value(JS::Value(number_format.max_fraction_digits()), seen_objects);
|
|
|
|
}
|
|
|
|
if (number_format.has_min_significant_digits()) {
|
|
|
|
out("\n minimumSignificantDigits: ");
|
|
|
|
print_value(JS::Value(number_format.min_significant_digits()), seen_objects);
|
|
|
|
}
|
|
|
|
if (number_format.has_max_significant_digits()) {
|
|
|
|
out("\n maximumSignificantDigits: ");
|
|
|
|
print_value(JS::Value(number_format.max_significant_digits()), seen_objects);
|
|
|
|
}
|
|
|
|
out("\n useGrouping: ");
|
|
|
|
print_value(JS::Value(number_format.use_grouping()), seen_objects);
|
|
|
|
out("\n roundingType: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.rounding_type_string()), seen_objects);
|
|
|
|
out("\n notation: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.notation_string()), seen_objects);
|
|
|
|
if (number_format.has_compact_display()) {
|
|
|
|
out("\n compactDisplay: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.compact_display_string()), seen_objects);
|
|
|
|
}
|
|
|
|
out("\n signDisplay: ");
|
|
|
|
print_value(js_string(object.vm(), number_format.sign_display_string()), seen_objects);
|
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static void print_primitive_wrapper_object(FlyString const& name, JS::Object const& object, HashTable<JS::Object*>& seen_objects)
|
2020-06-03 23:05:49 +00:00
|
|
|
{
|
2020-12-04 22:58:10 +00:00
|
|
|
// BooleanObject, NumberObject, StringObject
|
|
|
|
print_type(name);
|
|
|
|
out(" ");
|
|
|
|
print_value(object.value_of(), seen_objects);
|
2020-06-03 23:05:49 +00:00
|
|
|
}
|
|
|
|
|
2020-08-10 21:48:37 +00:00
|
|
|
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects)
|
2020-03-26 11:26:11 +00:00
|
|
|
{
|
2020-04-08 16:38:09 +00:00
|
|
|
if (value.is_empty()) {
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\033[34;1m<empty>\033[0m");
|
2020-04-08 16:38:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-04-09 03:30:45 +00:00
|
|
|
|
2020-03-26 11:26:11 +00:00
|
|
|
if (value.is_object()) {
|
2020-04-01 20:18:47 +00:00
|
|
|
if (seen_objects.contains(&value.as_object())) {
|
2020-03-26 11:26:11 +00:00
|
|
|
// FIXME: Maybe we should only do this for circular references,
|
|
|
|
// not for all reoccurring objects.
|
2020-11-09 19:10:59 +00:00
|
|
|
out("<already printed Object {}>", &value.as_object());
|
2020-03-26 11:26:11 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-04-01 20:18:47 +00:00
|
|
|
seen_objects.set(&value.as_object());
|
2020-03-26 11:26:11 +00:00
|
|
|
}
|
|
|
|
|
2020-03-31 17:43:45 +00:00
|
|
|
if (value.is_object()) {
|
2020-04-01 20:18:47 +00:00
|
|
|
auto& object = value.as_object();
|
2021-07-05 17:58:51 +00:00
|
|
|
if (is<JS::Array>(object))
|
2021-06-08 20:53:36 +00:00
|
|
|
return print_array(static_cast<JS::Array&>(object), seen_objects);
|
2020-04-01 20:18:47 +00:00
|
|
|
if (object.is_function())
|
2020-03-31 17:43:45 +00:00
|
|
|
return print_function(object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::Date>(object))
|
2020-03-31 17:43:45 +00:00
|
|
|
return print_date(object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::Error>(object))
|
2020-04-02 07:54:15 +00:00
|
|
|
return print_error(object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::RegExpObject>(object))
|
2020-12-04 22:58:10 +00:00
|
|
|
return print_regexp_object(object, seen_objects);
|
2021-06-12 20:54:40 +00:00
|
|
|
if (is<JS::Map>(object))
|
|
|
|
return print_map(object, seen_objects);
|
2021-06-08 21:08:47 +00:00
|
|
|
if (is<JS::Set>(object))
|
|
|
|
return print_set(object, seen_objects);
|
2021-06-13 22:47:08 +00:00
|
|
|
if (is<JS::DataView>(object))
|
|
|
|
return print_data_view(object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::ProxyObject>(object))
|
2020-12-04 22:58:10 +00:00
|
|
|
return print_proxy_object(object, seen_objects);
|
2021-04-01 20:14:05 +00:00
|
|
|
if (is<JS::Promise>(object))
|
|
|
|
return print_promise(object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::ArrayBuffer>(object))
|
2020-12-04 22:58:10 +00:00
|
|
|
return print_array_buffer(object, seen_objects);
|
2021-10-13 21:05:27 +00:00
|
|
|
if (is<JS::ShadowRealm>(object))
|
|
|
|
return print_shadow_realm(object, seen_objects);
|
2020-12-04 22:58:10 +00:00
|
|
|
if (object.is_typed_array())
|
|
|
|
return print_typed_array(object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::StringObject>(object))
|
2020-12-04 22:58:10 +00:00
|
|
|
return print_primitive_wrapper_object("String", object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::NumberObject>(object))
|
2020-12-04 22:58:10 +00:00
|
|
|
return print_primitive_wrapper_object("Number", object, seen_objects);
|
2021-01-01 16:46:39 +00:00
|
|
|
if (is<JS::BooleanObject>(object))
|
2020-12-04 22:58:10 +00:00
|
|
|
return print_primitive_wrapper_object("Boolean", object, seen_objects);
|
2021-07-14 20:59:49 +00:00
|
|
|
if (is<JS::Temporal::Calendar>(object))
|
|
|
|
return print_temporal_calendar(object, seen_objects);
|
2021-07-15 23:17:01 +00:00
|
|
|
if (is<JS::Temporal::Duration>(object))
|
|
|
|
return print_temporal_duration(object, seen_objects);
|
2021-07-07 16:43:17 +00:00
|
|
|
if (is<JS::Temporal::Instant>(object))
|
|
|
|
return print_temporal_instant(object, seen_objects);
|
2021-07-22 19:06:27 +00:00
|
|
|
if (is<JS::Temporal::PlainDate>(object))
|
|
|
|
return print_temporal_plain_date(object, seen_objects);
|
2021-07-22 19:07:16 +00:00
|
|
|
if (is<JS::Temporal::PlainDateTime>(object))
|
|
|
|
return print_temporal_plain_date_time(object, seen_objects);
|
2021-09-06 22:02:33 +00:00
|
|
|
if (is<JS::Temporal::PlainMonthDay>(object))
|
|
|
|
return print_temporal_plain_month_day(object, seen_objects);
|
2021-07-28 18:29:45 +00:00
|
|
|
if (is<JS::Temporal::PlainTime>(object))
|
|
|
|
return print_temporal_plain_time(object, seen_objects);
|
2021-09-06 21:57:25 +00:00
|
|
|
if (is<JS::Temporal::PlainYearMonth>(object))
|
|
|
|
return print_temporal_plain_year_month(object, seen_objects);
|
2021-07-06 22:56:32 +00:00
|
|
|
if (is<JS::Temporal::TimeZone>(object))
|
|
|
|
return print_temporal_time_zone(object, seen_objects);
|
2021-08-01 17:16:47 +00:00
|
|
|
if (is<JS::Temporal::ZonedDateTime>(object))
|
|
|
|
return print_temporal_zoned_date_time(object, seen_objects);
|
2021-08-25 02:38:08 +00:00
|
|
|
if (is<JS::Intl::DisplayNames>(object))
|
|
|
|
return print_intl_display_names(object, seen_objects);
|
2021-09-02 12:32:55 +00:00
|
|
|
if (is<JS::Intl::Locale>(object))
|
|
|
|
return print_intl_locale(object, seen_objects);
|
2021-09-06 12:44:54 +00:00
|
|
|
if (is<JS::Intl::ListFormat>(object))
|
|
|
|
return print_intl_list_format(object, seen_objects);
|
2021-09-10 11:30:45 +00:00
|
|
|
if (is<JS::Intl::NumberFormat>(object))
|
|
|
|
return print_intl_number_format(object, seen_objects);
|
2020-03-31 17:43:45 +00:00
|
|
|
return print_object(object, seen_objects);
|
|
|
|
}
|
2020-03-26 11:26:11 +00:00
|
|
|
|
|
|
|
if (value.is_string())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\033[32;1m");
|
2020-06-06 00:14:10 +00:00
|
|
|
else if (value.is_number() || value.is_bigint())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\033[35;1m");
|
2020-03-26 11:26:11 +00:00
|
|
|
else if (value.is_boolean())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\033[33;1m");
|
2020-03-26 13:54:43 +00:00
|
|
|
else if (value.is_null())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\033[33;1m");
|
2020-03-26 13:54:43 +00:00
|
|
|
else if (value.is_undefined())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\033[34;1m");
|
2020-03-26 11:26:11 +00:00
|
|
|
if (value.is_string())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\"");
|
2020-10-12 16:03:07 +00:00
|
|
|
else if (value.is_negative_zero())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("-");
|
|
|
|
out("{}", value.to_string_without_side_effects());
|
2020-03-26 11:26:11 +00:00
|
|
|
if (value.is_string())
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\"");
|
|
|
|
out("\033[0m");
|
2020-03-26 11:26:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void print(JS::Value value)
|
|
|
|
{
|
|
|
|
HashTable<JS::Object*> seen_objects;
|
|
|
|
print_value(value, seen_objects);
|
2020-11-09 19:10:59 +00:00
|
|
|
outln();
|
2020-03-26 11:26:11 +00:00
|
|
|
}
|
|
|
|
|
2021-07-06 22:58:50 +00:00
|
|
|
static bool write_to_file(String const& path)
|
2020-04-02 15:52:40 +00:00
|
|
|
{
|
2021-01-12 18:21:59 +00:00
|
|
|
int fd = open(path.characters(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
2020-04-02 15:52:40 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2021-10-24 12:33:56 +00:00
|
|
|
static bool parse_and_run(JS::Interpreter& interpreter, StringView source, StringView source_name)
|
2020-05-14 15:29:24 +00:00
|
|
|
{
|
2021-08-14 15:30:37 +00:00
|
|
|
auto program_type = s_as_module ? JS::Program::Type::Module : JS::Program::Type::Script;
|
|
|
|
auto parser = JS::Parser(JS::Lexer(source), program_type);
|
2020-05-14 15:29:24 +00:00
|
|
|
auto program = parser.parse_program();
|
|
|
|
|
|
|
|
if (s_dump_ast)
|
|
|
|
program->dump(0);
|
|
|
|
|
|
|
|
if (parser.has_errors()) {
|
|
|
|
auto error = parser.errors()[0];
|
2020-05-26 12:00:36 +00:00
|
|
|
auto hint = error.source_location_hint(source);
|
|
|
|
if (!hint.is_empty())
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("{}", hint);
|
2020-09-27 13:18:55 +00:00
|
|
|
vm->throw_exception<JS::SyntaxError>(interpreter.global_object(), error.to_string());
|
2020-05-14 15:29:24 +00:00
|
|
|
} else {
|
2021-10-24 11:34:46 +00:00
|
|
|
if (JS::Bytecode::g_dump_bytecode || s_run_bytecode) {
|
|
|
|
auto executable = JS::Bytecode::Generator::generate(*program);
|
2021-10-24 12:33:56 +00:00
|
|
|
executable.name = source_name;
|
2021-06-13 16:10:20 +00:00
|
|
|
if (s_opt_bytecode) {
|
|
|
|
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
|
2021-10-24 11:34:46 +00:00
|
|
|
passes.perform(executable);
|
2021-06-13 16:10:20 +00:00
|
|
|
dbgln("Optimisation passes took {}us", passes.elapsed());
|
|
|
|
}
|
|
|
|
|
2021-10-24 11:34:46 +00:00
|
|
|
if (JS::Bytecode::g_dump_bytecode)
|
|
|
|
executable.dump();
|
2021-06-10 19:04:12 +00:00
|
|
|
|
|
|
|
if (s_run_bytecode) {
|
2021-09-11 18:36:25 +00:00
|
|
|
JS::Bytecode::Interpreter bytecode_interpreter(interpreter.global_object(), interpreter.realm());
|
2021-11-17 12:00:38 +00:00
|
|
|
auto result = bytecode_interpreter.run(executable);
|
|
|
|
// Since all the error handling code uses vm.exception() we just rethrow any exception we got here.
|
|
|
|
if (result.is_error())
|
|
|
|
vm->throw_exception(interpreter.global_object(), result.throw_completion().value());
|
2021-06-10 19:04:32 +00:00
|
|
|
} else {
|
|
|
|
return true;
|
2021-06-10 19:04:12 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
interpreter.run(interpreter.global_object(), *program);
|
|
|
|
}
|
2020-05-14 15:29:24 +00:00
|
|
|
}
|
|
|
|
|
2021-01-29 08:16:06 +00:00
|
|
|
auto handle_exception = [&] {
|
2021-04-11 22:08:28 +00:00
|
|
|
auto* exception = vm->exception();
|
|
|
|
vm->clear_exception();
|
2020-11-09 19:10:59 +00:00
|
|
|
out("Uncaught exception: ");
|
2021-04-11 22:08:28 +00:00
|
|
|
print(exception->value());
|
2021-04-24 16:15:02 +00:00
|
|
|
auto& traceback = exception->traceback();
|
|
|
|
if (traceback.size() > 1) {
|
2020-11-08 12:58:49 +00:00
|
|
|
unsigned repetitions = 0;
|
2021-04-24 16:15:02 +00:00
|
|
|
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;
|
|
|
|
}
|
2020-11-08 12:58:49 +00:00
|
|
|
}
|
|
|
|
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.
|
2021-04-24 16:15:02 +00:00
|
|
|
outln(" -> {}", traceback_frame.function_name);
|
2020-11-08 12:58:49 +00:00
|
|
|
outln(" {} more calls", repetitions);
|
|
|
|
} else {
|
|
|
|
for (size_t j = 0; j < repetitions + 1; ++j)
|
2021-04-24 16:15:02 +00:00
|
|
|
outln(" -> {}", traceback_frame.function_name);
|
2020-11-08 12:58:49 +00:00
|
|
|
}
|
|
|
|
repetitions = 0;
|
|
|
|
}
|
2020-06-02 13:12:04 +00:00
|
|
|
}
|
2021-01-29 08:16:06 +00:00
|
|
|
};
|
|
|
|
|
2021-03-18 17:35:58 +00:00
|
|
|
if (vm->exception()) {
|
|
|
|
handle_exception();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (s_print_last_result)
|
2020-09-27 13:18:55 +00:00
|
|
|
print(vm->last_value());
|
2021-03-18 17:35:58 +00:00
|
|
|
if (vm->exception()) {
|
|
|
|
handle_exception();
|
2021-04-11 22:08:28 +00:00
|
|
|
return false;
|
2021-01-29 08:16:06 +00:00
|
|
|
}
|
2020-05-14 15:29:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
static JS::ThrowCompletionOr<JS::Value> load_file_impl(JS::VM& vm, JS::GlobalObject& global_object)
|
2021-05-26 00:04:09 +00:00
|
|
|
{
|
2021-10-29 21:13:18 +00:00
|
|
|
auto filename = TRY(vm.argument(0).to_string(global_object));
|
2021-05-26 00:04:09 +00:00
|
|
|
auto file = Core::File::construct(filename);
|
2021-10-29 21:13:18 +00:00
|
|
|
if (!file->open(Core::OpenMode::ReadOnly))
|
|
|
|
return vm.throw_completion<JS::Error>(global_object, String::formatted("Failed to open '{}': {}", filename, file->error_string()));
|
2021-05-26 00:04:09 +00:00
|
|
|
auto file_contents = file->read_all();
|
2021-06-18 18:11:26 +00:00
|
|
|
auto source = StringView { file_contents };
|
2021-05-26 00:04:09 +00:00
|
|
|
auto parser = JS::Parser(JS::Lexer(source));
|
|
|
|
auto program = parser.parse_program();
|
|
|
|
if (parser.has_errors()) {
|
|
|
|
auto& error = parser.errors()[0];
|
2021-10-29 21:13:18 +00:00
|
|
|
return vm.throw_completion<JS::SyntaxError>(global_object, error.to_string());
|
2021-05-26 00:04:09 +00:00
|
|
|
}
|
|
|
|
// FIXME: Use eval()-like semantics and execute in current scope?
|
|
|
|
vm.interpreter().run(global_object, *program);
|
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
static JS::ThrowCompletionOr<JS::Value> load_json_impl(JS::VM& vm, JS::GlobalObject& global_object)
|
2021-09-16 19:48:07 +00:00
|
|
|
{
|
2021-10-29 21:13:18 +00:00
|
|
|
auto filename = TRY(vm.argument(0).to_string(global_object));
|
2021-09-16 19:48:07 +00:00
|
|
|
auto file = Core::File::construct(filename);
|
2021-10-29 21:13:18 +00:00
|
|
|
if (!file->open(Core::OpenMode::ReadOnly))
|
|
|
|
return vm.throw_completion<JS::Error>(global_object, String::formatted("Failed to open '{}': {}", filename, file->error_string()));
|
2021-09-16 19:48:07 +00:00
|
|
|
auto file_contents = file->read_all();
|
|
|
|
auto json = JsonValue::from_string(file_contents);
|
2021-11-15 00:46:51 +00:00
|
|
|
if (json.is_error())
|
2021-10-29 21:13:18 +00:00
|
|
|
return vm.throw_completion<JS::SyntaxError>(global_object, JS::ErrorType::JsonMalformed);
|
2021-09-16 19:48:07 +00:00
|
|
|
return JS::JSONObject::parse_json_value(global_object, json.value());
|
|
|
|
}
|
|
|
|
|
2021-03-17 15:52:26 +00:00
|
|
|
void ReplObject::initialize_global_object()
|
2020-04-18 11:18:06 +00:00
|
|
|
{
|
2021-03-17 15:52:26 +00:00
|
|
|
Base::initialize_global_object();
|
2021-07-05 23:15:08 +00:00
|
|
|
define_direct_property("global", this, JS::Attribute::Enumerable);
|
2021-07-05 22:12:54 +00:00
|
|
|
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
|
2021-10-29 21:13:18 +00:00
|
|
|
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);
|
|
|
|
define_native_function("loadJSON", load_json, 1, attr);
|
2020-04-01 19:20:32 +00:00
|
|
|
}
|
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::save_to_file)
|
2020-04-02 15:52:40 +00:00
|
|
|
{
|
2020-09-27 16:36:49 +00:00
|
|
|
if (!vm.argument_count())
|
2020-04-02 15:52:40 +00:00
|
|
|
return JS::Value(false);
|
2020-09-27 16:36:49 +00:00
|
|
|
String save_path = vm.argument(0).to_string_without_side_effects();
|
2020-04-02 15:52:40 +00:00
|
|
|
StringView path = StringView(save_path.characters());
|
|
|
|
if (write_to_file(path)) {
|
|
|
|
return JS::Value(true);
|
|
|
|
}
|
|
|
|
return JS::Value(false);
|
|
|
|
}
|
2020-04-13 13:04:24 +00:00
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::exit_interpreter)
|
2020-04-01 19:20:32 +00:00
|
|
|
{
|
2020-09-27 16:36:49 +00:00
|
|
|
if (!vm.argument_count())
|
2020-04-01 19:20:32 +00:00
|
|
|
exit(0);
|
2021-10-29 21:13:18 +00:00
|
|
|
exit(TRY(vm.argument(0).to_number(global_object)).as_double());
|
2020-04-01 19:20:32 +00:00
|
|
|
}
|
2020-04-13 13:04:24 +00:00
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::repl_help)
|
2020-04-01 19:20:32 +00:00
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("REPL commands:");
|
|
|
|
outln(" exit(code): exit the REPL with specified code. Defaults to 0.");
|
|
|
|
outln(" help(): display this menu");
|
2021-05-26 00:04:09 +00:00
|
|
|
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\")");
|
2020-04-13 20:08:54 +00:00
|
|
|
return JS::js_undefined();
|
2020-04-01 19:20:32 +00:00
|
|
|
}
|
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::load_file)
|
2020-04-01 19:20:32 +00:00
|
|
|
{
|
2021-05-26 00:04:09 +00:00
|
|
|
return load_file_impl(vm, global_object);
|
2020-04-01 19:20:32 +00:00
|
|
|
}
|
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ReplObject::load_json)
|
2021-09-16 19:48:07 +00:00
|
|
|
{
|
|
|
|
return load_json_impl(vm, global_object);
|
|
|
|
}
|
|
|
|
|
2021-05-25 22:50:18 +00:00
|
|
|
void ScriptObject::initialize_global_object()
|
|
|
|
{
|
|
|
|
Base::initialize_global_object();
|
2021-07-05 23:15:08 +00:00
|
|
|
define_direct_property("global", this, JS::Attribute::Enumerable);
|
2021-07-05 22:12:54 +00:00
|
|
|
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
|
2021-10-29 21:13:18 +00:00
|
|
|
define_native_function("load", load_file, 1, attr);
|
|
|
|
define_native_function("loadJSON", load_json, 1, attr);
|
2021-05-25 22:50:18 +00:00
|
|
|
}
|
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ScriptObject::load_file)
|
2021-05-25 22:50:18 +00:00
|
|
|
{
|
2021-05-26 00:04:09 +00:00
|
|
|
return load_file_impl(vm, global_object);
|
2021-05-25 22:50:18 +00:00
|
|
|
}
|
|
|
|
|
2021-10-29 21:13:18 +00:00
|
|
|
JS_DEFINE_NATIVE_FUNCTION(ScriptObject::load_json)
|
2021-09-16 19:48:07 +00:00
|
|
|
{
|
|
|
|
return load_json_impl(vm, global_object);
|
|
|
|
}
|
|
|
|
|
2020-08-10 21:48:37 +00:00
|
|
|
static void repl(JS::Interpreter& interpreter)
|
2020-03-25 22:10:29 +00:00
|
|
|
{
|
2020-05-25 12:27:07 +00:00
|
|
|
while (!s_fail_repl) {
|
2020-03-25 22:10:29 +00:00
|
|
|
String piece = read_next_piece();
|
|
|
|
if (piece.is_empty())
|
2020-03-31 11:29:42 +00:00
|
|
|
continue;
|
2020-04-02 15:52:40 +00:00
|
|
|
repl_statements.append(piece);
|
2021-10-24 12:33:56 +00:00
|
|
|
parse_and_run(interpreter, piece, "REPL");
|
2020-03-25 22:10:29 +00:00
|
|
|
}
|
|
|
|
}
|
2020-03-09 20:58:27 +00:00
|
|
|
|
2020-04-24 16:59:16 +00:00
|
|
|
static Function<void()> interrupt_interpreter;
|
2020-08-10 21:48:37 +00:00
|
|
|
static void sigint_handler()
|
2020-04-24 16:59:16 +00:00
|
|
|
{
|
|
|
|
interrupt_interpreter();
|
|
|
|
}
|
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
class ReplConsoleClient final : public JS::ConsoleClient {
|
|
|
|
public:
|
|
|
|
ReplConsoleClient(JS::Console& console)
|
|
|
|
: ConsoleClient(console)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual JS::Value log() override
|
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("{}", vm().join_arguments());
|
2020-05-04 14:09:05 +00:00
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value info() override
|
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("(i) {}", vm().join_arguments());
|
2020-05-04 14:09:05 +00:00
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value debug() override
|
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("\033[36;1m{}\033[0m", vm().join_arguments());
|
2020-05-04 14:09:05 +00:00
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value warn() override
|
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("\033[33;1m{}\033[0m", vm().join_arguments());
|
2020-05-04 14:09:05 +00:00
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value error() override
|
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("\033[31;1m{}\033[0m", vm().join_arguments());
|
2020-05-04 14:09:05 +00:00
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value clear() override
|
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
out("\033[3J\033[H\033[2J");
|
2020-05-04 14:09:05 +00:00
|
|
|
fflush(stdout);
|
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value trace() override
|
|
|
|
{
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("{}", vm().join_arguments());
|
2020-06-02 12:54:26 +00:00
|
|
|
auto trace = get_trace();
|
2020-05-05 09:48:57 +00:00
|
|
|
for (auto& function_name : trace) {
|
|
|
|
if (function_name.is_empty())
|
2020-05-04 14:09:05 +00:00
|
|
|
function_name = "<anonymous>";
|
2020-11-09 19:10:59 +00:00
|
|
|
outln(" -> {}", function_name);
|
2020-05-04 14:09:05 +00:00
|
|
|
}
|
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value count() override
|
|
|
|
{
|
2020-09-29 19:15:06 +00:00
|
|
|
auto label = vm().argument_count() ? vm().argument(0).to_string_without_side_effects() : "default";
|
2020-05-04 14:09:05 +00:00
|
|
|
auto counter_value = m_console.counter_increment(label);
|
2020-11-09 19:10:59 +00:00
|
|
|
outln("{}: {}", label, counter_value);
|
2020-05-04 14:09:05 +00:00
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
2020-05-04 14:09:05 +00:00
|
|
|
virtual JS::Value count_reset() override
|
|
|
|
{
|
2020-09-29 19:15:06 +00:00
|
|
|
auto label = vm().argument_count() ? vm().argument(0).to_string_without_side_effects() : "default";
|
2020-11-09 19:10:59 +00:00
|
|
|
if (m_console.counter_reset(label))
|
|
|
|
outln("{}: 0", label);
|
|
|
|
else
|
|
|
|
outln("\033[33;1m\"{}\" doesn't have a count\033[0m", label);
|
2020-05-04 14:09:05 +00:00
|
|
|
return JS::js_undefined();
|
|
|
|
}
|
2021-04-18 15:08:14 +00:00
|
|
|
|
|
|
|
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();
|
|
|
|
}
|
2020-05-04 14:09:05 +00:00
|
|
|
};
|
|
|
|
|
2021-11-22 19:25:30 +00:00
|
|
|
ErrorOr<int> serenity_main(Main::Arguments arguments)
|
2020-03-07 18:42:11 +00:00
|
|
|
{
|
2020-03-16 18:18:46 +00:00
|
|
|
bool gc_on_every_allocation = false;
|
2020-04-30 20:37:50 +00:00
|
|
|
bool disable_syntax_highlight = false;
|
2021-06-16 13:55:34 +00:00
|
|
|
Vector<String> script_paths;
|
2020-03-12 09:51:41 +00:00
|
|
|
|
|
|
|
Core::ArgsParser args_parser;
|
2020-12-05 15:22:58 +00:00
|
|
|
args_parser.set_general_help("This is a JavaScript interpreter.");
|
2020-04-26 14:19:30 +00:00
|
|
|
args_parser.add_option(s_dump_ast, "Dump the AST", "dump-ast", 'A');
|
2021-10-24 11:34:46 +00:00
|
|
|
args_parser.add_option(JS::Bytecode::g_dump_bytecode, "Dump the bytecode", "dump-bytecode", 'd');
|
2021-06-03 08:46:30 +00:00
|
|
|
args_parser.add_option(s_run_bytecode, "Run the bytecode", "run-bytecode", 'b');
|
2021-06-13 16:10:20 +00:00
|
|
|
args_parser.add_option(s_opt_bytecode, "Optimize the bytecode", "optimize-bytecode", 'p');
|
2021-08-14 15:30:37 +00:00
|
|
|
args_parser.add_option(s_as_module, "Treat as module", "as-module", 'm');
|
2020-04-26 14:19:30 +00:00
|
|
|
args_parser.add_option(s_print_last_result, "Print last result", "print-last-result", 'l');
|
2020-03-16 18:18:46 +00:00
|
|
|
args_parser.add_option(gc_on_every_allocation, "GC on every allocation", "gc-on-every-allocation", 'g');
|
2021-10-02 14:35:55 +00:00
|
|
|
#ifdef JS_TRACK_ZOMBIE_CELLS
|
|
|
|
bool zombify_dead_cells = false;
|
2021-09-11 14:44:40 +00:00
|
|
|
args_parser.add_option(zombify_dead_cells, "Zombify dead cells (to catch missing GC marks)", "zombify-dead-cells", 'z');
|
2021-10-02 14:35:55 +00:00
|
|
|
#endif
|
2020-04-30 20:37:50 +00:00
|
|
|
args_parser.add_option(disable_syntax_highlight, "Disable live syntax highlighting", "no-syntax-highlight", 's');
|
2021-06-16 13:55:34 +00:00
|
|
|
args_parser.add_positional_argument(script_paths, "Path to script files", "scripts", Core::ArgsParser::Required::No);
|
2021-11-22 19:25:30 +00:00
|
|
|
args_parser.parse(arguments.argc, arguments.argv);
|
2020-03-12 09:51:41 +00:00
|
|
|
|
2020-04-30 20:37:50 +00:00
|
|
|
bool syntax_highlight = !disable_syntax_highlight;
|
|
|
|
|
2020-09-23 19:29:57 +00:00
|
|
|
vm = JS::VM::create();
|
2021-04-01 20:14:12 +00:00
|
|
|
// 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(")");
|
|
|
|
};
|
2020-04-24 16:59:16 +00:00
|
|
|
OwnPtr<JS::Interpreter> interpreter;
|
|
|
|
|
|
|
|
interrupt_interpreter = [&] {
|
2021-04-11 22:08:28 +00:00
|
|
|
auto error = JS::Error::create(interpreter->global_object(), "Received SIGINT");
|
2020-09-27 13:18:55 +00:00
|
|
|
vm->throw_exception(interpreter->global_object(), error);
|
2020-04-24 16:59:16 +00:00
|
|
|
};
|
|
|
|
|
2021-06-16 13:55:34 +00:00
|
|
|
if (script_paths.is_empty()) {
|
2020-05-14 15:29:24 +00:00
|
|
|
s_print_last_result = true;
|
2020-09-20 17:24:44 +00:00
|
|
|
interpreter = JS::Interpreter::create<ReplObject>(*vm);
|
2020-09-29 19:15:06 +00:00
|
|
|
ReplConsoleClient console_client(interpreter->global_object().console());
|
|
|
|
interpreter->global_object().console().set_client(console_client);
|
2020-04-01 19:20:32 +00:00
|
|
|
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
|
2021-10-02 14:35:55 +00:00
|
|
|
#ifdef JS_TRACK_ZOMBIE_CELLS
|
2021-09-11 14:44:40 +00:00
|
|
|
interpreter->heap().set_zombify_dead_cells(zombify_dead_cells);
|
2021-10-02 14:35:55 +00:00
|
|
|
#endif
|
2020-09-27 13:18:55 +00:00
|
|
|
interpreter->vm().set_underscore_is_last_value(true);
|
2020-04-01 19:20:32 +00:00
|
|
|
|
2021-10-03 11:17:33 +00:00
|
|
|
auto& global_environment = interpreter->realm().global_environment();
|
|
|
|
|
2020-05-26 10:34:39 +00:00
|
|
|
s_editor = Line::Editor::construct();
|
2020-10-25 23:36:06 +00:00
|
|
|
s_editor->load_history(s_history_path);
|
2020-04-11 09:09:10 +00:00
|
|
|
|
|
|
|
signal(SIGINT, [](int) {
|
2020-04-28 20:01:22 +00:00
|
|
|
if (!s_editor->is_editing())
|
|
|
|
sigint_handler();
|
2020-10-25 23:36:06 +00:00
|
|
|
s_editor->save_history(s_history_path);
|
2020-04-11 09:09:10 +00:00
|
|
|
});
|
|
|
|
|
2020-04-26 14:19:30 +00:00
|
|
|
s_editor->on_display_refresh = [syntax_highlight](Line::Editor& editor) {
|
2020-04-09 03:30:45 +00:00
|
|
|
auto stylize = [&](Line::Span span, Line::Style styles) {
|
|
|
|
if (syntax_highlight)
|
|
|
|
editor.stylize(span, styles);
|
|
|
|
};
|
|
|
|
editor.strip_styles();
|
|
|
|
|
2020-04-26 14:19:30 +00:00
|
|
|
size_t open_indents = s_repl_line_level;
|
2020-04-09 03:30:45 +00:00
|
|
|
|
2020-05-26 17:00:30 +00:00
|
|
|
auto line = editor.line();
|
|
|
|
JS::Lexer lexer(line);
|
2020-04-09 03:30:45 +00:00
|
|
|
bool indenters_starting_line = true;
|
|
|
|
for (JS::Token token = lexer.next(); token.type() != JS::TokenType::Eof; token = lexer.next()) {
|
2021-09-01 16:13:53 +00:00
|
|
|
auto length = Utf8View { token.value() }.length();
|
2020-05-26 17:00:30 +00:00
|
|
|
auto start = token.line_column() - 1;
|
2020-04-09 03:30:45 +00:00
|
|
|
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;
|
2020-04-05 14:03:12 +00:00
|
|
|
}
|
|
|
|
}
|
2020-04-09 03:30:45 +00:00
|
|
|
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
switch (token.category()) {
|
|
|
|
case JS::TokenCategory::Invalid:
|
2021-09-01 16:13:53 +00:00
|
|
|
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Red), Line::Style::Underline });
|
2020-04-09 03:30:45 +00:00
|
|
|
break;
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
case JS::TokenCategory::Number:
|
2021-09-01 16:13:53 +00:00
|
|
|
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Magenta) });
|
2020-04-09 03:30:45 +00:00
|
|
|
break;
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
case JS::TokenCategory::String:
|
2021-09-01 16:13:53 +00:00
|
|
|
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Green), Line::Style::Bold });
|
2020-04-09 03:30:45 +00:00
|
|
|
break;
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
case JS::TokenCategory::Punctuation:
|
2020-04-09 03:30:45 +00:00
|
|
|
break;
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
case JS::TokenCategory::Operator:
|
2020-04-09 03:30:45 +00:00
|
|
|
break;
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
case JS::TokenCategory::Keyword:
|
|
|
|
switch (token.type()) {
|
|
|
|
case JS::TokenType::BoolLiteral:
|
|
|
|
case JS::TokenType::NullLiteral:
|
2021-09-01 16:13:53 +00:00
|
|
|
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow), Line::Style::Bold });
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
break;
|
|
|
|
default:
|
2021-09-01 16:13:53 +00:00
|
|
|
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Bold });
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
break;
|
|
|
|
}
|
2020-04-09 03:30:45 +00:00
|
|
|
break;
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
case JS::TokenCategory::ControlKeyword:
|
2021-09-01 16:13:53 +00:00
|
|
|
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Cyan), Line::Style::Italic });
|
2020-04-09 03:30:45 +00:00
|
|
|
break;
|
LibJS: Unify syntax highlighting
So far we have three different syntax highlighters for LibJS:
- js's Line::Editor stylization
- JS::MarkupGenerator
- GUI::JSSyntaxHighlighter
This not only caused repetition of most token types in each highlighter
but also a lot of inconsistency regarding the styling of certain tokens:
- JSSyntaxHighlighter was considering TokenType::Period to be an
operator whereas MarkupGenerator categorized it as punctuation.
- MarkupGenerator was considering TokenType::{Break,Case,Continue,
Default,Switch,With} control keywords whereas JSSyntaxHighlighter just
disregarded them
- MarkupGenerator considered some future reserved keywords invalid and
others not. JSSyntaxHighlighter and js disregarded most
Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well
as each individual highlighter's switch/case construct.
I added a TokenCategory enum, and each TokenType is now associated to a
certain category, which the syntax highlighters then can use for styling
rather than operating on the token type directly. This also makes
changing a token's category everywhere easier, should we need to do that
(e.g. I decided to make TokenType::{Period,QuestionMarkPeriod}
TokenCategory::Operator for now, but we might want to change them to
Punctuation.
2020-10-04 21:28:59 +00:00
|
|
|
case JS::TokenCategory::Identifier:
|
2021-09-01 16:13:53 +00:00
|
|
|
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::White), Line::Style::Bold });
|
2021-07-05 17:17:08 +00:00
|
|
|
break;
|
2020-04-09 03:30:45 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
editor.set_prompt(prompt_for_level(open_indents));
|
|
|
|
};
|
2020-04-11 09:09:55 +00:00
|
|
|
|
2021-10-03 11:17:33 +00:00
|
|
|
auto complete = [&interpreter, &global_environment](Line::Editor const& editor) -> Vector<Line::CompletionSuggestion> {
|
2020-05-19 04:12:01 +00:00
|
|
|
auto line = editor.line(editor.cursor());
|
|
|
|
|
|
|
|
JS::Lexer lexer { line };
|
|
|
|
enum {
|
|
|
|
Initial,
|
|
|
|
CompleteVariable,
|
|
|
|
CompleteNullProperty,
|
|
|
|
CompleteProperty,
|
|
|
|
} mode { Initial };
|
|
|
|
|
|
|
|
StringView variable_name;
|
|
|
|
StringView property_name;
|
2020-04-11 14:32:15 +00:00
|
|
|
|
2020-04-11 09:09:55 +00:00
|
|
|
// 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
|
2020-05-19 04:12:01 +00:00
|
|
|
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:
|
2021-07-15 22:03:09 +00:00
|
|
|
if (js_token.type() == JS::TokenType::Identifier) {
|
2020-05-19 04:12:01 +00:00
|
|
|
// ...<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
|
|
|
|
|
2020-04-19 14:02:28 +00:00
|
|
|
Vector<Line::CompletionSuggestion> results;
|
2020-04-11 09:09:55 +00:00
|
|
|
|
2021-11-10 23:55:02 +00:00
|
|
|
Function<void(JS::Shape const&, StringView)> list_all_properties = [&results, &list_all_properties](JS::Shape const& shape, auto property_pattern) {
|
2021-07-06 22:58:50 +00:00
|
|
|
for (auto const& descriptor : shape.property_table()) {
|
2020-07-08 04:38:46 +00:00
|
|
|
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 };
|
2020-05-02 15:01:09 +00:00
|
|
|
if (!results.contains_slow(completion)) { // hide duplicates
|
2021-06-13 10:00:27 +00:00
|
|
|
results.append(String(key));
|
2020-04-11 14:32:15 +00:00
|
|
|
}
|
2020-04-11 09:09:55 +00:00
|
|
|
}
|
|
|
|
}
|
2021-07-06 22:58:50 +00:00
|
|
|
if (auto const* prototype = shape.prototype()) {
|
2020-04-11 09:09:55 +00:00
|
|
|
list_all_properties(prototype->shape(), property_pattern);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-05-19 04:12:01 +00:00
|
|
|
switch (mode) {
|
|
|
|
case CompleteProperty: {
|
2021-09-22 10:44:56 +00:00
|
|
|
Optional<JS::Value> maybe_value;
|
2021-10-03 11:17:33 +00:00
|
|
|
auto maybe_variable = vm->resolve_binding(variable_name, &global_environment);
|
2021-09-22 10:44:56 +00:00
|
|
|
if (vm->exception())
|
|
|
|
break;
|
2021-11-02 16:49:08 +00:00
|
|
|
maybe_value = TRY_OR_DISCARD(maybe_variable.get_value(interpreter->global_object()));
|
2021-10-03 11:17:33 +00:00
|
|
|
VERIFY(!maybe_value->is_empty());
|
2020-04-11 09:09:55 +00:00
|
|
|
|
2021-09-22 10:44:56 +00:00
|
|
|
auto variable = *maybe_value;
|
2020-04-11 09:09:55 +00:00
|
|
|
if (!variable.is_object())
|
2020-05-19 04:12:01 +00:00
|
|
|
break;
|
2020-04-11 09:09:55 +00:00
|
|
|
|
2021-10-12 18:24:57 +00:00
|
|
|
auto const* object = MUST(variable.to_object(interpreter->global_object()));
|
2021-07-06 22:58:50 +00:00
|
|
|
auto const& shape = object->shape();
|
2020-05-19 04:12:01 +00:00
|
|
|
list_all_properties(shape, property_name);
|
2020-04-11 14:32:15 +00:00
|
|
|
if (results.size())
|
2020-05-19 04:12:01 +00:00
|
|
|
editor.suggest(property_name.length());
|
|
|
|
break;
|
2020-04-11 09:09:55 +00:00
|
|
|
}
|
2020-05-19 04:12:01 +00:00
|
|
|
case CompleteVariable: {
|
2021-07-06 22:58:50 +00:00
|
|
|
auto const& variable = interpreter->global_object();
|
2020-05-19 04:12:01 +00:00
|
|
|
list_all_properties(variable.shape(), variable_name);
|
2021-10-03 11:20:15 +00:00
|
|
|
|
|
|
|
for (String& name : global_environment.declarative_record().bindings()) {
|
|
|
|
if (name.starts_with(variable_name))
|
|
|
|
results.empend(name);
|
|
|
|
}
|
|
|
|
|
2020-05-19 04:12:01 +00:00
|
|
|
if (results.size())
|
|
|
|
editor.suggest(variable_name.length());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
2021-02-23 19:42:32 +00:00
|
|
|
VERIFY_NOT_REACHED();
|
2020-05-19 04:12:01 +00:00
|
|
|
}
|
|
|
|
|
2020-04-11 09:09:55 +00:00
|
|
|
return results;
|
|
|
|
};
|
2020-05-19 04:12:01 +00:00
|
|
|
s_editor->on_tab_complete = move(complete);
|
2020-04-01 19:04:51 +00:00
|
|
|
repl(*interpreter);
|
2020-10-25 23:36:06 +00:00
|
|
|
s_editor->save_history(s_history_path);
|
2020-03-25 22:10:29 +00:00
|
|
|
} else {
|
2021-05-25 22:50:18 +00:00
|
|
|
interpreter = JS::Interpreter::create<ScriptObject>(*vm);
|
2020-09-29 19:15:06 +00:00
|
|
|
ReplConsoleClient console_client(interpreter->global_object().console());
|
|
|
|
interpreter->global_object().console().set_client(console_client);
|
2020-04-01 19:20:32 +00:00
|
|
|
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
|
2021-10-02 14:35:55 +00:00
|
|
|
#ifdef JS_TRACK_ZOMBIE_CELLS
|
2021-09-11 14:44:40 +00:00
|
|
|
interpreter->heap().set_zombify_dead_cells(zombify_dead_cells);
|
2021-10-02 14:35:55 +00:00
|
|
|
#endif
|
2020-04-01 19:20:32 +00:00
|
|
|
|
2020-04-24 16:59:16 +00:00
|
|
|
signal(SIGINT, [](int) {
|
|
|
|
sigint_handler();
|
|
|
|
});
|
|
|
|
|
2021-06-16 13:55:34 +00:00
|
|
|
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();
|
2021-06-18 18:11:26 +00:00
|
|
|
auto source = StringView { file_contents };
|
2021-06-16 13:55:34 +00:00
|
|
|
builder.append(source);
|
2020-03-25 22:10:29 +00:00
|
|
|
}
|
2020-03-07 18:42:11 +00:00
|
|
|
|
2021-10-24 12:33:56 +00:00
|
|
|
StringBuilder source_name_builder;
|
|
|
|
source_name_builder.join(", ", script_paths);
|
|
|
|
|
|
|
|
if (!parse_and_run(*interpreter, builder.string_view(), source_name_builder.string_view()))
|
2020-04-13 00:05:21 +00:00
|
|
|
return 1;
|
2020-03-25 22:10:29 +00:00
|
|
|
}
|
2020-03-08 18:59:59 +00:00
|
|
|
|
2020-03-07 18:42:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|