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

1364 lines
52 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
/*
LibJS: Start fleshing out a bytecode for the JavaScript engine :^) This patch begins the work of implementing JavaScript execution in a bytecode VM instead of an AST tree-walk interpreter. It's probably quite naive, but we have to start somewhere. The basic idea is that you call Bytecode::Generator::generate() on an AST node and it hands you back a Bytecode::Block filled with instructions that can then be interpreted by a Bytecode::Interpreter. This first version only implements two instructions: Load and Add. :^) Each bytecode block has infinity registers, and the interpreter resizes its register file to fit the block being executed. Two new `js` options are added in this patch as well: `-d` will dump the generated bytecode `-b` will execute the generated bytecode Note that unless `-d` and/or `-b` are specified, none of the bytecode related stuff in LibJS runs at all. This is implemented in parallel with the existing AST interpreter. :^)
2021-06-03 08:46:30 +00:00
* Copyright (c) 2020-2021, 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>
LibJS: Generate bytecode in basic blocks instead of one big block This limits the size of each block (currently set to 1K), and gets us closer to a canonical, more easily analysable bytecode format. As a result of this, "Labels" are now simply entries to basic blocks. Since there is no more 'conditional' jump (as all jumps are always taken), JumpIf{True,False} are unified to JumpConditional, and JumpIfNullish is renamed to JumpNullish. Also fixes #7914 as a result of reimplementing the loop logic.
2021-06-09 02:19:58 +00:00
#include <LibJS/Bytecode/BasicBlock.h>
LibJS: Start fleshing out a bytecode for the JavaScript engine :^) This patch begins the work of implementing JavaScript execution in a bytecode VM instead of an AST tree-walk interpreter. It's probably quite naive, but we have to start somewhere. The basic idea is that you call Bytecode::Generator::generate() on an AST node and it hands you back a Bytecode::Block filled with instructions that can then be interpreted by a Bytecode::Interpreter. This first version only implements two instructions: Load and Add. :^) Each bytecode block has infinity registers, and the interpreter resizes its register file to fit the block being executed. Two new `js` options are added in this patch as well: `-d` will dump the generated bytecode `-b` will execute the generated bytecode Note that unless `-d` and/or `-b` are specified, none of the bytecode related stuff in LibJS runs at all. This is implemented in parallel with the existing AST interpreter. :^)
2021-06-03 08:46:30 +00:00
#include <LibJS/Bytecode/Generator.h>
#include <LibJS/Bytecode/Interpreter.h>
LibJS: Add a basic pass manager and add some basic passes This commit adds a bunch of passes, the most interesting of which is a pass that merges blocks together, and a pass that places blocks that flow into each other next to each other, and a very simply pass that removes duplicate basic blocks. Note that this does not remove the jump at the end of each block in that pass to avoid scope creep in the passes.
2021-06-13 16:10:20 +00:00
#include <LibJS/Bytecode/PassManager.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>
LibJS: Add the DataView built-in object
2021-06-13 22:47:08 +00:00
#include <LibJS/Runtime/DataView.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>
LibJS: Rename Function => FunctionObject
2021-06-27 19:48:34 +00:00
#include <LibJS/Runtime/FunctionObject.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: Implement pretty-printing of Intl.DisplayNames
2021-08-25 02:38:08 +00:00
#include <LibJS/Runtime/Intl/DisplayNames.h>
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 12:44:54 +00:00
#include <LibJS/Runtime/Intl/ListFormat.h>
js: Implement pretty-printing of Intl.Locale
2021-09-02 12:32:55 +00:00
#include <LibJS/Runtime/Intl/Locale.h>
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 11:30:45 +00:00
#include <LibJS/Runtime/Intl/NumberFormat.h>
LibJS: Add the Map built-in object
2021-06-12 20:54:40 +00:00
#include <LibJS/Runtime/Map.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>
LibJS: Rename ScriptFunction => OrdinaryFunctionObject These are basically what the spec calls "ordinary function objects", so let's have the name reflect that. :^)
2021-06-27 20:15:58 +00:00
#include <LibJS/Runtime/OrdinaryFunctionObject.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/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>
LibJS: Add the Set built-in object
2021-06-08 21:08:47 +00:00
#include <LibJS/Runtime/Set.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>
js: Implement pretty-printing of Temporal.Calendar objects
2021-07-14 20:59:49 +00:00
#include <LibJS/Runtime/Temporal/Calendar.h>
js: Implement pretty-printing of Temporal.Duration objects
2021-07-15 23:17:01 +00:00
#include <LibJS/Runtime/Temporal/Duration.h>
js: Implement pretty-printing of Temporal.Instant objects
2021-07-07 16:43:17 +00:00
#include <LibJS/Runtime/Temporal/Instant.h>
js: Implement pretty-printing of Temporal.PlainDate objects
2021-07-22 19:06:27 +00:00
#include <LibJS/Runtime/Temporal/PlainDate.h>
js: Implement pretty-printing of Temporal.PlainDateTime objects
2021-07-22 19:07:16 +00:00
#include <LibJS/Runtime/Temporal/PlainDateTime.h>
js: Implement pretty-printing of Temporal.PlainMonthDay objects
2021-09-06 22:02:33 +00:00
#include <LibJS/Runtime/Temporal/PlainMonthDay.h>
js: Implement pretty-printing of Temporal.PlainTime objects
2021-07-28 18:29:45 +00:00
#include <LibJS/Runtime/Temporal/PlainTime.h>
js: Implement pretty-printing of Temporal.PlainYearMonth objects
2021-09-06 21:57:25 +00:00
#include <LibJS/Runtime/Temporal/PlainYearMonth.h>
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 22:56:32 +00:00
#include <LibJS/Runtime/Temporal/TimeZone.h>
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 17:16:47 +00:00
#include <LibJS/Runtime/Temporal/ZonedDateTime.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/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;
LibJS: Start fleshing out a bytecode for the JavaScript engine :^) This patch begins the work of implementing JavaScript execution in a bytecode VM instead of an AST tree-walk interpreter. It's probably quite naive, but we have to start somewhere. The basic idea is that you call Bytecode::Generator::generate() on an AST node and it hands you back a Bytecode::Block filled with instructions that can then be interpreted by a Bytecode::Interpreter. This first version only implements two instructions: Load and Add. :^) Each bytecode block has infinity registers, and the interpreter resizes its register file to fit the block being executed. Two new `js` options are added in this patch as well: `-d` will dump the generated bytecode `-b` will execute the generated bytecode Note that unless `-d` and/or `-b` are specified, none of the bytecode related stuff in LibJS runs at all. This is implemented in parallel with the existing AST interpreter. :^)
2021-06-03 08:46:30 +00:00
static bool s_dump_bytecode = false;
static bool s_run_bytecode = false;
LibJS: Add a basic pass manager and add some basic passes This commit adds a bunch of passes, the most interesting of which is a pass that merges blocks together, and a pass that places blocks that flow into each other next to each other, and a very simply pass that removes duplicate basic blocks. Note that this does not remove the jump at the end of each block in that pass to avoid scope creep in the passes.
2021-06-13 16:10:20 +00:00
static bool s_opt_bytecode = false;
LibJS: Add a mode to parse JS as a module In a module strict mode should be enabled at the start of parsing and we allow import and export statements.
2021-08-14 15:30:37 +00:00
static bool s_as_module = false;
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
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);
js: Insert newline after each line in REPL mode This makes ASI work in the REPL.
2021-06-20 20:58:57 +00:00
piece.append('\n');
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 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: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_type(FlyString const& name)
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[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: Rewrite most of Object for spec compliance :^) This is a huge patch, I know. In hindsight this perhaps could've been done slightly more incremental, but I started and then fixed everything until it worked, and here we are. I tried splitting of some completely unrelated changes into separate commits, however. Anyway. This is a rewrite of most of Object, and by extension large parts of Array, Proxy, Reflect, String, TypedArray, and some other things. What we already had worked fine for about 90% of things, but getting the last 10% right proved to be increasingly difficult with the current code that sort of grew organically and is only very loosely based on the spec - this became especially obvious when we started fixing a large number of test262 failures. Key changes include: - 1:1 matching function names and parameters of all object-related functions, to avoid ambiguity. Previously we had things like put(), which the spec doesn't have - as a result it wasn't always clear which need to be used. - Better separation between object abstract operations and internal methods - the former are always the same, the latter can be overridden (and are therefore virtual). The internal methods (i.e. [[Foo]] in the spec) are now prefixed with 'internal_' for clarity - again, it was previously not always clear which AO a certain method represents, get() could've been both Get and [[Get]] (I don't know which one it was closer to right now). Note that some of the old names have been kept until all code relying on them is updated, but they are now simple wrappers around the closest matching standard abstract operation. - Simplifications of the storage layer: functions that write values to storage are now prefixed with 'storage_' to make their purpose clear, and as they are not part of the spec they should not contain any steps specified by it. Much functionality is now covered by the layers above it and was removed (e.g. handling of accessors, attribute checks). - PropertyAttributes has been greatly simplified, and is being replaced by PropertyDescriptor - a concept similar to the current implementation, but more aligned with the actual spec. See the commit message of the previous commit where it was introduced for details. - As a bonus, and since I had to look at the spec a whole lot anyway, I introduced more inline comments with the exact steps from the spec - this makes it super easy to verify correctness. - East-const all the things. As a result of all of this, things are much more correct but a bit slower now. Retaining speed wasn't a consideration at all, I have done no profiling of the new code - there might be low hanging fruits, which we can then harvest separately. Special thanks to Idan for helping me with this by tracking down bugs, updating everything outside of LibJS to work with these changes (LibWeb, Spreadsheet, HackStudio), as well as providing countless patches to fix regressions I introduced - there still are very few (we got it down to 5), but we also get many new passing test262 tests in return. :^) Co-authored-by: Idan Horowitz <idan.horowitz@gmail.com>
2021-07-04 17:14:16 +00:00
auto value = array.get(it.index());
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
// The V8 repl doesn't throw an exception here, and instead just
// prints 'undefined'. We may choose to replicate that behavior in
// the future, but for now lets just catch the error
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: Rewrite most of Object for spec compliance :^) This is a huge patch, I know. In hindsight this perhaps could've been done slightly more incremental, but I started and then fixed everything until it worked, and here we are. I tried splitting of some completely unrelated changes into separate commits, however. Anyway. This is a rewrite of most of Object, and by extension large parts of Array, Proxy, Reflect, String, TypedArray, and some other things. What we already had worked fine for about 90% of things, but getting the last 10% right proved to be increasingly difficult with the current code that sort of grew organically and is only very loosely based on the spec - this became especially obvious when we started fixing a large number of test262 failures. Key changes include: - 1:1 matching function names and parameters of all object-related functions, to avoid ambiguity. Previously we had things like put(), which the spec doesn't have - as a result it wasn't always clear which need to be used. - Better separation between object abstract operations and internal methods - the former are always the same, the latter can be overridden (and are therefore virtual). The internal methods (i.e. [[Foo]] in the spec) are now prefixed with 'internal_' for clarity - again, it was previously not always clear which AO a certain method represents, get() could've been both Get and [[Get]] (I don't know which one it was closer to right now). Note that some of the old names have been kept until all code relying on them is updated, but they are now simple wrappers around the closest matching standard abstract operation. - Simplifications of the storage layer: functions that write values to storage are now prefixed with 'storage_' to make their purpose clear, and as they are not part of the spec they should not contain any steps specified by it. Much functionality is now covered by the layers above it and was removed (e.g. handling of accessors, attribute checks). - PropertyAttributes has been greatly simplified, and is being replaced by PropertyDescriptor - a concept similar to the current implementation, but more aligned with the actual spec. See the commit message of the previous commit where it was introduced for details. - As a bonus, and since I had to look at the spec a whole lot anyway, I introduced more inline comments with the exact steps from the spec - this makes it super easy to verify correctness. - East-const all the things. As a result of all of this, things are much more correct but a bit slower now. Retaining speed wasn't a consideration at all, I have done no profiling of the new code - there might be low hanging fruits, which we can then harvest separately. Special thanks to Idan for helping me with this by tracking down bugs, updating everything outside of LibJS to work with these changes (LibWeb, Spreadsheet, HackStudio), as well as providing countless patches to fix regressions I introduced - there still are very few (we got it down to 5), but we also get many new passing test262 tests in return. :^) Co-authored-by: Idan Horowitz <idan.horowitz@gmail.com>
2021-07-04 17:14:16 +00:00
auto value = object.get(entry.index());
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 18:35:09 +00:00
// The V8 repl doesn't throw an exception here, and instead just
// prints 'undefined'. We may choose to replicate that behavior in
// the future, but for now lets just catch the error
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: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_function(JS::Object const& 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: Rename ScriptFunction => OrdinaryFunctionObject These are basically what the spec calls "ordinary function objects", so let's have the name reflect that. :^)
2021-06-27 20:15:58 +00:00
if (is<JS::OrdinaryFunctionObject>(object))
js: Convert to east const
2021-07-06 22:58:50 +00:00
out(" {}", static_cast<JS::OrdinaryFunctionObject const&>(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: Convert to east const
2021-07-06 22:58:50 +00:00
out(" {}", static_cast<JS::NativeFunction const&>(object).name());
js: Tweak pretty-printing of functions and null
2020-03-26 13:54:43 +00:00
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_date(JS::Object const& 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");
js: Convert to east const
2021-07-06 22:58:50 +00:00
out(" \033[34;1m{}\033[0m", static_cast<JS::Date const&>(object).string());
js: Implement print function for Date objects
2020-03-31 17:43:45 +00:00
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_error(JS::Object const& 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());
LibJS: Remove the NativeProperty mechanism from LibJS These were an ad-hoc way to implement special behaviour when reading or writing to specific object properties. Because these were effectively replaced by the abillity to override the internal methods of Object, they are no longer needed.
2021-07-07 16:34:26 +00:00
if (name.is_accessor() || message.is_accessor()) {
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_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
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_regexp_object(JS::Object const& object, HashTable<JS::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
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& regexp_object = static_cast<JS::RegExpObject const&>(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
// 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());
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_proxy_object(JS::Object const& object, 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
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& proxy_object = static_cast<JS::ProxyObject const&>(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
print_type("Proxy");
out("\n target: ");
print_value(&proxy_object.target(), seen_objects);
out("\n handler: ");
print_value(&proxy_object.handler(), seen_objects);
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_map(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
LibJS: Add the Map built-in object
2021-06-12 20:54:40 +00:00
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& map = static_cast<JS::Map const&>(object);
LibJS: Add the Map built-in object
2021-06-12 20:54:40 +00:00
auto& entries = map.entries();
print_type("Map");
out(" {{");
bool first = true;
for (auto& entry : entries) {
print_separator(first);
print_value(entry.key, seen_objects);
out(" => ");
print_value(entry.value, seen_objects);
}
if (!first)
out(" ");
out("}}");
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_set(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
LibJS: Add the Set built-in object
2021-06-08 21:08:47 +00:00
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& set = static_cast<JS::Set const&>(object);
LibJS: Add the Set built-in object
2021-06-08 21:08:47 +00:00
auto& values = set.values();
print_type("Set");
out(" {{");
bool first = true;
for (auto& value : values) {
print_separator(first);
print_value(value, seen_objects);
}
if (!first)
out(" ");
out("}}");
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_promise(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
js: Add REPL pretty-printing handler for Promises
2021-04-01 20:14:05 +00:00
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& promise = static_cast<JS::Promise const&>(object);
js: Add REPL pretty-printing handler for Promises
2021-04-01 20:14:05 +00:00
print_type("Promise");
switch (promise.state()) {
case JS::Promise::State::Pending:
out("\n state: ");
out("\033[36;1mPending\033[0m");
break;
case JS::Promise::State::Fulfilled:
out("\n state: ");
out("\033[32;1mFulfilled\033[0m");
out("\n result: ");
print_value(promise.result(), seen_objects);
break;
case JS::Promise::State::Rejected:
out("\n state: ");
out("\033[31;1mRejected\033[0m");
out("\n result: ");
print_value(promise.result(), seen_objects);
break;
default:
VERIFY_NOT_REACHED();
}
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_array_buffer(JS::Object const& object, 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
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& array_buffer = static_cast<JS::ArrayBuffer const&>(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
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(" ");
}
}
}
js: Add print_number method and use it to print out TypedArray values We can't construct Values with u64 and i64. I tried adding these constructors, but then it refuses to build in lagom.
2021-06-17 00:00:12 +00:00
template<typename T>
static void print_number(T number) requires IsArithmetic<T>
{
out("\033[35;1m");
out("{}", number);
out("\033[0m");
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_typed_array(JS::Object const& object, 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
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& typed_array_base = static_cast<JS::TypedArrayBase const&>(object);
js: Handle detached ArrayBuffer in print_typed_array() Co-authored-by: Idan Horowitz <idan.horowitz@gmail.com>
2021-07-04 16:36:10 +00:00
auto& array_buffer = *typed_array_base.viewed_array_buffer();
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
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");
js: Handle detached ArrayBuffer in print_typed_array() Co-authored-by: Idan Horowitz <idan.horowitz@gmail.com>
2021-07-04 16:36:10 +00:00
if (array_buffer.is_detached())
out(" (detached)");
out(" @ {:p}", &array_buffer);
if (!length || array_buffer.is_detached())
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;
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("[ "); \
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& typed_array = static_cast<JS::ClassName const&>(typed_array_base); \
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
auto data = typed_array.data(); \
for (size_t i = 0; i < length; ++i) { \
if (i > 0) \
out(", "); \
js: Add print_number method and use it to print out TypedArray values We can't construct Values with u64 and i64. I tried adding these constructors, but then it refuses to build in lagom.
2021-06-17 00:00:12 +00:00
print_number(data[i]); \
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(" ]"); \
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: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_data_view(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
LibJS: Add the DataView built-in object
2021-06-13 22:47:08 +00:00
{
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto& data_view = static_cast<JS::DataView const&>(object);
LibJS: Add the DataView built-in object
2021-06-13 22:47:08 +00:00
print_type("DataView");
out("\n byteLength: ");
print_value(JS::Value(data_view.byte_length()), seen_objects);
out("\n byteOffset: ");
print_value(JS::Value(data_view.byte_offset()), seen_objects);
out("\n buffer: ");
print_type("ArrayBuffer");
out(" @ {:p}", data_view.viewed_array_buffer());
}
js: Implement pretty-printing of Temporal.Calendar objects
2021-07-14 20:59:49 +00:00
static void print_temporal_calendar(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& calendar = static_cast<JS::Temporal::Calendar const&>(object);
print_type("Temporal.Calendar");
out(" ");
print_value(JS::js_string(object.vm(), calendar.identifier()), seen_objects);
}
js: Implement pretty-printing of Temporal.Duration objects
2021-07-15 23:17:01 +00:00
static void print_temporal_duration(JS::Object const& object, HashTable<JS::Object*>&)
{
auto& duration = static_cast<JS::Temporal::Duration const&>(object);
print_type("Temporal.Duration");
out(" \033[34;1m{} y, {} M, {} w, {} d, {} h, {} m, {} s, {} ms, {} us, {} ns\033[0m", duration.years(), duration.months(), duration.weeks(), duration.days(), duration.hours(), duration.minutes(), duration.seconds(), duration.milliseconds(), duration.microseconds(), duration.nanoseconds());
}
js: Implement pretty-printing of Temporal.Instant objects
2021-07-07 16:43:17 +00:00
static void print_temporal_instant(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& instant = static_cast<JS::Temporal::Instant const&>(object);
print_type("Temporal.Instant");
js: Tweak pretty-printing of Temporal.{Instant,TimeZone} objects No need for the key/value style here, just put it right after the type.
2021-07-14 20:59:17 +00:00
out(" ");
js: Implement pretty-printing of Temporal.Instant objects
2021-07-07 16:43:17 +00:00
// FIXME: Print human readable date and time, like in print_date() - ideally handling arbitrarily large values since we get a bigint.
print_value(&instant.nanoseconds(), seen_objects);
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
static void print_temporal_plain_date(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
js: Implement pretty-printing of Temporal.PlainDate objects
2021-07-22 19:06:27 +00:00
{
auto& plain_date = static_cast<JS::Temporal::PlainDate const&>(object);
print_type("Temporal.PlainDate");
out(" \033[34;1m{:04}-{:02}-{:02}\033[0m", plain_date.iso_year(), plain_date.iso_month(), plain_date.iso_day());
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
out("\n calendar: ");
print_value(&plain_date.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainDate objects
2021-07-22 19:06:27 +00:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
static void print_temporal_plain_date_time(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
js: Implement pretty-printing of Temporal.PlainDateTime objects
2021-07-22 19:07:16 +00:00
{
auto& plain_date_time = static_cast<JS::Temporal::PlainDateTime const&>(object);
print_type("Temporal.PlainDateTime");
out(" \033[34;1m{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}{:03}{:03}\033[0m", plain_date_time.iso_year(), plain_date_time.iso_month(), plain_date_time.iso_day(), plain_date_time.iso_hour(), plain_date_time.iso_minute(), plain_date_time.iso_second(), plain_date_time.iso_millisecond(), plain_date_time.iso_microsecond(), plain_date_time.iso_nanosecond());
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
out("\n calendar: ");
print_value(&plain_date_time.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainDateTime objects
2021-07-22 19:07:16 +00:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
static void print_temporal_plain_month_day(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
js: Implement pretty-printing of Temporal.PlainMonthDay objects
2021-09-06 22:02:33 +00:00
{
auto& plain_month_day = static_cast<JS::Temporal::PlainMonthDay const&>(object);
print_type("Temporal.PlainMonthDay");
// Also has an [[ISOYear]] internal slot, but showing that here seems rather unexpected.
out(" \033[34;1m{:02}-{:02}\033[0m", plain_month_day.iso_month(), plain_month_day.iso_day());
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
out("\n calendar: ");
print_value(&plain_month_day.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainMonthDay objects
2021-09-06 22:02:33 +00:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
static void print_temporal_plain_time(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
js: Implement pretty-printing of Temporal.PlainTime objects
2021-07-28 18:29:45 +00:00
{
auto& plain_time = static_cast<JS::Temporal::PlainTime const&>(object);
print_type("Temporal.PlainTime");
out(" \033[34;1m{:02}:{:02}:{:02}.{:03}{:03}{:03}\033[0m", plain_time.iso_hour(), plain_time.iso_minute(), plain_time.iso_second(), plain_time.iso_millisecond(), plain_time.iso_microsecond(), plain_time.iso_nanosecond());
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
out("\n calendar: ");
print_value(&plain_time.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainTime objects
2021-07-28 18:29:45 +00:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
static void print_temporal_plain_year_month(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
js: Implement pretty-printing of Temporal.PlainYearMonth objects
2021-09-06 21:57:25 +00:00
{
auto& plain_year_month = static_cast<JS::Temporal::PlainYearMonth const&>(object);
print_type("Temporal.PlainYearMonth");
// Also has an [[ISODay]] internal slot, but showing that here seems rather unexpected.
out(" \033[34;1m{:04}-{:02}\033[0m", plain_year_month.iso_year(), plain_year_month.iso_month());
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 22:08:28 +00:00
out("\n calendar: ");
print_value(&plain_year_month.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainYearMonth objects
2021-09-06 21:57:25 +00:00
}
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 22:56:32 +00:00
static void print_temporal_time_zone(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& time_zone = static_cast<JS::Temporal::TimeZone const&>(object);
print_type("Temporal.TimeZone");
js: Tweak pretty-printing of Temporal.{Instant,TimeZone} objects No need for the key/value style here, just put it right after the type.
2021-07-14 20:59:17 +00:00
out(" ");
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 22:56:32 +00:00
print_value(JS::js_string(object.vm(), time_zone.identifier()), seen_objects);
if (time_zone.offset_nanoseconds().has_value()) {
out("\n offset (ns): ");
print_value(JS::Value(*time_zone.offset_nanoseconds()), seen_objects);
}
}
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 17:16:47 +00:00
static void print_temporal_zoned_date_time(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& zoned_date_time = static_cast<JS::Temporal::ZonedDateTime const&>(object);
print_type("Temporal.ZonedDateTime");
out("\n epochNanoseconds: ");
print_value(&zoned_date_time.nanoseconds(), seen_objects);
out("\n timeZone: ");
print_value(&zoned_date_time.time_zone(), seen_objects);
out("\n calendar: ");
print_value(&zoned_date_time.calendar(), seen_objects);
}
js: Implement pretty-printing of Intl.DisplayNames
2021-08-25 02:38:08 +00:00
static void print_intl_display_names(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& display_names = static_cast<JS::Intl::DisplayNames const&>(object);
print_type("Intl.DisplayNames");
out("\n locale: ");
print_value(js_string(object.vm(), display_names.locale()), seen_objects);
out("\n type: ");
print_value(js_string(object.vm(), display_names.type_string()), seen_objects);
out("\n style: ");
print_value(js_string(object.vm(), display_names.style_string()), seen_objects);
out("\n fallback: ");
print_value(js_string(object.vm(), display_names.fallback_string()), seen_objects);
}
js: Implement pretty-printing of Intl.Locale
2021-09-02 12:32:55 +00:00
static void print_intl_locale(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& locale = static_cast<JS::Intl::Locale const&>(object);
print_type("Intl.Locale");
out("\n locale: ");
print_value(js_string(object.vm(), locale.locale()), seen_objects);
if (locale.has_calendar()) {
out("\n calendar: ");
print_value(js_string(object.vm(), locale.calendar()), seen_objects);
}
if (locale.has_case_first()) {
out("\n caseFirst: ");
print_value(js_string(object.vm(), locale.case_first()), seen_objects);
}
if (locale.has_collation()) {
out("\n collation: ");
print_value(js_string(object.vm(), locale.collation()), seen_objects);
}
if (locale.has_hour_cycle()) {
out("\n hourCycle: ");
print_value(js_string(object.vm(), locale.hour_cycle()), seen_objects);
}
if (locale.has_numbering_system()) {
out("\n numberingSystem: ");
print_value(js_string(object.vm(), locale.numbering_system()), seen_objects);
}
out("\n numeric: ");
print_value(JS::Value(locale.numeric()), seen_objects);
}
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 12:44:54 +00:00
static void print_intl_list_format(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& list_format = static_cast<JS::Intl::ListFormat const&>(object);
print_type("Intl.ListFormat");
out("\n locale: ");
print_value(js_string(object.vm(), list_format.locale()), seen_objects);
out("\n type: ");
print_value(js_string(object.vm(), list_format.type_string()), seen_objects);
out("\n style: ");
print_value(js_string(object.vm(), list_format.style_string()), seen_objects);
}
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 11:30:45 +00:00
static void print_intl_number_format(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
{
auto& number_format = static_cast<JS::Intl::NumberFormat const&>(object);
print_type("Intl.NumberFormat");
out("\n locale: ");
print_value(js_string(object.vm(), number_format.locale()), seen_objects);
out("\n dataLocale: ");
print_value(js_string(object.vm(), number_format.data_locale()), seen_objects);
out("\n numberingSystem: ");
print_value(js_string(object.vm(), number_format.numbering_system()), seen_objects);
out("\n style: ");
print_value(js_string(object.vm(), number_format.style_string()), seen_objects);
if (number_format.has_currency()) {
out("\n currency: ");
print_value(js_string(object.vm(), number_format.currency()), seen_objects);
}
if (number_format.has_currency_display()) {
out("\n currencyDisplay: ");
print_value(js_string(object.vm(), number_format.currency_display_string()), seen_objects);
}
if (number_format.has_currency_sign()) {
out("\n currencySign: ");
print_value(js_string(object.vm(), number_format.currency_sign_string()), seen_objects);
}
if (number_format.has_unit()) {
out("\n unit: ");
print_value(js_string(object.vm(), number_format.unit()), seen_objects);
}
if (number_format.has_unit_display()) {
out("\n unitDisplay: ");
print_value(js_string(object.vm(), number_format.unit_display_string()), seen_objects);
}
out("\n minimumIntegerDigits: ");
print_value(JS::Value(number_format.min_integer_digits()), seen_objects);
if (number_format.has_min_fraction_digits()) {
out("\n minimumFractionDigits: ");
print_value(JS::Value(number_format.min_fraction_digits()), seen_objects);
}
if (number_format.has_max_fraction_digits()) {
out("\n maximumFractionDigits: ");
print_value(JS::Value(number_format.max_fraction_digits()), seen_objects);
}
if (number_format.has_min_significant_digits()) {
out("\n minimumSignificantDigits: ");
print_value(JS::Value(number_format.min_significant_digits()), seen_objects);
}
if (number_format.has_max_significant_digits()) {
out("\n maximumSignificantDigits: ");
print_value(JS::Value(number_format.max_significant_digits()), seen_objects);
}
out("\n useGrouping: ");
print_value(JS::Value(number_format.use_grouping()), seen_objects);
out("\n roundingType: ");
print_value(js_string(object.vm(), number_format.rounding_type_string()), seen_objects);
out("\n notation: ");
print_value(js_string(object.vm(), number_format.notation_string()), seen_objects);
if (number_format.has_compact_display()) {
out("\n compactDisplay: ");
print_value(js_string(object.vm(), number_format.compact_display_string()), seen_objects);
}
out("\n signDisplay: ");
print_value(js_string(object.vm(), number_format.sign_display_string()), seen_objects);
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static void print_primitive_wrapper_object(FlyString const& name, JS::Object const& object, HashTable<JS::Object*>& seen_objects)
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
}
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();
LibJS: Remove Object::is_array() in favor of Value::is_array() and RTTI It's way too easy to get this wrong: for the IsArray abstract operation, Value::is_array() needs to be called. Since we have RTTI, the virtual Object::is_array() method is not needed anymore - if we need to know whether something is *actually* a JS::Array (we currently check in more cases than we should, I think) and not a Proxy with an Array target, we should do that in a way that doesn't look like an abstract operation.
2021-07-05 17:58:51 +00:00
if (is<JS::Array>(object))
LibJS: Handle Proxy with Array target in IsArray() abstract operation This was missing from Value::is_array(), which is equivalent to the spec's IsArray() abstract operation - it treats a Proxy value with an Array target object as being an Array. It can throw, so needs both the global object and an exception check now.
2021-06-08 20:53:36 +00:00
return print_array(static_cast<JS::Array&>(object), seen_objects);
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 (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: Add the Map built-in object
2021-06-12 20:54:40 +00:00
if (is<JS::Map>(object))
return print_map(object, seen_objects);
LibJS: Add the Set built-in object
2021-06-08 21:08:47 +00:00
if (is<JS::Set>(object))
return print_set(object, seen_objects);
LibJS: Add the DataView built-in object
2021-06-13 22:47:08 +00:00
if (is<JS::DataView>(object))
return print_data_view(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 pretty-printing of Temporal.Calendar objects
2021-07-14 20:59:49 +00:00
if (is<JS::Temporal::Calendar>(object))
return print_temporal_calendar(object, seen_objects);
js: Implement pretty-printing of Temporal.Duration objects
2021-07-15 23:17:01 +00:00
if (is<JS::Temporal::Duration>(object))
return print_temporal_duration(object, seen_objects);
js: Implement pretty-printing of Temporal.Instant objects
2021-07-07 16:43:17 +00:00
if (is<JS::Temporal::Instant>(object))
return print_temporal_instant(object, seen_objects);
js: Implement pretty-printing of Temporal.PlainDate objects
2021-07-22 19:06:27 +00:00
if (is<JS::Temporal::PlainDate>(object))
return print_temporal_plain_date(object, seen_objects);
js: Implement pretty-printing of Temporal.PlainDateTime objects
2021-07-22 19:07:16 +00:00
if (is<JS::Temporal::PlainDateTime>(object))
return print_temporal_plain_date_time(object, seen_objects);
js: Implement pretty-printing of Temporal.PlainMonthDay objects
2021-09-06 22:02:33 +00:00
if (is<JS::Temporal::PlainMonthDay>(object))
return print_temporal_plain_month_day(object, seen_objects);
js: Implement pretty-printing of Temporal.PlainTime objects
2021-07-28 18:29:45 +00:00
if (is<JS::Temporal::PlainTime>(object))
return print_temporal_plain_time(object, seen_objects);
js: Implement pretty-printing of Temporal.PlainYearMonth objects
2021-09-06 21:57:25 +00:00
if (is<JS::Temporal::PlainYearMonth>(object))
return print_temporal_plain_year_month(object, seen_objects);
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 22:56:32 +00:00
if (is<JS::Temporal::TimeZone>(object))
return print_temporal_time_zone(object, seen_objects);
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 17:16:47 +00:00
if (is<JS::Temporal::ZonedDateTime>(object))
return print_temporal_zoned_date_time(object, seen_objects);
js: Implement pretty-printing of Intl.DisplayNames
2021-08-25 02:38:08 +00:00
if (is<JS::Intl::DisplayNames>(object))
return print_intl_display_names(object, seen_objects);
js: Implement pretty-printing of Intl.Locale
2021-09-02 12:32:55 +00:00
if (is<JS::Intl::Locale>(object))
return print_intl_locale(object, seen_objects);
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 12:44:54 +00:00
if (is<JS::Intl::ListFormat>(object))
return print_intl_list_format(object, seen_objects);
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 11:30:45 +00:00
if (is<JS::Intl::NumberFormat>(object))
return print_intl_number_format(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
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static bool write_to_file(String const& 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;
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
static bool parse_and_run(JS::Interpreter& interpreter, StringView const& source)
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
{
LibJS: Add a mode to parse JS as a module In a module strict mode should be enabled at the start of parsing and we allow import and export statements.
2021-08-14 15:30:37 +00:00
auto program_type = s_as_module ? JS::Program::Type::Module : JS::Program::Type::Script;
auto parser = JS::Parser(JS::Lexer(source), program_type);
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 15:29:24 +00:00
auto program = parser.parse_program();
if (s_dump_ast)
program->dump(0);
if (parser.has_errors()) {
auto error = parser.errors()[0];
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: Don't generate bytecode after we've encountered a parser error
2021-06-10 19:04:12 +00:00
if (s_dump_bytecode || s_run_bytecode) {
auto unit = JS::Bytecode::Generator::generate(*program);
LibJS: Add a basic pass manager and add some basic passes This commit adds a bunch of passes, the most interesting of which is a pass that merges blocks together, and a pass that places blocks that flow into each other next to each other, and a very simply pass that removes duplicate basic blocks. Note that this does not remove the jump at the end of each block in that pass to avoid scope creep in the passes.
2021-06-13 16:10:20 +00:00
if (s_opt_bytecode) {
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
passes.perform(unit);
dbgln("Optimisation passes took {}us", passes.elapsed());
}
LibJS: Don't generate bytecode after we've encountered a parser error
2021-06-10 19:04:12 +00:00
if (s_dump_bytecode) {
for (auto& block : unit.basic_blocks)
block.dump(unit);
if (!unit.string_table->is_empty()) {
outln();
unit.string_table->dump();
}
}
if (s_run_bytecode) {
LibJS: Allocate a Realm next to GlobalObject in Interpreter::create() Also pass a Realm reference to the Bytecode::Interpreter constructor, just like we pass the GlobalObject.
2021-09-11 18:36:25 +00:00
JS::Bytecode::Interpreter bytecode_interpreter(interpreter.global_object(), interpreter.realm());
LibJS: Don't generate bytecode after we've encountered a parser error
2021-06-10 19:04:12 +00:00
bytecode_interpreter.run(unit);
LibJS: Show the VM's last value after executing bytecode programs
2021-06-10 19:04:32 +00:00
} else {
return true;
LibJS: Don't generate bytecode after we've encountered a parser error
2021-06-10 19:04:12 +00:00
}
} else {
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();
LibJS: Implement the 'Hashbang Grammar for JS' proposal Stage 3 since August 2019 - we already have shebang stripping implemented in js(1), so this removes it from there in favor of adding support to the lexer directly. Most straightforward proposal and implementation I've ever seen :^) https://github.com/tc39/proposal-hashbang
2021-06-18 18:11:26 +00:00
auto source = StringView { file_contents };
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
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();
LibJS: Add define_direct_property and remove the define_property helper This removes all usages of the non-standard define_property helper method and replaces all it's usages with the specification required alternative or with define_direct_property where appropriate.
2021-07-05 23:15:08 +00:00
define_direct_property("global", this, JS::Attribute::Enumerable);
LibJS: Remove the default length & attributes from define_native_* These are usually incorrect, and people sometimes forget to add the correct values as a result of them being optional, so they should just be specified explicitly.
2021-07-05 22:12:54 +00:00
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
define_native_function("exit", exit_interpreter, 0, attr);
define_native_function("help", repl_help, 0, attr);
define_native_function("load", load_file, 1, attr);
define_native_function("save", save_to_file, 1, attr);
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();
LibJS: Add define_direct_property and remove the define_property helper This removes all usages of the non-standard define_property helper method and replaces all it's usages with the specification required alternative or with define_direct_property where appropriate.
2021-07-05 23:15:08 +00:00
define_direct_property("global", this, JS::Attribute::Enumerable);
LibJS: Remove the default length & attributes from define_native_* These are usually incorrect, and people sometimes forget to add the correct values as a result of them being optional, so they should just be specified explicitly.
2021-07-05 22:12:54 +00:00
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
define_native_function("load", load_file, 1, attr);
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
}
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;
LibJS+js+test-js: Add GC debug mode that keeps cells "alive" as zombies This patch adds a `-z` option to js and test-js. When run in this mode, garbage cells are never actually destroyed. We instead keep them around in a special zombie state. This allows us to validate that zombies don't get marked in future GC scans (since there were not supposed to be any more references!) :^) Cells get notified when they become a zombie (via did_become_zombie()) and this is used by WeakContainer cells to deregister themselves from the heap.
2021-09-11 14:44:40 +00:00
bool zombify_dead_cells = false;
js: Turn on live syntax highlighting by default
2020-04-30 20:37:50 +00:00
bool disable_syntax_highlight = false;
Userland: Allow multiple files to be run by js js only accepted a single script file to run before this. With this patch, multiple scripts can be run in the same execution environment, allowing the user to specify a "preamble script" to be executed before the main script.
2021-06-16 13:55:34 +00:00
Vector<String> script_paths;
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
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');
LibJS: Start fleshing out a bytecode for the JavaScript engine :^) This patch begins the work of implementing JavaScript execution in a bytecode VM instead of an AST tree-walk interpreter. It's probably quite naive, but we have to start somewhere. The basic idea is that you call Bytecode::Generator::generate() on an AST node and it hands you back a Bytecode::Block filled with instructions that can then be interpreted by a Bytecode::Interpreter. This first version only implements two instructions: Load and Add. :^) Each bytecode block has infinity registers, and the interpreter resizes its register file to fit the block being executed. Two new `js` options are added in this patch as well: `-d` will dump the generated bytecode `-b` will execute the generated bytecode Note that unless `-d` and/or `-b` are specified, none of the bytecode related stuff in LibJS runs at all. This is implemented in parallel with the existing AST interpreter. :^)
2021-06-03 08:46:30 +00:00
args_parser.add_option(s_dump_bytecode, "Dump the bytecode", "dump-bytecode", 'd');
args_parser.add_option(s_run_bytecode, "Run the bytecode", "run-bytecode", 'b');
LibJS: Add a basic pass manager and add some basic passes This commit adds a bunch of passes, the most interesting of which is a pass that merges blocks together, and a pass that places blocks that flow into each other next to each other, and a very simply pass that removes duplicate basic blocks. Note that this does not remove the jump at the end of each block in that pass to avoid scope creep in the passes.
2021-06-13 16:10:20 +00:00
args_parser.add_option(s_opt_bytecode, "Optimize the bytecode", "optimize-bytecode", 'p');
LibJS: Add a mode to parse JS as a module In a module strict mode should be enabled at the start of parsing and we allow import and export statements.
2021-08-14 15:30:37 +00:00
args_parser.add_option(s_as_module, "Treat as module", "as-module", 'm');
js: Follow Serenity C++ naming conventions
2020-04-26 14:19:30 +00:00
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');
LibJS+js+test-js: Add GC debug mode that keeps cells "alive" as zombies This patch adds a `-z` option to js and test-js. When run in this mode, garbage cells are never actually destroyed. We instead keep them around in a special zombie state. This allows us to validate that zombies don't get marked in future GC scans (since there were not supposed to be any more references!) :^) Cells get notified when they become a zombie (via did_become_zombie()) and this is used by WeakContainer cells to deregister themselves from the heap.
2021-09-11 14:44:40 +00:00
args_parser.add_option(zombify_dead_cells, "Zombify dead cells (to catch missing GC marks)", "zombify-dead-cells", 'z');
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: Allow multiple files to be run by js js only accepted a single script file to run before this. With this patch, multiple scripts can be run in the same execution environment, allowing the user to specify a "preamble script" to be executed before the main script.
2021-06-16 13:55:34 +00:00
args_parser.add_positional_argument(script_paths, "Path to script files", "scripts", 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: Allow multiple files to be run by js js only accepted a single script file to run before this. With this patch, multiple scripts can be run in the same execution environment, allowing the user to specify a "preamble script" to be executed before the main script.
2021-06-16 13:55:34 +00:00
if (script_paths.is_empty()) {
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+js+test-js: Add GC debug mode that keeps cells "alive" as zombies This patch adds a `-z` option to js and test-js. When run in this mode, garbage cells are never actually destroyed. We instead keep them around in a special zombie state. This allows us to validate that zombies don't get marked in future GC scans (since there were not supposed to be any more references!) :^) Cells get notified when they become a zombie (via did_become_zombie()) and this is used by WeakContainer cells to deregister themselves from the heap.
2021-09-11 14:44:40 +00:00
interpreter->heap().set_zombify_dead_cells(zombify_dead_cells);
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()) {
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
auto length = Utf8View { 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:
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
stylize({ start, end, Line::Span::CodepointOriented }, { 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:
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
stylize({ start, end, Line::Span::CodepointOriented }, { 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:
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
stylize({ start, end, Line::Span::CodepointOriented }, { 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:
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Yellow), Line::Style::Bold });
LibJS: Unify syntax highlighting So far we have three different syntax highlighters for LibJS: - js's Line::Editor stylization - JS::MarkupGenerator - GUI::JSSyntaxHighlighter This not only caused repetition of most token types in each highlighter but also a lot of inconsistency regarding the styling of certain tokens: - JSSyntaxHighlighter was considering TokenType::Period to be an operator whereas MarkupGenerator categorized it as punctuation. - MarkupGenerator was considering TokenType::{Break,Case,Continue, Default,Switch,With} control keywords whereas JSSyntaxHighlighter just disregarded them - MarkupGenerator considered some future reserved keywords invalid and others not. JSSyntaxHighlighter and js disregarded most Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well as each individual highlighter's switch/case construct. I added a TokenCategory enum, and each TokenType is now associated to a certain category, which the syntax highlighters then can use for styling rather than operating on the token type directly. This also makes changing a token's category everywhere easier, should we need to do that (e.g. I decided to make TokenType::{Period,QuestionMarkPeriod} TokenCategory::Operator for now, but we might want to change them to Punctuation.
2020-10-04 21:28:59 +00:00
break;
default:
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::Blue), Line::Style::Bold });
LibJS: Unify syntax highlighting So far we have three different syntax highlighters for LibJS: - js's Line::Editor stylization - JS::MarkupGenerator - GUI::JSSyntaxHighlighter This not only caused repetition of most token types in each highlighter but also a lot of inconsistency regarding the styling of certain tokens: - JSSyntaxHighlighter was considering TokenType::Period to be an operator whereas MarkupGenerator categorized it as punctuation. - MarkupGenerator was considering TokenType::{Break,Case,Continue, Default,Switch,With} control keywords whereas JSSyntaxHighlighter just disregarded them - MarkupGenerator considered some future reserved keywords invalid and others not. JSSyntaxHighlighter and js disregarded most Adding a new token type meant adding it to ENUMERATE_JS_TOKENS as well as each individual highlighter's switch/case construct. I added a TokenCategory enum, and each TokenType is now associated to a certain category, which the syntax highlighters then can use for styling rather than operating on the token type directly. This also makes changing a token's category everywhere easier, should we need to do that (e.g. I decided to make TokenType::{Period,QuestionMarkPeriod} TokenCategory::Operator for now, but we might want to change them to Punctuation.
2020-10-04 21:28:59 +00:00
break;
}
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:
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
stylize({ start, end, Line::Span::CodepointOriented }, { 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:
js: Use CodepointOriented spans and use the codepoint length of token We were previously using byte-oriented spans. This would work if not for token.line_column() being in codepoints.
2021-09-01 16:13:53 +00:00
stylize({ start, end, Line::Span::CodepointOriented }, { Line::Style::Foreground(Line::Style::XtermColor::White), Line::Style::Bold });
Everywhere: Add break after the last case label before `default` We already do this in most places, so the style should be consistent. Also, Clang does not like it, as this could cause an unexpected compile error if some statements are added to the default label or a new label is added above it.
2021-07-05 17:17:08 +00:00
break;
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
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto complete = [&interpreter](Line::Editor const& editor) -> Vector<Line::CompletionSuggestion> {
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 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:
Utilities: Make the js REPL autocomplete correctly handle `new Ident` Previously, `new` was being recognised as an identifier, which was preventing this from working.
2021-07-15 22:03:09 +00:00
if (js_token.type() == JS::TokenType::Identifier) {
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
// ...<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
js: Convert to east const
2021-07-06 22:58:50 +00:00
Function<void(JS::Shape const&, StringView const&)> list_all_properties = [&results, &list_all_properties](JS::Shape const& shape, auto& property_pattern) {
for (auto const& descriptor : shape.property_table()) {
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: Make StringOrSymbol always be FlyString in the string case This makes equality checking O(1) instead of O(n).
2021-06-13 10:00:27 +00:00
results.append(String(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
}
}
js: Convert to east const
2021-07-06 22:58:50 +00:00
if (auto const* prototype = shape.prototype()) {
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
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
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto const* object = variable.to_object(interpreter->global_object());
auto const& 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: {
js: Convert to east const
2021-07-06 22:58:50 +00:00
auto const& variable = interpreter->global_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
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);
LibJS+js+test-js: Add GC debug mode that keeps cells "alive" as zombies This patch adds a `-z` option to js and test-js. When run in this mode, garbage cells are never actually destroyed. We instead keep them around in a special zombie state. This allows us to validate that zombies don't get marked in future GC scans (since there were not supposed to be any more references!) :^) Cells get notified when they become a zombie (via did_become_zombie()) and this is used by WeakContainer cells to deregister themselves from the heap.
2021-09-11 14:44:40 +00:00
interpreter->heap().set_zombify_dead_cells(zombify_dead_cells);
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: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 16:59:16 +00:00
signal(SIGINT, [](int) {
sigint_handler();
});
Userland: Allow multiple files to be run by js js only accepted a single script file to run before this. With this patch, multiple scripts can be run in the same execution environment, allowing the user to specify a "preamble script" to be executed before the main script.
2021-06-16 13:55:34 +00:00
StringBuilder builder;
for (auto& path : script_paths) {
auto file = Core::File::construct(path);
if (!file->open(Core::OpenMode::ReadOnly)) {
warnln("Failed to open {}: {}", path, file->error_string());
return 1;
}
auto file_contents = file->read_all();
LibJS: Implement the 'Hashbang Grammar for JS' proposal Stage 3 since August 2019 - we already have shebang stripping implemented in js(1), so this removes it from there in favor of adding support to the lexer directly. Most straightforward proposal and implementation I've ever seen :^) https://github.com/tc39/proposal-hashbang
2021-06-18 18:11:26 +00:00
auto source = StringView { file_contents };
Userland: Allow multiple files to be run by js js only accepted a single script file to run before this. With this patch, multiple scripts can be run in the same execution environment, allowing the user to specify a "preamble script" to be executed before the main script.
2021-06-16 13:55:34 +00:00
builder.append(source);
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
}
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
Userland: Allow multiple files to be run by js js only accepted a single script file to run before this. With this patch, multiple scripts can be run in the same execution environment, allowing the user to specify a "preamble script" to be executed before the main script.
2021-06-16 13:55:34 +00:00
if (!parse_and_run(*interpreter, builder.to_string()))
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