beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 00:50:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7
ladybird/Userland/Utilities/js.cpp

1016 lines
36 KiB
C++
Raw Normal View History

LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
Everywhere: Use linusg@serenityos.org for my copyright headers
2021-04-22 20:51:19 +00:00
* Copyright (c) 2020-2021, Linus Groh <linusg@serenityos.org>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
*/
Utilities: Correct non-standard assert macros includes
2021-05-15 10:34:40 +00:00
#include <AK/Assertions.h>
js: Take the script file as a command-line argument Now that we have the beginnings of a parser, let's take the script to run as a command-line argument and move all the test scripts into /home/anon/js :^) To run a script, simply use "js": $ js my-script.js To get an AST dump before execution, you can use "js -A"
2020-03-12 09:51:41 +00:00
#include <AK/ByteBuffer.h>
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
#include <AK/Format.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
#include <AK/NonnullOwnPtr.h>
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
#include <AK/StringBuilder.h>
js: Take the script file as a command-line argument Now that we have the beginnings of a parser, let's take the script to run as a command-line argument and move all the test scripts into /home/anon/js :^) To run a script, simply use "js": $ js my-script.js To get an AST dump before execution, you can use "js -A"
2020-03-12 09:51:41 +00:00
#include <LibCore/ArgsParser.h>
#include <LibCore/File.h>
js: Load and save history from/to ~/.js-history This is super useful when hacking on LibJS and in general :^)
2020-10-25 23:36:06 +00:00
#include <LibCore/StandardPaths.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
#include <LibJS/AST.h>
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
#include <LibJS/Console.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
#include <LibJS/Interpreter.h>
LibJS: Add Javascript lexer and parser This adds a basic Javascript lexer and parser. It can parse the currently existing demo programs. More work needs to be done to turn it into a complete parser than can parse arbitrary JS Code. The lexer outputs tokens with preceeding whitespace and comments in the trivia member. This should allow us to generate the exact source code by concatenating the generated tokens. The parser is written in a way that it always returns a complete syntax tree. Error conditions are represented as nodes in the tree. This simplifies the code and allows it to be used as an early stage parser, e.g for parsing JS documents in an IDE while editing the source code.:
2020-03-11 18:27:43 +00:00
#include <LibJS/Parser.h>
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
#include <LibJS/Runtime/Array.h>
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
#include <LibJS/Runtime/ArrayBuffer.h>
#include <LibJS/Runtime/BooleanObject.h>
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
#include <LibJS/Runtime/Date.h>
js: Handle exceptions thrown during REPL execution We now print thrown exceptions and clear the interpreter state so it can continue running instead of refusing to do anything after an exception has been thrown. Fixes #1572.
2020-04-02 07:54:15 +00:00
#include <LibJS/Runtime/Error.h>
js: Tweak pretty-printing of functions and null
2020-03-26 13:54:43 +00:00
#include <LibJS/Runtime/Function.h>
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 16:53:28 +00:00
#include <LibJS/Runtime/GlobalObject.h>
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
#include <LibJS/Runtime/NativeFunction.h>
#include <LibJS/Runtime/NumberObject.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/Object.h>
#include <LibJS/Runtime/PrimitiveString.h>
js: Add REPL pretty-printing handler for Promises
2021-04-01 20:14:05 +00:00
#include <LibJS/Runtime/Promise.h>
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
#include <LibJS/Runtime/ProxyObject.h>
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 23:05:49 +00:00
#include <LibJS/Runtime/RegExpObject.h>
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
#include <LibJS/Runtime/ScriptFunction.h>
LibJS: Start implementing object shapes This patch adds JS::Shape, which implements a transition tree for our Object class. Object property keys, prototypes and attributes are now stored in a Shape, and each Object has a Shape. When adding a property to an Object, we make a transition from the old Shape to a new Shape. If we've made the same exact transition in the past (with another Object), we reuse the same transition and both objects may now share a Shape. This will become the foundation of inline caching and other engine optimizations in the future. :^)
2020-04-02 17:32:21 +00:00
#include <LibJS/Runtime/Shape.h>
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
#include <LibJS/Runtime/StringObject.h>
#include <LibJS/Runtime/TypedArray.h>
LibJS: Add "Heap" and "Runtime" subdirectories Let's try to keep LibJS tidy as it expands. :^)
2020-03-16 13:20:30 +00:00
#include <LibJS/Runtime/Value.h>
LibLine: Rename LineEditor.{cpp,h} => Editor.{cpp,h}
2020-03-31 11:34:57 +00:00
#include <LibLine/Editor.h>
LibC+Everywhere: Remove open_with_path_length() in favor of open() This API was a mostly gratuitous deviation from POSIX that gave up some portability in exchange for avoiding the occasional strlen(). I don't think that was actually achieving anything valuable, so let's just chill out and have the same open() API as everyone else. :^)
2021-01-12 18:21:59 +00:00
#include <fcntl.h>
Userland: Install LibLine's signal handlers in the JS repl
2020-04-11 09:09:10 +00:00
#include <signal.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
#include <stdio.h>
Everywhere: Remove klog(), dbg() and purge all LogStream usage :^) Good-bye LogStream. Long live AK::Format!
2021-03-12 16:29:37 +00:00
#include <unistd.h>
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
js: Use VM::exception() instead of Interpreter::exception() The VM is always there, but we only have an Interpreter while we are running code.
2020-09-23 19:29:57 +00:00
RefPtr<JS::VM> vm;
Userland/JS: Add the 'save("file")' repl command Calling save("file") in a repl saves all the typed lines so far into the specified file. It currently does not have great support for multilined functions since those get turned into one line.
2020-04-02 15:52:40 +00:00
Vector<String> repl_statements;
LibJS: Rename GlobalObject::initialize() => initialize_global_object() This function was shadowing Object::initialize() which cannot be called on global objects and has a different set of parameters.
2021-03-17 15:52:26 +00:00
class ReplObject final : public JS::GlobalObject {
JS_OBJECT(ReplObject, JS::GlobalObject);
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
public:
js: Use default constructor and destructor for global objects
2021-05-26 00:01:07 +00:00
ReplObject() = default;
LibJS: Rename GlobalObject::initialize() => initialize_global_object() This function was shadowing Object::initialize() which cannot be called on global objects and has a different set of parameters.
2021-03-17 15:52:26 +00:00
virtual void initialize_global_object() override;
js: Use default constructor and destructor for global objects
2021-05-26 00:01:07 +00:00
virtual ~ReplObject() override = default;
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
private:
LibJS: Pass GlobalObject& to native functions and property accessors More work towards supporting multiple global objects. Native C++ code now get a GlobalObject& and don't have to ask the Interpreter for it. I've added macros for declaring and defining native callbacks since this was pretty tedious and this makes it easier next time we want to change any of these signatures.
2020-06-20 11:55:34 +00:00
JS_DECLARE_NATIVE_FUNCTION(exit_interpreter);
JS_DECLARE_NATIVE_FUNCTION(repl_help);
js: Remove test mode Now that we have a standalone test-js program, the "-t" test mode of the js REPL is unused and can simply be removed. Required functionality has been duplicated in test-js (isStrictMode function, loading of testing utilities). Also remove outdated information about tests from the js(1) man page.
2020-07-06 22:17:39 +00:00
JS_DECLARE_NATIVE_FUNCTION(load_file);
LibJS: Pass GlobalObject& to native functions and property accessors More work towards supporting multiple global objects. Native C++ code now get a GlobalObject& and don't have to ask the Interpreter for it. I've added macros for declaring and defining native callbacks since this was pretty tedious and this makes it easier next time we want to change any of these signatures.
2020-06-20 11:55:34 +00:00
JS_DECLARE_NATIVE_FUNCTION(save_to_file);
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
};
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-25 22:50:18 +00:00
class ScriptObject final : public JS::GlobalObject {
JS_OBJECT(ScriptObject, JS::GlobalObject);
public:
js: Use default constructor and destructor for global objects
2021-05-26 00:01:07 +00:00
ScriptObject() = default;
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-25 22:50:18 +00:00
virtual void initialize_global_object() override;
js: Use default constructor and destructor for global objects
2021-05-26 00:01:07 +00:00
virtual ~ScriptObject() override = default;
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-25 22:50:18 +00:00
private:
JS_DECLARE_NATIVE_FUNCTION(load_file);
};
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
static bool s_dump_ast = false;
static bool s_print_last_result = false;
LibLine: Use Core::EventLoop for outer read loop This commit changes LibLine's internal structure to work in an event loop, and as a result, also switches it to being a Core::Object.
2020-05-26 10:34:39 +00:00
static RefPtr<Line::Editor> s_editor;
js: Load and save history from/to ~/.js-history This is super useful when hacking on LibJS and in general :^)
2020-10-25 23:36:06 +00:00
static String s_history_path = String::formatted("{}/.js-history", Core::StandardPaths::home_directory());
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
static int s_repl_line_level = 0;
LibLine: Change get_line to return a Result<String, Error> This fixes a bunch of FIXME's in LibLine. Also handles the case where read() would read zero bytes in vt_dsr() and effectively block forever by erroring out. Fixes #2370
2020-05-25 12:27:07 +00:00
static bool s_fail_repl = false;
JS repl: Fix indentation when a line starts with '})]'
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();
}
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 21:48:37 +00:00
static String read_next_piece()
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
{
StringBuilder piece;
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 17:12:11 +00:00
auto line_level_delta_for_next_line { 0 };
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
do {
LibLine: Change get_line to return a Result<String, Error> This fixes a bunch of FIXME's in LibLine. Also handles the case where read() would read zero bytes in vt_dsr() and effectively block forever by erroring out. Fixes #2370
2020-05-25 12:27:07 +00:00
auto line_result = s_editor->get_line(prompt_for_level(s_repl_line_level));
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 17:12:11 +00:00
line_level_delta_for_next_line = 0;
LibLine: Change get_line to return a Result<String, Error> This fixes a bunch of FIXME's in LibLine. Also handles the case where read() would read zero bytes in vt_dsr() and effectively block forever by erroring out. Fixes #2370
2020-05-25 12:27:07 +00:00
if (line_result.is_error()) {
s_fail_repl = true;
return "";
}
auto& line = line_result.value();
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
s_editor->add_to_history(line);
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
piece.append(line);
auto lexer = JS::Lexer(line);
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 17:12:11 +00:00
enum {
NotInLabelOrObjectKey,
InLabelOrObjectKeyIdentifier,
InLabelOrObjectKey
} label_state { NotInLabelOrObjectKey };
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
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:
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 17:12:11 +00:00
label_state = NotInLabelOrObjectKey;
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
s_repl_line_level++;
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
break;
case JS::TokenType::BracketClose:
case JS::TokenType::CurlyClose:
case JS::TokenType::ParenClose:
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 17:12:11 +00:00
label_state = NotInLabelOrObjectKey;
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
s_repl_line_level--;
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
break;
Userland/js: Prompt for more input on labels and object keys Closes #2452
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;
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
default:
break;
}
}
Userland/js: Prompt for more input on labels and object keys Closes #2452
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);
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
return piece.to_string();
}
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects);
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
static void print_type(const FlyString& name)
{
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)
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
{
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
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) {
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
print_separator(first);
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
auto value = it.value_and_attributes(&array).value;
// 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
js: Use VM::exception() instead of Interpreter::exception() The VM is always there, but we only have an Interpreter while we are running code.
2020-09-23 19:29:57 +00:00
if (vm->exception())
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;
print_value(value, seen_objects);
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
}
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
if (!first)
out(" ");
out("]");
js: Implement some modest pretty-printing of values
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)
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
{
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
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()) {
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
print_separator(first);
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\"\033[33;1m{}\033[0m\": ", 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
auto value = entry.value_and_attributes(&object).value;
// 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
js: Use VM::exception() instead of Interpreter::exception() The VM is always there, but we only have an Interpreter while we are running code.
2020-09-23 19:29:57 +00:00
if (vm->exception())
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;
print_value(value, seen_objects);
LibJS: Add a number-indexed property storage to all Objects Objects can have both named and indexed properties. Previously we kept all property names as strings. This patch separates named and indexed properties and splits them between Object::m_storage and m_elements. This allows us to do much faster array-style access using numeric indices. It also makes the Array class much less special, since all Objects now have number-indexed storage. :^)
2020-04-06 14:53:02 +00:00
}
LibJS: Implement correct object property ordering This commit introduces a way to get an object's own properties in the correct order. The "correct order" for JS object properties is first all array-like index properties (numeric keys) sorted by insertion order, followed by all string properties sorted by insertion order. Objects also now print correctly in the repl! Before this commit: courage ~/js-tests $ js > ({ foo: 1, bar: 2, baz: 3 }) { bar: 2, foo: 1, baz: 3 } After: courage ~/js-tests $ js > ({ foo: 1, bar: 2, baz: 3 }) { foo: 1, bar: 2, baz: 3 }
2020-04-29 02:19:31 +00:00
for (auto& it : object.shape().property_table_ordered()) {
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
print_separator(first);
LibJS: Integrate Symbols into objects as valid keys This allows objects properties to be created for symbol keys in addition to just plain strings/numbers
2020-07-08 04:38:46 +00:00
if (it.key.is_string()) {
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\"\033[33;1m{}\033[0m\": ", it.key.to_display_string());
LibJS: Integrate Symbols into objects as valid keys This allows objects properties to be created for symbol keys in addition to just plain strings/numbers
2020-07-08 04:38:46 +00:00
} else {
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
out("[\033[33;1m{}\033[0m]: ", it.key.to_display_string());
LibJS: Integrate Symbols into objects as valid keys This allows objects properties to be created for symbol keys in addition to just plain strings/numbers
2020-07-08 04:38:46 +00:00
}
LibJS: Start implementing object shapes This patch adds JS::Shape, which implements a transition tree for our Object class. Object property keys, prototypes and attributes are now stored in a Shape, and each Object has a Shape. When adding a property to an Object, we make a transition from the old Shape to a new Shape. If we've made the same exact transition in the past (with another Object), we reuse the same transition and both objects may now share a Shape. This will become the foundation of inline caching and other engine optimizations in the future. :^)
2020-04-02 17:32:21 +00:00
print_value(object.get_direct(it.value.offset), seen_objects);
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
}
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
if (!first)
out(" ");
out("}}");
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
}
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
static void print_function(const JS::Object& object, HashTable<JS::Object*>&)
js: Tweak pretty-printing of functions and null
2020-03-26 13:54:43 +00:00
{
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
print_type(object.class_name());
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::ScriptFunction>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
out(" {}", static_cast<const JS::ScriptFunction&>(object).name());
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
else if (is<JS::NativeFunction>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
out(" {}", static_cast<const JS::NativeFunction&>(object).name());
js: Tweak pretty-printing of functions and null
2020-03-26 13:54:43 +00:00
}
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-11 22:08:28 +00:00
static void print_date(const JS::Object& object, HashTable<JS::Object*>&)
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
{
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
print_type("Date");
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-11 22:08:28 +00:00
out(" \033[34;1m{}\033[0m", static_cast<const JS::Date&>(object).string());
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
}
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-11 22:08:28 +00:00
static void print_error(const JS::Object& object, HashTable<JS::Object*>& seen_objects)
js: Handle exceptions thrown during REPL execution We now print thrown exceptions and clear the interpreter state so it can continue running instead of refusing to do anything after an exception has been thrown. Fixes #1572.
2020-04-02 07:54:15 +00:00
{
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
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());
if (name.is_accessor() || name.is_native_property() || message.is_accessor() || message.is_native_property()) {
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);
}
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
}
static void print_regexp_object(const JS::Object& object, HashTable<JS::Object*>&)
{
auto& regexp_object = static_cast<const JS::RegExpObject&>(object);
// Use RegExp.prototype.source rather than RegExpObject::pattern() so we get proper escaping
auto source = regexp_object.get("source").to_primitive_string(object.global_object())->string();
print_type("RegExp");
out(" \033[34;1m/{}/{}\033[0m", source, regexp_object.flags());
}
static void print_proxy_object(const JS::Object& object, HashTable<JS::Object*>& seen_objects)
{
auto& proxy_object = static_cast<const JS::ProxyObject&>(object);
print_type("Proxy");
out("\n target: ");
print_value(&proxy_object.target(), seen_objects);
out("\n handler: ");
print_value(&proxy_object.handler(), seen_objects);
}
js: Add REPL pretty-printing handler for Promises
2021-04-01 20:14:05 +00:00
static void print_promise(const JS::Object& object, HashTable<JS::Object*>& seen_objects)
{
auto& promise = static_cast<const JS::Promise&>(object);
print_type("Promise");
switch (promise.state()) {
case JS::Promise::State::Pending:
out("\n state: ");
out("\033[36;1mPending\033[0m");
break;
case JS::Promise::State::Fulfilled:
out("\n state: ");
out("\033[32;1mFulfilled\033[0m");
out("\n result: ");
print_value(promise.result(), seen_objects);
break;
case JS::Promise::State::Rejected:
out("\n state: ");
out("\033[31;1mRejected\033[0m");
out("\n result: ");
print_value(promise.result(), seen_objects);
break;
default:
VERIFY_NOT_REACHED();
}
}
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
static void print_array_buffer(const JS::Object& object, HashTable<JS::Object*>& seen_objects)
{
auto& array_buffer = static_cast<const JS::ArrayBuffer&>(object);
auto& buffer = array_buffer.buffer();
auto byte_length = array_buffer.byte_length();
print_type("ArrayBuffer");
out("\n byteLength: ");
print_value(JS::Value((double)byte_length), seen_objects);
js: Don't print newline for empty ArrayBuffer If we don't have any bytes to print in hex representation, just return early instead of printing a newline in preparation for the data that won't follow. :^)
2021-05-21 18:20:43 +00:00
if (!byte_length)
return;
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
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(" ");
}
}
}
static void print_typed_array(const JS::Object& object, HashTable<JS::Object*>& seen_objects)
{
auto& typed_array_base = static_cast<const JS::TypedArrayBase&>(object);
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");
out(" @ {:p}", typed_array_base.viewed_array_buffer());
if (!length)
return;
outln();
// FIXME: This kinda sucks.
#define __JS_ENUMERATE(ClassName, snake_name, PrototypeName, ConstructorName, ArrayType) \
js: Replace TypedArray class_name() string compare with is<T>()
2021-03-18 17:34:18 +00:00
if (is<JS::ClassName>(object)) { \
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
out("[ "); \
auto& typed_array = static_cast<const JS::ClassName&>(typed_array_base); \
auto data = typed_array.data(); \
for (size_t i = 0; i < length; ++i) { \
if (i > 0) \
out(", "); \
print_value(JS::Value(data[i]), seen_objects); \
} \
out(" ]"); \
return; \
}
JS_ENUMERATE_TYPED_ARRAYS
#undef __JS_ENUMERATE
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY_NOT_REACHED();
js: Handle exceptions thrown during REPL execution We now print thrown exceptions and clear the interpreter state so it can continue running instead of refusing to do anything after an exception has been thrown. Fixes #1572.
2020-04-02 07:54:15 +00:00
}
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
static void print_primitive_wrapper_object(const FlyString& name, const JS::Object& object, HashTable<JS::Object*>& seen_objects)
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 23:05:49 +00:00
{
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
// BooleanObject, NumberObject, StringObject
print_type(name);
out(" ");
print_value(object.value_of(), seen_objects);
LibJS: Lex and parse regex literals, add RegExp objects This adds regex parsing/lexing, as well as a relatively empty RegExpObject. The purpose of this patch is to allow the engine to not get hung up on parsing regexes. This will aid in finding new syntax errors (say, from google or twitter) without having to replace all of their regexes first!
2020-06-03 23:05:49 +00:00
}
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 21:48:37 +00:00
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects)
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
{
LibJS: Handle empty values in Value::to_string()
2020-04-08 16:38:09 +00:00
if (value.is_empty()) {
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\033[34;1m<empty>\033[0m");
LibJS: Handle empty values in Value::to_string()
2020-04-08 16:38:09 +00:00
return;
}
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 03:30:45 +00:00
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
if (value.is_object()) {
LibJS: Make Value::as_object() return Object& Let's move towards using references over pointers in LibJS as well. I had originally steered away from it because that's how I've seen things done in other engines. But this is not the other engines. :^)
2020-04-01 20:18:47 +00:00
if (seen_objects.contains(&value.as_object())) {
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
// FIXME: Maybe we should only do this for circular references,
// not for all reoccurring objects.
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("<already printed Object {}>", &value.as_object());
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
return;
}
LibJS: Make Value::as_object() return Object& Let's move towards using references over pointers in LibJS as well. I had originally steered away from it because that's how I've seen things done in other engines. But this is not the other engines. :^)
2020-04-01 20:18:47 +00:00
seen_objects.set(&value.as_object());
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
}
if (value.is_array())
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 print_array(static_cast<JS::Array&>(value.as_object()), seen_objects);
LibWeb+LibJS: Move DOM Window object to dedicated classes LibWeb now creates a WindowObject which inherits from GlobalObject. Allocation of the global object is moved out of the Interpreter ctor to allow for specialized construction. The existing Window interfaces are moved to WindowObject with their implementation code in the new Window class.
2020-04-01 16:53:28 +00:00
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
if (value.is_object()) {
LibJS: Make Value::as_object() return Object& Let's move towards using references over pointers in LibJS as well. I had originally steered away from it because that's how I've seen things done in other engines. But this is not the other engines. :^)
2020-04-01 20:18:47 +00:00
auto& object = value.as_object();
if (object.is_function())
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
return print_function(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::Date>(object))
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
return print_date(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::Error>(object))
js: Handle exceptions thrown during REPL execution We now print thrown exceptions and clear the interpreter state so it can continue running instead of refusing to do anything after an exception has been thrown. Fixes #1572.
2020-04-02 07:54:15 +00:00
return print_error(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::RegExpObject>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
return print_regexp_object(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::ProxyObject>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
return print_proxy_object(object, seen_objects);
js: Add REPL pretty-printing handler for Promises
2021-04-01 20:14:05 +00:00
if (is<JS::Promise>(object))
return print_promise(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::ArrayBuffer>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
return print_array_buffer(object, seen_objects);
if (object.is_typed_array())
return print_typed_array(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::StringObject>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
return print_primitive_wrapper_object("String", object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::NumberObject>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
return print_primitive_wrapper_object("Number", object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 16:46:39 +00:00
if (is<JS::BooleanObject>(object))
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
return print_primitive_wrapper_object("Boolean", object, seen_objects);
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
return print_object(object, seen_objects);
}
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
if (value.is_string())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\033[32;1m");
LibJS: Add BigInt
2020-06-06 00:14:10 +00:00
else if (value.is_number() || value.is_bigint())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\033[35;1m");
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
else if (value.is_boolean())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\033[33;1m");
js: Tweak pretty-printing of functions and null
2020-03-26 13:54:43 +00:00
else if (value.is_null())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\033[33;1m");
js: Tweak pretty-printing of functions and null
2020-03-26 13:54:43 +00:00
else if (value.is_undefined())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\033[34;1m");
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
if (value.is_string())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\"");
js: Print negative zero with minus sign
2020-10-12 16:03:07 +00:00
else if (value.is_negative_zero())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("-");
out("{}", value.to_string_without_side_effects());
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
if (value.is_string())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\"");
out("\033[0m");
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
}
static void print(JS::Value value)
{
HashTable<JS::Object*> seen_objects;
print_value(value, seen_objects);
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln();
js: Implement some modest pretty-printing of values
2020-03-26 11:26:11 +00:00
}
AK+Userland: Fix some compiler warnings and make variables const-ref This fixes a few compiler warnings and makes some variables const-ref in preparation for the next commit which changes how ByteBuffer works.
2021-05-14 18:53:27 +00:00
static bool file_has_shebang(ByteBuffer const& file_contents)
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
{
if (file_contents.size() >= 2 && file_contents[0] == '#' && file_contents[1] == '!')
return true;
return false;
}
AK+Userland: Fix some compiler warnings and make variables const-ref This fixes a few compiler warnings and makes some variables const-ref in preparation for the next commit which changes how ByteBuffer works.
2021-05-14 18:53:27 +00:00
static StringView strip_shebang(ByteBuffer const& file_contents)
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
{
size_t i = 0;
for (i = 2; i < file_contents.size(); ++i) {
if (file_contents[i] == '\n')
break;
}
return StringView((const char*)file_contents.data() + i, file_contents.size() - i);
}
LibC+Everywhere: Remove open_with_path_length() in favor of open() This API was a mostly gratuitous deviation from POSIX that gave up some portability in exchange for avoiding the occasional strlen(). I don't think that was actually achieving anything valuable, so let's just chill out and have the same open() API as everyone else. :^)
2021-01-12 18:21:59 +00:00
static bool write_to_file(const String& path)
Userland/JS: Add the 'save("file")' repl command Calling save("file") in a repl saves all the typed lines so far into the specified file. It currently does not have great support for multilined functions since those get turned into one line.
2020-04-02 15:52:40 +00:00
{
LibC+Everywhere: Remove open_with_path_length() in favor of open() This API was a mostly gratuitous deviation from POSIX that gave up some portability in exchange for avoiding the occasional strlen(). I don't think that was actually achieving anything valuable, so let's just chill out and have the same open() API as everyone else. :^)
2021-01-12 18:21:59 +00:00
int fd = open(path.characters(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
Userland/JS: Add the 'save("file")' repl command Calling save("file") in a repl saves all the typed lines so far into the specified file. It currently does not have great support for multilined functions since those get turned into one line.
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;
}
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 21:48:37 +00:00
static bool parse_and_run(JS::Interpreter& interpreter, const StringView& source)
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
{
auto parser = JS::Parser(JS::Lexer(source));
auto program = parser.parse_program();
if (s_dump_ast)
program->dump(0);
if (parser.has_errors()) {
auto error = parser.errors()[0];
js: Show a "source location hint" for syntax errors :^)
2020-05-26 12:00:36 +00:00
auto hint = error.source_location_hint(source);
if (!hint.is_empty())
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("{}", hint);
LibJS: Move most of Interpreter into VM This patch moves the exception state, call stack and scope stack from Interpreter to VM. I'm doing this to help myself discover what the split between Interpreter and VM should be, by shuffling things around and seeing what falls where. With these changes, we no longer have a persistent lexical environment for the current global object on the Interpreter's call stack. Instead, we push/pop that environment on Interpreter::run() enter/exit. Since it should only be used to find the global "this", and not for variable storage (that goes directly into the global object instead!), I had to insert some short-circuiting when walking the environment parent chain during variable lookup. Note that this is a "stepping stone" commit, not a final design.
2020-09-27 13:18:55 +00:00
vm->throw_exception<JS::SyntaxError>(interpreter.global_object(), error.to_string());
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
} else {
LibJS: Make more Interpreter functions take a GlobalObject&
2020-06-08 19:25:16 +00:00
interpreter.run(interpreter.global_object(), *program);
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
}
js: Handle exceptions thrown during value printing If an exception was thrown while printing the last computed value in the REPL, it would always assert on next input. Something like this would always assert: > a=[];Object.defineProperty(a,"0",{get:()=>{throw ""}}) > 1 + 2
2021-01-29 08:16:06 +00:00
auto handle_exception = [&] {
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-11 22:08:28 +00:00
auto* exception = vm->exception();
vm->clear_exception();
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("Uncaught exception: ");
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-11 22:08:28 +00:00
print(exception->value());
LibJS: Consolidate exception function names and source ranges Instead of storing the function names (in a badly named Vector<String>) and source ranges separately, consolidate them into a new struct: TracebackFrame. This makes it both easier to use now and easier to extend in the future. Unlike before we now keep each call frame's current node source range in the traceback frame next to the function name, meaning we can display line and column numbers outside of the VM and after the call stack is emptied.
2021-04-24 16:15:02 +00:00
auto& traceback = exception->traceback();
if (traceback.size() > 1) {
js: Limit number of consecutive error trace entries being printed > function f(){f()}f() Uncaught exception: [RuntimeError]: Call stack size limit exceeded -> f 1234 more calls -> (global execution context) > function a(x){if(x>0){a(x-1)}else{throw Error()}}function b(x){if(x>0){b(x-1)}else{a(5)}}function c(){b(2)}c() Uncaught exception: [Error] -> a 5 more calls -> b -> b -> b -> c -> (global execution context)
2020-11-08 12:58:49 +00:00
unsigned repetitions = 0;
LibJS: Consolidate exception function names and source ranges Instead of storing the function names (in a badly named Vector<String>) and source ranges separately, consolidate them into a new struct: TracebackFrame. This makes it both easier to use now and easier to extend in the future. Unlike before we now keep each call frame's current node source range in the traceback frame next to the function name, meaning we can display line and column numbers outside of the VM and after the call stack is emptied.
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;
}
js: Limit number of consecutive error trace entries being printed > function f(){f()}f() Uncaught exception: [RuntimeError]: Call stack size limit exceeded -> f 1234 more calls -> (global execution context) > function a(x){if(x>0){a(x-1)}else{throw Error()}}function b(x){if(x>0){b(x-1)}else{a(5)}}function c(){b(2)}c() Uncaught exception: [Error] -> a 5 more calls -> b -> b -> b -> c -> (global execution context)
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.
LibJS: Consolidate exception function names and source ranges Instead of storing the function names (in a badly named Vector<String>) and source ranges separately, consolidate them into a new struct: TracebackFrame. This makes it both easier to use now and easier to extend in the future. Unlike before we now keep each call frame's current node source range in the traceback frame next to the function name, meaning we can display line and column numbers outside of the VM and after the call stack is emptied.
2021-04-24 16:15:02 +00:00
outln(" -> {}", traceback_frame.function_name);
js: Limit number of consecutive error trace entries being printed > function f(){f()}f() Uncaught exception: [RuntimeError]: Call stack size limit exceeded -> f 1234 more calls -> (global execution context) > function a(x){if(x>0){a(x-1)}else{throw Error()}}function b(x){if(x>0){b(x-1)}else{a(5)}}function c(){b(2)}c() Uncaught exception: [Error] -> a 5 more calls -> b -> b -> b -> c -> (global execution context)
2020-11-08 12:58:49 +00:00
outln(" {} more calls", repetitions);
} else {
for (size_t j = 0; j < repetitions + 1; ++j)
LibJS: Consolidate exception function names and source ranges Instead of storing the function names (in a badly named Vector<String>) and source ranges separately, consolidate them into a new struct: TracebackFrame. This makes it both easier to use now and easier to extend in the future. Unlike before we now keep each call frame's current node source range in the traceback frame next to the function name, meaning we can display line and column numbers outside of the VM and after the call stack is emptied.
2021-04-24 16:15:02 +00:00
outln(" -> {}", traceback_frame.function_name);
js: Limit number of consecutive error trace entries being printed > function f(){f()}f() Uncaught exception: [RuntimeError]: Call stack size limit exceeded -> f 1234 more calls -> (global execution context) > function a(x){if(x>0){a(x-1)}else{throw Error()}}function b(x){if(x>0){b(x-1)}else{a(5)}}function c(){b(2)}c() Uncaught exception: [Error] -> a 5 more calls -> b -> b -> b -> c -> (global execution context)
2020-11-08 12:58:49 +00:00
}
repetitions = 0;
}
js: Print call stack on exception thrown outside the global context
2020-06-02 13:12:04 +00:00
}
js: Handle exceptions thrown during value printing If an exception was thrown while printing the last computed value in the REPL, it would always assert on next input. Something like this would always assert: > a=[];Object.defineProperty(a,"0",{get:()=>{throw ""}}) > 1 + 2
2021-01-29 08:16:06 +00:00
};
js: Don't print last value after exception and return non-success If in 'foo(); bar();' bar fails, we'd get the error of that and then foo's return value - that's probably not something anyone expects. Also make sure to return non-success so the process will exit with 1.
2021-03-18 17:35:58 +00:00
if (vm->exception()) {
handle_exception();
return false;
}
if (s_print_last_result)
LibJS: Move most of Interpreter into VM This patch moves the exception state, call stack and scope stack from Interpreter to VM. I'm doing this to help myself discover what the split between Interpreter and VM should be, by shuffling things around and seeing what falls where. With these changes, we no longer have a persistent lexical environment for the current global object on the Interpreter's call stack. Instead, we push/pop that environment on Interpreter::run() enter/exit. Since it should only be used to find the global "this", and not for variable storage (that goes directly into the global object instead!), I had to insert some short-circuiting when walking the environment parent chain during variable lookup. Note that this is a "stepping stone" commit, not a final design.
2020-09-27 13:18:55 +00:00
print(vm->last_value());
js: Don't print last value after exception and return non-success If in 'foo(); bar();' bar fails, we'd get the error of that and then foo's return value - that's probably not something anyone expects. Also make sure to return non-success so the process will exit with 1.
2021-03-18 17:35:58 +00:00
if (vm->exception()) {
handle_exception();
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-11 22:08:28 +00:00
return false;
js: Handle exceptions thrown during value printing If an exception was thrown while printing the last computed value in the REPL, it would always assert on next input. Something like this would always assert: > a=[];Object.defineProperty(a,"0",{get:()=>{throw ""}}) > 1 + 2
2021-01-29 08:16:06 +00:00
}
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
return true;
}
js: Consolidate and re-implement the load() function This replaces the two sloppy copies of the load() function with a cleaned up implementation: - Only use the first argument, to load multiple files just call the function multiple times - Fix a crash when using any non-string argument - Throw an error if the file can't be opened instead of logging to stderr - Don't use parse_and_run(), which would print the AST of the loaded file when using -A, for example - it's used either way as the entry point in both REPL and non-REPL mode, so we already get exception handling and all that
2021-05-26 00:04:09 +00:00
static JS::Value load_file_impl(JS::VM& vm, JS::GlobalObject& global_object)
{
auto filename = vm.argument(0).to_string(global_object);
if (vm.exception())
return {};
auto file = Core::File::construct(filename);
if (!file->open(Core::OpenMode::ReadOnly)) {
vm.throw_exception<JS::Error>(global_object, String::formatted("Failed to open '{}': {}", filename, file->error_string()));
return {};
}
auto file_contents = file->read_all();
auto source = file_has_shebang(file_contents)
? strip_shebang(file_contents)
: StringView { file_contents };
auto parser = JS::Parser(JS::Lexer(source));
auto program = parser.parse_program();
if (parser.has_errors()) {
auto& error = parser.errors()[0];
vm.throw_exception<JS::SyntaxError>(global_object, error.to_string());
return {};
}
// FIXME: Use eval()-like semantics and execute in current scope?
vm.interpreter().run(global_object, *program);
return JS::js_undefined();
}
LibJS: Rename GlobalObject::initialize() => initialize_global_object() This function was shadowing Object::initialize() which cannot be called on global objects and has a different set of parameters.
2021-03-17 15:52:26 +00:00
void ReplObject::initialize_global_object()
LibJS: Move builtin prototypes to the global object This moves us towards being able to run JavaScript in different global objects without allocating a separate GC heap.
2020-04-18 11:18:06 +00:00
{
LibJS: Rename GlobalObject::initialize() => initialize_global_object() This function was shadowing Object::initialize() which cannot be called on global objects and has a different set of parameters.
2021-03-17 15:52:26 +00:00
Base::initialize_global_object();
Userland/js: Add `global` property to the global object + help fix This adds a `global` property to the global object so that `global == this` when typed into the REPL. This matches what Node.js does and helps with testing on existing JS code that uses `global` to detect its environment.
2020-06-02 11:02:29 +00:00
define_property("global", this, JS::Attribute::Enumerable);
LibJS: Simplify and normalize publicly-exposed Object functions Previously, the Object class had many different types of functions for each action. For example: get_by_index, get(PropertyName), get(FlyString). This is a bit verbose, so these methods have been shortened to simply use the PropertyName structure. The methods then internally call _by_index if necessary. Note that the _by_index have been made private to enforce this change. Secondly, a clear distinction has been made between "putting" and "defining" an object property. "Putting" should mean modifying a (potentially) already existing property. This is akin to doing "a.b = 'foo'". This implies two things about put operations: - They will search the prototype chain for setters and call them, if necessary. - If no property exists with a particular key, the put operation should create a new property with the default attributes (configurable, writable, and enumerable). In contrast, "defining" a property should completely overwrite any existing value without calling setters (if that property is configurable, of course). Thus, all of the many JS objects have had any "put" calls changed to "define_property" calls. Additionally, "put_native_function" and "put_native_property" have had their "put" replaced with "define". Finally, "put_own_property" has been made private, as all necessary functionality should be exposed with the put and define_property methods.
2020-05-27 04:33:37 +00:00
define_native_function("exit", exit_interpreter);
define_native_function("help", repl_help);
define_native_function("load", load_file, 1);
define_native_function("save", save_to_file, 1);
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
}
LibJS: Pass GlobalObject& to native functions and property accessors More work towards supporting multiple global objects. Native C++ code now get a GlobalObject& and don't have to ask the Interpreter for it. I've added macros for declaring and defining native callbacks since this was pretty tedious and this makes it easier next time we want to change any of these signatures.
2020-06-20 11:55:34 +00:00
JS_DEFINE_NATIVE_FUNCTION(ReplObject::save_to_file)
Userland/JS: Add the 'save("file")' repl command Calling save("file") in a repl saves all the typed lines so far into the specified file. It currently does not have great support for multilined functions since those get turned into one line.
2020-04-02 15:52:40 +00:00
{
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 16:36:49 +00:00
if (!vm.argument_count())
Userland/JS: Add the 'save("file")' repl command Calling save("file") in a repl saves all the typed lines so far into the specified file. It currently does not have great support for multilined functions since those get turned into one line.
2020-04-02 15:52:40 +00:00
return JS::Value(false);
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 16:36:49 +00:00
String save_path = vm.argument(0).to_string_without_side_effects();
Userland/JS: Add the 'save("file")' repl command Calling save("file") in a repl saves all the typed lines so far into the specified file. It currently does not have great support for multilined functions since those get turned into one line.
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);
}
js: Add assertNotReached() function in test mode
2020-04-13 13:04:24 +00:00
LibJS: Pass GlobalObject& to native functions and property accessors More work towards supporting multiple global objects. Native C++ code now get a GlobalObject& and don't have to ask the Interpreter for it. I've added macros for declaring and defining native callbacks since this was pretty tedious and this makes it easier next time we want to change any of these signatures.
2020-06-20 11:55:34 +00:00
JS_DEFINE_NATIVE_FUNCTION(ReplObject::exit_interpreter)
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
{
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 16:36:49 +00:00
if (!vm.argument_count())
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
exit(0);
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 16:36:49 +00:00
auto exit_code = vm.argument(0).to_number(global_object);
js: Use VM::exception() instead of Interpreter::exception() The VM is always there, but we only have an Interpreter while we are running code.
2020-09-23 19:29:57 +00:00
if (::vm->exception())
LibJS: Pass Interpreter& to Value::to_number() et al. This patch is unfortunately rather large and might make some things feel bloated, but it is necessary to fix a few flaws in LibJS, primarily blindly coercing values to numbers without exception checks - i.e. interpreter.argument(0).to_i32(); // can fail!!! Some examples where the interpreter would actually crash: var o = { toString: () => { throw Error() } }; +o; o - 1; "foo".charAt(o); "bar".repeat(o); To fix this, we now have the following... to_double(Interpreter&) to_i32() to_i32(Interpreter&) to_size_t() to_size_t(Interpreter&) ...and a whole lot of exception checking. There's intentionally no to_double(), use as_double() directly instead. This way we still can use these convenient utility functions but don't need to check for exceptions if we are sure the value already is a number. Fixes #2267.
2020-05-17 23:28:00 +00:00
return {};
exit(exit_code.as_double());
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
}
js: Add assertNotReached() function in test mode
2020-04-13 13:04:24 +00:00
LibJS: Pass GlobalObject& to native functions and property accessors More work towards supporting multiple global objects. Native C++ code now get a GlobalObject& and don't have to ask the Interpreter for it. I've added macros for declaring and defining native callbacks since this was pretty tedious and this makes it easier next time we want to change any of these signatures.
2020-06-20 11:55:34 +00:00
JS_DEFINE_NATIVE_FUNCTION(ReplObject::repl_help)
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
{
js: Use new string formatting functions
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");
js: Consolidate and re-implement the load() function This replaces the two sloppy copies of the load() function with a cleaned up implementation: - Only use the first argument, to load multiple files just call the function multiple times - Fix a crash when using any non-string argument - Throw an error if the file can't be opened instead of logging to stderr - Don't use parse_and_run(), which would print the AST of the loaded file when using -A, for example - it's used either way as the entry point in both REPL and non-REPL mode, so we already get exception handling and all that
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\")");
js: Output text using printf() and return undefined in help()
2020-04-13 20:08:54 +00:00
return JS::js_undefined();
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
}
LibJS: Pass GlobalObject& to native functions and property accessors More work towards supporting multiple global objects. Native C++ code now get a GlobalObject& and don't have to ask the Interpreter for it. I've added macros for declaring and defining native callbacks since this was pretty tedious and this makes it easier next time we want to change any of these signatures.
2020-06-20 11:55:34 +00:00
JS_DEFINE_NATIVE_FUNCTION(ReplObject::load_file)
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
{
js: Consolidate and re-implement the load() function This replaces the two sloppy copies of the load() function with a cleaned up implementation: - Only use the first argument, to load multiple files just call the function multiple times - Fix a crash when using any non-string argument - Throw an error if the file can't be opened instead of logging to stderr - Don't use parse_and_run(), which would print the AST of the loaded file when using -A, for example - it's used either way as the entry point in both REPL and non-REPL mode, so we already get exception handling and all that
2021-05-26 00:04:09 +00:00
return load_file_impl(vm, global_object);
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
}
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-25 22:50:18 +00:00
void ScriptObject::initialize_global_object()
{
Base::initialize_global_object();
define_property("global", this, JS::Attribute::Enumerable);
define_native_function("load", load_file, 1);
}
JS_DEFINE_NATIVE_FUNCTION(ScriptObject::load_file)
{
js: Consolidate and re-implement the load() function This replaces the two sloppy copies of the load() function with a cleaned up implementation: - Only use the first argument, to load multiple files just call the function multiple times - Fix a crash when using any non-string argument - Throw an error if the file can't be opened instead of logging to stderr - Don't use parse_and_run(), which would print the AST of the loaded file when using -A, for example - it's used either way as the entry point in both REPL and non-REPL mode, so we already get exception handling and all that
2021-05-26 00:04:09 +00:00
return load_file_impl(vm, global_object);
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-25 22:50:18 +00:00
}
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 21:48:37 +00:00
static void repl(JS::Interpreter& interpreter)
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
{
LibLine: Change get_line to return a Result<String, Error> This fixes a bunch of FIXME's in LibLine. Also handles the case where read() would read zero bytes in vt_dsr() and effectively block forever by erroring out. Fixes #2370
2020-05-25 12:27:07 +00:00
while (!s_fail_repl) {
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
String piece = read_next_piece();
if (piece.is_empty())
js: Don't exit the REPL when pressing enter on an empty line
2020-03-31 11:29:42 +00:00
continue;
Userland/JS: Add the 'save("file")' repl command Calling save("file") in a repl saves all the typed lines so far into the specified file. It currently does not have great support for multilined functions since those get turned into one line.
2020-04-02 15:52:40 +00:00
repl_statements.append(piece);
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
parse_and_run(interpreter, piece);
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
}
}
js: Make it a little easier to add new AST builder functions
2020-03-09 20:58:27 +00:00
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 16:59:16 +00:00
static Function<void()> interrupt_interpreter;
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 21:48:37 +00:00
static void sigint_handler()
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 16:59:16 +00:00
{
interrupt_interpreter();
}
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
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
{
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("{}", vm().join_arguments());
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value info() override
{
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("(i) {}", vm().join_arguments());
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value debug() override
{
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("\033[36;1m{}\033[0m", vm().join_arguments());
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value warn() override
{
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("\033[33;1m{}\033[0m", vm().join_arguments());
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value error() override
{
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("\033[31;1m{}\033[0m", vm().join_arguments());
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value clear() override
{
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
out("\033[3J\033[H\033[2J");
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
fflush(stdout);
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value trace() override
{
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("{}", vm().join_arguments());
LibJS: Move Interpreter::get_trace() to ConsoleClient Having it globally on the interpreter is confusing as the last call frame is skipped, which is specific to console.trace().
2020-06-02 12:54:26 +00:00
auto trace = get_trace();
js: Tighten up ReplConsoleClient::trace() a little bit Remove a bunch of unnecessary String copying.
2020-05-05 09:48:57 +00:00
for (auto& function_name : trace) {
if (function_name.is_empty())
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
function_name = "<anonymous>";
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln(" -> {}", function_name);
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
}
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value count() override
{
LibJS: Move Console from Interpreter to GlobalObject Each JS global object has its own "console", so it makes more sense to store it in GlobalObject. We'll need some smartness later to bundle up console messages from all the different frames that make up a page later, but this works for now.
2020-09-29 19:15:06 +00:00
auto label = vm().argument_count() ? vm().argument(0).to_string_without_side_effects() : "default";
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
auto counter_value = m_console.counter_increment(label);
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
outln("{}: {}", label, counter_value);
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
return JS::js_undefined();
}
LibJS: Implement console.assert()
2021-04-18 15:08:14 +00:00
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
virtual JS::Value count_reset() override
{
LibJS: Move Console from Interpreter to GlobalObject Each JS global object has its own "console", so it makes more sense to store it in GlobalObject. We'll need some smartness later to bundle up console messages from all the different frames that make up a page later, but this works for now.
2020-09-29 19:15:06 +00:00
auto label = vm().argument_count() ? vm().argument(0).to_string_without_side_effects() : "default";
js: Use new string formatting functions
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);
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
return JS::js_undefined();
}
LibJS: Implement console.assert()
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();
}
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 14:09:05 +00:00
};
js: Take the script file as a command-line argument Now that we have the beginnings of a parser, let's take the script to run as a command-line argument and move all the test scripts into /home/anon/js :^) To run a script, simply use "js": $ js my-script.js To get an AST dump before execution, you can use "js -A"
2020-03-12 09:51:41 +00:00
int main(int argc, char** argv)
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
{
LibJS+js: Add a debug option (js -g) to GC after every allocation This is very useful for discovering collector bugs.
2020-03-16 18:18:46 +00:00
bool gc_on_every_allocation = false;
js: Turn on live syntax highlighting by default
2020-04-30 20:37:50 +00:00
bool disable_syntax_highlight = false;
js: Take the script file as a command-line argument Now that we have the beginnings of a parser, let's take the script to run as a command-line argument and move all the test scripts into /home/anon/js :^) To run a script, simply use "js": $ js my-script.js To get an AST dump before execution, you can use "js -A"
2020-03-12 09:51:41 +00:00
const char* script_path = nullptr;
Core::ArgsParser args_parser;
Userland: Write some '--help' descriptions where appropriate
2020-12-05 15:22:58 +00:00
args_parser.set_general_help("This is a JavaScript interpreter.");
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
args_parser.add_option(s_dump_ast, "Dump the AST", "dump-ast", 'A');
args_parser.add_option(s_print_last_result, "Print last result", "print-last-result", 'l');
LibJS+js: Add a debug option (js -g) to GC after every allocation This is very useful for discovering collector bugs.
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');
js: Turn on live syntax highlighting by default
2020-04-30 20:37:50 +00:00
args_parser.add_option(disable_syntax_highlight, "Disable live syntax highlighting", "no-syntax-highlight", 's');
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
args_parser.add_positional_argument(script_path, "Path to script file", "script", Core::ArgsParser::Required::No);
js: Take the script file as a command-line argument Now that we have the beginnings of a parser, let's take the script to run as a command-line argument and move all the test scripts into /home/anon/js :^) To run a script, simply use "js": $ js my-script.js To get an AST dump before execution, you can use "js -A"
2020-03-12 09:51:41 +00:00
args_parser.parse(argc, argv);
js: Turn on live syntax highlighting by default
2020-04-30 20:37:50 +00:00
bool syntax_highlight = !disable_syntax_highlight;
js: Use VM::exception() instead of Interpreter::exception() The VM is always there, but we only have an Interpreter while we are running code.
2020-09-23 19:29:57 +00:00
vm = JS::VM::create();
js: Hook up promise rejection tracking callbacks We now leverage the VM's promise rejection tracker callbacks and print a warning in either of these cases: - A promise was rejected without any handlers - A handler was added to an already rejected promise
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(")");
};
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 16:59:16 +00:00
OwnPtr<JS::Interpreter> interpreter;
interrupt_interpreter = [&] {
LibJS: Make Errors fully spec compliant The previous handling of the name and message properties specifically was breaking websites that created their own error types and relied on the error prototype working correctly - not assuming an JS::Error this object, that is. The way it works now, and it is supposed to work, is: - Error.prototype.name and Error.prototype.message just have initial string values and are no longer getters/setters - When constructing an error with a message, we create a regular property on the newly created object, so a lookup of the message property will either get it from the object directly or go though the prototype chain - Internal m_name/m_message properties are no longer needed and removed This makes printing errors slightly more complicated, as we can no longer rely on the (safe) internal properties, and cannot trust a property lookup either - get_without_side_effects() is used to solve this, it's not perfect but something we can revisit later. I did some refactoring along the way, there was some really old stuff in there - accessing vm.call_frame().arguments[0] is not something we (have to) do anymore :^) Fixes #6245.
2021-04-11 22:08:28 +00:00
auto error = JS::Error::create(interpreter->global_object(), "Received SIGINT");
LibJS: Move most of Interpreter into VM This patch moves the exception state, call stack and scope stack from Interpreter to VM. I'm doing this to help myself discover what the split between Interpreter and VM should be, by shuffling things around and seeing what falls where. With these changes, we no longer have a persistent lexical environment for the current global object on the Interpreter's call stack. Instead, we push/pop that environment on Interpreter::run() enter/exit. Since it should only be used to find the global "this", and not for variable storage (that goes directly into the global object instead!), I had to insert some short-circuiting when walking the environment parent chain during variable lookup. Note that this is a "stepping stone" commit, not a final design.
2020-09-27 13:18:55 +00:00
vm->throw_exception(interpreter->global_object(), error);
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 16:59:16 +00:00
};
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
if (script_path == nullptr) {
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
s_print_last_result = true;
LibJS+Clients: Add JS::VM object, separate Heap from Interpreter Taking a big step towards a world of multiple global object, this patch adds a new JS::VM object that houses the JS::Heap. This means that the Heap moves out of Interpreter, and the same Heap can now be used by multiple Interpreters, and can also outlive them. The VM keeps a stack of Interpreter pointers. We push/pop on this stack when entering/exiting execution with a given Interpreter. This allows us to make this change without disturbing too much of the existing code. There is still a 1-to-1 relationship between Interpreter and the global object. This will change in the future. Ultimately, the goal here is to make Interpreter a transient object that only needs to exist while you execute some code. Getting there will take a lot more work though. :^) Note that in LibWeb, the global JS::VM is called main_thread_vm(), to distinguish it from future worker VM's.
2020-09-20 17:24:44 +00:00
interpreter = JS::Interpreter::create<ReplObject>(*vm);
LibJS: Move Console from Interpreter to GlobalObject Each JS global object has its own "console", so it makes more sense to store it in GlobalObject. We'll need some smartness later to bundle up console messages from all the different frames that make up a page later, but this works for now.
2020-09-29 19:15:06 +00:00
ReplConsoleClient console_client(interpreter->global_object().console());
interpreter->global_object().console().set_client(console_client);
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
LibJS: Move most of Interpreter into VM This patch moves the exception state, call stack and scope stack from Interpreter to VM. I'm doing this to help myself discover what the split between Interpreter and VM should be, by shuffling things around and seeing what falls where. With these changes, we no longer have a persistent lexical environment for the current global object on the Interpreter's call stack. Instead, we push/pop that environment on Interpreter::run() enter/exit. Since it should only be used to find the global "this", and not for variable storage (that goes directly into the global object instead!), I had to insert some short-circuiting when walking the environment parent chain during variable lookup. Note that this is a "stepping stone" commit, not a final design.
2020-09-27 13:18:55 +00:00
interpreter->vm().set_underscore_is_last_value(true);
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
LibLine: Use Core::EventLoop for outer read loop This commit changes LibLine's internal structure to work in an event loop, and as a result, also switches it to being a Core::Object.
2020-05-26 10:34:39 +00:00
s_editor = Line::Editor::construct();
js: Load and save history from/to ~/.js-history This is super useful when hacking on LibJS and in general :^)
2020-10-25 23:36:06 +00:00
s_editor->load_history(s_history_path);
Userland: Install LibLine's signal handlers in the JS repl
2020-04-11 09:09:10 +00:00
signal(SIGINT, [](int) {
LibLine: Ignore interrupts unless actively editing It does not make much sense to receive an interrupt and process it *much later*. Also patches Userland/js to only create exceptions while some code is actually running.
2020-04-28 20:01:22 +00:00
if (!s_editor->is_editing())
sigint_handler();
js: Load and save history from/to ~/.js-history This is super useful when hacking on LibJS and in general :^)
2020-10-25 23:36:06 +00:00
s_editor->save_history(s_history_path);
Userland: Install LibLine's signal handlers in the JS repl
2020-04-11 09:09:10 +00:00
});
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
s_editor->on_display_refresh = [syntax_highlight](Line::Editor& editor) {
JS repl: Fix indentation when a line starts with '})]'
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();
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
size_t open_indents = s_repl_line_level;
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 03:30:45 +00:00
LibJS: Fix incorrect token column values (#2401) - initializing m_line_column to 1 in the lexer results in incorrect column values in tokens on the first line of input. - not incrementing m_line_column when EOF is reached results in an incorrect column value on the last token.
2020-05-26 17:00:30 +00:00
auto line = editor.line();
JS::Lexer lexer(line);
JS repl: Fix indentation when a line starts with '})]'
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()) {
auto length = token.value().length();
LibJS: Fix incorrect token column values (#2401) - initializing m_line_column to 1 in the lexer results in incorrect column values in tokens on the first line of input. - not incrementing m_line_column when EOF is reached results in an incorrect column value on the last token.
2020-05-26 17:00:30 +00:00
auto start = token.line_column() - 1;
JS repl: Fix indentation when a line starts with '})]'
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;
JS Repl: Add live syntax highlighting This patchset adds live syntax highlighting to the js repl. It is turned off by default and can be enabled via the -s flag.
2020-04-05 14:03:12 +00:00
}
}
JS repl: Fix indentation when a line starts with '})]'
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:
LibLine: Support RGB colors This also patches Userland/js.
2020-05-10 07:57:36 +00:00
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Red), Line::Style::Underline });
JS repl: Fix indentation when a line starts with '})]'
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:
LibLine: Support RGB colors This also patches Userland/js.
2020-05-10 07:57:36 +00:00
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Magenta) });
JS repl: Fix indentation when a line starts with '})]'
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:
LibLine: Support RGB colors This also patches Userland/js.
2020-05-10 07:57:36 +00:00
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Green), Line::Style::Bold });
JS repl: Fix indentation when a line starts with '})]'
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:
JS repl: Fix indentation when a line starts with '})]'
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:
JS repl: Fix indentation when a line starts with '})]'
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:
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow), Line::Style::Bold });
break;
default:
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Bold });
break;
}
JS repl: Fix indentation when a line starts with '})]'
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:
LibLine: Support RGB colors This also patches Userland/js.
2020-05-10 07:57:36 +00:00
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Cyan), Line::Style::Italic });
JS repl: Fix indentation when a line starts with '})]'
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:
LibLine: Support RGB colors This also patches Userland/js.
2020-05-10 07:57:36 +00:00
stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::White), Line::Style::Bold });
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 03:30:45 +00:00
default:
break;
}
}
editor.set_prompt(prompt_for_level(open_indents));
};
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
auto complete = [&interpreter](const Line::Editor& editor) -> Vector<Line::CompletionSuggestion> {
auto line = editor.line(editor.cursor());
JS::Lexer lexer { line };
enum {
Initial,
CompleteVariable,
CompleteNullProperty,
CompleteProperty,
} mode { Initial };
StringView variable_name;
StringView property_name;
LibLine: Display suggestions and cycle between them With extra color (tm) This commit also patches the users of LibLine to properly use the new API
2020-04-11 14:32:15 +00:00
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
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
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
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:
if (js_token.is_identifier_name()) {
// ...<name>...
mode = CompleteVariable;
variable_name = js_token.value();
} else {
mode = Initial;
}
break;
}
}
bool last_token_has_trivia = js_token.trivia().length() > 0;
if (mode == CompleteNullProperty) {
mode = CompleteProperty;
property_name = "";
last_token_has_trivia = false; // <name> <dot> [tab] is sensible to complete.
}
if (mode == Initial || last_token_has_trivia)
return {}; // we do not know how to complete this
LibLine: Allow suggestions to have trailing trivia strings These strings would be applied when inserted into the buffer, but are not shown as part of the suggestion. This commit also patches up Userland/js and Shell to use this functionality
2020-04-19 14:02:28 +00:00
Vector<Line::CompletionSuggestion> results;
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
Function<void(const JS::Shape&, const StringView&)> list_all_properties = [&results, &list_all_properties](const JS::Shape& shape, auto& property_pattern) {
for (const auto& descriptor : shape.property_table()) {
LibJS: Integrate Symbols into objects as valid keys This allows objects properties to be created for symbol keys in addition to just plain strings/numbers
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 };
js: Ignore property attributes for completion Only being able to complete enumerable properties is annoying, especially since we updated everything to use the correct attributes. Most standard built-in objects are *not* enumerable.
2020-05-02 15:01:09 +00:00
if (!results.contains_slow(completion)) { // hide duplicates
LibJS: Integrate Symbols into objects as valid keys This allows objects properties to be created for symbol keys in addition to just plain strings/numbers
2020-07-08 04:38:46 +00:00
results.append(key);
LibLine: Display suggestions and cycle between them With extra color (tm) This commit also patches the users of LibLine to properly use the new API
2020-04-11 14:32:15 +00:00
}
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
}
}
if (const auto* prototype = shape.prototype()) {
list_all_properties(prototype->shape(), property_pattern);
}
};
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
switch (mode) {
case CompleteProperty: {
LibJS: Move most of Interpreter into VM This patch moves the exception state, call stack and scope stack from Interpreter to VM. I'm doing this to help myself discover what the split between Interpreter and VM should be, by shuffling things around and seeing what falls where. With these changes, we no longer have a persistent lexical environment for the current global object on the Interpreter's call stack. Instead, we push/pop that environment on Interpreter::run() enter/exit. Since it should only be used to find the global "this", and not for variable storage (that goes directly into the global object instead!), I had to insert some short-circuiting when walking the environment parent chain during variable lookup. Note that this is a "stepping stone" commit, not a final design.
2020-09-27 13:18:55 +00:00
auto maybe_variable = vm->get_variable(variable_name, interpreter->global_object());
LibJS: Stop using Optional<Value> in favor of Value's empty state JS::Value already has the empty state ({} or Value() gives you one.) Use this instead of wrapping Value in Optional in some places. I've also added Value::value_or(Value) so you can easily provide a fallback value when one is not present.
2020-04-25 16:43:34 +00:00
if (maybe_variable.is_empty()) {
LibJS: Simplify and normalize publicly-exposed Object functions Previously, the Object class had many different types of functions for each action. For example: get_by_index, get(PropertyName), get(FlyString). This is a bit verbose, so these methods have been shortened to simply use the PropertyName structure. The methods then internally call _by_index if necessary. Note that the _by_index have been made private to enforce this change. Secondly, a clear distinction has been made between "putting" and "defining" an object property. "Putting" should mean modifying a (potentially) already existing property. This is akin to doing "a.b = 'foo'". This implies two things about put operations: - They will search the prototype chain for setters and call them, if necessary. - If no property exists with a particular key, the put operation should create a new property with the default attributes (configurable, writable, and enumerable). In contrast, "defining" a property should completely overwrite any existing value without calling setters (if that property is configurable, of course). Thus, all of the many JS objects have had any "put" calls changed to "define_property" calls. Additionally, "put_native_function" and "put_native_property" have had their "put" replaced with "define". Finally, "put_own_property" has been made private, as all necessary functionality should be exposed with the put and define_property methods.
2020-05-27 04:33:37 +00:00
maybe_variable = interpreter->global_object().get(FlyString(variable_name));
LibJS: Stop using Optional<Value> in favor of Value's empty state JS::Value already has the empty state ({} or Value() gives you one.) Use this instead of wrapping Value in Optional in some places. I've also added Value::value_or(Value) so you can easily provide a fallback value when one is not present.
2020-04-25 16:43:34 +00:00
if (maybe_variable.is_empty())
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
break;
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
}
LibJS: Stop using Optional<Value> in favor of Value's empty state JS::Value already has the empty state ({} or Value() gives you one.) Use this instead of wrapping Value in Optional in some places. I've also added Value::value_or(Value) so you can easily provide a fallback value when one is not present.
2020-04-25 16:43:34 +00:00
auto variable = maybe_variable;
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
if (!variable.is_object())
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
break;
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 16:36:49 +00:00
const auto* object = variable.to_object(interpreter->global_object());
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
const auto& shape = object->shape();
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
list_all_properties(shape, property_name);
LibLine: Display suggestions and cycle between them With extra color (tm) This commit also patches the users of LibLine to properly use the new API
2020-04-11 14:32:15 +00:00
if (results.size())
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
editor.suggest(property_name.length());
break;
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
}
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
case CompleteVariable: {
const auto& variable = interpreter->global_object();
list_all_properties(variable.shape(), variable_name);
if (results.size())
editor.suggest(variable_name.length());
break;
}
default:
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 19:42:32 +00:00
VERIFY_NOT_REACHED();
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
}
Userland: Add primitive autocomplete to the JS repl This patch adds primitive support for autocompletion in the JS repl, it only supports completing global names and properties on variables :^)
2020-04-11 09:09:55 +00:00
return results;
};
LibLine: Unify completion hooks and adapt its users LibLine should ultimately not care about what a "token" means in the context of its user, so force the user to split the buffer itself. This also allows the users to pick up contextual clues as well, since they have to lex the line themselves. This commit pacthes Shell and the JS repl to better handle completions, so certain wrong behaviours are now corrected as well: - JS repl can now complete "Object . getOw<tab>" - Shell can now complete "echo | ca<tab>" and paths inside strings
2020-05-19 04:12:01 +00:00
s_editor->on_tab_complete = move(complete);
LibJS: Add Interpreter::create<GlobalObjectType>() Force Interpreter construction to go via a create() helper that takes the global object type as a template parameter.
2020-04-01 19:04:51 +00:00
repl(*interpreter);
js: Load and save history from/to ~/.js-history This is super useful when hacking on LibJS and in general :^)
2020-10-25 23:36:06 +00:00
s_editor->save_history(s_history_path);
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
} else {
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-25 22:50:18 +00:00
interpreter = JS::Interpreter::create<ScriptObject>(*vm);
LibJS: Move Console from Interpreter to GlobalObject Each JS global object has its own "console", so it makes more sense to store it in GlobalObject. We'll need some smartness later to bundle up console messages from all the different frames that make up a page later, but this works for now.
2020-09-29 19:15:06 +00:00
ReplConsoleClient console_client(interpreter->global_object().console());
interpreter->global_object().console().set_client(console_client);
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 16:59:16 +00:00
signal(SIGINT, [](int) {
sigint_handler();
});
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
auto file = Core::File::construct(script_path);
LibCore+Everywhere: Move OpenMode out of IODevice ...and make it an enum class so people don't omit "OpenMode".
2021-05-12 09:26:43 +00:00
if (!file->open(Core::OpenMode::ReadOnly)) {
js: Use new string formatting functions
2020-11-09 19:10:59 +00:00
warnln("Failed to open {}: {}", script_path, file->error_string());
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
return 1;
}
auto file_contents = file->read_all();
StringView source;
Userland/JS: Extend the global object when using a REPL When we enter a repl we call initialize_global_object on our custom ReplObject in order to expose REPL specific features. Specifically: help(), exit(code), and load("file1.js", "file2.js", "fileEtc.js").
2020-04-01 19:20:32 +00:00
if (file_has_shebang(file_contents)) {
source = strip_shebang(file_contents);
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
} else {
source = file_contents;
}
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
if (!parse_and_run(*interpreter, source))
LibJS: Do not execute scripts with parse errors This adds missing checks in several LibJS consumers.
2020-04-13 00:05:21 +00:00
return 1;
Userland: Implement JS REPL If you invoke `js` without a script path, it will now enter REPL mode, where you input commands one by one and immediately get each one interpreted in one shared interpreter. We support multi-line commands in case we detect you have unclosed braces or parens or brackets.
2020-03-25 22:10:29 +00:00
}
js: Exercise the garbage collector a little bit
2020-03-08 18:59:59 +00:00
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 18:42:11 +00:00
return 0;
}
Reference in a new issue Copy permalink