Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Utilities/js.cpp

1572 lines
61 KiB
C++
Raw Normal View History

LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
/*
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 10:46:30 +02:00
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
Everywhere: Use linusg@serenityos.org for my copyright headers
2021-04-22 22:51:19 +02: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 19:42:11 +01: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 01:24:48 -07: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 19:42:11 +01:00
*/
Utilities: Correct non-standard assert macros includes
2021-05-15 12:34:40 +02: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 10:51:41 +01: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 19:42:11 +01: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-26 01:10:29 +03: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 10:51:41 +01: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>
LibCore+LibSystem: Move syscall wrappers from LibSystem to LibCore With this change, System::foo() becomes Core::System::foo(). Since LibCore builds on other systems than SerenityOS, we now have to make sure that wrappers work with just a standard C library underneath.
2021-11-23 10:59:50 +01:00
#include <LibCore/System.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 19:42:11 +01: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 06:49:58 +04:30
#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 10:46:30 +02: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 20:40:20 +04:30
#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 16:09:05 +02: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 19:42:11 +01: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 19:27:43 +01:00
#include <LibJS/Parser.h>
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01: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-14 01:47:08 +03:00
#include <LibJS/Runtime/DataView.h>
js: Implement print function for Date objects
2020-03-31 18:43:45 +01:00
#include <LibJS/Runtime/Date.h>
LibJS+js: Pretty-print Date objects using the ToDateString AO
2022-01-14 17:55:11 -05:00
#include <LibJS/Runtime/DatePrototype.h>
LibJS: Rename OrdinaryFunctionObject to ECMAScriptFunctionObject The old name is the result of the perhaps somewhat confusingly named abstract operation OrdinaryFunctionCreate(), which creates an "ordinary object" (https://tc39.es/ecma262/#ordinary-object) in contrast to an "exotic object" (https://tc39.es/ecma262/#exotic-object). However, the term "Ordinary Function" is not used anywhere in the spec, instead the created object is referred to as an "ECMAScript Function Object" (https://tc39.es/ecma262/#sec-ecmascript-function-objects), so let's call it that. The "ordinary" vs. "exotic" distinction is important because there are also "Built-in Function Objects", which can be either implemented as ordinary ECMAScript function objects, or as exotic objects (our NativeFunction). More work needs to be done to move a lot of infrastructure to ECMAScriptFunctionObject in order to make FunctionObject nothing more than an interface for objects that implement [[Call]] and optionally [[Construct]].
2021-09-24 22:40:38 +02:00
#include <LibJS/Runtime/ECMAScriptFunctionObject.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 09:54:15 +02:00
#include <LibJS/Runtime/Error.h>
LibJS: Rename Function => FunctionObject
2021-06-27 21:48:34 +02: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 18:53:28 +02:00
#include <LibJS/Runtime/GlobalObject.h>
js: Implement pretty-printing of Intl.DateTimeFormat
2021-11-28 18:05:32 -05:00
#include <LibJS/Runtime/Intl/DateTimeFormat.h>
js: Implement pretty-printing of Intl.DisplayNames
2021-08-24 22:38:08 -04:00
#include <LibJS/Runtime/Intl/DisplayNames.h>
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 08:44:54 -04:00
#include <LibJS/Runtime/Intl/ListFormat.h>
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
#include <LibJS/Runtime/Intl/Locale.h>
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
#include <LibJS/Runtime/Intl/NumberFormat.h>
js: Add a simple loadJSON(path) built-in to load JSON from a file This is very handy when you want to load data from /proc, for example.
2021-09-16 21:48:07 +02:00
#include <LibJS/Runtime/JSONObject.h>
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03: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 14:20:30 +01:00
#include <LibJS/Runtime/Object.h>
#include <LibJS/Runtime/PrimitiveString.h>
js: Add REPL pretty-printing handler for Promises
2021-04-01 22:14:05 +02: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 16:05:49 -07:00
#include <LibJS/Runtime/RegExpObject.h>
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
#include <LibJS/Runtime/Set.h>
js: Implement pretty-printing of ShadowRealm
2021-10-13 22:05:27 +01:00
#include <LibJS/Runtime/ShadowRealm.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 19:32:21 +02: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 21:59:49 +01:00
#include <LibJS/Runtime/Temporal/Calendar.h>
js: Implement pretty-printing of Temporal.Duration objects
2021-07-16 00:17:01 +01:00
#include <LibJS/Runtime/Temporal/Duration.h>
js: Implement pretty-printing of Temporal.Instant objects
2021-07-07 17:43:17 +01:00
#include <LibJS/Runtime/Temporal/Instant.h>
js: Implement pretty-printing of Temporal.PlainDate objects
2021-07-22 20:06:27 +01:00
#include <LibJS/Runtime/Temporal/PlainDate.h>
js: Implement pretty-printing of Temporal.PlainDateTime objects
2021-07-22 20:07:16 +01:00
#include <LibJS/Runtime/Temporal/PlainDateTime.h>
js: Implement pretty-printing of Temporal.PlainMonthDay objects
2021-09-06 23:02:33 +01:00
#include <LibJS/Runtime/Temporal/PlainMonthDay.h>
js: Implement pretty-printing of Temporal.PlainTime objects
2021-07-28 19:29:45 +01:00
#include <LibJS/Runtime/Temporal/PlainTime.h>
js: Implement pretty-printing of Temporal.PlainYearMonth objects
2021-09-06 22:57:25 +01:00
#include <LibJS/Runtime/Temporal/PlainYearMonth.h>
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 23:56:32 +01:00
#include <LibJS/Runtime/Temporal/TimeZone.h>
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 18:16:47 +01: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 14:20:30 +01:00
#include <LibJS/Runtime/Value.h>
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
#include <LibJS/SourceTextModule.h>
LibLine: Rename LineEditor.{cpp,h} => Editor.{cpp,h}
2020-03-31 13:34:57 +02:00
#include <LibLine/Editor.h>
js: Port to LibMain :^) This wasn't particularly difficult, and there's not much use for the nicer interface yet either. While unveil() is of limited use in js(1) as it should be able to open arbitrary files, I feel like we should be able to add a pledge() call.
2021-11-22 19:25:30 +00:00
#include <LibMain/Main.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 19:21:59 +01:00
#include <fcntl.h>
Userland: Install LibLine's signal handlers in the JS repl
2020-04-11 13:39:10 +04:30
#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 19:42:11 +01:00
#include <stdio.h>
Userland: Invoke tzset in applications that care about time zones In most applications, we invoke tzset once at startup for now. Most of these are short lived and don't need to know about time zone changes. The exception is the ClockWidget in the taskbar. Here, we invoke tzset each time we update the system time. This way, any time zone changes can take effect immediately.
2022-01-24 16:12:19 -05:00
#include <time.h>
Everywhere: Remove klog(), dbg() and purge all LogStream usage :^) Good-bye LogStream. Long live AK::Format!
2021-03-12 17:29:37 +01: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 19:42:11 +01: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 21:29:57 +02: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 11:52:40 -04:00
Vector<String> repl_statements;
LibJS: Fix that '_' no longer accessed the last value in the REPL This is now also not a concept that VM knows about and handled completely by the REPL.
2022-01-16 02:05:32 +01:00
JS::Handle<JS::Value> last_value = JS::make_handle(JS::js_undefined());
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 11:52:40 -04: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 16:52:26 +01: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 15:20:32 -04:00
public:
js: Use default constructor and destructor for global objects
2021-05-26 01:01:07 +01: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 16:52:26 +01:00
virtual void initialize_global_object() override;
js: Use default constructor and destructor for global objects
2021-05-26 01:01:07 +01: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 15:20:32 -04:00
private:
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
JS_DECLARE_NATIVE_FUNCTION(exit_interpreter);
JS_DECLARE_NATIVE_FUNCTION(repl_help);
JS_DECLARE_NATIVE_FUNCTION(load_file);
JS_DECLARE_NATIVE_FUNCTION(save_to_file);
JS_DECLARE_NATIVE_FUNCTION(load_json);
LibJS: Fix that '_' no longer accessed the last value in the REPL This is now also not a concept that VM knows about and handled completely by the REPL.
2022-01-16 02:05:32 +01:00
JS_DECLARE_NATIVE_FUNCTION(last_value_getter);
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 15:20:32 -04:00
};
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-26 00:50:18 +02: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 01:01:07 +01:00
ScriptObject() = default;
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-26 00:50:18 +02:00
virtual void initialize_global_object() override;
js: Use default constructor and destructor for global objects
2021-05-26 01:01:07 +01: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-26 00:50:18 +02:00
private:
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
JS_DECLARE_NATIVE_FUNCTION(load_file);
JS_DECLARE_NATIVE_FUNCTION(load_json);
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-26 00:50:18 +02:00
};
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01: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 10:46:30 +02:00
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 20:40:20 +04:30
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 17:30:37 +02:00
static bool s_as_module = false;
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01:00
static bool s_print_last_result = false;
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
static bool s_strip_ansi = false;
js: Add command line flag for disabling source line hints
2021-11-23 23:02:19 +02:00
static bool s_disable_source_location_hints = 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 15:04:39 +04:30
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 15:19:30 +01: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 16:57:07 +04:30
static bool s_fail_repl = false;
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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-26 01:10:29 +03:00
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 23:48:37 +02: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-26 01:10:29 +03:00
{
StringBuilder piece;
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 21:42:11 +04:30
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-26 01:10:29 +03: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 16:57:07 +04:30
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 21:42:11 +04:30
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 16:57:07 +04:30
if (line_result.is_error()) {
s_fail_repl = true;
return "";
}
auto& line = line_result.value();
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01: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-26 01:10:29 +03:00
piece.append(line);
js: Insert newline after each line in REPL mode This makes ASI work in the REPL.
2021-06-20 13:58:57 -07: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-26 01:10:29 +03:00
auto lexer = JS::Lexer(line);
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 21:42:11 +04:30
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-26 01:10:29 +03: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 21:42:11 +04:30
label_state = NotInLabelOrObjectKey;
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01: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-26 01:10:29 +03: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 21:42:11 +04:30
label_state = NotInLabelOrObjectKey;
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01: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-26 01:10:29 +03:00
break;
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 21:42:11 +04:30
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-26 01:10:29 +03:00
default:
break;
}
}
Userland/js: Prompt for more input on labels and object keys Closes #2452
2020-05-30 21:42:11 +04:30
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-26 01:10:29 +03:00
return piece.to_string();
}
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
static String strip_ansi(StringView format_string)
{
if (format_string.is_empty())
return String::empty();
StringBuilder builder;
size_t i;
for (i = 0; i < format_string.length() - 1; ++i) {
if (format_string[i] == '\033' && format_string[i + 1] == '[') {
while (i < format_string.length() && format_string[i] != 'm')
++i;
} else {
builder.append(format_string[i]);
}
}
if (i < format_string.length())
builder.append(format_string[i]);
return builder.to_string();
}
template<typename... Parameters>
static void js_out(CheckedFormatString<Parameters...>&& fmtstr, const Parameters&... parameters)
{
if (!s_strip_ansi)
return out(move(fmtstr), parameters...);
auto stripped_fmtstr = strip_ansi(fmtstr.view());
out(stripped_fmtstr, parameters...);
}
template<typename... Parameters>
static void js_outln(CheckedFormatString<Parameters...>&& fmtstr, const Parameters&... parameters)
{
if (!s_strip_ansi)
return outln(move(fmtstr), parameters...);
auto stripped_fmtstr = strip_ansi(fmtstr.view());
outln(stripped_fmtstr, parameters...);
}
inline void js_outln() { outln(); }
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects);
js: Convert to east const
2021-07-06 23:58:50 +01: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
{
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("[\033[36;1m{}\033[0m]", 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
}
static void print_separator(bool& first)
{
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(first ? " " : ", ");
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
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 11:35:09 -07:00
static void print_array(JS::Array& array, HashTable<JS::Object*>& seen_objects)
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
{
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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 11:35:09 -07: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: Convert Object::get() to ThrowCompletionOr To no one's surprise, this patch is pretty big - this is possibly the most used AO of all of them. Definitely worth it though.
2021-10-02 23:52:27 +01:00
auto value_or_error = array.get(it.index());
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 11:35:09 -07: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
LibJS: Convert Object::get() to ThrowCompletionOr To no one's surprise, this patch is pretty big - this is possibly the most used AO of all of them. Definitely worth it though.
2021-10-02 23:52:27 +01:00
if (value_or_error.is_error())
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 11:35:09 -07:00
return;
LibJS: Convert Object::get() to ThrowCompletionOr To no one's surprise, this patch is pretty big - this is possibly the most used AO of all of them. Definitely worth it though.
2021-10-02 23:52:27 +01:00
auto value = value_or_error.release_value();
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 11:35:09 -07:00
print_value(value, seen_objects);
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01: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)
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
js_out("]");
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01: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 11:35:09 -07:00
static void print_object(JS::Object& object, HashTable<JS::Object*>& seen_objects)
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
{
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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 11:35:09 -07: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: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\"\033[33;1m{}\033[0m\": ", entry.index());
LibJS: Convert Object::get() to ThrowCompletionOr To no one's surprise, this patch is pretty big - this is possibly the most used AO of all of them. Definitely worth it though.
2021-10-02 23:52:27 +01:00
auto value_or_error = object.get(entry.index());
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 11:35:09 -07: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
LibJS: Convert Object::get() to ThrowCompletionOr To no one's surprise, this patch is pretty big - this is possibly the most used AO of all of them. Definitely worth it though.
2021-10-02 23:52:27 +01:00
if (value_or_error.is_error())
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 11:35:09 -07:00
return;
LibJS: Convert Object::get() to ThrowCompletionOr To no one's surprise, this patch is pretty big - this is possibly the most used AO of all of them. Definitely worth it though.
2021-10-02 23:52:27 +01:00
auto value = value_or_error.release_value();
LibJS: Object index properties have descriptors; Handle sparse indices This patch adds an IndexedProperties object for storing indexed properties within an Object. This accomplishes two goals: indexed properties now have an associated descriptor, and objects now gracefully handle sparse properties. The IndexedProperties class is a wrapper around two other classes, one for simple indexed properties storage, and one for general indexed property storage. Simple indexed property storage is the common-case, and is simply a vector of properties which all have attributes of default_attributes (writable, enumerable, and configurable). General indexed property storage is for a collection of indexed properties where EITHER one or more properties have attributes other than default_attributes OR there is a property with a large index (in particular, large is '200' or higher). Indexed properties are now treated relatively the same as storage within the various Object methods. Additionally, there is a custom iterator class for IndexedProperties which makes iteration easy. The iterator skips empty values by default, but can be configured otherwise. Likewise, it evaluates getters by default, but can be set not to.
2020-05-27 11:35:09 -07:00
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 16:53:02 +02: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-28 19:19:31 -07: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-07 21:38:46 -07:00
if (it.key.is_string()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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-07 21:38:46 -07:00
} else {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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-07 21:38:46 -07: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 19:32:21 +02:00
print_value(object.get_direct(it.value.offset), seen_objects);
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01: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)
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
js_out("}}");
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
}
js: Convert to east const
2021-07-06 23:58:50 +01:00
static void print_function(JS::Object const& object, HashTable<JS::Object*>&)
js: Tweak pretty-printing of functions and null
2020-03-26 14:54:43 +01: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 OrdinaryFunctionObject to ECMAScriptFunctionObject The old name is the result of the perhaps somewhat confusingly named abstract operation OrdinaryFunctionCreate(), which creates an "ordinary object" (https://tc39.es/ecma262/#ordinary-object) in contrast to an "exotic object" (https://tc39.es/ecma262/#exotic-object). However, the term "Ordinary Function" is not used anywhere in the spec, instead the created object is referred to as an "ECMAScript Function Object" (https://tc39.es/ecma262/#sec-ecmascript-function-objects), so let's call it that. The "ordinary" vs. "exotic" distinction is important because there are also "Built-in Function Objects", which can be either implemented as ordinary ECMAScript function objects, or as exotic objects (our NativeFunction). More work needs to be done to move a lot of infrastructure to ECMAScriptFunctionObject in order to make FunctionObject nothing more than an interface for objects that implement [[Call]] and optionally [[Construct]].
2021-09-24 22:40:38 +02:00
if (is<JS::ECMAScriptFunctionObject>(object))
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" {}", static_cast<JS::ECMAScriptFunctionObject const&>(object).name());
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 17:46:39 +01:00
else if (is<JS::NativeFunction>(object))
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" {}", static_cast<JS::NativeFunction const&>(object).name());
js: Tweak pretty-printing of functions and null
2020-03-26 14:54:43 +01:00
}
js: Convert to east const
2021-07-06 23:58:50 +01:00
static void print_date(JS::Object const& object, HashTable<JS::Object*>&)
js: Implement print function for Date objects
2020-03-31 18:43:45 +01:00
{
js: Improve pretty-printing of various objects For many object types we only ever used the regular print_object() in the js REPL - resulting in a useless "{ }". This patch adds more individual representations for the following types: - Boolean/Number/String object: print wrapped value - ArrayBuffer: print byteLength and hex-formatted bytes in chunks of 16 - TypedArray: print length, byteLength, buffer pointer and values - Proxy: print target and handler Also improve the existing pretty-printing output: - More consistency, most objects now follow the format "[Type] ..." - Some coloring tweaks - No two spaces in empty arrays & objects Possible future improvements: - Add line breaks between elements of long arrays & objects Closes #4310.
2020-12-04 22:58:10 +00:00
print_type("Date");
LibJS+js: Pretty-print Date objects using the ToDateString AO
2022-01-14 17:55:11 -05:00
js_out(" \033[34;1m{}\033[0m", JS::to_date_string(static_cast<JS::Date const&>(object).date_value()));
js: Implement print function for Date objects
2020-03-31 18:43:45 +01:00
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 09:54:15 +02: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-12 00:08:28 +02: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 19:34:26 +03: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-12 00:08:28 +02: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())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" \033[31;1m{}\033[0m", message_string);
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-12 00:08:28 +02: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
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 23:58:50 +01: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
print_type("RegExp");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" \033[34;1m/{}/{}\033[0m", regexp_object.escape_regexp_pattern(), regexp_object.flags());
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 23:58:50 +01: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 23:58:50 +01: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n target: ");
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_value(&proxy_object.target(), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n handler: ");
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_value(&proxy_object.handler(), seen_objects);
}
js: Convert to east const
2021-07-06 23:58:50 +01:00
static void print_map(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
{
js: Convert to east const
2021-07-06 23:58:50 +01:00
auto& map = static_cast<JS::Map const&>(object);
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
auto& entries = map.entries();
print_type("Map");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" {{");
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
bool first = true;
for (auto& entry : entries) {
print_separator(first);
print_value(entry.key, seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" => ");
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
print_value(entry.value, seen_objects);
}
if (!first)
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
js_out("}}");
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
}
js: Convert to east const
2021-07-06 23:58:50 +01:00
static void print_set(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
{
js: Convert to east const
2021-07-06 23:58:50 +01:00
auto& set = static_cast<JS::Set const&>(object);
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
auto& values = set.values();
print_type("Set");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" {{");
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
bool first = true;
for (auto& value : values) {
print_separator(first);
print_value(value, seen_objects);
}
if (!first)
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
js_out("}}");
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 22:14:05 +02:00
{
js: Convert to east const
2021-07-06 23:58:50 +01:00
auto& promise = static_cast<JS::Promise const&>(object);
js: Add REPL pretty-printing handler for Promises
2021-04-01 22:14:05 +02:00
print_type("Promise");
switch (promise.state()) {
case JS::Promise::State::Pending:
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n state: ");
js_out("\033[36;1mPending\033[0m");
js: Add REPL pretty-printing handler for Promises
2021-04-01 22:14:05 +02:00
break;
case JS::Promise::State::Fulfilled:
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n state: ");
js_out("\033[32;1mFulfilled\033[0m");
js_out("\n result: ");
js: Add REPL pretty-printing handler for Promises
2021-04-01 22:14:05 +02:00
print_value(promise.result(), seen_objects);
break;
case JS::Promise::State::Rejected:
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n state: ");
js_out("\033[31;1mRejected\033[0m");
js_out("\n result: ");
js: Add REPL pretty-printing handler for Promises
2021-04-01 22:14:05 +02:00
print_value(promise.result(), seen_objects);
break;
default:
VERIFY_NOT_REACHED();
}
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 23:58:50 +01: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n byteLength: ");
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_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 19:20:43 +01:00
if (!byte_length)
return;
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln();
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
for (size_t i = 0; i < byte_length; ++i) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("{:02x}", buffer[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
if (i + 1 < byte_length) {
if ((i + 1) % 32 == 0)
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln();
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
else if ((i + 1) % 16 == 0)
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
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
else
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
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: Implement pretty-printing of ShadowRealm
2021-10-13 22:05:27 +01:00
static void print_shadow_realm(JS::Object const&, HashTable<JS::Object*>&)
{
// Not much we can show here that would be useful. Realm pointer address?!
print_type("ShadowRealm");
}
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 01:00:12 +01:00
template<typename T>
static void print_number(T number) requires IsArithmetic<T>
{
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[35;1m");
js_out("{}", number);
js_out("\033[0m");
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 01:00:12 +01:00
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 23:58:50 +01: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 17:36:10 +01: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());
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n length: ");
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_value(JS::Value(length), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n byteLength: ");
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_value(JS::Value(typed_array_base.byte_length()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n 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
print_type("ArrayBuffer");
js: Handle detached ArrayBuffer in print_typed_array() Co-authored-by: Idan Horowitz <idan.horowitz@gmail.com>
2021-07-04 17:36:10 +01:00
if (array_buffer.is_detached())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" (detached)");
js_out(" @ {:p}", &array_buffer);
js: Handle detached ArrayBuffer in print_typed_array() Co-authored-by: Idan Horowitz <idan.horowitz@gmail.com>
2021-07-04 17:36:10 +01:00
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;
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln();
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
// 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 18:34:18 +01:00
if (is<JS::ClassName>(object)) { \
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("[ "); \
js: Convert to east const
2021-07-06 23:58:50 +01: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) \
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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 01:00:12 +01: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
} \
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ]"); \
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; \
}
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 20:42:32 +01: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 09:54:15 +02:00
}
js: Convert to east const
2021-07-06 23:58:50 +01:00
static void print_data_view(JS::Object const& object, HashTable<JS::Object*>& seen_objects)
LibJS: Add the DataView built-in object
2021-06-14 01:47:08 +03:00
{
js: Convert to east const
2021-07-06 23:58:50 +01:00
auto& data_view = static_cast<JS::DataView const&>(object);
LibJS: Add the DataView built-in object
2021-06-14 01:47:08 +03:00
print_type("DataView");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n byteLength: ");
LibJS: Add the DataView built-in object
2021-06-14 01:47:08 +03:00
print_value(JS::Value(data_view.byte_length()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n byteOffset: ");
LibJS: Add the DataView built-in object
2021-06-14 01:47:08 +03:00
print_value(JS::Value(data_view.byte_offset()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n buffer: ");
LibJS: Add the DataView built-in object
2021-06-14 01:47:08 +03:00
print_type("ArrayBuffer");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" @ {:p}", data_view.viewed_array_buffer());
LibJS: Add the DataView built-in object
2021-06-14 01:47:08 +03:00
}
js: Implement pretty-printing of Temporal.Calendar objects
2021-07-14 21:59:49 +01: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
js: Implement pretty-printing of Temporal.Calendar objects
2021-07-14 21:59:49 +01:00
print_value(JS::js_string(object.vm(), calendar.identifier()), seen_objects);
}
js: Implement pretty-printing of Temporal.Duration objects
2021-07-16 00:17:01 +01: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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.Duration objects
2021-07-16 00:17:01 +01:00
}
js: Implement pretty-printing of Temporal.Instant objects
2021-07-07 17:43:17 +01: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: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
js: Implement pretty-printing of Temporal.Instant objects
2021-07-07 17:43:17 +01: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 23:08:28 +01: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 20:06:27 +01:00
{
auto& plain_date = static_cast<JS::Temporal::PlainDate const&>(object);
print_type("Temporal.PlainDate");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" \033[34;1m{:04}-{:02}-{:02}\033[0m", plain_date.iso_year(), plain_date.iso_month(), plain_date.iso_day());
js_out("\n calendar: ");
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01:00
print_value(&plain_date.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainDate objects
2021-07-22 20:06:27 +01:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01: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 20:07:16 +01:00
{
auto& plain_date_time = static_cast<JS::Temporal::PlainDateTime const&>(object);
print_type("Temporal.PlainDateTime");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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_out("\n calendar: ");
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01:00
print_value(&plain_date_time.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainDateTime objects
2021-07-22 20:07:16 +01:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01: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 23:02:33 +01: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.
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" \033[34;1m{:02}-{:02}\033[0m", plain_month_day.iso_month(), plain_month_day.iso_day());
js_out("\n calendar: ");
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01:00
print_value(&plain_month_day.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainMonthDay objects
2021-09-06 23:02:33 +01:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01: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 19:29:45 +01:00
{
auto& plain_time = static_cast<JS::Temporal::PlainTime const&>(object);
print_type("Temporal.PlainTime");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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_out("\n calendar: ");
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01:00
print_value(&plain_time.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainTime objects
2021-07-28 19:29:45 +01:00
}
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01: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 22:57:25 +01: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.
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" \033[34;1m{:04}-{:02}\033[0m", plain_year_month.iso_year(), plain_year_month.iso_month());
js_out("\n calendar: ");
js: Include calendar in pretty-printing output of more Temporal objects We were only showing it for ZonedDateTime so far.
2021-09-06 23:08:28 +01:00
print_value(&plain_year_month.calendar(), seen_objects);
js: Implement pretty-printing of Temporal.PlainYearMonth objects
2021-09-06 22:57:25 +01:00
}
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 23:56:32 +01: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: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 23:56:32 +01:00
print_value(JS::js_string(object.vm(), time_zone.identifier()), seen_objects);
if (time_zone.offset_nanoseconds().has_value()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n offset (ns): ");
js: Implement pretty-printing of Temporal.TimeZone objects
2021-07-06 23:56:32 +01:00
print_value(JS::Value(*time_zone.offset_nanoseconds()), seen_objects);
}
}
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 18:16:47 +01: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n epochNanoseconds: ");
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 18:16:47 +01:00
print_value(&zoned_date_time.nanoseconds(), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n timeZone: ");
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 18:16:47 +01:00
print_value(&zoned_date_time.time_zone(), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n calendar: ");
js: Implement pretty-printing of Temporal.ZonedDateTime objects
2021-08-01 18:16:47 +01:00
print_value(&zoned_date_time.calendar(), seen_objects);
}
js: Implement pretty-printing of Intl.DisplayNames
2021-08-24 22:38:08 -04: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n locale: ");
js: Implement pretty-printing of Intl.DisplayNames
2021-08-24 22:38:08 -04:00
print_value(js_string(object.vm(), display_names.locale()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n type: ");
js: Implement pretty-printing of Intl.DisplayNames
2021-08-24 22:38:08 -04:00
print_value(js_string(object.vm(), display_names.type_string()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n style: ");
js: Implement pretty-printing of Intl.DisplayNames
2021-08-24 22:38:08 -04:00
print_value(js_string(object.vm(), display_names.style_string()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n fallback: ");
js: Implement pretty-printing of Intl.DisplayNames
2021-08-24 22:38:08 -04:00
print_value(js_string(object.vm(), display_names.fallback_string()), seen_objects);
js: Pretty-print the Intl.DisplayNames [[LanguageDisplay]] internal slot
2022-01-12 13:56:04 -05:00
if (display_names.has_language_display()) {
js_out("\n languageDisplay: ");
print_value(js_string(object.vm(), display_names.language_display_string()), seen_objects);
}
js: Implement pretty-printing of Intl.DisplayNames
2021-08-24 22:38:08 -04:00
}
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n locale: ");
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
print_value(js_string(object.vm(), locale.locale()), seen_objects);
if (locale.has_calendar()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n calendar: ");
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
print_value(js_string(object.vm(), locale.calendar()), seen_objects);
}
if (locale.has_case_first()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n caseFirst: ");
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
print_value(js_string(object.vm(), locale.case_first()), seen_objects);
}
if (locale.has_collation()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n collation: ");
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
print_value(js_string(object.vm(), locale.collation()), seen_objects);
}
if (locale.has_hour_cycle()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n hourCycle: ");
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
print_value(js_string(object.vm(), locale.hour_cycle()), seen_objects);
}
if (locale.has_numbering_system()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n numberingSystem: ");
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
print_value(js_string(object.vm(), locale.numbering_system()), seen_objects);
}
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n numeric: ");
js: Implement pretty-printing of Intl.Locale
2021-09-02 08:32:55 -04:00
print_value(JS::Value(locale.numeric()), seen_objects);
}
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 08:44:54 -04: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n locale: ");
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 08:44:54 -04:00
print_value(js_string(object.vm(), list_format.locale()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n type: ");
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 08:44:54 -04:00
print_value(js_string(object.vm(), list_format.type_string()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n style: ");
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 08:44:54 -04:00
print_value(js_string(object.vm(), list_format.style_string()), seen_objects);
}
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04: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");
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n locale: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.locale()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n dataLocale: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.data_locale()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n numberingSystem: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.numbering_system()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n style: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.style_string()), seen_objects);
if (number_format.has_currency()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n currency: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.currency()), seen_objects);
}
if (number_format.has_currency_display()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n currencyDisplay: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.currency_display_string()), seen_objects);
}
if (number_format.has_currency_sign()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n currencySign: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.currency_sign_string()), seen_objects);
}
if (number_format.has_unit()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n unit: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.unit()), seen_objects);
}
if (number_format.has_unit_display()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n unitDisplay: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.unit_display_string()), seen_objects);
}
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n minimumIntegerDigits: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(JS::Value(number_format.min_integer_digits()), seen_objects);
if (number_format.has_min_fraction_digits()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n minimumFractionDigits: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(JS::Value(number_format.min_fraction_digits()), seen_objects);
}
if (number_format.has_max_fraction_digits()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n maximumFractionDigits: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(JS::Value(number_format.max_fraction_digits()), seen_objects);
}
if (number_format.has_min_significant_digits()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n minimumSignificantDigits: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(JS::Value(number_format.min_significant_digits()), seen_objects);
}
if (number_format.has_max_significant_digits()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n maximumSignificantDigits: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(JS::Value(number_format.max_significant_digits()), seen_objects);
}
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n useGrouping: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(JS::Value(number_format.use_grouping()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n roundingType: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.rounding_type_string()), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n notation: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.notation_string()), seen_objects);
if (number_format.has_compact_display()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n compactDisplay: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.compact_display_string()), seen_objects);
}
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\n signDisplay: ");
js: Implement pretty-printing of Intl.NumberFormat
2021-09-10 07:30:45 -04:00
print_value(js_string(object.vm(), number_format.sign_display_string()), seen_objects);
}
js: Implement pretty-printing of Intl.DateTimeFormat
2021-11-28 18:05:32 -05:00
static void print_intl_date_time_format(JS::Object& object, HashTable<JS::Object*>& seen_objects)
{
auto& date_time_format = static_cast<JS::Intl::DateTimeFormat&>(object);
print_type("Intl.DateTimeFormat");
js_out("\n locale: ");
print_value(js_string(object.vm(), date_time_format.locale()), seen_objects);
js_out("\n pattern: ");
print_value(js_string(object.vm(), date_time_format.pattern()), seen_objects);
js_out("\n calendar: ");
print_value(js_string(object.vm(), date_time_format.calendar()), seen_objects);
js_out("\n numberingSystem: ");
print_value(js_string(object.vm(), date_time_format.numbering_system()), seen_objects);
if (date_time_format.has_hour_cycle()) {
js_out("\n hourCycle: ");
print_value(js_string(object.vm(), date_time_format.hour_cycle_string()), seen_objects);
}
js_out("\n timeZone: ");
print_value(js_string(object.vm(), date_time_format.time_zone()), seen_objects);
if (date_time_format.has_date_style()) {
js_out("\n dateStyle: ");
print_value(js_string(object.vm(), date_time_format.date_style_string()), seen_objects);
}
if (date_time_format.has_time_style()) {
js_out("\n timeStyle: ");
print_value(js_string(object.vm(), date_time_format.time_style_string()), seen_objects);
}
JS::Intl::for_each_calendar_field(date_time_format.global_object(), date_time_format, [&](auto& option, auto const& property, auto const&) -> JS::ThrowCompletionOr<void> {
using ValueType = typename RemoveReference<decltype(option)>::ValueType;
if (!option.has_value())
return {};
js_out("\n {}: ", property);
if constexpr (IsIntegral<ValueType>) {
print_value(JS::Value(*option), seen_objects);
} else {
auto name = Unicode::calendar_pattern_style_to_string(*option);
print_value(js_string(object.vm(), name), seen_objects);
}
return {};
});
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 16:05:49 -07: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);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out(" ");
LibJS: Remove Object::value_of() Being really close to Object.prototype.valueOf() name wise makes this unnecessarily confusing - while it sometimes serves as the implementation of a valueOf() function, it's an abstraction which the spec doesn't have. Use the appropriate getters to retrieve specific internal slots instead, most commonly [[FooData]] from the primitive wrapper objects. For the Object class specifically, use the Value(Object*) ctor instead.
2021-12-10 22:50:02 +00:00
print_value(&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 16:05:49 -07:00
}
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 23:48:37 +02:00
static void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects)
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
{
LibJS: Handle empty values in Value::to_string()
2020-04-08 17:38:09 +01:00
if (value.is_empty()) {
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[34;1m<empty>\033[0m");
LibJS: Handle empty values in Value::to_string()
2020-04-08 17:38:09 +01:00
return;
}
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01: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 22:18:47 +02:00
if (seen_objects.contains(&value.as_object())) {
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
// FIXME: Maybe we should only do this for circular references,
// not for all reoccurring objects.
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("<already printed Object {}>", &value.as_object());
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01: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 22:18:47 +02:00
seen_objects.set(&value.as_object());
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
}
js: Implement print function for Date objects
2020-03-31 18:43:45 +01: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 22:18:47 +02: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 18:58:51 +01: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 21:53:36 +01: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 22:18:47 +02:00
if (object.is_function())
js: Implement print function for Date objects
2020-03-31 18:43:45 +01:00
return print_function(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 17:46:39 +01:00
if (is<JS::Date>(object))
js: Implement print function for Date objects
2020-03-31 18:43:45 +01:00
return print_date(object, seen_objects);
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 17:46:39 +01: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 09:54:15 +02:00
return print_error(object, seen_objects);
js: Pretty-print custom error types
2021-11-23 22:56:21 +02:00
auto prototype_or_error = object.internal_get_prototype_of();
if (prototype_or_error.has_value() && prototype_or_error.value() == object.global_object().error_prototype())
return print_error(object, seen_objects);
vm->clear_exception();
LibJS: Remove hand-rolled Object is_foo() helpers in favor of RTTI
2021-01-01 17:46:39 +01: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 23:54:40 +03:00
if (is<JS::Map>(object))
return print_map(object, seen_objects);
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
if (is<JS::Set>(object))
return print_set(object, seen_objects);
LibJS: Add the DataView built-in object
2021-06-14 01:47:08 +03: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 17:46:39 +01: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 22:14:05 +02: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 17:46:39 +01: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);
js: Implement pretty-printing of ShadowRealm
2021-10-13 22:05:27 +01:00
if (is<JS::ShadowRealm>(object))
return print_shadow_realm(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
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 17:46:39 +01: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 17:46:39 +01: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 17:46:39 +01: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 21:59:49 +01:00
if (is<JS::Temporal::Calendar>(object))
return print_temporal_calendar(object, seen_objects);
js: Implement pretty-printing of Temporal.Duration objects
2021-07-16 00:17:01 +01: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 17:43:17 +01: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 20:06:27 +01: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 20:07:16 +01: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 23:02:33 +01: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 19:29:45 +01: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 22:57:25 +01: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 23:56:32 +01: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 18:16:47 +01: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-24 22:38:08 -04: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 08:32:55 -04:00
if (is<JS::Intl::Locale>(object))
return print_intl_locale(object, seen_objects);
js: Implement pretty-printing of Intl.ListFormat
2021-09-06 08:44:54 -04: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 07:30:45 -04:00
if (is<JS::Intl::NumberFormat>(object))
return print_intl_number_format(object, seen_objects);
js: Implement pretty-printing of Intl.DateTimeFormat
2021-11-28 18:05:32 -05:00
if (is<JS::Intl::DateTimeFormat>(object))
return print_intl_date_time_format(object, seen_objects);
js: Implement print function for Date objects
2020-03-31 18:43:45 +01:00
return print_object(object, seen_objects);
}
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
if (value.is_string())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[32;1m");
LibJS: Add BigInt
2020-06-06 01:14:10 +01:00
else if (value.is_number() || value.is_bigint())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[35;1m");
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
else if (value.is_boolean())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[33;1m");
js: Tweak pretty-printing of functions and null
2020-03-26 14:54:43 +01:00
else if (value.is_null())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[33;1m");
js: Tweak pretty-printing of functions and null
2020-03-26 14:54:43 +01:00
else if (value.is_undefined())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[34;1m");
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
if (value.is_string())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\"");
js: Print negative zero with minus sign
2020-10-12 18:03:07 +02:00
else if (value.is_negative_zero())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("-");
js_out("{}", value.to_string_without_side_effects());
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
if (value.is_string())
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\"");
js_out("\033[0m");
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
}
static void print(JS::Value value)
{
HashTable<JS::Object*> seen_objects;
print_value(value, seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln();
js: Implement some modest pretty-printing of values
2020-03-26 12:26:11 +01:00
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 11:52:40 -04: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 19:21:59 +01: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 11:52:40 -04: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;
}
LibJS: Include executable name in bytecode dumps
2021-10-24 14:33:56 +02:00
static bool parse_and_run(JS::Interpreter& interpreter, StringView source, StringView source_name)
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 16:29:24 +01:00
{
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
enum class ReturnEarly {
No,
Yes,
};
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 16:29:24 +01:00
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
JS::ThrowCompletionOr<JS::Value> result { JS::js_undefined() };
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 16:29:24 +01:00
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
auto run_script_or_module = [&](Variant<NonnullRefPtr<JS::Script>, NonnullRefPtr<JS::SourceTextModule>> script_or_module) {
auto program = script_or_module.visit(
[](auto& visitor) -> NonnullRefPtr<JS::Program> {
return visitor->parse_node();
});
if (s_dump_ast)
program->dump(0);
LibJS: Convert Interpreter::run() to ThrowCompletionOr<Value> Instead of making it a void function, checking for an exception, and then receiving the relevant result via VM::last_value(), we can consolidate all of this by using completions. This allows us to remove more uses of VM::exception(), and all uses of VM::last_value().
2022-01-08 21:28:27 +01:00
LibJS: Move global "should dump bytecode" flag into LibJS This will allow us to trigger bytecode executable dumps when generating bytecode inside LibJS as well, not just in clients like js and test-js.
2021-10-24 13:34:46 +02:00
if (JS::Bytecode::g_dump_bytecode || s_run_bytecode) {
auto executable = JS::Bytecode::Generator::generate(*program);
LibJS: Include executable name in bytecode dumps
2021-10-24 14:33:56 +02:00
executable.name = source_name;
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 20:40:20 +04:30
if (s_opt_bytecode) {
auto& passes = JS::Bytecode::Interpreter::optimization_pipeline();
LibJS: Move global "should dump bytecode" flag into LibJS This will allow us to trigger bytecode executable dumps when generating bytecode inside LibJS as well, not just in clients like js and test-js.
2021-10-24 13:34:46 +02:00
passes.perform(executable);
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 20:40:20 +04:30
dbgln("Optimisation passes took {}us", passes.elapsed());
}
LibJS: Move global "should dump bytecode" flag into LibJS This will allow us to trigger bytecode executable dumps when generating bytecode inside LibJS as well, not just in clients like js and test-js.
2021-10-24 13:34:46 +02:00
if (JS::Bytecode::g_dump_bytecode)
executable.dump();
LibJS: Don't generate bytecode after we've encountered a parser error
2021-06-10 21:04:12 +02:00
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 19:36:25 +01:00
JS::Bytecode::Interpreter bytecode_interpreter(interpreter.global_object(), interpreter.realm());
LibJS: Convert Interpreter::run() to ThrowCompletionOr<Value> Instead of making it a void function, checking for an exception, and then receiving the relevant result via VM::last_value(), we can consolidate all of this by using completions. This allows us to remove more uses of VM::exception(), and all uses of VM::last_value().
2022-01-08 21:28:27 +01:00
result = bytecode_interpreter.run(executable);
LibJS: Show the VM's last value after executing bytecode programs
2021-06-10 21:04:32 +02:00
} else {
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
return ReturnEarly::Yes;
LibJS: Don't generate bytecode after we've encountered a parser error
2021-06-10 21:04:12 +02:00
}
} else {
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
result = script_or_module.visit(
[&](auto& visitor) {
return interpreter.run(*visitor);
});
}
return ReturnEarly::No;
};
if (!s_as_module) {
auto script_or_error = JS::Script::parse(source, interpreter.realm(), source_name);
if (script_or_error.is_error()) {
auto error = script_or_error.error()[0];
auto hint = error.source_location_hint(source);
if (!hint.is_empty())
outln("{}", hint);
outln(error.to_string());
vm->throw_exception<JS::SyntaxError>(interpreter.global_object(), error.to_string());
} else {
auto return_early = run_script_or_module(move(script_or_error.value()));
if (return_early == ReturnEarly::Yes)
return true;
}
} else {
auto module_or_error = JS::SourceTextModule::parse(source, interpreter.realm(), source_name);
if (module_or_error.is_error()) {
auto error = module_or_error.error()[0];
auto hint = error.source_location_hint(source);
if (!hint.is_empty())
outln("{}", hint);
outln(error.to_string());
vm->throw_exception<JS::SyntaxError>(interpreter.global_object(), error.to_string());
} else {
auto return_early = run_script_or_module(move(module_or_error.value()));
if (return_early == ReturnEarly::Yes)
return true;
LibJS: Don't generate bytecode after we've encountered a parser error
2021-06-10 21:04:12 +02:00
}
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 16:29:24 +01: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 09:16:06 +01: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-12 00:08:28 +02:00
auto* exception = vm->exception();
vm->clear_exception();
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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-12 00:08:28 +02: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 18:15:02 +02: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 18:15:02 +02: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.
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln(" -> {}", traceback_frame.function_name);
js_outln(" {} more calls", repetitions);
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
} else {
for (size_t j = 0; j < repetitions + 1; ++j)
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_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 14:12:04 +01: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 09:16:06 +01:00
};
LibJS: Fix that '_' no longer accessed the last value in the REPL This is now also not a concept that VM knows about and handled completely by the REPL.
2022-01-16 02:05:32 +01:00
if (!result.is_error())
last_value = JS::make_handle(result.value());
LibJS: Convert Interpreter::run() to ThrowCompletionOr<Value> Instead of making it a void function, checking for an exception, and then receiving the relevant result via VM::last_value(), we can consolidate all of this by using completions. This allows us to remove more uses of VM::exception(), and all uses of VM::last_value().
2022-01-08 21:28:27 +01:00
if (result.is_error()) {
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
if (!vm->exception()) {
// Until js no longer relies on vm->exception() we have to set it in case the exception was cleared
VERIFY(result.throw_completion().value().has_value());
auto throw_value = result.release_error().release_value().release_value();
auto* exception = interpreter.heap().allocate<JS::Exception>(interpreter.global_object(), throw_value);
vm->set_exception(*exception);
}
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 18:35:58 +01:00
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-12 00:08:28 +02:00
return false;
LibJS: Convert Interpreter::run() to ThrowCompletionOr<Value> Instead of making it a void function, checking for an exception, and then receiving the relevant result via VM::last_value(), we can consolidate all of this by using completions. This allows us to remove more uses of VM::exception(), and all uses of VM::last_value().
2022-01-08 21:28:27 +01:00
} else if (s_print_last_result) {
print(result.value());
if (vm->exception()) {
handle_exception();
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 09:16:06 +01:00
}
js: Throw a regular SyntaxError for errors from the parser
2020-05-14 16:29:24 +01:00
return true;
}
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
static JS::ThrowCompletionOr<JS::Value> load_file_impl(JS::VM& vm, JS::GlobalObject& global_object)
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 01:04:09 +01:00
{
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
auto filename = TRY(vm.argument(0).to_string(global_object));
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 01:04:09 +01:00
auto file = Core::File::construct(filename);
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
if (!file->open(Core::OpenMode::ReadOnly))
return vm.throw_completion<JS::Error>(global_object, String::formatted("Failed to open '{}': {}", filename, file->error_string()));
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 01:04:09 +01:00
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 19:11:26 +01:00
auto source = StringView { file_contents };
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
auto script_or_error = JS::Script::parse(source, vm.interpreter().realm(), filename);
if (script_or_error.is_error()) {
auto& error = script_or_error.error()[0];
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
return vm.throw_completion<JS::SyntaxError>(global_object, error.to_string());
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 01:04:09 +01:00
}
// FIXME: Use eval()-like semantics and execute in current scope?
LibJS: Refactor interpreter to use Script and Source Text Modules This also refactors interpreter creation to follow InitializeHostDefinedRealm, but I couldn't fit it in the title :^) This allows us to follow the spec much more closely rather than being completely ad-hoc with just the parse node instead of having all the surrounding data such as the realm of the parse node. The interpreter creation refactor creates the global execution context once and doesn't take it off the stack. This allows LibWeb to take the global execution context and manually handle it, following the HTML spec. The HTML spec calls this the "realm execution context" of the environment settings object. It also allows us to specify the globalThis type, as it can be different from the global object type. For example, on the web, Window global objects use a WindowProxy global this value to enforce the same origin policy on operations like [[GetOwnProperty]]. Finally, it allows us to directly call Program::execute in perform_eval and perform_shadow_realm_eval as this moves global_declaration_instantiation into Interpreter::run (ScriptEvaluation) as per the spec. Note that this doesn't evalulate Source Text Modules yet or refactor the bytecode interpreter, that's work for future us :^) This patch was originally build by Luke for the environment settings object change but was also needed for modules. So I (davidot) have modified it with the new completion changes and setup for that. Co-authored-by: davidot <davidot@serenityos.org>
2022-01-16 13:16:04 +01:00
TRY(vm.interpreter().run(script_or_error.value()));
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 01:04:09 +01:00
return JS::js_undefined();
}
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
static JS::ThrowCompletionOr<JS::Value> load_json_impl(JS::VM& vm, JS::GlobalObject& global_object)
js: Add a simple loadJSON(path) built-in to load JSON from a file This is very handy when you want to load data from /proc, for example.
2021-09-16 21:48:07 +02:00
{
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
auto filename = TRY(vm.argument(0).to_string(global_object));
js: Add a simple loadJSON(path) built-in to load JSON from a file This is very handy when you want to load data from /proc, for example.
2021-09-16 21:48:07 +02:00
auto file = Core::File::construct(filename);
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
if (!file->open(Core::OpenMode::ReadOnly))
return vm.throw_completion<JS::Error>(global_object, String::formatted("Failed to open '{}': {}", filename, file->error_string()));
js: Add a simple loadJSON(path) built-in to load JSON from a file This is very handy when you want to load data from /proc, for example.
2021-09-16 21:48:07 +02:00
auto file_contents = file->read_all();
auto json = JsonValue::from_string(file_contents);
AK: Make JSON parser return ErrorOr<JsonValue> (instead of Optional) Also add slightly richer parse errors now that we can include a string literal with returned errors. This will allow us to use TRY() when working with JSON data.
2021-11-15 01:46:51 +01:00
if (json.is_error())
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
return vm.throw_completion<JS::SyntaxError>(global_object, JS::ErrorType::JsonMalformed);
js: Add a simple loadJSON(path) built-in to load JSON from a file This is very handy when you want to load data from /proc, for example.
2021-09-16 21:48:07 +02:00
return JS::JSONObject::parse_json_value(global_object, json.value());
}
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 16:52:26 +01: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 13:18:06 +02: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 16:52:26 +01: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-06 02:15:08 +03: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-06 01:12:54 +03:00
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
define_native_function("exit", exit_interpreter, 0, attr);
define_native_function("help", repl_help, 0, attr);
define_native_function("load", load_file, 1, attr);
define_native_function("save", save_to_file, 1, attr);
define_native_function("loadJSON", load_json, 1, attr);
LibJS: Fix that '_' no longer accessed the last value in the REPL This is now also not a concept that VM knows about and handled completely by the REPL.
2022-01-16 02:05:32 +01:00
define_native_accessor(
"_",
[](JS::VM&, JS::GlobalObject&) {
return last_value.value();
},
[](JS::VM& vm, JS::GlobalObject& global_object) -> JS::ThrowCompletionOr<JS::Value> {
VERIFY(is<ReplObject>(global_object));
outln("Disable writing last value to '_'");
// We must delete first otherwise this setter gets called recursively.
TRY(global_object.internal_delete(JS::PropertyKey { "_" }));
auto value = vm.argument(0);
TRY(global_object.internal_set(JS::PropertyKey { "_" }, value, &global_object));
return value;
},
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 15:20:32 -04:00
}
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04: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 11:52:40 -04: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 18:36:49 +02: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 11:52:40 -04: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 18:36:49 +02: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 11:52:40 -04: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 14:04:24 +01:00
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04: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 15:20:32 -04: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 18:36:49 +02: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 15:20:32 -04:00
exit(0);
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
exit(TRY(vm.argument(0).to_number(global_object)).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 15:20:32 -04:00
}
js: Add assertNotReached() function in test mode
2020-04-13 14:04:24 +01:00
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04: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 15:20:32 -04:00
{
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln("REPL commands:");
js_outln(" exit(code): exit the REPL with specified code. Defaults to 0.");
js_outln(" help(): display this menu");
js_outln(" load(file): load given JS file into running session. For example: load(\"foo.js\")");
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 21:08:54 +01: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 15:20:32 -04:00
}
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04: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 15:20:32 -04: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 01:04:09 +01: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 15:20:32 -04:00
}
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
JS_DEFINE_NATIVE_FUNCTION(ReplObject::load_json)
js: Add a simple loadJSON(path) built-in to load JSON from a file This is very handy when you want to load data from /proc, for example.
2021-09-16 21:48:07 +02:00
{
return load_json_impl(vm, global_object);
}
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-26 00:50:18 +02: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-06 02:15:08 +03: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-06 01:12:54 +03:00
u8 attr = JS::Attribute::Configurable | JS::Attribute::Writable | JS::Attribute::Enumerable;
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
define_native_function("load", load_file, 1, attr);
define_native_function("loadJSON", load_json, 1, attr);
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-26 00:50:18 +02:00
}
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
JS_DEFINE_NATIVE_FUNCTION(ScriptObject::load_file)
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-26 00:50:18 +02: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 01:04:09 +01: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-26 00:50:18 +02:00
}
js: Convert JavaScript REPL to ThrowCompletionOr
2021-10-29 17:13:18 -04:00
JS_DEFINE_NATIVE_FUNCTION(ScriptObject::load_json)
js: Add a simple loadJSON(path) built-in to load JSON from a file This is very handy when you want to load data from /proc, for example.
2021-09-16 21:48:07 +02:00
{
return load_json_impl(vm, global_object);
}
Userland: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code.
2020-08-10 23:48:37 +02: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-26 01:10:29 +03: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 16:57:07 +04:30
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-26 01:10:29 +03: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 13:29:42 +02: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 11:52:40 -04:00
repl_statements.append(piece);
LibJS: Include executable name in bytecode dumps
2021-10-24 14:33:56 +02:00
parse_and_run(interpreter, piece, "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-26 01:10:29 +03:00
}
}
js: Make it a little easier to add new AST builder functions
2020-03-09 21:58:27 +01:00
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 17:59:16 +01: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 23:48:37 +02:00
static void sigint_handler()
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 17:59:16 +01:00
{
interrupt_interpreter();
}
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 16:09:05 +02:00
class ReplConsoleClient final : public JS::ConsoleClient {
public:
ReplConsoleClient(JS::Console& console)
: ConsoleClient(console)
{
}
LibJS+WebContent+js: Bring console.clear() to spec This is identical to before, since we don't have "group stacks" yet, but clear() now uses ThrowCompletionOr.
2021-12-08 19:24:17 +00:00
virtual void clear() override
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 16:09:05 +02:00
{
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("\033[3J\033[H\033[2J");
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
m_group_stack_depth = 0;
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 16:09:05 +02:00
fflush(stdout);
}
LibJS: Implement console.assert()
2021-04-18 17:08:14 +02:00
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
virtual void end_group() override
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 16:09:05 +02:00
{
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
if (m_group_stack_depth > 0)
m_group_stack_depth--;
}
// 2.3. Printer(logLevel, args[, options]), https://console.spec.whatwg.org/#printer
virtual JS::ThrowCompletionOr<JS::Value> printer(JS::Console::LogLevel log_level, PrinterArguments arguments) override
{
String indent = String::repeated(" ", m_group_stack_depth);
LibJS+WebContent+js: Bring console.trace() to spec The spec very kindly defines `Printer` as accepting "Implementation-specific representations of printable things such as a stack trace or group." for the `args`. We make use of that here by passing the `Trace` itself to `Printer`, instead of having to produce a representation of the stack trace in advance and then pass that to `Printer`. That both avoids the hassle of tracking whether the data has been html-encoded or not, and means clients don't have to implement the whole `trace()` algorithm, but only the code needed to output the trace.
2021-12-10 13:48:38 +00:00
if (log_level == JS::Console::LogLevel::Trace) {
auto trace = arguments.get<JS::Console::Trace>();
StringBuilder builder;
if (!trace.label.is_empty())
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
builder.appendff("{}\033[36;1m{}\033[0m\n", indent, trace.label);
LibJS+WebContent+js: Bring console.trace() to spec The spec very kindly defines `Printer` as accepting "Implementation-specific representations of printable things such as a stack trace or group." for the `args`. We make use of that here by passing the `Trace` itself to `Printer`, instead of having to produce a representation of the stack trace in advance and then pass that to `Printer`. That both avoids the hassle of tracking whether the data has been html-encoded or not, and means clients don't have to implement the whole `trace()` algorithm, but only the code needed to output the trace.
2021-12-10 13:48:38 +00:00
for (auto& function_name : trace.stack)
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
builder.appendff("{}-> {}\n", indent, function_name);
LibJS+WebContent+js: Bring console.trace() to spec The spec very kindly defines `Printer` as accepting "Implementation-specific representations of printable things such as a stack trace or group." for the `args`. We make use of that here by passing the `Trace` itself to `Printer`, instead of having to produce a representation of the stack trace in advance and then pass that to `Printer`. That both avoids the hassle of tracking whether the data has been html-encoded or not, and means clients don't have to implement the whole `trace()` algorithm, but only the code needed to output the trace.
2021-12-10 13:48:38 +00:00
js_outln("{}", builder.string_view());
return JS::js_undefined();
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 16:09:05 +02:00
}
LibJS: Implement console.assert()
2021-04-18 17:08:14 +02:00
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
if (log_level == JS::Console::LogLevel::Group || log_level == JS::Console::LogLevel::GroupCollapsed) {
auto group = arguments.get<JS::Console::Group>();
js_outln("{}\033[36;1m{}\033[0m", indent, group.label);
m_group_stack_depth++;
return JS::js_undefined();
}
LibJS+WebContent+js: Bring console.trace() to spec The spec very kindly defines `Printer` as accepting "Implementation-specific representations of printable things such as a stack trace or group." for the `args`. We make use of that here by passing the `Trace` itself to `Printer`, instead of having to produce a representation of the stack trace in advance and then pass that to `Printer`. That both avoids the hassle of tracking whether the data has been html-encoded or not, and means clients don't have to implement the whole `trace()` algorithm, but only the code needed to output the trace.
2021-12-10 13:48:38 +00:00
auto output = String::join(" ", arguments.get<Vector<JS::Value>>());
LibJS+WebContent+js: Reimplement console.log() and friends to spec This implements the Logger and Printer abstract operations defined in the console spec, and stubs out the Formatter AO. These are then used for the "output a categorized log message" functions.
2021-12-10 12:26:25 +00:00
m_console.output_debug_message(log_level, output);
switch (log_level) {
case JS::Console::LogLevel::Debug:
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
js_outln("{}\033[36;1m{}\033[0m", indent, output);
LibJS+WebContent+js: Reimplement console.log() and friends to spec This implements the Logger and Printer abstract operations defined in the console spec, and stubs out the Formatter AO. These are then used for the "output a categorized log message" functions.
2021-12-10 12:26:25 +00:00
break;
case JS::Console::LogLevel::Error:
LibJS+WebContent+js: Bring console.assert() to spec
2021-12-08 19:43:29 +00:00
case JS::Console::LogLevel::Assert:
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
js_outln("{}\033[31;1m{}\033[0m", indent, output);
LibJS+WebContent+js: Reimplement console.log() and friends to spec This implements the Logger and Printer abstract operations defined in the console spec, and stubs out the Formatter AO. These are then used for the "output a categorized log message" functions.
2021-12-10 12:26:25 +00:00
break;
case JS::Console::LogLevel::Info:
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
js_outln("{}(i) {}", indent, output);
LibJS+WebContent+js: Reimplement console.log() and friends to spec This implements the Logger and Printer abstract operations defined in the console spec, and stubs out the Formatter AO. These are then used for the "output a categorized log message" functions.
2021-12-10 12:26:25 +00:00
break;
case JS::Console::LogLevel::Log:
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
js_outln("{}{}", indent, output);
LibJS+WebContent+js: Reimplement console.log() and friends to spec This implements the Logger and Printer abstract operations defined in the console spec, and stubs out the Formatter AO. These are then used for the "output a categorized log message" functions.
2021-12-10 12:26:25 +00:00
break;
case JS::Console::LogLevel::Warn:
LibJS+WebContent+js: Bring console.count[Reset]() to spec The `CountReset` log level is displayed as a warning, since the message is always to warn that the counter doesn't exist. This is also in line with the table at https://console.spec.whatwg.org/#loglevel-severity
2021-12-08 19:12:06 +00:00
case JS::Console::LogLevel::CountReset:
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
js_outln("{}\033[33;1m{}\033[0m", indent, output);
LibJS+WebContent+js: Reimplement console.log() and friends to spec This implements the Logger and Printer abstract operations defined in the console spec, and stubs out the Formatter AO. These are then used for the "output a categorized log message" functions.
2021-12-10 12:26:25 +00:00
break;
default:
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
js_outln("{}{}", indent, output);
LibJS+WebContent+js: Reimplement console.log() and friends to spec This implements the Logger and Printer abstract operations defined in the console spec, and stubs out the Formatter AO. These are then used for the "output a categorized log message" functions.
2021-12-10 12:26:25 +00:00
break;
}
return JS::js_undefined();
}
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
private:
int m_group_stack_depth { 0 };
js: Customise the behaviour of JS::Console with ReplConsoleClient This also makes our JavaScript tests not fail.
2020-05-04 16:09:05 +02:00
};
js: Port to LibMain :^) This wasn't particularly difficult, and there's not much use for the nicer interface yet either. While unveil() is of limited use in js(1) as it should be able to open arbitrary files, I feel like we should be able to add a pledge() call.
2021-11-22 19:25:30 +00:00
ErrorOr<int> serenity_main(Main::Arguments arguments)
LibJS: Start building a JavaScript engine for SerenityOS :^) I always tell people to start building things by working on the thing that seems the most interesting right now. The most interesting thing here was an AST + simple interpreter, so that's where we start! There is no lexer or parser yet, we build an AST directly and then execute it in the interpreter, producing a return value. This seems like the start of something interesting. :^)
2020-03-07 19:42:11 +01:00
{
js: Use pledge() It is now no longer possible to make network connections from a hijacked js(1) :^)
2021-11-22 20:41:58 +00:00
#ifdef __serenity__
Userland: Link directly against LibUnicodeData where needed This is partially a revert of commits: 10a8b6d4116c6a627a6c189154af032f69b29c21 561b67a1add82538502ef2f5733f1d86718898ad Rather than adding the prot_exec pledge requried to use dlopen(), we can link directly against LibUnicodeData in applications that we know need that library. This might make the dlopen() dance a bit unnecessary. The same purpose might now be fulfilled with weak symbols. That can be revisted next, but for now, this at least removes the potential security risk of apps like the Browser having prot_exec privileges.
2021-12-29 13:10:12 -05:00
TRY(Core::System::pledge("stdio rpath wpath cpath tty sigaction"));
js: Use pledge() It is now no longer possible to make network connections from a hijacked js(1) :^)
2021-11-22 20:41:58 +00:00
#endif
LibJS+js: Add a debug option (js -g) to GC after every allocation This is very useful for discovering collector bugs.
2020-03-16 19:18:46 +01:00
bool gc_on_every_allocation = false;
js: Turn on live syntax highlighting by default
2020-04-30 22:37:50 +02:00
bool disable_syntax_highlight = false;
Userland: Use Core::ArgsParser's Vector<StringView> API everywhere ...and remove the Vector<String> variant since there are no remaining users of this API.
2021-11-26 22:32:37 +01:00
Vector<StringView> 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 10:51:41 +01:00
Core::ArgsParser args_parser;
Userland: Write some '--help' descriptions where appropriate
2020-12-05 16:22:58 +01:00
args_parser.set_general_help("This is a JavaScript interpreter.");
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01:00
args_parser.add_option(s_dump_ast, "Dump the AST", "dump-ast", 'A');
LibJS: Move global "should dump bytecode" flag into LibJS This will allow us to trigger bytecode executable dumps when generating bytecode inside LibJS as well, not just in clients like js and test-js.
2021-10-24 13:34:46 +02:00
args_parser.add_option(JS::Bytecode::g_dump_bytecode, "Dump the bytecode", "dump-bytecode", 'd');
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 10:46:30 +02:00
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 20:40:20 +04:30
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 17:30:37 +02:00
args_parser.add_option(s_as_module, "Treat as module", "as-module", 'm');
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01:00
args_parser.add_option(s_print_last_result, "Print last result", "print-last-result", 'l');
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
args_parser.add_option(s_strip_ansi, "Disable ANSI colors", "disable-ansi-colors", 'c');
js: Add command line flag for disabling source line hints
2021-11-23 23:02:19 +02:00
args_parser.add_option(s_disable_source_location_hints, "Disable source location hints", "disable-source-location-hints", 'h');
LibJS+js: Add a debug option (js -g) to GC after every allocation This is very useful for discovering collector bugs.
2020-03-16 19:18:46 +01:00
args_parser.add_option(gc_on_every_allocation, "GC on every allocation", "gc-on-every-allocation", 'g');
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#ifdef JS_TRACK_ZOMBIE_CELLS
bool zombify_dead_cells = 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 16:44:40 +02:00
args_parser.add_option(zombify_dead_cells, "Zombify dead cells (to catch missing GC marks)", "zombify-dead-cells", 'z');
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#endif
js: Turn on live syntax highlighting by default
2020-04-30 22:37:50 +02: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);
Everywhere: Use ArgsParser::parse() with Main::Arguments directly Use the updated API everywhere we are currently manually passing in `arguments.argc` and `arguments.argv`.
2021-11-22 19:03:05 -05:00
args_parser.parse(arguments);
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 10:51:41 +01:00
Userland: Invoke tzset in applications that care about time zones In most applications, we invoke tzset once at startup for now. Most of these are short lived and don't need to know about time zone changes. The exception is the ClockWidget in the taskbar. Here, we invoke tzset each time we update the system time. This way, any time zone changes can take effect immediately.
2022-01-24 16:12:19 -05:00
tzset();
js: Turn on live syntax highlighting by default
2020-04-30 22:37:50 +02: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 21:29:57 +02:00
vm = JS::VM::create();
LibJS: Implement ImportCall and HostImportModuleDynamically This allows us to load modules from scripts. This can be dangerous as it can load arbitrary files. Because of that it fails and throws by default. Currently, only js and JavaScriptTestRunner enable the default hook. This also adds tests to test-js which test module code. Because we form a spec perspective can't "enter" a module this is the easiest way to run tests without having to modify test-js to have special cases for modules. To specify modules in test-js we use the extension '.mjs' this is to ensure the files are not executed. We do still want to lint these files so the prettier scripts have changed to look for '.mjs' files as well.
2022-01-18 19:39:36 +01:00
vm->enable_default_host_import_module_dynamically_hook();
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 22:14:12 +02: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
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("WARNING: A promise was rejected without any handlers");
js_out(" (result: ");
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 22:14:12 +02:00
HashTable<JS::Object*> seen_objects;
print_value(promise.result(), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln(")");
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 22:14:12 +02:00
};
vm->on_promise_rejection_handled = [](auto& promise) {
// FIXME: Optionally make print_value() to print to stderr
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_out("WARNING: A handler was added to an already rejected promise");
js_out(" (result: ");
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 22:14:12 +02:00
HashTable<JS::Object*> seen_objects;
print_value(promise.result(), seen_objects);
js: Add command line flag for disabling ANSI colors
2021-11-23 22:46:28 +02:00
js_outln(")");
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 22:14:12 +02:00
};
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 17:59:16 +01: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-12 00:08:28 +02: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 15:18:55 +02:00
vm->throw_exception(interpreter->global_object(), error);
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 17:59:16 +01: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 16:29:24 +01: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 19:24:44 +02: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 21:15:06 +02: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 15:20:32 -04:00
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#ifdef JS_TRACK_ZOMBIE_CELLS
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 16:44:40 +02:00
interpreter->heap().set_zombify_dead_cells(zombify_dead_cells);
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#endif
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 15:20:32 -04:00
js: Fix that auto completion of properties failed For this we store the global environment in which we can do a lookup for the references variable. This is probably not entirely as the spec would specify as we would need a running executing context at all times you do things with references. Fixes #10281
2021-10-03 13:17:33 +02:00
auto& global_environment = interpreter->realm().global_environment();
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 15:04:39 +04:30
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 13:39:10 +04:30
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-29 00:31:22 +04:30
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 13:39:10 +04:30
});
js: Follow Serenity C++ naming conventions
2020-04-26 15:19:30 +01:00
s_editor->on_display_refresh = [syntax_highlight](Line::Editor& editor) {
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 15:19:30 +01:00
size_t open_indents = s_repl_line_level;
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 13:00:30 -04:00
auto line = editor.line();
JS::Lexer lexer(line);
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 13:00:30 -04:00
auto start = token.line_column() - 1;
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 18:33:12 +04:30
}
}
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 22:28:59 +01: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 08:00:45 +04:30
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 22:28:59 +01: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 08:00:45 +04:30
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 22:28:59 +01: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 08:00:45 +04:30
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 22:28:59 +01:00
case JS::TokenCategory::Punctuation:
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 22:28:59 +01:00
case JS::TokenCategory::Operator:
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 22:28:59 +01: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 22:28:59 +01: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 22:28:59 +01:00
break;
}
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 22:28:59 +01: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 08:00:45 +04:30
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 22:28:59 +01: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 19:17:08 +02:00
break;
JS repl: Fix indentation when a line starts with '})]'
2020-04-09 08:00:45 +04:30
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 13:39:55 +04:30
js: Fix that auto completion of properties failed For this we store the global environment in which we can do a lookup for the references variable. This is probably not entirely as the spec would specify as we would need a running executing context at all times you do things with references. Fixes #10281
2021-10-03 13:17:33 +02:00
auto complete = [&interpreter, &global_environment](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 08:42:01 +04:30
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 19:02:15 +04:30
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 13:39:55 +04:30
// 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 08:42:01 +04:30
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-16 02:33:09 +04:30
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 08:42:01 +04:30
// ...<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 18:32:28 +04:30
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 13:39:55 +04:30
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
Function<void(JS::Shape const&, StringView)> list_all_properties = [&results, &list_all_properties](JS::Shape const& shape, auto property_pattern) {
js: Convert to east const
2021-07-06 23:58:50 +01:00
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-07 21:38:46 -07: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 16:01:09 +01: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 12:00:27 +02: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 19:02:15 +04:30
}
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 13:39:55 +04:30
}
}
js: Convert to east const
2021-07-06 23:58:50 +01: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 13:39:55 +04:30
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 08:42:01 +04:30
switch (mode) {
case CompleteProperty: {
js: Remove uses of TRY_OR_DISCARD() Slightly more verbose, but that's the last user of TRY_OR_DISCARD gone!
2022-01-04 22:54:31 +01:00
auto reference_or_error = vm->resolve_binding(variable_name, &global_environment);
if (reference_or_error.is_error())
return {};
auto value_or_error = reference_or_error.value().get_value(interpreter->global_object());
if (value_or_error.is_error())
return {};
auto variable = value_or_error.value();
VERIFY(!variable.is_empty());
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 13:39:55 +04:30
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 08:42:01 +04:30
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 13:39:55 +04:30
LibJS: Convert to_object() to ThrowCompletionOr
2021-10-12 19:24:57 +01:00
auto const* object = MUST(variable.to_object(interpreter->global_object()));
js: Convert to east const
2021-07-06 23:58:50 +01:00
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 08:42:01 +04:30
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 19:02:15 +04:30
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 08:42:01 +04:30
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 13:39:55 +04:30
}
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 08:42:01 +04:30
case CompleteVariable: {
js: Convert to east const
2021-07-06 23:58:50 +01: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 08:42:01 +04:30
list_all_properties(variable.shape(), variable_name);
js: Allow for completion of lexically declared variables This does require us to have a method which lists all the bindings in a declarative environment which is not in the spec.
2021-10-03 13:20:15 +02:00
for (String& name : global_environment.declarative_record().bindings()) {
if (name.starts_with(variable_name))
results.empend(name);
}
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 08:42:01 +04:30
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 20:42:32 +01: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 08:42:01 +04:30
}
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 13:39:55 +04:30
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 08:42:01 +04:30
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 21:04:51 +02: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-26 01:10:29 +03:00
} else {
js: Define load() in global object for scripts Having load() present is required in order to run test262.
2021-05-26 00:50:18 +02: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 21:15:06 +02: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 15:20:32 -04:00
interpreter->heap().set_should_collect_on_every_allocation(gc_on_every_allocation);
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#ifdef JS_TRACK_ZOMBIE_CELLS
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 16:44:40 +02:00
interpreter->heap().set_zombify_dead_cells(zombify_dead_cells);
LibJS: Put zombie cell tracking code behind a compile-time flag Since this is a debug-only feature, let's not have it impact GC marking performance when you don't need it.
2021-10-02 16:35:55 +02:00
#endif
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 15:20:32 -04:00
js: Interrupt running script or REPL evaluation when receiving SIGINT
2020-04-24 17:59:16 +01:00
signal(SIGINT, [](int) {
sigint_handler();
});
js: Display a warning if multiple files are given Also instead of making a frankenstein path with all the paths combined just take the first one, this is needed for resolving modules.
2022-01-17 18:47:32 +01:00
if (script_paths.size() > 1)
warnln("Warning: Multiple files supplied, this will concatenate the sources and resolve modules as if it was the first file");
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) {
js: Improve usage of `TRY` when executing a file program
2021-12-08 19:33:41 -05:00
auto file = TRY(Core::File::open(path, Core::OpenMode::ReadOnly));
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
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 19:11:26 +01: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-26 01:10:29 +03: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 19:42:11 +01:00
js: Display a warning if multiple files are given Also instead of making a frankenstein path with all the paths combined just take the first one, this is needed for resolving modules.
2022-01-17 18:47:32 +01:00
// We resolve modules as if it is the first file
LibJS: Include executable name in bytecode dumps
2021-10-24 14:33:56 +02:00
js: Display a warning if multiple files are given Also instead of making a frankenstein path with all the paths combined just take the first one, this is needed for resolving modules.
2022-01-17 18:47:32 +01:00
if (!parse_and_run(*interpreter, builder.string_view(), script_paths[0]))
LibJS: Do not execute scripts with parse errors This adds missing checks in several LibJS consumers.
2020-04-13 02:05:21 +02: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-26 01:10:29 +03:00
}
js: Exercise the garbage collector a little bit
2020-03-08 19:59:59 +01: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 19:42:11 +01:00
return 0;
}
Reference in a new issue Copy permalink