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/Libraries/LibWeb/CodeGenerators/WrapperGenerator.cpp

694 lines
27 KiB
C++
Raw Normal View History

LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <AK/ByteBuffer.h>
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
#include <AK/GenericLexer.h>
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
#include <AK/HashMap.h>
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
#include <AK/LexicalPath.h>
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
#include <AK/StringBuilder.h>
#include <LibCore/ArgsParser.h>
#include <LibCore/File.h>
#include <ctype.h>
LibWeb+LibJS: Add a naive way to check if a wrapper "is" a certain type Instead of only checking the class_name(), we now generate an is_foo() virtual in the wrapper generator. (It's currently something we override on Bindings::Wrapper, which is not really scalable.) Longer term we'll need to think up something smarter for verifying that one wrapper "is" another type of wrapper.
2020-06-20 22:19:29 +02:00
static String snake_name(const StringView& title_name)
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
{
StringBuilder builder;
LibWeb+LibJS: Add a naive way to check if a wrapper "is" a certain type Instead of only checking the class_name(), we now generate an is_foo() virtual in the wrapper generator. (It's currently something we override on Bindings::Wrapper, which is not really scalable.) Longer term we'll need to think up something smarter for verifying that one wrapper "is" another type of wrapper.
2020-06-20 22:19:29 +02:00
bool first = true;
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
bool last_was_uppercase = false;
LibWeb+LibJS: Add a naive way to check if a wrapper "is" a certain type Instead of only checking the class_name(), we now generate an is_foo() virtual in the wrapper generator. (It's currently something we override on Bindings::Wrapper, which is not really scalable.) Longer term we'll need to think up something smarter for verifying that one wrapper "is" another type of wrapper.
2020-06-20 22:19:29 +02:00
for (auto ch : title_name) {
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
if (isupper(ch)) {
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
if (!first && !last_was_uppercase)
LibWeb+LibJS: Add a naive way to check if a wrapper "is" a certain type Instead of only checking the class_name(), we now generate an is_foo() virtual in the wrapper generator. (It's currently something we override on Bindings::Wrapper, which is not really scalable.) Longer term we'll need to think up something smarter for verifying that one wrapper "is" another type of wrapper.
2020-06-20 22:19:29 +02:00
builder.append('_');
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
builder.append(tolower(ch));
} else {
builder.append(ch);
}
LibWeb+LibJS: Add a naive way to check if a wrapper "is" a certain type Instead of only checking the class_name(), we now generate an is_foo() virtual in the wrapper generator. (It's currently something we override on Bindings::Wrapper, which is not really scalable.) Longer term we'll need to think up something smarter for verifying that one wrapper "is" another type of wrapper.
2020-06-20 22:19:29 +02:00
first = false;
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
last_was_uppercase = isupper(ch);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
}
return builder.to_string();
}
LibWeb: Add HTML elements to factories, add missing tags and attributes This is mostly to get the grunt work of the way. This is split up into multiple commits to hopefully make it more manageable to review. Note that these are not full implementations, and the bindings mostly get the low hanging fruit. Also implements some attributes that I kept out because they had dashes in them. Therefore, this closes #2905.
2020-08-09 17:10:41 +01:00
static String make_input_acceptable_cpp(const String& input)
LibWeb: Allow specifying a custom attribute name for [Reflect] Sometimes the IDL attribute and the DOM attribute don't have the same exact name. In those cases, we can now do this: [Reflect=foobar] attribute DOMString fooBar;
2020-07-24 13:23:47 +02:00
{
LibWeb: Add HTML elements to factories, add missing tags and attributes This is mostly to get the grunt work of the way. This is split up into multiple commits to hopefully make it more manageable to review. Note that these are not full implementations, and the bindings mostly get the low hanging fruit. Also implements some attributes that I kept out because they had dashes in them. Therefore, this closes #2905.
2020-08-09 17:10:41 +01:00
if (input == "class" || input == "template" || input == "for") {
LibWeb: Allow specifying a custom attribute name for [Reflect] Sometimes the IDL attribute and the DOM attribute don't have the same exact name. In those cases, we can now do this: [Reflect=foobar] attribute DOMString fooBar;
2020-07-24 13:23:47 +02:00
StringBuilder builder;
builder.append(input);
builder.append('_');
return builder.to_string();
}
LibWeb: Add HTML elements to factories, add missing tags and attributes This is mostly to get the grunt work of the way. This is split up into multiple commits to hopefully make it more manageable to review. Note that these are not full implementations, and the bindings mostly get the low hanging fruit. Also implements some attributes that I kept out because they had dashes in them. Therefore, this closes #2905.
2020-08-09 17:10:41 +01:00
String input_without_dashes = input;
input_without_dashes.replace("-", "_");
return input_without_dashes;
LibWeb: Allow specifying a custom attribute name for [Reflect] Sometimes the IDL attribute and the DOM attribute don't have the same exact name. In those cases, we can now do this: [Reflect=foobar] attribute DOMString fooBar;
2020-07-24 13:23:47 +02:00
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
namespace IDL {
struct Type {
String name;
bool nullable { false };
};
struct Parameter {
Type type;
String name;
};
struct Function {
Type return_type;
String name;
Vector<Parameter> parameters;
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
HashMap<String, String> extended_attributes;
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
size_t length() const
{
// FIXME: Take optional arguments into account
return parameters.size();
}
};
struct Attribute {
bool readonly { false };
LibWeb: Generate HTMLCanvasElement bindings from IDL :^)
2020-06-21 15:37:13 +02:00
bool unsigned_ { false };
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
Type type;
String name;
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
HashMap<String, String> extended_attributes;
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
// Added for convenience after parsing
String getter_callback_name;
String setter_callback_name;
};
struct Interface {
String name;
String parent_name;
Vector<Attribute> attributes;
Vector<Function> functions;
// Added for convenience after parsing
String wrapper_class;
String wrapper_base_class;
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
String fully_qualified_name;
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
};
LibWeb: Mark compilation-unit-only functions as static This enables a nice warning in case a function becomes dead code. Also, in the case of {Event,Node}WrapperFactory.cpp, the corresponding header was forgotten. This would cause an issue later when we enable -Wmissing-declarations. Is my clang-format misconfigured? Why is the diff for NodeWrapperFactory.cpp so large?
2020-08-11 00:07:16 +02:00
static OwnPtr<Interface> parse_interface(const StringView& input)
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
{
auto interface = make<Interface>();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
GenericLexer lexer(input);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
auto assert_specific = [&](char ch) {
auto consumed = lexer.consume();
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
if (consumed != ch) {
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
dbg() << "Expected '" << ch << "' at offset " << lexer.tell() << " but got '" << consumed << "'";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
ASSERT_NOT_REACHED();
}
};
auto consume_whitespace = [&] {
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
lexer.consume_while([](char ch) { return isspace(ch); });
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
};
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
auto assert_string = [&](const StringView& expected) {
bool saw_expected = lexer.consume_specific(expected);
ASSERT(saw_expected);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
};
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
assert_string("interface");
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
interface->name = lexer.consume_until([](auto ch) { return isspace(ch); });
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.consume_specific(':')) {
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
interface->parent_name = lexer.consume_until([](auto ch) { return isspace(ch); });
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
}
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
assert_specific('{');
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
auto parse_type = [&] {
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
auto name = lexer.consume_until([](auto ch) { return isspace(ch) || ch == '?'; });
auto nullable = lexer.consume_specific('?');
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
return Type { name, nullable };
};
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
auto parse_attribute = [&](HashMap<String, String>& extended_attributes) {
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
bool readonly = lexer.consume_specific("readonly");
if (readonly)
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.consume_specific("attribute"))
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
bool unsigned_ = lexer.consume_specific("unsigned");
if (unsigned_)
LibWeb: Generate HTMLCanvasElement bindings from IDL :^)
2020-06-21 15:37:13 +02:00
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
auto type = parse_type();
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
auto name = lexer.consume_until([](auto ch) { return isspace(ch) || ch == ';'; });
consume_whitespace();
assert_specific(';');
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
Attribute attribute;
attribute.readonly = readonly;
LibWeb: Generate HTMLCanvasElement bindings from IDL :^)
2020-06-21 15:37:13 +02:00
attribute.unsigned_ = unsigned_;
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
attribute.type = type;
attribute.name = name;
attribute.getter_callback_name = String::format("%s_getter", snake_name(attribute.name).characters());
attribute.setter_callback_name = String::format("%s_setter", snake_name(attribute.name).characters());
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
attribute.extended_attributes = move(extended_attributes);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
interface->attributes.append(move(attribute));
};
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
auto parse_function = [&](HashMap<String, String>& extended_attributes) {
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
auto return_type = parse_type();
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
auto name = lexer.consume_until([](auto ch) { return isspace(ch) || ch == '('; });
consume_whitespace();
assert_specific('(');
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
Vector<Parameter> parameters;
for (;;) {
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.consume_specific(')'))
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
break;
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
auto type = parse_type();
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
auto name = lexer.consume_until([](auto ch) { return isspace(ch) || ch == ',' || ch == ')'; });
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
parameters.append({ move(type), move(name) });
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.consume_specific(')'))
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
break;
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
assert_specific(',');
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
}
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
consume_whitespace();
assert_specific(';');
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
interface->functions.append(Function { return_type, name, move(parameters), move(extended_attributes) });
};
auto parse_extended_attributes = [&] {
HashMap<String, String> extended_attributes;
for (;;) {
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.consume_specific(']'))
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
break;
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
auto name = lexer.consume_until([](auto ch) { return ch == ']' || ch == '=' || ch == ','; });
if (lexer.consume_specific('=')) {
auto value = lexer.consume_until([](auto ch) { return ch == ']' || ch == ','; });
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
extended_attributes.set(name, value);
} else {
extended_attributes.set(name, {});
}
}
consume_whitespace();
return extended_attributes;
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
};
for (;;) {
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
HashMap<String, String> extended_attributes;
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
consume_whitespace();
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.consume_specific('}'))
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
break;
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.consume_specific('[')) {
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
extended_attributes = parse_extended_attributes();
}
LibWeb: Use GenericLexer in WrapperGenerator
2020-08-21 09:51:57 -04:00
if (lexer.next_is("readonly") || lexer.next_is("attribute")) {
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
parse_attribute(extended_attributes);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
continue;
}
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
parse_function(extended_attributes);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
}
interface->wrapper_class = String::format("%sWrapper", interface->name.characters());
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
interface->wrapper_base_class = String::format("%sWrapper", interface->parent_name.is_empty() ? "" : interface->parent_name.characters());
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
return interface;
}
}
static void generate_header(const IDL::Interface&);
static void generate_implementation(const IDL::Interface&);
int main(int argc, char** argv)
{
Core::ArgsParser args_parser;
const char* path = nullptr;
bool header_mode = false;
bool implementation_mode = false;
args_parser.add_option(header_mode, "Generate the wrapper .h file", "header", 'H');
args_parser.add_option(implementation_mode, "Generate the wrapper .cpp file", "implementation", 'I');
args_parser.add_positional_argument(path, "IDL file", "idl-file");
args_parser.parse(argc, argv);
auto file_or_error = Core::File::open(path, Core::IODevice::ReadOnly);
if (file_or_error.is_error()) {
fprintf(stderr, "Cannot open %s\n", path);
return 1;
}
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
LexicalPath lexical_path(path);
auto namespace_ = lexical_path.parts().at(lexical_path.parts().size() - 2);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
auto data = file_or_error.value()->read_all();
auto interface = IDL::parse_interface(data);
if (!interface) {
fprintf(stderr, "Cannot parse %s\n", path);
return 1;
}
LibWeb: Add empty IDL bindings for current SVG elements Nothing in them right now as the classes don't contain the IDL methods.
2020-10-02 20:57:28 +01:00
if (namespace_.is_one_of("DOM", "HTML", "UIEvents", "HighResolutionTime", "SVG")) {
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
StringBuilder builder;
builder.append(namespace_);
builder.append("::");
builder.append(interface->name);
interface->fully_qualified_name = builder.to_string();
} else {
interface->fully_qualified_name = interface->name;
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
#if 0
dbg() << "Attributes:";
for (auto& attribute : interface->attributes) {
dbg() << " " << (attribute.readonly ? "Readonly " : "")
<< attribute.type.name << (attribute.type.nullable ? "?" : "")
<< " " << attribute.name;
}
dbg() << "Functions:";
for (auto& function : interface->functions) {
dbg() << " " << function.return_type.name << (function.return_type.nullable ? "?" : "")
<< " " << function.name;
for (auto& parameter : function.parameters) {
dbg() << " " << parameter.type.name << (parameter.type.nullable ? "?" : "") << " " << parameter.name;
}
}
#endif
if (header_mode)
generate_header(*interface);
if (implementation_mode)
generate_implementation(*interface);
return 0;
}
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
static bool should_emit_wrapper_factory(const IDL::Interface& interface)
{
// FIXME: This is very hackish.
if (interface.name == "EventTarget")
return false;
if (interface.name == "Node")
return false;
if (interface.name == "Text")
return false;
if (interface.name == "Document")
return false;
if (interface.name == "DocumentType")
return false;
if (interface.name.ends_with("Element"))
return false;
LibWeb: Generate Event and MouseEvent bindings from IDL :^) We still have to hand-write a function to turn an Event& into a wrapper but this is still a hue improvement. Eventually we'll find a way to auto-generate that function as well.
2020-06-21 16:10:48 +02:00
if (interface.name.ends_with("Event"))
return false;
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
return true;
}
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
static bool is_wrappable_type(const IDL::Type& type)
{
if (type.name == "Node")
return true;
if (type.name == "Document")
return true;
if (type.name == "Text")
return true;
if (type.name == "DocumentType")
return true;
if (type.name.ends_with("Element"))
return true;
if (type.name == "ImageData")
return true;
return false;
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
static void generate_header(const IDL::Interface& interface)
{
auto& wrapper_class = interface.wrapper_class;
auto& wrapper_base_class = interface.wrapper_base_class;
out() << "#pragma once";
out() << "#include <LibWeb/Bindings/Wrapper.h>";
LibWeb: Move HTML object model stuff into LibWeb/HTML/ Take a hint from SVG and more all the HTML classes into HTML instead of mixing them with the DOM classes.
2020-07-26 15:08:16 +02:00
// FIXME: This is very strange.
out() << "#if __has_include(<LibWeb/DOM/" << interface.name << ".h>)";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "#include <LibWeb/DOM/" << interface.name << ".h>";
LibWeb: Move MouseEvent into the UIEvents namespace Named after the UIEvents specification that houses MouseEvent.
2020-07-28 17:21:23 +02:00
out() << "#elif __has_include(<LibWeb/HTML/" << interface.name << ".h>)";
LibWeb: Move HTML object model stuff into LibWeb/HTML/ Take a hint from SVG and more all the HTML classes into HTML instead of mixing them with the DOM classes.
2020-07-26 15:08:16 +02:00
out() << "#include <LibWeb/HTML/" << interface.name << ".h>";
LibWeb: Move MouseEvent into the UIEvents namespace Named after the UIEvents specification that houses MouseEvent.
2020-07-28 17:21:23 +02:00
out() << "#elif __has_include(<LibWeb/UIEvents/" << interface.name << ".h>)";
out() << "#include <LibWeb/UIEvents/" << interface.name << ".h>";
LibWeb: Implement performance.now() This patch introduces the HighResolutionTime namespace which is home to the Performance object (exposed via window.performance) performance.now() is currently the only function, and it returns the number of milliseconds since the window object was constructed. :^)
2020-09-29 18:19:18 +02:00
out() << "#elif __has_include(<LibWeb/HighResolutionTime/" << interface.name << ".h>)";
out() << "#include <LibWeb/HighResolutionTime/" << interface.name << ".h>";
LibWeb: Add empty IDL bindings for current SVG elements Nothing in them right now as the classes don't contain the IDL methods.
2020-10-02 20:57:28 +01:00
out() << "#elif __has_include(<LibWeb/SVG/" << interface.name << ".h>)";
out() << "#include <LibWeb/SVG/" << interface.name << ".h>";
LibWeb: Move HTML object model stuff into LibWeb/HTML/ Take a hint from SVG and more all the HTML classes into HTML instead of mixing them with the DOM classes.
2020-07-26 15:08:16 +02:00
out() << "#endif";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
if (wrapper_base_class != "Wrapper")
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "#include <LibWeb/Bindings/" << wrapper_base_class << ".h>";
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << "namespace Web::Bindings {";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "class " << wrapper_class << " : public " << wrapper_base_class << " {";
LibJS+LibWeb: Add JS::Object::inherits(class_name) To allow implementing the DOM class hierarchy in JS bindings, this patch adds an inherits() function that can be used to ask an Object if it inherits from a specific C++ class (by name). The necessary overrides are baked into each Object subclass by the new JS_OBJECT macro, which works similarly to C_OBJECT in LibCore. Thanks to @Dexesttp for suggesting this approach. :^)
2020-06-21 15:14:02 +02:00
out() << " JS_OBJECT(" << wrapper_class << ", " << wrapper_base_class << ");";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "public:";
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << " " << wrapper_class << "(JS::GlobalObject&, " << interface.fully_qualified_name << "&);";
LibJS: Simplify Cell::initialize() Remove the Interpreter& argument and pass only GlobalObject&. We can find everything we need via the global object anyway.
2020-07-22 17:50:18 +02:00
out() << " virtual void initialize(JS::GlobalObject&) override;";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << " virtual ~" << wrapper_class << "() override;";
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
if (wrapper_base_class == "Wrapper") {
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << " " << interface.fully_qualified_name << "& impl() { return *m_impl; }";
out() << " const " << interface.fully_qualified_name << "& impl() const { return *m_impl; }";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
} else {
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << " " << interface.fully_qualified_name << "& impl() { return static_cast<" << interface.fully_qualified_name << "&>(" << wrapper_base_class << "::impl()); }";
out() << " const " << interface.fully_qualified_name << "& impl() const { return static_cast<const " << interface.fully_qualified_name << "&>(" << wrapper_base_class << "::impl()); }";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
}
LibWeb+LibJS: Add a naive way to check if a wrapper "is" a certain type Instead of only checking the class_name(), we now generate an is_foo() virtual in the wrapper generator. (It's currently something we override on Bindings::Wrapper, which is not really scalable.) Longer term we'll need to think up something smarter for verifying that one wrapper "is" another type of wrapper.
2020-06-20 22:19:29 +02:00
auto is_foo_wrapper_name = snake_name(String::format("Is%s", wrapper_class.characters()));
out() << " virtual bool " << is_foo_wrapper_name << "() const final { return true; }";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "private:";
for (auto& function : interface.functions) {
out() << " JS_DECLARE_NATIVE_FUNCTION(" << snake_name(function.name) << ");";
}
for (auto& attribute : interface.attributes) {
out() << " JS_DECLARE_NATIVE_GETTER(" << snake_name(attribute.name) << "_getter);";
if (!attribute.readonly)
out() << " JS_DECLARE_NATIVE_SETTER(" << snake_name(attribute.name) << "_setter);";
}
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
if (wrapper_base_class == "Wrapper") {
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << " NonnullRefPtr<" << interface.fully_qualified_name << "> m_impl;";
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "};";
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
if (should_emit_wrapper_factory(interface)) {
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << wrapper_class << "* wrap(JS::GlobalObject&, " << interface.fully_qualified_name << "&);";
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "}";
}
void generate_implementation(const IDL::Interface& interface)
{
auto& wrapper_class = interface.wrapper_class;
auto& wrapper_base_class = interface.wrapper_base_class;
out() << "#include <AK/FlyString.h>";
out() << "#include <LibJS/Runtime/Array.h>";
out() << "#include <LibJS/Runtime/Value.h>";
out() << "#include <LibJS/Runtime/GlobalObject.h>";
out() << "#include <LibJS/Runtime/Error.h>";
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
out() << "#include <LibJS/Runtime/Function.h>";
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
out() << "#include <LibJS/Runtime/Uint8ClampedArray.h>";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "#include <LibWeb/Bindings/NodeWrapperFactory.h>";
out() << "#include <LibWeb/Bindings/" << wrapper_class << ".h>";
out() << "#include <LibWeb/DOM/Element.h>";
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
out() << "#include <LibWeb/DOM/EventListener.h>";
LibWeb: Disallow cross-origin access to <iframe>.contentDocument With this patch, we now enforce basic same-origin policy for this one <iframe> attribute. To make it easier to add more attributes like this, I've added an extended IDL attribute ("[ReturnNullIfCrossOrigin]") that does exactly what it sounds like. :^)
2020-09-22 18:26:33 +02:00
out() << "#include <LibWeb/HTML/HTMLElement.h>";
out() << "#include <LibWeb/Origin.h>";
LibWeb: Add Comment and DocumentFragment bindings, move querySelector... ...{All} to ParentNode. Exposes createDocumentFragment and createComment on Document. Stubs out the document.body setter. Also adds ParentNode back :^).
2020-08-17 19:14:30 +01:00
out() << "#include <LibWeb/Bindings/CommentWrapper.h>";
LibWeb: Add a whole bunch of HTML DOM bindings Note that these aren't full implementations of the bindings. This mostly implements the low hanging fruit (namely, basic reflections) There are some attributes that should be USVString instead of DOMString. However, USVString is a slightly different definition of DOMString, so it should suffice for now.
2020-07-27 05:04:26 +01:00
out() << "#include <LibWeb/Bindings/DocumentWrapper.h>";
LibWeb: Add Comment and DocumentFragment bindings, move querySelector... ...{All} to ParentNode. Exposes createDocumentFragment and createComment on Document. Stubs out the document.body setter. Also adds ParentNode back :^).
2020-08-17 19:14:30 +01:00
out() << "#include <LibWeb/Bindings/DocumentFragmentWrapper.h>";
LibWeb: Implement quirks mode detection This allows us to determine which mode to render the page in. Exposes "doctype" and "compatMode" on Document. Exposes "name", "publicId" and "systemId" on DocumentType.
2020-07-18 21:17:17 +01:00
out() << "#include <LibWeb/Bindings/DocumentTypeWrapper.h>";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
out() << "#include <LibWeb/Bindings/HTMLCanvasElementWrapper.h>";
LibWeb: Add Comment and DocumentFragment bindings, move querySelector... ...{All} to ParentNode. Exposes createDocumentFragment and createComment on Document. Stubs out the document.body setter. Also adds ParentNode back :^).
2020-08-17 19:14:30 +01:00
out() << "#include <LibWeb/Bindings/HTMLHeadElementWrapper.h>";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
out() << "#include <LibWeb/Bindings/HTMLImageElementWrapper.h>";
out() << "#include <LibWeb/Bindings/ImageDataWrapper.h>";
LibWeb: Add Comment and DocumentFragment bindings, move querySelector... ...{All} to ParentNode. Exposes createDocumentFragment and createComment on Document. Stubs out the document.body setter. Also adds ParentNode back :^).
2020-08-17 19:14:30 +01:00
out() << "#include <LibWeb/Bindings/TextWrapper.h>";
LibWeb: Generate HTMLCanvasElement bindings from IDL :^)
2020-06-21 15:37:13 +02:00
out() << "#include <LibWeb/Bindings/CanvasRenderingContext2DWrapper.h>";
LibWeb: Disallow cross-origin access to <iframe>.contentDocument With this patch, we now enforce basic same-origin policy for this one <iframe> attribute. To make it easier to add more attributes like this, I've added an extended IDL attribute ("[ReturnNullIfCrossOrigin]") that does exactly what it sounds like. :^)
2020-09-22 18:26:33 +02:00
out() << "#include <LibWeb/Bindings/WindowObject.h>";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
// FIXME: This is a total hack until we can figure out the namespace for a given type somehow.
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
out() << "using namespace Web::DOM;";
out() << "using namespace Web::HTML;";
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << "namespace Web::Bindings {";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
// Implementation: Wrapper constructor
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << wrapper_class << "::" << wrapper_class << "(JS::GlobalObject& global_object, " << interface.fully_qualified_name << "& impl)";
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
if (wrapper_base_class == "Wrapper") {
out() << " : Wrapper(*global_object.object_prototype())";
out() << " , m_impl(impl)";
} else {
out() << " : " << wrapper_base_class << "(global_object, impl)";
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "{";
out() << "}";
// Implementation: Wrapper initialize()
LibJS: Simplify Cell::initialize() Remove the Interpreter& argument and pass only GlobalObject&. We can find everything we need via the global object anyway.
2020-07-22 17:50:18 +02:00
out() << "void " << wrapper_class << "::initialize(JS::GlobalObject& global_object)";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "{";
out() << " [[maybe_unused]] u8 default_attributes = JS::Attribute::Enumerable | JS::Attribute::Configurable;";
LibJS: Simplify Cell::initialize() Remove the Interpreter& argument and pass only GlobalObject&. We can find everything we need via the global object anyway.
2020-07-22 17:50:18 +02:00
out() << " " << wrapper_base_class << "::initialize(global_object);";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
for (auto& attribute : interface.attributes) {
out() << " define_native_property(\"" << attribute.name << "\", " << attribute.getter_callback_name << ", " << (attribute.readonly ? "nullptr" : attribute.setter_callback_name) << ", default_attributes);";
}
for (auto& function : interface.functions) {
out() << " define_native_function(\"" << function.name << "\", " << snake_name(function.name) << ", " << function.length() << ", default_attributes);";
}
out() << "}";
// Implementation: Wrapper destructor
out() << wrapper_class << "::~" << wrapper_class << "()";
out() << "{";
out() << "}";
// Implementation: impl_from()
LibWeb: Generate HTMLImageElement bindings from IDL :^)
2020-06-21 15:26:09 +02:00
if (!interface.attributes.is_empty() || !interface.functions.is_empty()) {
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
out() << "static " << interface.fully_qualified_name << "* impl_from(JS::VM& vm, JS::GlobalObject& global_object)";
LibWeb: Generate HTMLImageElement bindings from IDL :^)
2020-06-21 15:26:09 +02:00
out() << "{";
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
out() << " auto* this_object = vm.this_value(global_object).to_object(global_object);";
LibWeb: Generate HTMLImageElement bindings from IDL :^)
2020-06-21 15:26:09 +02:00
out() << " if (!this_object)";
out() << " return {};";
out() << " if (!this_object->inherits(\"" << wrapper_class << "\")) {";
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
out() << " vm.throw_exception<JS::TypeError>(global_object, JS::ErrorType::NotA, \"" << interface.fully_qualified_name << "\");";
LibWeb: Generate HTMLImageElement bindings from IDL :^)
2020-06-21 15:26:09 +02:00
out() << " return nullptr;";
out() << " }";
out() << " return &static_cast<" << wrapper_class << "*>(this_object)->impl();";
out() << "}";
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
auto generate_to_cpp = [&](auto& parameter, auto& js_name, auto& js_suffix, auto cpp_name, bool return_void = false) {
auto generate_return = [&] {
if (return_void)
out() << " return;";
else
out() << " return {};";
};
if (parameter.type.name == "DOMString") {
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
out() << " auto " << cpp_name << " = " << js_name << js_suffix << ".to_string(global_object);";
out() << " if (vm.exception())";
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
generate_return();
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
} else if (parameter.type.name == "EventListener") {
out() << " if (!" << js_name << js_suffix << ".is_function()) {";
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
out() << " vm.throw_exception<JS::TypeError>(global_object, JS::ErrorType::NotA, \"Function\");";
LibWeb: Generate EventTarget bindings from IDL :^)
2020-06-21 12:27:41 +02:00
generate_return();
out() << " }";
out() << " auto " << cpp_name << " = adopt(*new EventListener(JS::make_handle(&" << js_name << js_suffix << ".as_function())));";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
} else if (is_wrappable_type(parameter.type)) {
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
out() << " auto " << cpp_name << "_object = " << js_name << js_suffix << ".to_object(global_object);";
out() << " if (vm.exception())";
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
generate_return();
LibJS+LibWeb: Add JS::Object::inherits(class_name) To allow implementing the DOM class hierarchy in JS bindings, this patch adds an inherits() function that can be used to ask an Object if it inherits from a specific C++ class (by name). The necessary overrides are baked into each Object subclass by the new JS_OBJECT macro, which works similarly to C_OBJECT in LibCore. Thanks to @Dexesttp for suggesting this approach. :^)
2020-06-21 15:14:02 +02:00
out() << " if (!" << cpp_name << "_object->inherits(\"" << parameter.type.name << "Wrapper\")) {";
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
out() << " vm.throw_exception<JS::TypeError>(global_object, JS::ErrorType::NotA, \"" << parameter.type.name << "\");";
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
generate_return();
out() << " }";
out() << " auto& " << cpp_name << " = static_cast<" << parameter.type.name << "Wrapper*>(" << cpp_name << "_object)->impl();";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
} else if (parameter.type.name == "double") {
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
out() << " auto " << cpp_name << " = " << js_name << js_suffix << ".to_double(global_object);";
out() << " if (vm.exception())";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
generate_return();
LibWeb: Add basic support for boolean IDL attributes :^)
2020-09-11 17:51:10 +02:00
} else if (parameter.type.name == "boolean") {
out() << " auto " << cpp_name << " = " << js_name << js_suffix << ".to_boolean();";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
} else {
dbg() << "Unimplemented JS-to-C++ conversion: " << parameter.type.name;
ASSERT_NOT_REACHED();
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
}
};
auto generate_arguments = [&](auto& parameters, auto& arguments_builder, bool return_void = false) {
Vector<String> parameter_names;
size_t argument_index = 0;
for (auto& parameter : parameters) {
parameter_names.append(snake_name(parameter.name));
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
out() << " auto arg" << argument_index << " = vm.argument(" << argument_index << ");";
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
generate_to_cpp(parameter, "arg", argument_index, snake_name(parameter.name), return_void);
++argument_index;
}
arguments_builder.join(", ", parameter_names);
};
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
auto generate_return_statement = [&](auto& return_type) {
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
if (return_type.name == "void") {
out() << " return JS::js_undefined();";
return;
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
if (return_type.nullable) {
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
if (return_type.name == "DOMString") {
out() << " if (retval.is_null())";
} else {
out() << " if (!retval)";
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << " return JS::js_null();";
}
if (return_type.name == "DOMString") {
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
out() << " return JS::js_string(vm, retval);";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
} else if (return_type.name == "ArrayFromVector") {
// FIXME: Remove this fake type hack once it's no longer needed.
// Basically once we have NodeList we can throw this out.
out() << " auto* new_array = JS::Array::create(global_object);";
out() << " for (auto& element : retval) {";
LibWeb: Make wrapper factory functions take JS::GlobalObject& Instead of taking the JS::Heap&. This allows us to get rid of some calls to JS::Interpreter::global_object(). We're getting closer and closer to multiple global objects. :^)
2020-06-23 16:57:39 +02:00
out() << " new_array->indexed_properties().append(wrap(global_object, element));";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << " }";
out() << " return new_array;";
LibWeb: Generate Event and MouseEvent bindings from IDL :^) We still have to hand-write a function to turn an Event& into a wrapper but this is still a hue improvement. Eventually we'll find a way to auto-generate that function as well.
2020-06-21 16:10:48 +02:00
} else if (return_type.name == "long" || return_type.name == "double") {
LibWeb: Generate HTMLCanvasElement bindings from IDL :^)
2020-06-21 15:37:13 +02:00
out() << " return JS::Value(retval);";
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
} else if (return_type.name == "Uint8ClampedArray") {
out() << " return retval;";
Meta+LibHTTP through LibWeb: Make clang-format-10 clean
2020-09-18 09:49:51 +02:00
} else if (return_type.name == "boolean") {
LibWeb: Add basic support for boolean IDL attributes :^)
2020-09-11 17:51:10 +02:00
out() << " return JS::Value(retval);";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
} else {
LibWeb: Make wrapper factory functions take JS::GlobalObject& Instead of taking the JS::Heap&. This allows us to get rid of some calls to JS::Interpreter::global_object(). We're getting closer and closer to multiple global objects. :^)
2020-06-23 16:57:39 +02:00
out() << " return wrap(global_object, const_cast<" << return_type.name << "&>(*retval));";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
}
};
// Implementation: Attributes
for (auto& attribute : interface.attributes) {
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
out() << "JS_DEFINE_NATIVE_GETTER(" << wrapper_class << "::" << attribute.getter_callback_name << ")";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "{";
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
out() << " auto* impl = impl_from(vm, global_object);";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << " if (!impl)";
out() << " return {};";
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
LibWeb: Disallow cross-origin access to <iframe>.contentDocument With this patch, we now enforce basic same-origin policy for this one <iframe> attribute. To make it easier to add more attributes like this, I've added an extended IDL attribute ("[ReturnNullIfCrossOrigin]") that does exactly what it sounds like. :^)
2020-09-22 18:26:33 +02:00
if (attribute.extended_attributes.contains("ReturnNullIfCrossOrigin")) {
out() << " if (!impl->may_access_from_origin(static_cast<WindowObject&>(global_object).origin()))";
out() << " return JS::js_null();";
}
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
if (attribute.extended_attributes.contains("Reflect")) {
LibWeb: Allow specifying a custom attribute name for [Reflect] Sometimes the IDL attribute and the DOM attribute don't have the same exact name. In those cases, we can now do this: [Reflect=foobar] attribute DOMString fooBar;
2020-07-24 13:23:47 +02:00
auto attribute_name = attribute.extended_attributes.get("Reflect").value();
if (attribute_name.is_null())
attribute_name = attribute.name;
LibWeb: Add HTML elements to factories, add missing tags and attributes This is mostly to get the grunt work of the way. This is split up into multiple commits to hopefully make it more manageable to review. Note that these are not full implementations, and the bindings mostly get the low hanging fruit. Also implements some attributes that I kept out because they had dashes in them. Therefore, this closes #2905.
2020-08-09 17:10:41 +01:00
attribute_name = make_input_acceptable_cpp(attribute_name);
LibWeb: Allow specifying a custom attribute name for [Reflect] Sometimes the IDL attribute and the DOM attribute don't have the same exact name. In those cases, we can now do this: [Reflect=foobar] attribute DOMString fooBar;
2020-07-24 13:23:47 +02:00
out() << " auto retval = impl->attribute(HTML::AttributeNames::" << attribute_name << ");";
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
} else {
out() << " auto retval = impl->" << snake_name(attribute.name) << "();";
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
generate_return_statement(attribute.type);
out() << "}";
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
if (!attribute.readonly) {
out() << "JS_DEFINE_NATIVE_SETTER(" << wrapper_class << "::" << attribute.setter_callback_name << ")";
out() << "{";
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
out() << " auto* impl = impl_from(vm, global_object);";
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
out() << " if (!impl)";
out() << " return;";
generate_to_cpp(attribute, "value", "", "cpp_value", true);
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
if (attribute.extended_attributes.contains("Reflect")) {
LibWeb: Allow specifying a custom attribute name for [Reflect] Sometimes the IDL attribute and the DOM attribute don't have the same exact name. In those cases, we can now do this: [Reflect=foobar] attribute DOMString fooBar;
2020-07-24 13:23:47 +02:00
auto attribute_name = attribute.extended_attributes.get("Reflect").value();
if (attribute_name.is_null())
attribute_name = attribute.name;
LibWeb: Add HTML elements to factories, add missing tags and attributes This is mostly to get the grunt work of the way. This is split up into multiple commits to hopefully make it more manageable to review. Note that these are not full implementations, and the bindings mostly get the low hanging fruit. Also implements some attributes that I kept out because they had dashes in them. Therefore, this closes #2905.
2020-08-09 17:10:41 +01:00
attribute_name = make_input_acceptable_cpp(attribute_name);
LibWeb: Allow specifying a custom attribute name for [Reflect] Sometimes the IDL attribute and the DOM attribute don't have the same exact name. In those cases, we can now do this: [Reflect=foobar] attribute DOMString fooBar;
2020-07-24 13:23:47 +02:00
out() << " impl->set_attribute(HTML::AttributeNames::" << attribute_name << ", cpp_value);";
LibWeb: Add code generation for reflecting IDL attributes You can now tag reflecting attributes with [Reflect] to generate code that does basic DOM element attribute get/set. (This patch also makes it easy to add more extended attributes like that going forward.) From the HTML spec: "Some IDL attributes are defined to reflect a particular content attribute. This means that on getting, the IDL attribute returns the current value of the content attribute, and on setting, the IDL attribute changes the value of the content attribute to the given value."
2020-07-24 12:59:47 +02:00
} else {
out() << " impl->set_" << snake_name(attribute.name) << "(cpp_value);";
}
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
out() << "}";
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
}
// Implementation: Functions
for (auto& function : interface.functions) {
out() << "JS_DEFINE_NATIVE_FUNCTION(" << wrapper_class << "::" << snake_name(function.name) << ")";
out() << "{";
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
out() << " auto* impl = impl_from(vm, global_object);";
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << " if (!impl)";
out() << " return {};";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
if (function.length() > 0) {
LibJS: Make native function/property callbacks take VM, not Interpreter More work on decoupling the general runtime from Interpreter. The goal is becoming clearer. Interpreter should be one possible way to execute code inside a VM. In the future we might have other ways :^)
2020-09-27 18:36:49 +02:00
out() << " if (vm.argument_count() < " << function.length() << ") {";
LibWeb: Add Comment and DocumentFragment bindings, move querySelector... ...{All} to ParentNode. Exposes createDocumentFragment and createComment on Document. Stubs out the document.body setter. Also adds ParentNode back :^).
2020-08-17 19:14:30 +01:00
if (function.length() == 1)
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
out() << " vm.throw_exception<JS::TypeError>(global_object, JS::ErrorType::BadArgCountOne, \"" << function.name << "\");";
LibWeb: Add Comment and DocumentFragment bindings, move querySelector... ...{All} to ParentNode. Exposes createDocumentFragment and createComment on Document. Stubs out the document.body setter. Also adds ParentNode back :^).
2020-08-17 19:14:30 +01:00
else
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
out() << " vm.throw_exception<JS::TypeError>(global_object, JS::ErrorType::BadArgCountMany, \"" << function.name << "\", \"" << function.length() << "\");";
LibJS: Make Interpreter::throw_exception() a void function The motivation for this change is twofold: - Returning a JS::Value is misleading as one would expect it to carry some meaningful information, like maybe the error object that's being created, but in fact it is always empty. Supposedly to serve as a shortcut for the common case of "throw and return empty value", but that's just leading us to my second point. - Inconsistent usage / coding style: as of this commit there are 114 uses of throw_exception() discarding its return value and 55 uses directly returning the call result (in LibJS, not counting LibWeb); with the first style often having a more explicit empty value (or nullptr in some cases) return anyway. One more line to always make the return value obvious is should be worth it. So now it's basically always these steps, which is already being used in the majority of cases (as outlined above): - Throw an exception. This mutates interpreter state by updating m_exception and unwinding, but doesn't return anything. - Let the caller explicitly return an empty value, nullptr or anything else itself.
2020-08-25 12:52:32 +02:00
out() << " return {};";
out() << " }";
LibWeb: Generate CanvasRenderingContext2D bindings from IDL :^) We're still missing optional argument support, so this implementation doesn't support fill(), only fill(fill_rule). Still it's really nice to get rid of so much hand-written wrapper code.
2020-06-22 18:39:22 +02:00
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
StringBuilder arguments_builder;
LibWeb: Generate Element bindings from IDL :^) Had to do a bunch more hacking on WrapperGenerator to support this. We now support attribute setters as well.
2020-06-21 11:39:32 +02:00
generate_arguments(function.parameters, arguments_builder);
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
if (function.return_type.name != "void") {
out() << " auto retval = impl->" << snake_name(function.name) << "(" << arguments_builder.to_string() << ");";
} else {
out() << " impl->" << snake_name(function.name) << "(" << arguments_builder.to_string() << ");";
}
generate_return_statement(function.return_type);
out() << "}";
}
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
// Implementation: Wrapper factory
if (should_emit_wrapper_factory(interface)) {
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
out() << wrapper_class << "* wrap(JS::GlobalObject& global_object, " << interface.fully_qualified_name << "& impl)";
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
out() << "{";
LibWeb: Make wrapper factory functions take JS::GlobalObject& Instead of taking the JS::Heap&. This allows us to get rid of some calls to JS::Interpreter::global_object(). We're getting closer and closer to multiple global objects. :^)
2020-06-23 16:57:39 +02:00
out() << " return static_cast<" << wrapper_class << "*>(wrap_impl(global_object, impl));";
LibWeb: Generate ImageData bindings from IDL :^)
2020-06-21 15:57:10 +02:00
out() << "}";
}
LibWeb: Start generating JS wrappers from (simplified) WebIDL :^) This patch introduces a hackish but functional IDL parser and uses it to generate the JS bindings for Node and Document. We'll see how far this simple parser takes us. The important thing right now is generating code, not being a perfect IDL parser. :^)
2020-06-20 22:09:38 +02:00
out() << "}";
}
Reference in a new issue Copy permalink