dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Userland/DevTools/HackStudio/Debugger/EvaluateExpressionDialog.cpp

148 lines
5 KiB
C++
Raw Normal View History

HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
/*
* Copyright (c) 2021, Hunter Salyer <thefalsehonesty@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include "EvaluateExpressionDialog.h"
#include "DebuggerGlobalJSObject.h"
#include <LibGUI/BoxLayout.h>
#include <LibGUI/Button.h>
#include <LibGUI/TextBox.h>
#include <LibGUI/Widget.h>
#include <LibGfx/FontDatabase.h>
#include <LibJS/Interpreter.h>
#include <LibJS/MarkupGenerator.h>
#include <LibJS/Parser.h>
#include <LibJS/SyntaxHighlighter.h>
#include <LibWeb/DOM/DocumentType.h>
namespace HackStudio {
static JS::VM& global_vm()
{
static RefPtr<JS::VM> vm;
if (!vm)
vm = JS::VM::create();
return *vm;
}
EvaluateExpressionDialog::EvaluateExpressionDialog(Window* parent_window)
: Dialog(parent_window)
, m_interpreter(JS::Interpreter::create<DebuggerGlobalJSObject>(global_vm()))
{
set_title("Evaluate Expression");
set_icon(parent_window->icon());
build(parent_window);
}
void EvaluateExpressionDialog::build(Window* parent_window)
{
auto& widget = set_main_widget<GUI::Widget>();
int width = max(parent_window->width() / 2, 150);
int height = max(parent_window->height() * (2 / 3), 350);
set_rect(x(), y(), width, height);
widget.set_layout<GUI::VerticalBoxLayout>();
widget.set_fill_with_background_color(true);
Userland+LibGUI: Add shorthand versions of the Margins constructor This allows for typing [8] instead of [8, 8, 8, 8] to specify the same margin on all edges, for example. The constructors follow CSS' style of specifying margins. The added constructors are: - Margins(int all): Sets the same margin on all edges. - Margins(int vertical, int horizontal): Sets the first argument to top and bottom margins, and the second argument to left and right margins. - Margins(int top, int vertical, int bottom): Sets the first argument to the top margin, the second argument to the left and right margins, and the third argument to the bottom margin.
2021-08-16 21:11:38 -03:00
widget.layout()->set_margins(6);
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
widget.layout()->set_spacing(6);
m_text_editor = widget.add<GUI::TextBox>();
m_text_editor->set_fixed_height(19);
m_text_editor->set_syntax_highlighter(make<JS::SyntaxHighlighter>());
m_text_editor->set_font(Gfx::FontDatabase::default_fixed_width_font());
m_text_editor->set_history_enabled(true);
auto base_document = Web::DOM::Document::create();
base_document->append_child(adopt_ref(*new Web::DOM::DocumentType(base_document)));
LibWeb: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 06:00:49 -03:00
auto html_element = base_document->create_element("html").release_value();
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
base_document->append_child(html_element);
LibWeb: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 06:00:49 -03:00
auto head_element = base_document->create_element("head").release_value();
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
html_element->append_child(head_element);
LibWeb: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 06:00:49 -03:00
auto body_element = base_document->create_element("body").release_value();
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
html_element->append_child(body_element);
m_output_container = body_element;
m_output_view = widget.add<Web::InProcessWebView>();
m_output_view->set_document(base_document);
auto& button_container_outer = widget.add<GUI::Widget>();
button_container_outer.set_fixed_height(20);
button_container_outer.set_layout<GUI::VerticalBoxLayout>();
auto& button_container_inner = button_container_outer.add<GUI::Widget>();
button_container_inner.set_layout<GUI::HorizontalBoxLayout>();
button_container_inner.layout()->set_spacing(6);
Userland+LibGUI: Add shorthand versions of the Margins constructor This allows for typing [8] instead of [8, 8, 8, 8] to specify the same margin on all edges, for example. The constructors follow CSS' style of specifying margins. The added constructors are: - Margins(int all): Sets the same margin on all edges. - Margins(int vertical, int horizontal): Sets the first argument to top and bottom margins, and the second argument to left and right margins. - Margins(int top, int vertical, int bottom): Sets the first argument to the top margin, the second argument to the left and right margins, and the third argument to the bottom margin.
2021-08-16 21:11:38 -03:00
button_container_inner.layout()->set_margins({ 4, 0, 4 });
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
button_container_inner.layout()->add_spacer();
m_evaluate_button = button_container_inner.add<GUI::Button>();
m_evaluate_button->set_fixed_height(20);
m_evaluate_button->set_text("Evaluate");
m_evaluate_button->on_click = [this](auto) {
handle_evaluation(m_text_editor->text());
};
m_close_button = button_container_inner.add<GUI::Button>();
m_close_button->set_fixed_height(20);
m_close_button->set_text("Close");
m_close_button->on_click = [this](auto) {
done(ExecOK);
};
m_text_editor->on_return_pressed = [this] {
m_evaluate_button->click();
};
m_text_editor->on_escape_pressed = [this] {
m_close_button->click();
};
m_text_editor->set_focus(true);
}
Everywhere: Run clang-format
2022-04-01 14:58:27 -03:00
void EvaluateExpressionDialog::handle_evaluation(String const& expression)
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
{
m_output_container->remove_all_children();
m_output_view->update();
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 09:16:04 -03:00
auto script_or_error = JS::Script::parse(expression, m_interpreter->realm());
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
StringBuilder output_html;
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 17:28:27 -03:00
auto result = JS::ThrowCompletionOr<JS::Value> { JS::js_undefined() };
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 09:16:04 -03:00
if (script_or_error.is_error()) {
auto error = script_or_error.error()[0];
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
auto hint = error.source_location_hint(expression);
if (!hint.is_empty())
output_html.append(String::formatted("<pre>{}</pre>", escape_html_entities(hint)));
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 17:28:27 -03:00
result = m_interpreter->vm().throw_completion<JS::SyntaxError>(m_interpreter->global_object(), error.to_string());
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03: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 09:16:04 -03:00
result = m_interpreter->run(script_or_error.value());
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
}
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 17:28:27 -03:00
if (result.is_error()) {
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
output_html.append("Uncaught exception: ");
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 17:28:27 -03:00
auto error = *result.throw_completion().value();
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
if (error.is_object())
output_html.append(JS::MarkupGenerator::html_from_error(error.as_object()));
else
output_html.append(JS::MarkupGenerator::html_from_value(error));
set_output(output_html.string_view());
return;
}
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 17:28:27 -03:00
set_output(JS::MarkupGenerator::html_from_value(result.value()));
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
}
Everywhere: Pass AK::StringView by value
2021-11-10 20:55:02 -03:00
void EvaluateExpressionDialog::set_output(StringView html)
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
{
LibWeb: Check for valid names in Document.createElement() & friends We now validate that the provided tag names are valid XML tag names, and otherwise throw an "invalid character" DOM exception. 2% progression on ACID3. :^)
2022-02-26 06:00:49 -03:00
auto paragraph = m_output_container->document().create_element("p").release_value();
HackStudio: Add evaluate expression popup to debugger This implements a dialog that can be used to evaluate a JS expression in the HackStudio's Debugger context. It also implements simple C++ Variable <-> JS Value conversion, allowing for JS expressions to read/write variables in the debugger scope. Currently, C++ structs are mapped to JS objects by way of a JS proxy, however this leads to issues when printing, so this will be changed in a later commit.
2021-04-12 22:02:47 -03:00
paragraph->set_inner_html(html);
m_output_container->append_child(paragraph);
}
}
Reference in a new issue Copy permalink