mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-23 17:52:26 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/HTML/Parser/HTMLParser.cpp

3399 lines
138 KiB
C++
Raw Normal View History

LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
/*
LibWeb: Add the PageTransitionEvent interface and fire "pageshow" events We now fire "pageshow" events at the appropriate time during document loading (done by the parser.) Note that there are no corresponding "pagehide" events yet.
2021-09-26 12:39:27 +02:00
* Copyright (c) 2020-2021, Andreas Kling <kling@serenityos.org>
LibWeb: Implement HTML fragment serialisation and use it in innerHTML The previous implementation was about a half implementation and was tied to Element::innerHTML. This separates it and puts it into HTMLDocumentParser, as this is in the parsing section of the spec. This provides a near finished HTML fragment serialisation algorithm, bar namespaces in attributes and the `is` value.
2021-09-13 22:42:15 +01:00
* Copyright (c) 2021, Luke Wilde <lukew@serenityos.org>
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
*/
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-17 16:57:17 +01:00
#include <AK/Debug.h>
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
#include <AK/SourceLocation.h>
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
#include <AK/Utf32View.h>
LibWeb: Use standardized encoding names, add encoding attribute to document
2020-11-13 11:16:28 +00:00
#include <LibTextCodec/Decoder.h>
LibWeb: Support comments in the "in head" insertion mode
2020-05-24 20:29:01 +02:00
#include <LibWeb/DOM/Comment.h>
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
#include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/DocumentType.h>
#include <LibWeb/DOM/ElementFactory.h>
LibWeb: Fire a DOMContentLoaded event when the new parser is finished With this change, we can finally load and render welcome.html :^)
2020-05-27 23:32:50 +02:00
#include <LibWeb/DOM/Event.h>
LibWeb: Implement HTML fragment serialisation and use it in innerHTML The previous implementation was about a half implementation and was tied to Element::innerHTML. This separates it and puts it into HTMLDocumentParser, as this is in the parsing section of the spec. This provides a near finished HTML fragment serialisation algorithm, bar namespaces in attributes and the `is` value.
2021-09-13 22:42:15 +01:00
#include <LibWeb/DOM/ProcessingInstruction.h>
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
#include <LibWeb/DOM/Text.h>
LibWeb: Dispatch "load" on document and window These happen right after "DOMContentLoaded" for now, which is incorrect since they should really wait until subresources have loaded. However, this makes a bunch of things work already so let's do it.
2020-10-18 13:45:28 +02:00
#include <LibWeb/DOM/Window.h>
LibWeb: Spin the event loop in HTML parser until scripts can run Call HTML::EventLoop::spin_until() from the HTML parser when deciding whether we can run a script yet. Note that spin_until() actually doesn't do any work yet.
2021-09-09 02:15:44 +02:00
#include <LibWeb/HTML/EventLoop/EventLoop.h>
LibWeb: Add HTML::EventNames and UIEvents::EventNames
2020-11-21 19:15:57 +00:00
#include <LibWeb/HTML/EventNames.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
#include <LibWeb/HTML/HTMLFormElement.h>
#include <LibWeb/HTML/HTMLHeadElement.h>
#include <LibWeb/HTML/HTMLScriptElement.h>
LibWeb: Implement "select" portion of reset_the_insertion_mode_appropriately Required by Dromaeo. With this, it no longer crashes.
2021-04-06 21:56:10 +01:00
#include <LibWeb/HTML/HTMLTableElement.h>
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
#include <LibWeb/HTML/HTMLTemplateElement.h>
LibWeb: Implement encoding sniffing algorithm This patch implements the HTML specification's "encoding sniffing algorithm", which is used when no encoding can be obtained from the Content-Type header (either because it doesn't contain a charset=...) value or the file has not been opened via HTTP (as with local files). It also modifies the creator of the HTMLDocumentParser to use the new HTMLDocumentParser::create_with_uncertain_encoding static method, which runs the encoding sniffing algorithm before instantiating the parser. This now allows us to load local HTML pages (or remote pages without a charset specified in the 'Content-Type' header) with a non-UTF-8 encoding such as 'windows-1252'. This would previously crash the browser. :^)
2021-05-12 10:47:12 +02:00
#include <LibWeb/HTML/Parser/HTMLEncodingDetection.h>
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
#include <LibWeb/HTML/Parser/HTMLParser.h>
LibWeb: Move the HTML parser into HTML/Parser/
2020-07-28 19:18:23 +02:00
#include <LibWeb/HTML/Parser/HTMLToken.h>
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
#include <LibWeb/Namespace.h>
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
#include <LibWeb/SVG/TagNames.h>
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
LibWeb: Move HTML classes into the Web::HTML namespace
2020-07-28 18:20:36 +02:00
namespace Web::HTML {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
static inline void log_parse_error(const SourceLocation& location = SourceLocation::current())
{
dbgln("Parse error! {}", location);
}
LibWeb: Add a PARSE_ERROR() macro to the new HTML parser Unless otherwise stated, we shouldn't stop parsing just because there's a parse error, so let's allow ourselves to continue. With this change, we can now tokenize and parse the ACID1 test. :^)
2020-05-25 20:02:27 +02:00
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
static Vector<FlyString> s_quirks_public_ids = {
"+//Silmaril//dtd html Pro v0r11 19970101//",
"-//AS//DTD HTML 3.0 asWedit + extensions//",
"-//AdvaSoft Ltd//DTD HTML 3.0 asWedit + extensions//",
"-//IETF//DTD HTML 2.0 Level 1//",
"-//IETF//DTD HTML 2.0 Level 2//",
"-//IETF//DTD HTML 2.0 Strict Level 1//",
"-//IETF//DTD HTML 2.0 Strict Level 2//",
"-//IETF//DTD HTML 2.0 Strict//",
"-//IETF//DTD HTML 2.0//",
"-//IETF//DTD HTML 2.1E//",
"-//IETF//DTD HTML 3.0//",
"-//IETF//DTD HTML 3.2 Final//",
"-//IETF//DTD HTML 3.2//",
"-//IETF//DTD HTML 3//",
"-//IETF//DTD HTML Level 0//",
"-//IETF//DTD HTML Level 1//",
"-//IETF//DTD HTML Level 2//",
"-//IETF//DTD HTML Level 3//",
"-//IETF//DTD HTML Strict Level 0//",
"-//IETF//DTD HTML Strict Level 1//",
"-//IETF//DTD HTML Strict Level 2//",
"-//IETF//DTD HTML Strict Level 3//",
"-//IETF//DTD HTML Strict//",
"-//IETF//DTD HTML//",
"-//Metrius//DTD Metrius Presentational//",
"-//Microsoft//DTD Internet Explorer 2.0 HTML Strict//",
"-//Microsoft//DTD Internet Explorer 2.0 HTML//",
"-//Microsoft//DTD Internet Explorer 2.0 Tables//",
"-//Microsoft//DTD Internet Explorer 3.0 HTML Strict//",
"-//Microsoft//DTD Internet Explorer 3.0 HTML//",
"-//Microsoft//DTD Internet Explorer 3.0 Tables//",
"-//Netscape Comm. Corp.//DTD HTML//",
"-//Netscape Comm. Corp.//DTD Strict HTML//",
"-//O'Reilly and Associates//DTD HTML 2.0//",
"-//O'Reilly and Associates//DTD HTML Extended 1.0//",
"-//O'Reilly and Associates//DTD HTML Extended Relaxed 1.0//",
"-//SQ//DTD HTML 2.0 HoTMetaL + extensions//",
"-//SoftQuad Software//DTD HoTMetaL PRO 6.0::19990601::extensions to HTML 4.0//",
"-//SoftQuad//DTD HoTMetaL PRO 4.0::19971010::extensions to HTML 4.0//",
"-//Spyglass//DTD HTML 2.0 Extended//",
"-//Sun Microsystems Corp.//DTD HotJava HTML//",
"-//Sun Microsystems Corp.//DTD HotJava Strict HTML//",
"-//W3C//DTD HTML 3 1995-03-24//",
"-//W3C//DTD HTML 3.2 Draft//",
"-//W3C//DTD HTML 3.2 Final//",
"-//W3C//DTD HTML 3.2//",
"-//W3C//DTD HTML 3.2S Draft//",
"-//W3C//DTD HTML 4.0 Frameset//",
"-//W3C//DTD HTML 4.0 Transitional//",
"-//W3C//DTD HTML Experimental 19960712//",
"-//W3C//DTD HTML Experimental 970421//",
"-//W3C//DTD W3 HTML//",
"-//W3O//DTD W3 HTML 3.0//",
"-//WebTechs//DTD Mozilla HTML 2.0//",
"-//WebTechs//DTD Mozilla HTML//"
};
LibWeb: Improvements to error handling in HTML foreign content parsing Follow the spec more closely when encountering an invalid start or end tag during foreign content parsing.
2021-09-14 23:49:45 +02:00
// https://html.spec.whatwg.org/multipage/parsing.html#mathml-text-integration-point
static bool is_mathml_text_integration_point(DOM::Element const&)
{
// FIXME: Implement.
return false;
}
// https://html.spec.whatwg.org/multipage/parsing.html#html-integration-point
static bool is_html_integration_point(DOM::Element const& element)
{
// A node is an HTML integration point if it is one of the following elements:
// FIXME: A MathML annotation-xml element whose start tag token had an attribute with the name "encoding" whose value was an ASCII case-insensitive match for the string "text/html"
// FIXME: A MathML annotation-xml element whose start tag token had an attribute with the name "encoding" whose value was an ASCII case-insensitive match for the string "application/xhtml+xml"
// An SVG foreignObject element
// An SVG desc element
// An SVG title element
if (element.tag_name().is_one_of(SVG::TagNames::foreignObject, SVG::TagNames::desc, SVG::TagNames::title))
return true;
return false;
}
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
RefPtr<DOM::Document> parse_html_document(StringView data, const AK::URL& url, const String& encoding)
LibWeb: Remove most uses of the old HTML parser The only remaining client of the old parser is the fragment parser used by the Element.innerHTML setter. We'll need to implement a bit more stuff in the new parser before we can switch that over.
2020-06-21 22:29:05 +02:00
{
LibWeb: Make HTMLDocumentParser take an existing document We shouldn't really be creating the document objects inside the parser, since that makes it hard to hook up e.g JavaScript bindings early on.
2020-12-13 16:59:22 +01:00
auto document = DOM::Document::create(url);
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTMLParser parser(document, data, encoding);
LibWeb: Remove most uses of the old HTML parser The only remaining client of the old parser is the fragment parser used by the Element.innerHTML setter. We'll need to implement a bit more stuff in the new parser before we can switch that over.
2020-06-21 22:29:05 +02:00
parser.run(url);
LibWeb: Make HTMLDocumentParser take an existing document We shouldn't really be creating the document objects inside the parser, since that makes it hard to hook up e.g JavaScript bindings early on.
2020-12-13 16:59:22 +01:00
return document;
LibWeb: Remove most uses of the old HTML parser The only remaining client of the old parser is the fragment parser used by the Element.innerHTML setter. We'll need to implement a bit more stuff in the new parser before we can switch that over.
2020-06-21 22:29:05 +02:00
}
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
HTMLParser::HTMLParser(DOM::Document& document, StringView input, const String& encoding)
LibWeb: Plumb content encoding into the new HTML parser We still don't handle non-ASCII input correctly, but at least now we'll convert e.g ISO-8859-1 to UTF-8 before starting to tokenize. This patch also makes "view source" work with the new parser. :^)
2020-05-28 12:35:19 +02:00
: m_tokenizer(input, encoding)
LibWeb: Make HTMLDocumentParser take an existing document We shouldn't really be creating the document objects inside the parser, since that makes it hard to hook up e.g JavaScript bindings early on.
2020-12-13 16:59:22 +01:00
, m_document(document)
test-web: Add ability to change page mid-test This allows you to not have to write a separate test file for the same thing but in a different situation. This doesn't handle when you change the page with location.href however. Changes the name of the page load handlers to prevent confusion with this.
2020-07-24 21:24:11 +01:00
{
LibWeb: Add an optional pointer to an HTMLParser to the HTMLTokenizer This is needed to access the 'adjusted current node' in the 'Markup declaration open state'. We don't want to create a full parser for something like syntax highlighting, so it's optional (null) by default.
2022-02-15 18:45:10 +00:00
m_tokenizer.set_parser({}, *this);
LibWeb: Add hack to disable StyleInvalidator while parsing document Running a StyleInvalidator for every attribute set in a new document was making it impossible to load larger sites. :^)
2020-12-15 18:53:35 +01:00
m_document->set_should_invalidate_styles_on_attribute_changes(false);
LibTextCodec: Use Optional<String> for get_standardized_encoding This patch changes get_standardized_encoding to use an Optional<String> return type instead of just returning the null string when unable to match the provided encoding to one of the canonical encoding names. This is part of an effort to move away from using null strings towards explicitly using Optional<String> to indicate that the String may not have a value.
2021-05-11 15:52:25 +02:00
auto standardized_encoding = TextCodec::get_standardized_encoding(encoding);
VERIFY(standardized_encoding.has_value());
m_document->set_encoding(standardized_encoding.value());
test-web: Add ability to change page mid-test This allows you to not have to write a separate test file for the same thing but in a different situation. This doesn't handle when you change the page with location.href however. Changes the name of the page load handlers to prevent confusion with this.
2020-07-24 21:24:11 +01:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTMLParser::~HTMLParser()
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Add hack to disable StyleInvalidator while parsing document Running a StyleInvalidator for every attribute set in a new document was making it impossible to load larger sites. :^)
2020-12-15 18:53:35 +01:00
m_document->set_should_invalidate_styles_on_attribute_changes(true);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::run(const AK::URL& url)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
m_document->set_url(url);
LibWeb: Plumb content encoding into the new HTML parser We still don't handle non-ASCII input correctly, but at least now we'll convert e.g ISO-8859-1 to UTF-8 before starting to tokenize. This patch also makes "view source" work with the new parser. :^)
2020-05-28 12:35:19 +02:00
m_document->set_source(m_tokenizer.source());
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
for (;;) {
auto optional_token = m_tokenizer.next_token();
if (!optional_token.has_value())
LibWeb: Fire a DOMContentLoaded event when the new parser is finished With this change, we can finally load and render welcome.html :^)
2020-05-27 23:32:50 +02:00
break;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
auto& token = optional_token.value();
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 15:33:24 +03:30
dbgln_if(PARSER_DEBUG, "[{}] {}", insertion_mode_name(), token.to_string());
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-17 16:57:17 +01:00
LibWeb: Check for HTML integration points in the tree constructor This particularly implements these two points: - "If the adjusted current node is an HTML integration point and the token is a start tag" - "If the adjusted current node is an HTML integration point and the token is a character token" This also adds spec comments to the tree constructor.
2021-10-01 02:18:55 +01:00
// https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
// As each token is emitted from the tokenizer, the user agent must follow the appropriate steps from the following list, known as the tree construction dispatcher:
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
if (m_stack_of_open_elements.is_empty()
|| adjusted_current_node().namespace_() == Namespace::HTML
LibWeb: Check for HTML integration points in the tree constructor This particularly implements these two points: - "If the adjusted current node is an HTML integration point and the token is a start tag" - "If the adjusted current node is an HTML integration point and the token is a character token" This also adds spec comments to the tree constructor.
2021-10-01 02:18:55 +01:00
|| (is_html_integration_point(adjusted_current_node()) && (token.is_start_tag() || token.is_character()))
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
|| token.is_end_of_file()) {
LibWeb: Check for HTML integration points in the tree constructor This particularly implements these two points: - "If the adjusted current node is an HTML integration point and the token is a start tag" - "If the adjusted current node is an HTML integration point and the token is a character token" This also adds spec comments to the tree constructor.
2021-10-01 02:18:55 +01:00
// -> If the stack of open elements is empty
// -> If the adjusted current node is an element in the HTML namespace
// FIXME: -> If the adjusted current node is a MathML text integration point and the token is a start tag whose tag name is neither "mglyph" nor "malignmark"
// FIXME: -> If the adjusted current node is a MathML text integration point and the token is a character token
// FIXME: -> If the adjusted current node is a MathML annotation-xml element and the token is a start tag whose tag name is "svg"
// -> If the adjusted current node is an HTML integration point and the token is a start tag
// -> If the adjusted current node is an HTML integration point and the token is a character token
// -> If the token is an end-of-file token
// Process the token according to the rules given in the section corresponding to the current insertion mode in HTML content.
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
process_using_the_rules_for(m_insertion_mode, token);
} else {
LibWeb: Check for HTML integration points in the tree constructor This particularly implements these two points: - "If the adjusted current node is an HTML integration point and the token is a start tag" - "If the adjusted current node is an HTML integration point and the token is a character token" This also adds spec comments to the tree constructor.
2021-10-01 02:18:55 +01:00
// -> Otherwise
// Process the token according to the rules given in the section for parsing tokens in foreign content.
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
process_using_the_rules_for_foreign_content(token);
}
LibWeb: Add a way to stop the new HTML parser Some things are specced to "stop parsing", which basically just means to stop fetching tokens and jump to "The end"
2020-05-28 18:55:18 +02:00
if (m_stop_parsing) {
Everywhere: Replace dbgln<flag>(...) with dbgln_if(flag, ...) Replacement made by `find Kernel Userland -name '*.h' -o -name '*.cpp' | sed -i -Ee 's/dbgln\b<(\w+)>\(/dbgln_if(\1, /g'`
2021-02-07 15:33:24 +03:30
dbgln_if(PARSER_DEBUG, "Stop parsing{}! :^)", m_parsing_fragment ? " fragment" : "");
LibWeb: Add a way to stop the new HTML parser Some things are specced to "stop parsing", which basically just means to stop fetching tokens and jump to "The end"
2020-05-28 18:55:18 +02:00
break;
}
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
}
LibWeb: Fire a DOMContentLoaded event when the new parser is finished With this change, we can finally load and render welcome.html :^)
2020-05-27 23:32:50 +02:00
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
flush_character_insertions();
LibWeb: Split out "The end" from the HTML parsing spec to a function Also add a spec link and some comments.
2021-09-26 00:00:00 +02:00
the_end();
}
// https://html.spec.whatwg.org/multipage/parsing.html#the-end
void HTMLParser::the_end()
{
// Once the user agent stops parsing the document, the user agent must run the following steps:
// FIXME: 1. If the active speculative HTML parser is not null, then stop the speculative HTML parser and return.
// FIXME: 2. Set the insertion point to undefined.
LibWeb: Fire a DOMContentLoaded event when the new parser is finished With this change, we can finally load and render welcome.html :^)
2020-05-27 23:32:50 +02:00
LibWeb: Split out "The end" from the HTML parsing spec to a function Also add a spec link and some comments.
2021-09-26 00:00:00 +02:00
// 3. Update the current document readiness to "interactive".
LibWeb: Implement "update the current document readiness" from spec The only difference from what we were already doing is that setting the same ready state twice no longer fires a "readystatechange" event. I don't think that could happen in practice though.
2021-09-26 12:22:16 +02:00
m_document->update_readiness(HTML::DocumentReadyState::Interactive);
LibWeb: Implement document ready state
2020-08-31 13:56:16 +01:00
LibWeb: Split out "The end" from the HTML parsing spec to a function Also add a spec link and some comments.
2021-09-26 00:00:00 +02:00
// 4. Pop all the nodes off the stack of open elements.
LibWeb: Pop entire stack of open elements at the end of parsing
2021-09-20 17:04:55 +02:00
while (!m_stack_of_open_elements.is_empty())
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Pop entire stack of open elements at the end of parsing
2021-09-20 17:04:55 +02:00
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 5. While the list of scripts that will execute when the document has finished parsing is not empty:
while (!m_document->scripts_to_execute_when_parsing_has_finished().is_empty()) {
// 1. Spin the event loop until the first script in the list of scripts that will execute when the document has finished parsing
// has its "ready to be parser-executed" flag set and the parser's Document has no style sheet that is blocking scripts.
LibWeb: Make <script src> loads partially async (by following the spec) Instead of firing up a network request and synchronously blocking for it to finish via a nested event loop, we now start an asynchronous request when encountering <script src>. Once the script load finishes (or fails), it gets executed at one of the synchronization points in the HTML parser. This solves some long-standing issues with random unexpected events getting dispatched in the middle of parsing.
2021-09-20 17:06:10 +02:00
main_thread_event_loop().spin_until([&] {
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
return m_document->scripts_to_execute_when_parsing_has_finished().first().is_ready_to_be_parser_executed()
&& !m_document->has_a_style_sheet_that_is_blocking_scripts();
LibWeb: Make <script src> loads partially async (by following the spec) Instead of firing up a network request and synchronously blocking for it to finish via a nested event loop, we now start an asynchronous request when encountering <script src>. Once the script load finishes (or fails), it gets executed at one of the synchronization points in the HTML parser. This solves some long-standing issues with random unexpected events getting dispatched in the middle of parsing.
2021-09-20 17:06:10 +02:00
});
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 2. Execute the first script in the list of scripts that will execute when the document has finished parsing.
m_document->scripts_to_execute_when_parsing_has_finished().first().execute_script();
// 3. Remove the first script element from the list of scripts that will execute when the document has finished parsing (i.e. shift out the first entry in the list).
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_document->scripts_to_execute_when_parsing_has_finished().take_first();
LibWeb: Handle two kinds of deferred script executions This patch adds two script lists to Document: - Scripts to execute when parsing has finished - Scripts to execute as soon as possible Since we don't actually load scripts asynchronously yet (we just do a synchronous load when parsing the <script> element for simplicity), these are already loaded by the time we get to "The end" of parsing.
2020-05-30 12:26:15 +02:00
}
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 6. Queue a global task on the DOM manipulation task source given the Document's relevant global object to run the following substeps:
LibWeb: Introduce the Environment Settings Object The environment settings object is effectively the context a piece of script is running under, for example, it contains the origin, responsible document, realm, global object and event loop for the current context. This effectively replaces ScriptExecutionContext, but it cannot be removed in this commit as EventTarget still depends on it. https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
2021-10-14 16:12:53 +01:00
old_queue_global_task_with_document(HTML::Task::Source::DOMManipulation, m_document, [document = m_document]() mutable {
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// FIXME: 1. Set the Document's load timing info's DOM content loaded event start time to the current high resolution time given the Document's relevant global object.
// 2. Fire an event named DOMContentLoaded at the Document object, with its bubbles attribute initialized to true.
auto content_loaded_event = DOM::Event::create(HTML::EventNames::DOMContentLoaded);
content_loaded_event->set_bubbles(true);
document->dispatch_event(content_loaded_event);
// FIXME: 3. Set the Document's load timing info's DOM content loaded event end time to the current high resolution time given the Document's relevant global object.
// FIXME: 4. Enable the client message queue of the ServiceWorkerContainer object whose associated service worker client is the Document object's relevant settings object.
// FIXME: 5. Invoke WebDriver BiDi DOM content loaded with the Document's browsing context, and a new WebDriver BiDi navigation status whose id is the Document object's navigation id, status is "pending", and url is the Document object's URL.
});
LibWeb: Dispatch "load" on document and window These happen right after "DOMContentLoaded" for now, which is incorrect since they should really wait until subresources have loaded. However, this makes a bunch of things work already so let's do it.
2020-10-18 13:45:28 +02:00
LibWeb: Make <script src> loads partially async (by following the spec) Instead of firing up a network request and synchronously blocking for it to finish via a nested event loop, we now start an asynchronous request when encountering <script src>. Once the script load finishes (or fails), it gets executed at one of the synchronization points in the HTML parser. This solves some long-standing issues with random unexpected events getting dispatched in the middle of parsing.
2021-09-20 17:06:10 +02:00
// 7. Spin the event loop until the set of scripts that will execute as soon as possible and the list of scripts that will execute in order as soon as possible are empty.
main_thread_event_loop().spin_until([&] {
return m_document->scripts_to_execute_as_soon_as_possible().is_empty();
});
LibWeb: Implement document ready state
2020-08-31 13:56:16 +01:00
LibWeb: Allow HTML parser to delay delivery of the document "load" event We will now spin in "the end" until there are no more "things delaying the load event". Of course, nothing actually uses this yet, and there are a lot of things that need to.
2021-09-26 01:03:42 +02:00
// 8. Spin the event loop until there is nothing that delays the load event in the Document.
// FIXME: Track down all the things that are supposed to delay the load event.
main_thread_event_loop().spin_until([&] {
return m_document->number_of_things_delaying_the_load_event() == 0;
});
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 9. Queue a global task on the DOM manipulation task source given the Document's relevant global object to run the following steps:
LibWeb: Introduce the Environment Settings Object The environment settings object is effectively the context a piece of script is running under, for example, it contains the origin, responsible document, realm, global object and event loop for the current context. This effectively replaces ScriptExecutionContext, but it cannot be removed in this commit as EventTarget still depends on it. https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
2021-10-14 16:12:53 +01:00
old_queue_global_task_with_document(HTML::Task::Source::DOMManipulation, m_document, [document = m_document]() mutable {
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 1. Update the current document readiness to "complete".
LibWeb: Implement "update the current document readiness" from spec The only difference from what we were already doing is that setting the same ready state twice no longer fires a "readystatechange" event. I don't think that could happen in practice though.
2021-09-26 12:22:16 +02:00
document->update_readiness(HTML::DocumentReadyState::Complete);
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 2. If the Document object's browsing context is null, then abort these steps.
if (!document->browsing_context())
return;
LibWeb: Add the PageTransitionEvent interface and fire "pageshow" events We now fire "pageshow" events at the appropriate time during document loading (done by the parser.) Note that there are no corresponding "pagehide" events yet.
2021-09-26 12:39:27 +02:00
// 3. Let window be the Document's relevant global object.
NonnullRefPtr<DOM::Window> window = document->window();
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// FIXME: 4. Set the Document's load timing info's load event start time to the current high resolution time given window.
// 5. Fire an event named load at window, with legacy target override flag set.
// FIXME: The legacy target override flag is currently set by a virtual override of dispatch_event()
// We should reorganize this so that the flag appears explicitly here instead.
LibWeb: Add the PageTransitionEvent interface and fire "pageshow" events We now fire "pageshow" events at the appropriate time during document loading (done by the parser.) Note that there are no corresponding "pagehide" events yet.
2021-09-26 12:39:27 +02:00
window->dispatch_event(DOM::Event::create(HTML::EventNames::load));
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// FIXME: 6. Invoke WebDriver BiDi load complete with the Document's browsing context, and a new WebDriver BiDi navigation status whose id is the Document object's navigation id, status is "complete", and url is the Document object's URL.
// FIXME: 7. Set the Document object's navigation id to null.
// FIXME: 8. Set the Document's load timing info's load event end time to the current high resolution time given window.
LibWeb: Add a "page showing" flag to documents This will be used to determine whether "pageshow" and "pagehide" events are appropriate. We won't actually make use of it until we implement more of history traversal and document unloading.
2021-09-26 12:26:39 +02:00
// 9. Assert: Document's page showing is false.
VERIFY(!document->page_showing());
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
LibWeb: Add a "page showing" flag to documents This will be used to determine whether "pageshow" and "pagehide" events are appropriate. We won't actually make use of it until we implement more of history traversal and document unloading.
2021-09-26 12:26:39 +02:00
// 10. Set the Document's page showing flag to true.
document->set_page_showing(true);
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
LibWeb: Add the PageTransitionEvent interface and fire "pageshow" events We now fire "pageshow" events at the appropriate time during document loading (done by the parser.) Note that there are no corresponding "pagehide" events yet.
2021-09-26 12:39:27 +02:00
// 11. Fire a page transition event named pageshow at window with false.
window->fire_a_page_transition_event(HTML::EventNames::pageshow, false);
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 12. Completely finish loading the Document.
document->completely_finish_loading();
// FIXME: 13. Queue the navigation timing entry for the Document.
});
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 18:32:39 +00:00
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// FIXME: 10. If the Document's print when loaded flag is set, then run the printing steps.
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 18:32:39 +00:00
LibWeb: Implement more of HTMLParser::the_end() and bring closer to spec
2021-09-26 00:51:02 +02:00
// 11. The Document is now ready for post-load tasks.
LibWeb: Make event dispatching spec-compliant Specification: https://dom.spec.whatwg.org/#concept-event-dispatch This also introduces shadow roots due to it being a requirement of the event dispatcher. However, it does not introduce the full shadow DOM, that can be left for future work. This changes some event dispatches which require certain attributes to be initialised to a value.
2020-11-21 18:32:39 +00:00
m_document->set_ready_for_post_load_tasks(true);
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
}
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::process_using_the_rules_for(InsertionMode mode, HTMLToken& token)
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
{
switch (mode) {
case InsertionMode::Initial:
handle_initial(token);
break;
case InsertionMode::BeforeHTML:
handle_before_html(token);
break;
case InsertionMode::BeforeHead:
handle_before_head(token);
break;
case InsertionMode::InHead:
handle_in_head(token);
break;
case InsertionMode::InHeadNoscript:
handle_in_head_noscript(token);
break;
case InsertionMode::AfterHead:
handle_after_head(token);
break;
case InsertionMode::InBody:
handle_in_body(token);
break;
case InsertionMode::AfterBody:
handle_after_body(token);
break;
case InsertionMode::AfterAfterBody:
handle_after_after_body(token);
break;
case InsertionMode::Text:
handle_text(token);
break;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
case InsertionMode::InTable:
handle_in_table(token);
break;
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
case InsertionMode::InTableBody:
handle_in_table_body(token);
break;
case InsertionMode::InRow:
handle_in_row(token);
break;
case InsertionMode::InCell:
handle_in_cell(token);
break;
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
case InsertionMode::InTableText:
handle_in_table_text(token);
break;
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
case InsertionMode::InSelectInTable:
handle_in_select_in_table(token);
break;
case InsertionMode::InSelect:
handle_in_select(token);
break;
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
case InsertionMode::InCaption:
handle_in_caption(token);
break;
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
case InsertionMode::InColumnGroup:
handle_in_column_group(token);
break;
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
case InsertionMode::InTemplate:
handle_in_template(token);
break;
case InsertionMode::InFrameset:
handle_in_frameset(token);
break;
case InsertionMode::AfterFrameset:
handle_after_frameset(token);
break;
case InsertionMode::AfterAfterFrameset:
handle_after_after_frameset(token);
break;
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
default:
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY_NOT_REACHED();
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
DOM::QuirksMode HTMLParser::which_quirks_mode(const HTMLToken& doctype_token) const
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
{
LibWeb: Change HTMLToken::m_doctype into named DoctypeData struct This is in preparation for an upcoming storage change of HTMLToken. In contrast to the other token types, the accessor can hand out a mutable reference to allow users to change parts of the DoctypeData easily.
2021-07-15 00:03:50 +02:00
if (doctype_token.doctype_data().force_quirks)
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
return DOM::QuirksMode::Yes;
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
// NOTE: The tokenizer puts the name into lower case for us.
LibWeb: Change HTMLToken::m_doctype into named DoctypeData struct This is in preparation for an upcoming storage change of HTMLToken. In contrast to the other token types, the accessor can hand out a mutable reference to allow users to change parts of the DoctypeData easily.
2021-07-15 00:03:50 +02:00
if (doctype_token.doctype_data().name != "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
return DOM::QuirksMode::Yes;
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
LibWeb: Change HTMLToken::m_doctype into named DoctypeData struct This is in preparation for an upcoming storage change of HTMLToken. In contrast to the other token types, the accessor can hand out a mutable reference to allow users to change parts of the DoctypeData easily.
2021-07-15 00:03:50 +02:00
auto const& public_identifier = doctype_token.doctype_data().public_identifier;
auto const& system_identifier = doctype_token.doctype_data().system_identifier;
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
if (public_identifier.equals_ignoring_case("-//W3O//DTD W3 HTML Strict 3.0//EN//"))
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
return DOM::QuirksMode::Yes;
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
if (public_identifier.equals_ignoring_case("-/W3C/DTD HTML 4.0 Transitional/EN"))
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
return DOM::QuirksMode::Yes;
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
if (public_identifier.equals_ignoring_case("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
return DOM::QuirksMode::Yes;
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
if (system_identifier.equals_ignoring_case("http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"))
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
return DOM::QuirksMode::Yes;
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
for (auto& public_id : s_quirks_public_ids) {
if (public_identifier.starts_with(public_id, CaseSensitivity::CaseInsensitive))
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
return DOM::QuirksMode::Yes;
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
}
LibWeb: Change HTMLToken::m_doctype into named DoctypeData struct This is in preparation for an upcoming storage change of HTMLToken. In contrast to the other token types, the accessor can hand out a mutable reference to allow users to change parts of the DoctypeData easily.
2021-07-15 00:03:50 +02:00
if (doctype_token.doctype_data().missing_system_identifier) {
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
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Frameset//", CaseSensitivity::CaseInsensitive))
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
return DOM::QuirksMode::Yes;
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
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Transitional//", CaseSensitivity::CaseInsensitive))
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
return DOM::QuirksMode::Yes;
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
}
if (public_identifier.starts_with("-//W3C//DTD XHTML 1.0 Frameset//", CaseSensitivity::CaseInsensitive))
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
return DOM::QuirksMode::Limited;
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
if (public_identifier.starts_with("-//W3C//DTD XHTML 1.0 Transitional//", CaseSensitivity::CaseInsensitive))
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
return DOM::QuirksMode::Limited;
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
LibWeb: Change HTMLToken::m_doctype into named DoctypeData struct This is in preparation for an upcoming storage change of HTMLToken. In contrast to the other token types, the accessor can hand out a mutable reference to allow users to change parts of the DoctypeData easily.
2021-07-15 00:03:50 +02:00
if (!doctype_token.doctype_data().missing_system_identifier) {
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
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Frameset//", CaseSensitivity::CaseInsensitive))
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
return DOM::QuirksMode::Limited;
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
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Transitional//", CaseSensitivity::CaseInsensitive))
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
return DOM::QuirksMode::Limited;
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
}
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
return DOM::QuirksMode::No;
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
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_initial(HTMLToken& token)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
if (token.is_character() && token.is_parser_whitespace()) {
return;
}
if (token.is_comment()) {
LibWeb: User getter and setter for Comment type HTMLTokens
2021-07-14 23:32:18 +02:00
auto comment = adopt_ref(*new DOM::Comment(document(), token.comment()));
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
document().append_child(move(comment));
return;
}
if (token.is_doctype()) {
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
auto doctype = adopt_ref(*new DOM::DocumentType(document()));
LibWeb: Change HTMLToken::m_doctype into named DoctypeData struct This is in preparation for an upcoming storage change of HTMLToken. In contrast to the other token types, the accessor can hand out a mutable reference to allow users to change parts of the DoctypeData easily.
2021-07-15 00:03:50 +02:00
doctype->set_name(token.doctype_data().name);
doctype->set_public_id(token.doctype_data().public_identifier);
doctype->set_system_id(token.doctype_data().system_identifier);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
document().append_child(move(doctype));
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
document().set_quirks_mode(which_quirks_mode(token));
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
m_insertion_mode = InsertionMode::BeforeHTML;
return;
}
LibWeb: Parse documents without DOCTYPE gracefully Seems like SOMEONE forgot to put a <!DOCTYPE html> on serenityos.org.. No matter, now we can handle it in the new parser! :^)
2020-05-28 00:21:31 +02:00
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
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
document().set_quirks_mode(DOM::QuirksMode::Yes);
LibWeb: Parse documents without DOCTYPE gracefully Seems like SOMEONE forgot to put a <!DOCTYPE html> on serenityos.org.. No matter, now we can handle it in the new parser! :^)
2020-05-28 00:21:31 +02:00
m_insertion_mode = InsertionMode::BeforeHTML;
process_using_the_rules_for(InsertionMode::BeforeHTML, token);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_before_html(HTMLToken& token)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
return;
}
if (token.is_comment()) {
LibWeb: User getter and setter for Comment type HTMLTokens
2021-07-14 23:32:18 +02:00
auto comment = adopt_ref(*new DOM::Comment(document(), token.comment()));
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
document().append_child(move(comment));
return;
}
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
if (token.is_character() && token.is_parser_whitespace()) {
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
auto element = create_element_for(token, Namespace::HTML);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
document().append_child(element);
LibWeb: Factor out the "stack of open elements" into its own class This will allow us to write more expressive parsing code. :^)
2020-05-24 19:24:36 +02:00
m_stack_of_open_elements.push(move(element));
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
m_insertion_mode = InsertionMode::BeforeHead;
return;
}
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::head, HTML::TagNames::body, HTML::TagNames::html, HTML::TagNames::br)) {
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
goto AnythingElse;
}
if (token.is_end_tag()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
return;
}
AnythingElse:
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
auto element = create_element(document(), HTML::TagNames::html, Namespace::HTML);
LibWeb: Parse barebones document without doctype, <html>, etc. Last night I tried making a little test page that had a bunch of <img> elements and nothing else. It didn't work. Fix this by correctly adding a synthesized <html> element to the document if we get something else in the "before html insertion mode.
2020-06-02 08:47:20 +02:00
document().append_child(element);
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
m_stack_of_open_elements.push(element);
// FIXME: If the Document is being loaded as part of navigation of a browsing context, then: run the application cache selection algorithm with no manifest, passing it the Document object.
m_insertion_mode = InsertionMode::BeforeHead;
process_using_the_rules_for(InsertionMode::BeforeHead, token);
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
DOM::Element& HTMLParser::current_node()
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Factor out the "stack of open elements" into its own class This will allow us to write more expressive parsing code. :^)
2020-05-24 19:24:36 +02:00
return m_stack_of_open_elements.current_node();
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
DOM::Element& HTMLParser::adjusted_current_node()
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
{
if (m_parsing_fragment && m_stack_of_open_elements.elements().size() == 1)
return *m_context_element;
return current_node();
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
DOM::Element& HTMLParser::node_before_current_node()
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
{
return m_stack_of_open_elements.elements().at(m_stack_of_open_elements.elements().size() - 2);
}
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// https://html.spec.whatwg.org/multipage/parsing.html#appropriate-place-for-inserting-a-node
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTMLParser::AdjustedInsertionLocation HTMLParser::find_appropriate_place_for_inserting_node()
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Factor out the "stack of open elements" into its own class This will allow us to write more expressive parsing code. :^)
2020-05-24 19:24:36 +02:00
auto& target = current_node();
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTMLParser::AdjustedInsertionLocation adjusted_insertion_location;
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// 2. Determine the adjusted insertion location using the first matching steps from the following list:
// `-> If foster parenting is enabled and target is a table, tbody, tfoot, thead, or tr element
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (m_foster_parenting && target.local_name().is_one_of(HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr)) {
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// 1. Let last template be the last template element in the stack of open elements, if any.
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
auto last_template = m_stack_of_open_elements.last_element_with_tag_name(HTML::TagNames::template_);
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// 2. Let last table be the last table element in the stack of open elements, if any.
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
auto last_table = m_stack_of_open_elements.last_element_with_tag_name(HTML::TagNames::table);
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// 3. If there is a last template and either there is no last table,
// or there is one, but last template is lower (more recently added) than last table in the stack of open elements,
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
if (last_template.element && (!last_table.element || last_template.index > last_table.index)) {
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// then: let adjusted insertion location be inside last template's template contents, after its last child (if any), and abort these steps.
// NOTE: This returns the template content, so no need to check the parent is a template.
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
return { verify_cast<HTMLTemplateElement>(last_template.element)->content(), nullptr };
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
}
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// 4. If there is no last table, then let adjusted insertion location be inside the first element in the stack of open elements (the html element),
// after its last child (if any), and abort these steps. (fragment case)
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
if (!last_table.element) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
// Guaranteed not to be a template element (it will be the html element),
// so no need to check the parent is a template.
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
return { m_stack_of_open_elements.elements().first(), nullptr };
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
}
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// 5. If last table has a parent node, then let adjusted insertion location be inside last table's parent node, immediately before last table, and abort these steps.
if (last_table.element->parent_node()) {
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
adjusted_insertion_location = { last_table.element->parent_node(), last_table.element };
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
} else {
// 6. Let previous element be the element immediately above last table in the stack of open elements.
LibWeb: Rename element_before() => element_immediately_above() This matches the spec terminology around the "stack of open elements".
2022-02-14 22:24:10 +01:00
auto previous_element = m_stack_of_open_elements.element_immediately_above(*last_table.element);
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// 7. Let adjusted insertion location be inside previous element, after its last child (if any).
adjusted_insertion_location = { previous_element, nullptr };
}
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
} else {
LibWeb: Add spec comments to find_appropriate_place_for_inserting_node()
2022-02-14 22:19:34 +01:00
// `-> Otherwise
// Let adjusted insertion location be inside target, after its last child (if any).
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
adjusted_insertion_location = { target, nullptr };
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
}
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
if (is<HTMLTemplateElement>(*adjusted_insertion_location.parent))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
return { verify_cast<HTMLTemplateElement>(*adjusted_insertion_location.parent).content(), nullptr };
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
return adjusted_insertion_location;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
NonnullRefPtr<DOM::Element> HTMLParser::create_element_for(const HTMLToken& token, const FlyString& namespace_)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
auto element = create_element(document(), token.tag_name(), namespace_);
LibWeb: Hide implementation details of HTMLToken attribute list Previously, HTMLToken would expose the Vector<Attribute> directly to its users. In preparation for a future change, all users now use implementation-agnostic APIs which do not expose the Vector directly.
2021-07-14 23:53:11 +02:00
token.for_each_attribute([&](auto& attribute) {
LibWeb: Remove StringBuilders from HTMLToken::AttributeBuilder
2021-05-23 08:50:48 +02:00
element->set_attribute(attribute.local_name, attribute.value);
LibWeb: Hide implementation details of HTMLToken attribute list Previously, HTMLToken would expose the Vector<Attribute> directly to its users. In preparation for a future change, all users now use implementation-agnostic APIs which do not expose the Vector directly.
2021-07-14 23:53:11 +02:00
return IterationDecision::Continue;
});
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
return element;
}
LibWeb: Use the new "ensure_pre_insertion_validity" in the HTML document parser Previously we didn't check if we could insert the element in the adjusted insertion location's parent. Also makes the return type NonnullRefPtr, as that's what element is.
2021-04-06 19:35:52 +01:00
// https://html.spec.whatwg.org/multipage/parsing.html#insert-a-foreign-element
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
NonnullRefPtr<DOM::Element> HTMLParser::insert_foreign_element(const HTMLToken& token, const FlyString& namespace_)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
LibWeb: Use the new "ensure_pre_insertion_validity" in the HTML document parser Previously we didn't check if we could insert the element in the adjusted insertion location's parent. Also makes the return type NonnullRefPtr, as that's what element is.
2021-04-06 19:35:52 +01:00
// FIXME: Pass in adjusted_insertion_location.parent as the intended parent.
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
auto element = create_element_for(token, namespace_);
LibWeb: Use the new "ensure_pre_insertion_validity" in the HTML document parser Previously we didn't check if we could insert the element in the adjusted insertion location's parent. Also makes the return type NonnullRefPtr, as that's what element is.
2021-04-06 19:35:52 +01:00
auto pre_insertion_validity = adjusted_insertion_location.parent->ensure_pre_insertion_validity(element, adjusted_insertion_location.insert_before_sibling);
// NOTE: If it's not possible to insert the element at the adjusted insertion location, the element is simply dropped.
if (!pre_insertion_validity.is_exception()) {
if (!m_parsing_fragment) {
// FIXME: push a new element queue onto element's relevant agent's custom element reactions stack.
}
adjusted_insertion_location.parent->insert_before(element, adjusted_insertion_location.insert_before_sibling);
if (!m_parsing_fragment) {
// FIXME: pop the element queue from element's relevant agent's custom element reactions stack, and invoke custom element reactions in that queue.
}
}
LibWeb: Factor out the "stack of open elements" into its own class This will allow us to write more expressive parsing code. :^)
2020-05-24 19:24:36 +02:00
m_stack_of_open_elements.push(element);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
return element;
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
NonnullRefPtr<DOM::Element> HTMLParser::insert_html_element(const HTMLToken& token)
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
{
return insert_foreign_element(token, Namespace::HTML);
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_before_head(HTMLToken& token)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
if (token.is_character() && token.is_parser_whitespace()) {
return;
}
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
if (token.is_comment()) {
insert_comment(token);
return;
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::head) {
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
auto element = insert_html_element(token);
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
m_head_element = verify_cast<HTMLHeadElement>(*element);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
m_insertion_mode = InsertionMode::InHead;
return;
}
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::head, HTML::TagNames::body, HTML::TagNames::html, HTML::TagNames::br)) {
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
goto AnythingElse;
}
if (token.is_end_tag()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
return;
}
AnythingElse:
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
m_head_element = verify_cast<HTMLHeadElement>(*insert_html_element(HTMLToken::make_start_tag(HTML::TagNames::head)));
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
m_insertion_mode = InsertionMode::InHead;
process_using_the_rules_for(InsertionMode::InHead, token);
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::insert_comment(HTMLToken& token)
LibWeb: Support comments in the "in head" insertion mode
2020-05-24 20:29:01 +02:00
{
auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
LibWeb: User getter and setter for Comment type HTMLTokens
2021-07-14 23:32:18 +02:00
adjusted_insertion_location.parent->insert_before(adopt_ref(*new DOM::Comment(document(), token.comment())), adjusted_insertion_location.insert_before_sibling);
LibWeb: Support comments in the "in head" insertion mode
2020-05-24 20:29:01 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_head(HTMLToken& token)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
if (token.is_parser_whitespace()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
return;
}
LibWeb: Support comments in the "in head" insertion mode
2020-05-24 20:29:01 +02:00
if (token.is_comment()) {
insert_comment(token);
return;
}
LibWeb: Handle some more parser inputs in the "in head" insertion mode
2020-05-25 20:16:48 +02:00
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle some more parser inputs in the "in head" insertion mode
2020-05-25 20:16:48 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Handle some more parser inputs in the "in head" insertion mode
2020-05-25 20:16:48 +02:00
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::base, HTML::TagNames::basefont, HTML::TagNames::bgsound, HTML::TagNames::link)) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
(void)m_stack_of_open_elements.pop();
LibWeb: Handle some more parser inputs in the "in head" insertion mode
2020-05-25 20:16:48 +02:00
token.acknowledge_self_closing_flag_if_set();
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::meta) {
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
auto element = insert_html_element(token);
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
token.acknowledge_self_closing_flag_if_set();
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::title) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
m_tokenizer.switch_to({}, HTMLTokenizer::State::RCDATA);
m_original_insertion_mode = m_insertion_mode;
m_insertion_mode = InsertionMode::Text;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && ((token.tag_name() == HTML::TagNames::noscript && m_scripting_enabled) || token.tag_name() == HTML::TagNames::noframes || token.tag_name() == HTML::TagNames::style)) {
LibWeb: Parse enough to handle a <style> inside a <head> :^)
2020-05-24 20:36:43 +02:00
parse_generic_raw_text_element(token);
return;
}
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::noscript && !m_scripting_enabled) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
m_insertion_mode = InsertionMode::InHeadNoscript;
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
return;
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::script) {
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
auto element = create_element_for(token, Namespace::HTML);
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
auto& script_element = verify_cast<HTMLScriptElement>(*element);
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
script_element.set_parser_document({}, document());
script_element.set_non_blocking({}, false);
if (m_parsing_fragment) {
LibWeb: Flesh out prepare_script and execute_script This fills in a bunch of the FIXMEs that was in prepare_script. execute_script is almost finished, it's just missing the module side. As an aside, let's not assert when inserting a script element with innerHTML.
2021-01-28 20:31:20 +00:00
script_element.set_already_started({}, true);
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
}
if (m_invoked_via_document_write) {
TODO();
}
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
adjusted_insertion_location.parent->insert_before(element, adjusted_insertion_location.insert_before_sibling, false);
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
m_stack_of_open_elements.push(element);
m_tokenizer.switch_to({}, HTMLTokenizer::State::ScriptData);
m_original_insertion_mode = m_insertion_mode;
m_insertion_mode = InsertionMode::Text;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::head) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
m_insertion_mode = InsertionMode::AfterHead;
return;
}
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::body, HTML::TagNames::html, HTML::TagNames::br)) {
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
goto AnythingElse;
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::template_) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
m_list_of_active_formatting_elements.add_marker();
m_frameset_ok = false;
m_insertion_mode = InsertionMode::InTemplate;
m_stack_of_template_insertion_modes.append(InsertionMode::InTemplate);
LibWeb: Hack the parser to dodge <template> elements in <head> for now
2020-05-30 19:23:04 +02:00
return;
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::template_) {
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
if (!m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
return;
}
generate_all_implied_end_tags_thoroughly();
if (current_node().local_name() != HTML::TagNames::template_)
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::template_);
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
m_stack_of_template_insertion_modes.take_last();
reset_the_insertion_mode_appropriately();
LibWeb: Hack the parser to dodge <template> elements in <head> for now
2020-05-30 19:23:04 +02:00
return;
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if ((token.is_start_tag() && token.tag_name() == HTML::TagNames::head) || token.is_end_tag()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
return;
}
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
AnythingElse:
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
m_insertion_mode = InsertionMode::AfterHead;
process_using_the_rules_for(m_insertion_mode, token);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_head_noscript(HTMLToken& token)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::noscript) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
m_insertion_mode = InsertionMode::InHead;
return;
}
if (token.is_parser_whitespace() || token.is_comment() || (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::basefont, HTML::TagNames::bgsound, HTML::TagNames::link, HTML::TagNames::meta, HTML::TagNames::noframes, HTML::TagNames::style))) {
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::br) {
goto AnythingElse;
}
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::head, HTML::TagNames::noscript)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
AnythingElse:
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
m_insertion_mode = InsertionMode::InHead;
process_using_the_rules_for(m_insertion_mode, token);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::parse_generic_raw_text_element(HTMLToken& token)
LibWeb: Parse enough to handle a <style> inside a <head> :^)
2020-05-24 20:36:43 +02:00
{
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Parse enough to handle a <style> inside a <head> :^)
2020-05-24 20:36:43 +02:00
m_tokenizer.switch_to({}, HTMLTokenizer::State::RAWTEXT);
m_original_insertion_mode = m_insertion_mode;
m_insertion_mode = InsertionMode::Text;
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
DOM::Text* HTMLParser::find_character_insertion_node()
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
{
auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
if (adjusted_insertion_location.insert_before_sibling) {
TODO();
}
if (adjusted_insertion_location.parent->is_document())
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
return nullptr;
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
if (adjusted_insertion_location.parent->last_child() && adjusted_insertion_location.parent->last_child()->is_text())
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
return verify_cast<DOM::Text>(adjusted_insertion_location.parent->last_child());
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
auto new_text_node = adopt_ref(*new DOM::Text(document(), ""));
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
adjusted_insertion_location.parent->append_child(new_text_node);
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
return new_text_node;
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::flush_character_insertions()
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
{
if (m_character_insertion_builder.is_empty())
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
return;
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
m_character_insertion_node->set_data(m_character_insertion_builder.to_string());
LibWeb: Call children_changed() on text nodes when flushing characters Now that we flush characters in a single place, we can call the Text's children_changed() from there instead of having a goofy targeted hack for <style> elements. :^)
2020-06-03 22:11:54 +02:00
m_character_insertion_node->parent()->children_changed();
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
m_character_insertion_builder.clear();
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::insert_character(u32 data)
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
{
auto node = find_character_insertion_node();
if (node == m_character_insertion_node) {
m_character_insertion_builder.append(Utf32View { &data, 1 });
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
return;
}
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
if (!m_character_insertion_node) {
m_character_insertion_node = node;
m_character_insertion_builder.append(Utf32View { &data, 1 });
return;
}
flush_character_insertions();
m_character_insertion_node = node;
m_character_insertion_builder.append(Utf32View { &data, 1 });
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_after_head(HTMLToken& token)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
if (token.is_character() && token.is_parser_whitespace()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
if (token.is_comment()) {
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
insert_comment(token);
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
process_using_the_rules_for(InsertionMode::InBody, token);
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::body) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
m_frameset_ok = false;
m_insertion_mode = InsertionMode::InBody;
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::frameset) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
m_insertion_mode = InsertionMode::InFrameset;
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::base, HTML::TagNames::basefont, HTML::TagNames::bgsound, HTML::TagNames::link, HTML::TagNames::meta, HTML::TagNames::noframes, HTML::TagNames::script, HTML::TagNames::style, HTML::TagNames::template_, HTML::TagNames::title)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Hack the parser to dodge <template> elements in <head> for now
2020-05-30 19:23:04 +02:00
m_stack_of_open_elements.push(*m_head_element);
process_using_the_rules_for(InsertionMode::InHead, token);
m_stack_of_open_elements.elements().remove_first_matching([&](auto& entry) {
return entry.ptr() == m_head_element;
});
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::template_) {
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
process_using_the_rules_for(InsertionMode::InHead, token);
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::body, HTML::TagNames::html, HTML::TagNames::br)) {
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
goto AnythingElse;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if ((token.is_start_tag() && token.tag_name() == HTML::TagNames::head) || token.is_end_tag()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
return;
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
AnythingElse:
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(HTMLToken::make_start_tag(HTML::TagNames::body));
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
m_insertion_mode = InsertionMode::InBody;
LibWeb: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
process_using_the_rules_for(m_insertion_mode, token);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::generate_implied_end_tags(const FlyString& exception)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
while (current_node().local_name() != exception && current_node().local_name().is_one_of(HTML::TagNames::dd, HTML::TagNames::dt, HTML::TagNames::li, HTML::TagNames::optgroup, HTML::TagNames::option, HTML::TagNames::p, HTML::TagNames::rb, HTML::TagNames::rp, HTML::TagNames::rt, HTML::TagNames::rtc))
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::generate_all_implied_end_tags_thoroughly()
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
{
while (current_node().local_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::colgroup, HTML::TagNames::dd, HTML::TagNames::dt, HTML::TagNames::li, HTML::TagNames::optgroup, HTML::TagNames::option, HTML::TagNames::p, HTML::TagNames::rb, HTML::TagNames::rp, HTML::TagNames::rt, HTML::TagNames::rtc, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr))
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::close_a_p_element()
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
{
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
generate_implied_end_tags(HTML::TagNames::p);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::p) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::p);
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_after_body(HTMLToken& token)
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
{
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
if (token.is_character() && token.is_parser_whitespace()) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +02:00
if (token.is_comment()) {
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
auto& insertion_location = m_stack_of_open_elements.first();
LibWeb: User getter and setter for Comment type HTMLTokens
2021-07-14 23:32:18 +02:00
insertion_location.append_child(adopt_ref(*new DOM::Comment(document(), token.comment())));
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
LibWeb: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +02:00
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +02:00
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
if (m_parsing_fragment) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
return;
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
}
m_insertion_mode = InsertionMode::AfterAfterBody;
return;
}
LibWeb: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +02:00
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_end_of_file()) {
stop_parsing();
return;
}
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +02:00
m_insertion_mode = InsertionMode::InBody;
process_using_the_rules_for(InsertionMode::InBody, token);
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_after_after_body(HTMLToken& token)
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
{
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
if (token.is_comment()) {
LibWeb: User getter and setter for Comment type HTMLTokens
2021-07-14 23:32:18 +02:00
auto comment = adopt_ref(*new DOM::Comment(document(), token.comment()));
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
document().append_child(move(comment));
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_doctype() || token.is_parser_whitespace() || (token.is_start_tag() && token.tag_name() == HTML::TagNames::html)) {
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
if (token.is_end_of_file()) {
LibWeb: Add a way to stop the new HTML parser Some things are specced to "stop parsing", which basically just means to stop fetching tokens and jump to "The end"
2020-05-28 18:55:18 +02:00
stop_parsing();
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
return;
}
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
m_insertion_mode = InsertionMode::InBody;
process_using_the_rules_for(m_insertion_mode, token);
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
}
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// https://html.spec.whatwg.org/multipage/parsing.html#reconstruct-the-active-formatting-elements
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::reconstruct_the_active_formatting_elements()
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
{
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 1. If there are no entries in the list of active formatting elements, then there is nothing to reconstruct; stop this algorithm.
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
if (m_list_of_active_formatting_elements.is_empty())
return;
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 2. If the last (most recently added) entry in the list of active formatting elements is a marker, or if it is an element that is in the stack of open elements,
// then there is nothing to reconstruct; stop this algorithm.
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
if (m_list_of_active_formatting_elements.entries().last().is_marker())
return;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
if (m_stack_of_open_elements.contains(*m_list_of_active_formatting_elements.entries().last().element))
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
return;
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 3. Let entry be the last (most recently added) element in the list of active formatting elements.
size_t index = m_list_of_active_formatting_elements.entries().size() - 1;
// NOTE: Entry will never be null, but must be a pointer instead of a reference to allow rebinding.
auto* entry = &m_list_of_active_formatting_elements.entries().at(index);
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
Rewind:
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 4. Rewind: If there are no entries before entry in the list of active formatting elements, then jump to the step labeled create.
if (index == 0)
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
goto Create;
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 5. Let entry be the entry one earlier than entry in the list of active formatting elements.
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
--index;
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
entry = &m_list_of_active_formatting_elements.entries().at(index);
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 6. If entry is neither a marker nor an element that is also in the stack of open elements, go to the step labeled rewind.
if (!entry->is_marker() && !m_stack_of_open_elements.contains(*entry->element))
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
goto Rewind;
Advance:
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 7. Advance: Let entry be the element one later than entry in the list of active formatting elements.
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
++index;
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
entry = &m_list_of_active_formatting_elements.entries().at(index);
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
Create:
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 8. Create: Insert an HTML element for the token for which the element entry was created, to obtain new element.
VERIFY(!entry->is_marker());
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
// FIXME: Hold on to the real token!
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
auto new_element = insert_html_element(HTMLToken::make_start_tag(entry->element->local_name()));
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 9. Replace the entry for entry in the list with an entry for new element.
m_list_of_active_formatting_elements.entries().at(index).element = new_element;
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
LibWeb: Handle markers when reconstructing active formatting elements The entry we get from the active formatting elements list during the Rewind step of "reconstruct the active formatting elements" can be a marker. Previously we assumed it was not a marker, which can trigger an assertion failure with certain malformed HTML. If the entry in this step is a marker, the spec simply ignores it. This is step 6 of the algorithm. This also makes the index unsigned, as this algorithm is a no-op if the list is empty. Additionally, this also adds spec comments to this algorithm. Fixes #12668.
2022-02-20 03:29:24 +00:00
// 10. If the entry for new element in the list of active formatting elements is not the last entry in the list, return to the step labeled advance.
if (index != m_list_of_active_formatting_elements.entries().size() - 1)
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
goto Advance;
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTMLParser::AdoptionAgencyAlgorithmOutcome HTMLParser::run_the_adoption_agency_algorithm(HTMLToken& token)
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
{
auto subject = token.tag_name();
// If the current node is an HTML element whose tag name is subject,
// and the current node is not in the list of active formatting elements,
// then pop the current node off the stack of open elements, and return.
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == subject && !m_list_of_active_formatting_elements.contains(current_node())) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Handle AAA situation where there's no formatting element found In this case, we're supposed to return from the AAA and then jump to a different behavior in the "in body" insertion mode. So now we do that.
2020-05-30 16:22:25 +02:00
return AdoptionAgencyAlgorithmOutcome::DoNothing;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
}
auto formatting_element = m_list_of_active_formatting_elements.last_element_with_tag_name_before_marker(subject);
LibWeb: Handle AAA situation where there's no formatting element found In this case, we're supposed to return from the AAA and then jump to a different behavior in the "in body" insertion mode. So now we do that.
2020-05-30 16:22:25 +02:00
if (!formatting_element)
return AdoptionAgencyAlgorithmOutcome::RunAnyOtherEndTagSteps;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
if (!m_stack_of_open_elements.contains(*formatting_element)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Fix a TODO in the adoption agency algorithm There's still a much bigger one at the end of the function though. :^)
2021-04-13 21:27:35 +02:00
m_list_of_active_formatting_elements.remove(*formatting_element);
return AdoptionAgencyAlgorithmOutcome::DoNothing;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
}
if (!m_stack_of_open_elements.has_in_scope(*formatting_element)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle AAA situation where there's no formatting element found In this case, we're supposed to return from the AAA and then jump to a different behavior in the "in body" insertion mode. So now we do that.
2020-05-30 16:22:25 +02:00
return AdoptionAgencyAlgorithmOutcome::DoNothing;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
}
if (formatting_element != &current_node()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +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
RefPtr<DOM::Element> furthest_block = m_stack_of_open_elements.topmost_special_node_below(*formatting_element);
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
if (!furthest_block) {
while (&current_node() != formatting_element)
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
(void)m_stack_of_open_elements.pop();
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
m_list_of_active_formatting_elements.remove(*formatting_element);
LibWeb: Handle AAA situation where there's no formatting element found In this case, we're supposed to return from the AAA and then jump to a different behavior in the "in body" insertion mode. So now we do that.
2020-05-30 16:22:25 +02:00
return AdoptionAgencyAlgorithmOutcome::DoNothing;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
}
// FIXME: Implement the rest of the AAA :^)
LibWeb: Fail gracefully when reaching the unimplemented part of the AAA Pages such as https://html5test.com are testing all sorts of weird, incomplete, and wrong HTML but can be useful or at least interesting for development - let's try to avoid crashing the process.
2022-02-15 19:03:08 +00:00
return AdoptionAgencyAlgorithmOutcome::DoNothing;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
bool HTMLParser::is_special_tag(const FlyString& tag_name, const FlyString& namespace_)
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
{
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
if (namespace_ == Namespace::HTML) {
return tag_name.is_one_of(
HTML::TagNames::address,
HTML::TagNames::applet,
HTML::TagNames::area,
HTML::TagNames::article,
HTML::TagNames::aside,
HTML::TagNames::base,
HTML::TagNames::basefont,
HTML::TagNames::bgsound,
HTML::TagNames::blockquote,
HTML::TagNames::body,
HTML::TagNames::br,
HTML::TagNames::button,
HTML::TagNames::caption,
HTML::TagNames::center,
HTML::TagNames::col,
HTML::TagNames::colgroup,
HTML::TagNames::dd,
HTML::TagNames::details,
HTML::TagNames::dir,
HTML::TagNames::div,
HTML::TagNames::dl,
HTML::TagNames::dt,
HTML::TagNames::embed,
HTML::TagNames::fieldset,
HTML::TagNames::figcaption,
HTML::TagNames::figure,
HTML::TagNames::footer,
HTML::TagNames::form,
HTML::TagNames::frame,
HTML::TagNames::frameset,
HTML::TagNames::h1,
HTML::TagNames::h2,
HTML::TagNames::h3,
HTML::TagNames::h4,
HTML::TagNames::h5,
HTML::TagNames::h6,
HTML::TagNames::head,
HTML::TagNames::header,
HTML::TagNames::hgroup,
HTML::TagNames::hr,
HTML::TagNames::html,
HTML::TagNames::iframe,
HTML::TagNames::img,
HTML::TagNames::input,
HTML::TagNames::keygen,
HTML::TagNames::li,
HTML::TagNames::link,
HTML::TagNames::listing,
HTML::TagNames::main,
HTML::TagNames::marquee,
HTML::TagNames::menu,
HTML::TagNames::meta,
HTML::TagNames::nav,
HTML::TagNames::noembed,
HTML::TagNames::noframes,
HTML::TagNames::noscript,
HTML::TagNames::object,
HTML::TagNames::ol,
HTML::TagNames::p,
HTML::TagNames::param,
HTML::TagNames::plaintext,
HTML::TagNames::pre,
HTML::TagNames::script,
HTML::TagNames::section,
HTML::TagNames::select,
HTML::TagNames::source,
HTML::TagNames::style,
HTML::TagNames::summary,
HTML::TagNames::table,
HTML::TagNames::tbody,
HTML::TagNames::td,
HTML::TagNames::template_,
HTML::TagNames::textarea,
HTML::TagNames::tfoot,
HTML::TagNames::th,
HTML::TagNames::thead,
HTML::TagNames::title,
HTML::TagNames::tr,
HTML::TagNames::track,
HTML::TagNames::ul,
HTML::TagNames::wbr,
HTML::TagNames::xmp);
} else if (namespace_ == Namespace::SVG) {
return tag_name.is_one_of(
SVG::TagNames::desc,
SVG::TagNames::foreignObject,
SVG::TagNames::title);
} else if (namespace_ == Namespace::MathML) {
TODO();
}
return false;
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_body(HTMLToken& token)
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
{
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
if (token.is_character()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
if (token.code_point() == 0) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle NULL character during "in body"
2020-06-03 22:37:45 -06:00
return;
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
}
if (token.is_parser_whitespace()) {
reconstruct_the_active_formatting_elements();
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
return;
}
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
reconstruct_the_active_formatting_elements();
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
m_frameset_ok = false;
return;
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
}
LibWeb: Parse comments in the "in body" insertion mode
2020-05-28 18:46:39 +02:00
if (token.is_comment()) {
insert_comment(token);
return;
}
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (m_stack_of_open_elements.contains(HTML::TagNames::template_))
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
return;
LibWeb: Hide implementation details of HTMLToken attribute list Previously, HTMLToken would expose the Vector<Attribute> directly to its users. In preparation for a future change, all users now use implementation-agnostic APIs which do not expose the Vector directly.
2021-07-14 23:53:11 +02:00
token.for_each_attribute([&](auto& attribute) {
if (!current_node().has_attribute(attribute.local_name))
current_node().set_attribute(attribute.local_name, attribute.value);
return IterationDecision::Continue;
});
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::base, HTML::TagNames::basefont, HTML::TagNames::bgsound, HTML::TagNames::link, HTML::TagNames::meta, HTML::TagNames::noframes, HTML::TagNames::script, HTML::TagNames::style, HTML::TagNames::template_, HTML::TagNames::title)) {
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::template_) {
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::body) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
if (m_stack_of_open_elements.elements().size() == 1
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
|| m_stack_of_open_elements.elements().at(1).local_name() != HTML::TagNames::body
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
|| m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
return;
}
m_frameset_ok = false;
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
auto& body_element = m_stack_of_open_elements.elements().at(1);
LibWeb: Hide implementation details of HTMLToken attribute list Previously, HTMLToken would expose the Vector<Attribute> directly to its users. In preparation for a future change, all users now use implementation-agnostic APIs which do not expose the Vector directly.
2021-07-14 23:53:11 +02:00
token.for_each_attribute([&](auto& attribute) {
if (!body_element.has_attribute(attribute.local_name))
body_element.set_attribute(attribute.local_name, attribute.value);
return IterationDecision::Continue;
});
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::frameset) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
if (m_stack_of_open_elements.elements().size() == 1
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
|| m_stack_of_open_elements.elements().at(1).local_name() != HTML::TagNames::body) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
return;
}
if (!m_frameset_ok)
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
TODO();
}
if (token.is_end_of_file()) {
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
if (!m_stack_of_template_insertion_modes.is_empty()) {
process_using_the_rules_for(InsertionMode::InTemplate, token);
return;
}
LibWeb: Handle end-of-file token during "in body" insertion mode
2020-05-30 12:40:12 +02:00
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
for (auto& node : m_stack_of_open_elements.elements()) {
if (!node.local_name().is_one_of(HTML::TagNames::dd, HTML::TagNames::dt, HTML::TagNames::li, HTML::TagNames::optgroup, HTML::TagNames::option, HTML::TagNames::p, HTML::TagNames::rb, HTML::TagNames::rp, HTML::TagNames::rt, HTML::TagNames::rtc, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr, HTML::TagNames::body, HTML::TagNames::html)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
break;
}
}
LibWeb: Handle end-of-file token during "in body" insertion mode
2020-05-30 12:40:12 +02:00
stop_parsing();
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::body) {
if (!m_stack_of_open_elements.has_in_scope(HTML::TagNames::body)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "body" end tags during "in body"
2020-06-03 22:36:08 -06:00
return;
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
}
LibWeb: Parse "body" end tags during "in body"
2020-06-03 22:36:08 -06:00
for (auto& node : m_stack_of_open_elements.elements()) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (!node.local_name().is_one_of(HTML::TagNames::dd, HTML::TagNames::dt, HTML::TagNames::li, HTML::TagNames::optgroup, HTML::TagNames::option, HTML::TagNames::p, HTML::TagNames::rb, HTML::TagNames::rp, HTML::TagNames::rt, HTML::TagNames::rtc, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr, HTML::TagNames::body, HTML::TagNames::html)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "body" end tags during "in body"
2020-06-03 22:36:08 -06:00
break;
}
}
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
m_insertion_mode = InsertionMode::AfterBody;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::html) {
if (!m_stack_of_open_elements.has_in_scope(HTML::TagNames::body)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle "html" end tag during "in body"
2020-06-03 23:28:57 -06:00
return;
}
for (auto& node : m_stack_of_open_elements.elements()) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (!node.local_name().is_one_of(HTML::TagNames::dd, HTML::TagNames::dt, HTML::TagNames::li, HTML::TagNames::optgroup, HTML::TagNames::option, HTML::TagNames::p, HTML::TagNames::rb, HTML::TagNames::rp, HTML::TagNames::rt, HTML::TagNames::rtc, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr, HTML::TagNames::body, HTML::TagNames::html)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle "html" end tag during "in body"
2020-06-03 23:28:57 -06:00
break;
}
}
m_insertion_mode = InsertionMode::AfterBody;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::address, HTML::TagNames::article, HTML::TagNames::aside, HTML::TagNames::blockquote, HTML::TagNames::center, HTML::TagNames::details, HTML::TagNames::dialog, HTML::TagNames::dir, HTML::TagNames::div, HTML::TagNames::dl, HTML::TagNames::fieldset, HTML::TagNames::figcaption, HTML::TagNames::figure, HTML::TagNames::footer, HTML::TagNames::header, HTML::TagNames::hgroup, HTML::TagNames::main, HTML::TagNames::menu, HTML::TagNames::nav, HTML::TagNames::ol, HTML::TagNames::p, HTML::TagNames::section, HTML::TagNames::summary, HTML::TagNames::ul)) {
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
close_a_p_element();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6)) {
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
close_a_p_element();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name().is_one_of(HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
return;
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::pre, HTML::TagNames::listing)) {
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
close_a_p_element();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
m_frameset_ok = false;
// If the next token is a U+000A LINE FEED (LF) character token,
// then ignore that token and move on to the next one.
// (Newlines at the start of pre blocks are ignored as an authoring convenience.)
auto next_token = m_tokenizer.next_token();
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
if (next_token.has_value() && next_token.value().is_character() && next_token.value().code_point() == '\n') {
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
// Ignore it.
} else {
process_using_the_rules_for(m_insertion_mode, next_token.value());
}
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::form) {
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
if (m_form_element && !m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
close_a_p_element();
auto element = insert_html_element(token);
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!m_stack_of_open_elements.contains(HTML::TagNames::template_))
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
m_form_element = verify_cast<HTMLFormElement>(*element);
LibWeb: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::li) {
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
m_frameset_ok = false;
for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
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
RefPtr<DOM::Element> node = m_stack_of_open_elements.elements()[i];
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::li) {
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
generate_implied_end_tags(HTML::TagNames::li);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::li) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::li);
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
break;
}
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
if (is_special_tag(node->local_name(), node->namespace_()) && !node->local_name().is_one_of(HTML::TagNames::address, HTML::TagNames::div, HTML::TagNames::p))
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
break;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
close_a_p_element();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::dd, HTML::TagNames::dt)) {
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
m_frameset_ok = false;
for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
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
RefPtr<DOM::Element> node = m_stack_of_open_elements.elements()[i];
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::dd) {
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
generate_implied_end_tags(HTML::TagNames::dd);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::dd) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::dd);
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
break;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::dt) {
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
generate_implied_end_tags(HTML::TagNames::dt);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::dt) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::dt);
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
break;
}
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
if (is_special_tag(node->local_name(), node->namespace_()) && !node->local_name().is_one_of(HTML::TagNames::address, HTML::TagNames::div, HTML::TagNames::p))
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
break;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
close_a_p_element();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::plaintext) {
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
close_a_p_element();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
m_tokenizer.switch_to({}, HTMLTokenizer::State::PLAINTEXT);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::button) {
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::button)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
generate_implied_end_tags();
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::button);
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
reconstruct_the_active_formatting_elements();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
m_frameset_ok = false;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::address, HTML::TagNames::article, HTML::TagNames::aside, HTML::TagNames::blockquote, HTML::TagNames::button, HTML::TagNames::center, HTML::TagNames::details, HTML::TagNames::dialog, HTML::TagNames::dir, HTML::TagNames::div, HTML::TagNames::dl, HTML::TagNames::fieldset, HTML::TagNames::figcaption, HTML::TagNames::figure, HTML::TagNames::footer, HTML::TagNames::header, HTML::TagNames::hgroup, HTML::TagNames::listing, HTML::TagNames::main, HTML::TagNames::menu, HTML::TagNames::nav, HTML::TagNames::ol, HTML::TagNames::pre, HTML::TagNames::section, HTML::TagNames::summary, HTML::TagNames::ul)) {
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
if (!m_stack_of_open_elements.has_in_scope(token.tag_name())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
return;
}
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != token.tag_name()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(token.tag_name());
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::form) {
if (!m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
LibWeb: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
auto node = m_form_element;
m_form_element = nullptr;
LibWeb: Fix broken parsing of </form> during "in body" insertion
2020-06-15 20:29:04 +02:00
if (!node || !m_stack_of_open_elements.has_in_scope(*node)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
return;
}
generate_implied_end_tags();
if (&current_node() != node) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
}
m_stack_of_open_elements.elements().remove_first_matching([&](auto& entry) { return entry.ptr() == node.ptr(); });
} else {
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!m_stack_of_open_elements.has_in_scope(HTML::TagNames::form)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle "form" end tag during "in body" if stack of open elements does not contain "template"
2020-06-03 23:03:19 -06:00
return;
}
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::form) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle "form" end tag during "in body" if stack of open elements does not contain "template"
2020-06-03 23:03:19 -06:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::form);
LibWeb: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
}
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::p) {
if (!m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(HTMLToken::make_start_tag(HTML::TagNames::p));
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
close_a_p_element();
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::li) {
if (!m_stack_of_open_elements.has_in_list_item_scope(HTML::TagNames::li)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Improve support for "a" and "li" during "in body" insertion We can now parse welcome.html once again, without resorting to hacks or fallbacks during "in body" :^)
2020-05-29 22:06:05 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
generate_implied_end_tags(HTML::TagNames::li);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::li) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-17 16:57:17 +01:00
dbgln("Expected <li> current node, but had <{}>", current_node().local_name());
LibWeb: Improve support for "a" and "li" during "in body" insertion We can now parse welcome.html once again, without resorting to hacks or fallbacks during "in body" :^)
2020-05-29 22:06:05 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::li);
LibWeb: Improve support for "a" and "li" during "in body" insertion We can now parse welcome.html once again, without resorting to hacks or fallbacks during "in body" :^)
2020-05-29 22:06:05 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::dd, HTML::TagNames::dt)) {
LibWeb: Handle "dd" and "dt" end tags during "in body"
2020-05-30 22:59:15 +02:00
if (!m_stack_of_open_elements.has_in_scope(token.tag_name())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle "dd" and "dt" end tags during "in body"
2020-05-30 22:59:15 +02:00
return;
}
generate_implied_end_tags(token.tag_name());
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != token.tag_name()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle "dd" and "dt" end tags during "in body"
2020-05-30 22:59:15 +02:00
}
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(token.tag_name());
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6)) {
if (!m_stack_of_open_elements.has_in_scope(HTML::TagNames::h1)
&& !m_stack_of_open_elements.has_in_scope(HTML::TagNames::h2)
&& !m_stack_of_open_elements.has_in_scope(HTML::TagNames::h3)
&& !m_stack_of_open_elements.has_in_scope(HTML::TagNames::h4)
&& !m_stack_of_open_elements.has_in_scope(HTML::TagNames::h5)
&& !m_stack_of_open_elements.has_in_scope(HTML::TagNames::h6)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle more benign parse errors in the "in body" insertion mode
2020-05-27 18:18:39 +02:00
return;
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
}
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != token.tag_name()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
}
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
for (;;) {
auto popped_element = m_stack_of_open_elements.pop();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (popped_element->local_name().is_one_of(HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6))
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
break;
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
return;
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::a) {
if (auto* element = m_list_of_active_formatting_elements.last_element_with_tag_name_before_marker(HTML::TagNames::a)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle AAA situation where there's no formatting element found In this case, we're supposed to return from the AAA and then jump to a different behavior in the "in body" insertion mode. So now we do that.
2020-05-30 16:22:25 +02:00
if (run_the_adoption_agency_algorithm(token) == AdoptionAgencyAlgorithmOutcome::RunAnyOtherEndTagSteps)
goto AnyOtherEndTag;
LibWeb: Handle an error condition for "a" start tag during "in body" If we have an <a> element on the list of active formatting elements when hitting another "a" start tag, that's a parse error. Recover by using the AAA.
2020-05-30 11:03:05 +02:00
m_list_of_active_formatting_elements.remove(*element);
m_stack_of_open_elements.elements().remove_first_matching([&](auto& entry) {
return entry.ptr() == element;
});
LibWeb: Improve support for "a" and "li" during "in body" insertion We can now parse welcome.html once again, without resorting to hacks or fallbacks during "in body" :^)
2020-05-29 22:06:05 +02:00
}
reconstruct_the_active_formatting_elements();
auto element = insert_html_element(token);
m_list_of_active_formatting_elements.add(*element);
return;
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::b, HTML::TagNames::big, HTML::TagNames::code, HTML::TagNames::em, HTML::TagNames::font, HTML::TagNames::i, HTML::TagNames::s, HTML::TagNames::small, HTML::TagNames::strike, HTML::TagNames::strong, HTML::TagNames::tt, HTML::TagNames::u)) {
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
reconstruct_the_active_formatting_elements();
auto element = insert_html_element(token);
m_list_of_active_formatting_elements.add(*element);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::nobr) {
LibWeb: Handle "nobr" start tag during "in body"
2020-06-03 23:03:44 -06:00
reconstruct_the_active_formatting_elements();
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (m_stack_of_open_elements.has_in_scope(HTML::TagNames::nobr)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Handle "nobr" start tag during "in body"
2020-06-03 23:03:44 -06:00
run_the_adoption_agency_algorithm(token);
reconstruct_the_active_formatting_elements();
}
auto element = insert_html_element(token);
m_list_of_active_formatting_elements.add(*element);
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::a, HTML::TagNames::b, HTML::TagNames::big, HTML::TagNames::code, HTML::TagNames::em, HTML::TagNames::font, HTML::TagNames::i, HTML::TagNames::nobr, HTML::TagNames::s, HTML::TagNames::small, HTML::TagNames::strike, HTML::TagNames::strong, HTML::TagNames::tt, HTML::TagNames::u)) {
LibWeb: Handle AAA situation where there's no formatting element found In this case, we're supposed to return from the AAA and then jump to a different behavior in the "in body" insertion mode. So now we do that.
2020-05-30 16:22:25 +02:00
if (run_the_adoption_agency_algorithm(token) == AdoptionAgencyAlgorithmOutcome::RunAnyOtherEndTagSteps)
goto AnyOtherEndTag;
LibWeb: Implement the first half of the Adoption Agency Algorithm The AAA is a somewhat daunting algorithm you have to run for certain tag when inserted inside the <body> element. The purpose of it is to resolve issues with mismatched tags. This patch implements the first half of the AAA. We also move the "list of active formatting elements" to its own class, since it kept accumulating little behaviors. "Marker" entries are now signified by null Element pointers in the list.
2020-05-27 23:22:42 +02:00
return;
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::applet, HTML::TagNames::marquee, HTML::TagNames::object)) {
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
reconstruct_the_active_formatting_elements();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
m_list_of_active_formatting_elements.add_marker();
m_frameset_ok = false;
LibWeb: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
return;
}
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::applet, HTML::TagNames::marquee, HTML::TagNames::object)) {
LibWeb: Parse end tags for "applet", "marquee", and "object" during "in body"
2020-06-03 22:33:10 -06:00
if (!m_stack_of_open_elements.has_in_scope(token.tag_name())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse end tags for "applet", "marquee", and "object" during "in body"
2020-06-03 22:33:10 -06:00
return;
}
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != token.tag_name()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse end tags for "applet", "marquee", and "object" during "in body"
2020-06-03 22:33:10 -06:00
}
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(token.tag_name());
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
return;
LibWeb: Implement enough HTML parsing to handle a small simple DOM :^) We can now parse a little DOM like this: <!DOCTYPE html> <html> <head></head> <body> <div></div> </body> </html> This is pretty slow work, but the incremental progress is satisfying!
2020-05-24 00:49:22 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::table) {
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
if (!document().in_quirks_mode()) {
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
close_a_p_element();
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
m_frameset_ok = false;
m_insertion_mode = InsertionMode::InTable;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::br) {
LibWeb: Parse "br" end tags during "in body"
2020-06-03 22:34:50 -06:00
token.drop_attributes();
goto BRStartTag;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::area, HTML::TagNames::br, HTML::TagNames::embed, HTML::TagNames::img, HTML::TagNames::keygen, HTML::TagNames::wbr)) {
LibWeb: Parse "br" end tags during "in body"
2020-06-03 22:34:50 -06:00
BRStartTag:
LibWeb: Handle various self-closing tags during "in body" insertion We can now parse self-closing "<img>" tags correctly! :^)
2020-05-28 00:25:30 +02:00
reconstruct_the_active_formatting_elements();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
(void)m_stack_of_open_elements.pop();
LibWeb: Handle various self-closing tags during "in body" insertion We can now parse self-closing "<img>" tags correctly! :^)
2020-05-28 00:25:30 +02:00
token.acknowledge_self_closing_flag_if_set();
m_frameset_ok = false;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::input) {
LibWeb: Parse "input" tags during the "in body" insertion mode
2020-05-28 12:18:46 +02:00
reconstruct_the_active_formatting_elements();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
(void)m_stack_of_open_elements.pop();
LibWeb: Parse "input" tags during the "in body" insertion mode
2020-05-28 12:18:46 +02:00
token.acknowledge_self_closing_flag_if_set();
auto type_attribute = token.attribute(HTML::AttributeNames::type);
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
if (type_attribute.is_null() || !type_attribute.equals_ignoring_case("hidden")) {
LibWeb: Parse "input" tags during the "in body" insertion mode
2020-05-28 12:18:46 +02:00
m_frameset_ok = false;
}
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::param, HTML::TagNames::source, HTML::TagNames::track)) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
(void)m_stack_of_open_elements.pop();
LibWeb: Parse param/source/track start tags during "in body" insertion
2020-06-05 21:59:46 +02:00
token.acknowledge_self_closing_flag_if_set();
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::hr) {
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p))
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
close_a_p_element();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
(void)m_stack_of_open_elements.pop();
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
token.acknowledge_self_closing_flag_if_set();
m_frameset_ok = false;
return;
}
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::image) {
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
// Parse error. Change the token's tag name to HTML::TagNames::img and reprocess it. (Don't ask.)
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: User getter+setter for HTMLToken tag name and self-closing flag
2021-07-14 23:37:48 +02:00
token.set_tag_name("img");
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
process_using_the_rules_for(m_insertion_mode, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::textarea) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Parse "textarea" tags during the "in body" insertion mode Had to handle some more cases in the tokenizer to support this.
2020-05-30 18:40:23 +02:00
LibWeb: Fix parsing of "<textarea></textarea>" When handling a "textarea" start tag, we have to ignore the next token if it's an LF ('\n'). However, we were not switching the tokenizer state before fetching the lookahead token, and this caused us to force the tokenizer into the RCDATA state too late, effectively getting it stuck in that state for way longer than it should be. Fixes #2508.
2020-06-05 12:05:42 +02:00
m_tokenizer.switch_to({}, HTMLTokenizer::State::RCDATA);
LibWeb: Parse "textarea" tags during the "in body" insertion mode Had to handle some more cases in the tokenizer to support this.
2020-05-30 18:40:23 +02:00
// If the next token is a U+000A LINE FEED (LF) character token,
// then ignore that token and move on to the next one.
// (Newlines at the start of pre blocks are ignored as an authoring convenience.)
auto next_token = m_tokenizer.next_token();
m_original_insertion_mode = m_insertion_mode;
m_frameset_ok = false;
m_insertion_mode = InsertionMode::Text;
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
if (next_token.has_value() && next_token.value().is_character() && next_token.value().code_point() == '\n') {
LibWeb: Parse "textarea" tags during the "in body" insertion mode Had to handle some more cases in the tokenizer to support this.
2020-05-30 18:40:23 +02:00
// Ignore it.
} else {
process_using_the_rules_for(m_insertion_mode, next_token.value());
}
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::xmp) {
if (m_stack_of_open_elements.has_in_button_scope(HTML::TagNames::p)) {
LibWeb: Handle "xmp" start tag during "in body"
2020-06-03 23:04:03 -06:00
close_a_p_element();
}
reconstruct_the_active_formatting_elements();
m_frameset_ok = false;
parse_generic_raw_text_element(token);
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::iframe) {
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
m_frameset_ok = false;
parse_generic_raw_text_element(token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && ((token.tag_name() == HTML::TagNames::noembed) || (token.tag_name() == HTML::TagNames::noscript && m_scripting_enabled))) {
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
parse_generic_raw_text_element(token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::select) {
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
reconstruct_the_active_formatting_elements();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
m_frameset_ok = false;
switch (m_insertion_mode) {
case InsertionMode::InTable:
case InsertionMode::InCaption:
case InsertionMode::InTableBody:
case InsertionMode::InRow:
case InsertionMode::InCell:
m_insertion_mode = InsertionMode::InSelectInTable;
break;
default:
m_insertion_mode = InsertionMode::InSelect;
break;
}
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::optgroup, HTML::TagNames::option)) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::option)
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
reconstruct_the_active_formatting_elements();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::rb, HTML::TagNames::rtc)) {
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (m_stack_of_open_elements.has_in_scope(HTML::TagNames::ruby))
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::ruby)
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::rp, HTML::TagNames::rt)) {
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (m_stack_of_open_elements.has_in_scope(HTML::TagNames::ruby))
generate_implied_end_tags(HTML::TagNames::rtc);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::rtc || current_node().local_name() != HTML::TagNames::ruby)
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::math) {
LibWeb: Don't crash when encountering <svg> or <math> elements Just treat them like unknown elements for now. :^)
2020-05-30 18:46:39 +02:00
reconstruct_the_active_formatting_elements();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
adjust_mathml_attributes(token);
adjust_foreign_attributes(token);
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_foreign_element(token, Namespace::MathML);
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_self_closing()) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
token.acknowledge_self_closing_flag_if_set();
}
LibWeb: Don't crash when encountering <svg> or <math> elements Just treat them like unknown elements for now. :^)
2020-05-30 18:46:39 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::svg) {
LibWeb: Don't crash when encountering <svg> or <math> elements Just treat them like unknown elements for now. :^)
2020-05-30 18:46:39 +02:00
reconstruct_the_active_formatting_elements();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
adjust_svg_attributes(token);
adjust_foreign_attributes(token);
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_foreign_element(token, Namespace::SVG);
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_self_closing()) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
token.acknowledge_self_closing_flag_if_set();
}
LibWeb: Don't crash when encountering <svg> or <math> elements Just treat them like unknown elements for now. :^)
2020-05-30 18:46:39 +02:00
return;
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if ((token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::frame, HTML::TagNames::head, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr))) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add all branches from the parsing spec to "in body" This makes us crash in TODO() more often, but it's better that we know what's missing instead of incorrectly ending up on the fallback path.
2020-05-29 21:20:49 +02:00
return;
}
// Any other start tag
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
if (token.is_start_tag()) {
reconstruct_the_active_formatting_elements();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
return;
}
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
if (token.is_end_tag()) {
LibWeb: Handle AAA situation where there's no formatting element found In this case, we're supposed to return from the AAA and then jump to a different behavior in the "in body" insertion mode. So now we do that.
2020-05-30 16:22:25 +02:00
AnyOtherEndTag:
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
RefPtr<DOM::Element> node;
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
node = m_stack_of_open_elements.elements()[i];
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == token.tag_name()) {
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
generate_implied_end_tags(token.tag_name());
if (node != current_node()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
}
while (&current_node() != node) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
break;
}
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
if (is_special_tag(node->local_name(), node->namespace_())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add missing special tag case in the "in body" insertion mode
2020-05-30 18:19:15 +02:00
return;
}
LibWeb: Finally parse enough that we can actually handle welcome.html! We made it, at last! What a long journey this was. :^)
2020-05-24 22:39:59 +02:00
}
return;
}
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::adjust_mathml_attributes(HTMLToken& token)
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
{
token.adjust_attribute_name("definitionurl", "definitionURL");
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::adjust_svg_tag_names(HTMLToken& token)
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
{
token.adjust_tag_name("altglyph", "altGlyph");
token.adjust_tag_name("altglyphdef", "altGlyphDef");
token.adjust_tag_name("altglyphitem", "altGlyphItem");
token.adjust_tag_name("animatecolor", "animateColor");
token.adjust_tag_name("animatemotion", "animateMotion");
token.adjust_tag_name("animatetransform", "animateTransform");
token.adjust_tag_name("clippath", "clipPath");
token.adjust_tag_name("feblend", "feBlend");
token.adjust_tag_name("fecolormatrix", "feColorMatrix");
token.adjust_tag_name("fecomponenttransfer", "feComponentTransfer");
token.adjust_tag_name("fecomposite", "feComposite");
token.adjust_tag_name("feconvolvematrix", "feConvolveMatrix");
token.adjust_tag_name("fediffuselighting", "feDiffuseLighting");
token.adjust_tag_name("fedisplacementmap", "feDisplacementMap");
token.adjust_tag_name("fedistantlight", "feDistantLight");
token.adjust_tag_name("fedropshadow", "feDropShadow");
token.adjust_tag_name("feflood", "feFlood");
token.adjust_tag_name("fefunca", "feFuncA");
token.adjust_tag_name("fefuncb", "feFuncB");
token.adjust_tag_name("fefuncg", "feFuncG");
token.adjust_tag_name("fefuncr", "feFuncR");
token.adjust_tag_name("fegaussianblur", "feGaussianBlur");
token.adjust_tag_name("feimage", "feImage");
token.adjust_tag_name("femerge", "feMerge");
token.adjust_tag_name("femergenode", "feMergeNode");
token.adjust_tag_name("femorphology", "feMorphology");
token.adjust_tag_name("feoffset", "feOffset");
token.adjust_tag_name("fepointlight", "fePointLight");
token.adjust_tag_name("fespecularlighting", "feSpecularLighting");
token.adjust_tag_name("fespotlight", "feSpotlight");
token.adjust_tag_name("glyphref", "glyphRef");
token.adjust_tag_name("lineargradient", "linearGradient");
token.adjust_tag_name("radialgradient", "radialGradient");
token.adjust_tag_name("textpath", "textPath");
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::adjust_svg_attributes(HTMLToken& token)
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
{
token.adjust_attribute_name("attributename", "attributeName");
token.adjust_attribute_name("attributetype", "attributeType");
token.adjust_attribute_name("basefrequency", "baseFrequency");
token.adjust_attribute_name("baseprofile", "baseProfile");
token.adjust_attribute_name("calcmode", "calcMode");
token.adjust_attribute_name("clippathunits", "clipPathUnits");
token.adjust_attribute_name("diffuseconstant", "diffuseConstant");
token.adjust_attribute_name("edgemode", "edgeMode");
token.adjust_attribute_name("filterunits", "filterUnits");
token.adjust_attribute_name("glyphref", "glyphRef");
token.adjust_attribute_name("gradienttransform", "gradientTransform");
token.adjust_attribute_name("gradientunits", "gradientUnits");
token.adjust_attribute_name("kernelmatrix", "kernelMatrix");
token.adjust_attribute_name("kernelunitlength", "kernelUnitLength");
token.adjust_attribute_name("keypoints", "keyPoints");
token.adjust_attribute_name("keysplines", "keySplines");
token.adjust_attribute_name("keytimes", "keyTimes");
token.adjust_attribute_name("lengthadjust", "lengthAdjust");
token.adjust_attribute_name("limitingconeangle", "limitingConeAngle");
token.adjust_attribute_name("markerheight", "markerHeight");
token.adjust_attribute_name("markerunits", "markerUnits");
token.adjust_attribute_name("markerwidth", "markerWidth");
token.adjust_attribute_name("maskcontentunits", "maskContentUnits");
token.adjust_attribute_name("maskunits", "maskUnits");
token.adjust_attribute_name("numoctaves", "numOctaves");
token.adjust_attribute_name("pathlength", "pathLength");
token.adjust_attribute_name("patterncontentunits", "patternContentUnits");
token.adjust_attribute_name("patterntransform", "patternTransform");
token.adjust_attribute_name("patternunits", "patternUnits");
token.adjust_attribute_name("pointsatx", "pointsAtX");
token.adjust_attribute_name("pointsaty", "pointsAtY");
token.adjust_attribute_name("pointsatz", "pointsAtZ");
token.adjust_attribute_name("preservealpha", "preserveAlpha");
token.adjust_attribute_name("preserveaspectratio", "preserveAspectRatio");
token.adjust_attribute_name("primitiveunits", "primitiveUnits");
token.adjust_attribute_name("refx", "refX");
token.adjust_attribute_name("refy", "refY");
token.adjust_attribute_name("repeatcount", "repeatCount");
token.adjust_attribute_name("repeatdur", "repeatDur");
token.adjust_attribute_name("requiredextensions", "requiredExtensions");
token.adjust_attribute_name("requiredfeatures", "requiredFeatures");
token.adjust_attribute_name("specularconstant", "specularConstant");
token.adjust_attribute_name("specularexponent", "specularExponent");
token.adjust_attribute_name("spreadmethod", "spreadMethod");
token.adjust_attribute_name("startoffset", "startOffset");
token.adjust_attribute_name("stddeviation", "stdDeviation");
token.adjust_attribute_name("stitchtiles", "stitchTiles");
token.adjust_attribute_name("surfacescale", "surfaceScale");
token.adjust_attribute_name("systemlanguage", "systemLanguage");
token.adjust_attribute_name("tablevalues", "tableValues");
token.adjust_attribute_name("targetx", "targetX");
token.adjust_attribute_name("targety", "targetY");
token.adjust_attribute_name("textlength", "textLength");
token.adjust_attribute_name("viewbox", "viewBox");
token.adjust_attribute_name("viewtarget", "viewTarget");
token.adjust_attribute_name("xchannelselector", "xChannelSelector");
token.adjust_attribute_name("ychannelselector", "yChannelSelector");
token.adjust_attribute_name("zoomandpan", "zoomAndPan");
}
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::adjust_foreign_attributes(HTMLToken& token)
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
{
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
token.adjust_foreign_attribute("xlink:actuate", "xlink", "actuate", Namespace::XLink);
token.adjust_foreign_attribute("xlink:arcrole", "xlink", "arcrole", Namespace::XLink);
token.adjust_foreign_attribute("xlink:href", "xlink", "href", Namespace::XLink);
token.adjust_foreign_attribute("xlink:role", "xlink", "role", Namespace::XLink);
token.adjust_foreign_attribute("xlink:show", "xlink", "show", Namespace::XLink);
token.adjust_foreign_attribute("xlink:title", "xlink", "title", Namespace::XLink);
token.adjust_foreign_attribute("xlink:type", "xlink", "type", Namespace::XLink);
token.adjust_foreign_attribute("xml:lang", "xml", "lang", Namespace::XML);
token.adjust_foreign_attribute("xml:space", "xml", "space", Namespace::XML);
token.adjust_foreign_attribute("xmlns", "", "xmlns", Namespace::XMLNS);
token.adjust_foreign_attribute("xmlns:xlink", "xmlns", "xlink", Namespace::XMLNS);
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::increment_script_nesting_level()
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
{
++m_script_nesting_level;
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::decrement_script_nesting_level()
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
{
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_script_nesting_level);
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
--m_script_nesting_level;
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_text(HTMLToken& token)
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
if (token.is_character()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
return;
}
LibWeb: Handle EOF tokens during "text" insertion
2020-06-06 16:32:27 +02:00
if (token.is_end_of_file()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::script)
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
verify_cast<HTMLScriptElement>(current_node()).set_already_started({}, true);
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Handle EOF tokens during "text" insertion
2020-06-06 16:32:27 +02:00
m_insertion_mode = m_original_insertion_mode;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::script) {
LibWeb: Remove hacky old ways of running <script> element contents Now that we're using the new HTML parser, we don't have to do the weird "run the script when inserted into the document, uhh, or when the text content of the script element changes" dance. Instead, we just follow the spec, and scripts run the way they should.
2020-06-23 16:38:44 +02:00
// Make sure the <script> element has up-to-date text content before preparing the script.
flush_character_insertions();
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
NonnullRefPtr<HTMLScriptElement> script = verify_cast<HTMLScriptElement>(current_node());
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
m_insertion_mode = m_original_insertion_mode;
// FIXME: Handle tokenizer insertion point stuff here.
increment_script_nesting_level();
script->prepare_script({});
decrement_script_nesting_level();
if (script_nesting_level() == 0)
m_parser_pause_flag = false;
// FIXME: Handle tokenizer insertion point stuff here too.
LibWeb: Bring up basic external script execution in the new parser This only works in some narrow cases, but should be enough for our own welcome.html at least. :^)
2020-05-27 23:01:04 +02:00
while (document().pending_parsing_blocking_script()) {
if (script_nesting_level() != 0) {
m_parser_pause_flag = true;
// FIXME: Abort the processing of any nested invocations of the tokenizer,
// yielding control back to the caller. (Tokenization will resume when
// the caller returns to the "outer" tree construction stage.)
TODO();
} else {
auto the_script = document().take_pending_parsing_blocking_script({});
m_tokenizer.set_blocked(true);
LibWeb: Spin the event loop in HTML parser until scripts can run Call HTML::EventLoop::spin_until() from the HTML parser when deciding whether we can run a script yet. Note that spin_until() actually doesn't do any work yet.
2021-09-09 02:15:44 +02:00
// If the parser's Document has a style sheet that is blocking scripts
// or the script's "ready to be parser-executed" flag is not set:
// spin the event loop until the parser's Document has no style sheet
// that is blocking scripts and the script's "ready to be parser-executed"
// flag is set.
if (m_document->has_a_style_sheet_that_is_blocking_scripts() || !script->is_ready_to_be_parser_executed()) {
main_thread_event_loop().spin_until([&] {
return !m_document->has_a_style_sheet_that_is_blocking_scripts() && script->is_ready_to_be_parser_executed();
});
}
LibWeb: Bring up basic external script execution in the new parser This only works in some narrow cases, but should be enough for our own welcome.html at least. :^)
2020-05-27 23:01:04 +02:00
LibWeb: Just ignore <script> elements that failed to load the script We're never gonna be able to run them if we can't load them so just let it go.
2020-06-15 18:37:48 +02:00
if (the_script->failed_to_load())
return;
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(the_script->is_ready_to_be_parser_executed());
LibWeb: Bring up basic external script execution in the new parser This only works in some narrow cases, but should be enough for our own welcome.html at least. :^)
2020-05-27 23:01:04 +02:00
if (m_aborted)
return;
m_tokenizer.set_blocked(false);
// FIXME: Handle tokenizer insertion point stuff here too.
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(script_nesting_level() == 0);
LibWeb: Bring up basic external script execution in the new parser This only works in some narrow cases, but should be enough for our own welcome.html at least. :^)
2020-05-27 23:01:04 +02:00
increment_script_nesting_level();
the_script->execute_script();
decrement_script_nesting_level();
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(script_nesting_level() == 0);
LibWeb: Bring up basic external script execution in the new parser This only works in some narrow cases, but should be enough for our own welcome.html at least. :^)
2020-05-27 23:01:04 +02:00
m_parser_pause_flag = false;
// FIXME: Handle tokenizer insertion point stuff here too.
}
}
LibWeb: A whole bunch of work towards spec-compliant <script> elements This is still very unfinished, but there's at least a skeleton of code.
2020-05-24 22:00:46 +02:00
return;
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
}
LibWeb: Bring up basic external script execution in the new parser This only works in some narrow cases, but should be enough for our own welcome.html at least. :^)
2020-05-27 23:01:04 +02:00
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
if (token.is_end_tag()) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: More work on the HTML parser and tokenizer The parser can now switch the state of the tokenizer! Very webby. :^)
2020-05-24 20:24:43 +02:00
m_insertion_mode = m_original_insertion_mode;
return;
}
LibWeb: Turn a bunch of ASSERT_NOT_REACHED() in the parser into TODO()
2020-05-30 10:35:25 +02:00
TODO();
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::clear_the_stack_back_to_a_table_context()
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
{
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
while (!current_node().local_name().is_one_of(HTML::TagNames::table, HTML::TagNames::template_, HTML::TagNames::html))
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::html)
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::clear_the_stack_back_to_a_table_row_context()
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
{
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
while (!current_node().local_name().is_one_of(HTML::TagNames::tr, HTML::TagNames::template_, HTML::TagNames::html))
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::html)
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::clear_the_stack_back_to_a_table_body_context()
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
{
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
while (!current_node().local_name().is_one_of(HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::template_, HTML::TagNames::html))
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::html)
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_row(HTMLToken& token)
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
{
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::th, HTML::TagNames::td)) {
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
clear_the_stack_back_to_a_table_row_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
m_insertion_mode = InsertionMode::InCell;
m_list_of_active_formatting_elements.add_marker();
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::tr) {
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::tr)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
return;
}
clear_the_stack_back_to_a_table_row_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
m_insertion_mode = InsertionMode::InTableBody;
return;
}
LibWeb: Fix two typo bugs in table parsing These were flushed out by the earlier fix to "table scope". Without the bad implementation of table scopes, ACID2 stopped parsing correctly.
2020-06-21 17:49:02 +02:00
if ((token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr))
|| (token.is_end_tag() && token.tag_name() == HTML::TagNames::table)) {
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::tr)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
return;
}
clear_the_stack_back_to_a_table_row_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
m_insertion_mode = InsertionMode::InTableBody;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead)) {
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(token.tag_name())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::tr)) {
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
return;
}
clear_the_stack_back_to_a_table_row_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
m_insertion_mode = InsertionMode::InTableBody;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::body, HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::html, HTML::TagNames::td, HTML::TagNames::th)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
return;
}
process_using_the_rules_for(InsertionMode::InTable, token);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::close_the_cell()
LibWeb: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
{
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (!current_node().local_name().is_one_of(HTML::TagNames::td, HTML::TagNames::th)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
while (!current_node().local_name().is_one_of(HTML::TagNames::td, HTML::TagNames::th))
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
(void)m_stack_of_open_elements.pop();
LibWeb: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
m_insertion_mode = InsertionMode::InRow;
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_cell(HTMLToken& token)
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
{
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::td, HTML::TagNames::th)) {
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(token.tag_name())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
return;
}
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != token.tag_name()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
LibWeb: Fix HTMLDocumentParser build
2020-05-28 18:20:55 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(token.tag_name());
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
m_insertion_mode = InsertionMode::InRow;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr)) {
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::td) && !m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::th)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
return;
}
close_the_cell();
process_using_the_rules_for(m_insertion_mode, token);
return;
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::body, HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::html)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr)) {
LibWeb: Fix two typo bugs in table parsing These were flushed out by the earlier fix to "table scope". Without the bad implementation of table scopes, ACID2 stopped parsing correctly.
2020-06-21 17:49:02 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(token.tag_name())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
return;
}
close_the_cell();
// Reprocess the token.
process_using_the_rules_for(m_insertion_mode, token);
return;
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
process_using_the_rules_for(InsertionMode::InBody, token);
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_table_text(HTMLToken& token)
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
{
if (token.is_character()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
if (token.code_point() == 0) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
return;
}
LibWeb: Move HTMLToken in HTMLDocumentParser This replaces a copy construction of an HTMLToken with a move(). This allows HTMLToken to be made non-copyable in a further commit.
2021-07-15 22:23:45 +02:00
m_pending_table_character_tokens.append(move(token));
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
return;
}
for (auto& pending_token : m_pending_table_character_tokens) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(pending_token.is_character());
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
if (!pending_token.is_parser_whitespace()) {
LibWeb: Take care of a FIXME in the "in table text" insertion mode
2020-08-30 20:10:19 +02:00
// If any of the tokens in the pending table character tokens list
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
// are character tokens that are not ASCII whitespace, then this is a parse error:
// reprocess the character tokens in the pending table character tokens list using
// the rules given in the "anything else" entry in the "in table" insertion mode.
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Take care of a FIXME in the "in table text" insertion mode
2020-08-30 20:10:19 +02:00
m_foster_parenting = true;
process_using_the_rules_for(InsertionMode::InBody, token);
m_foster_parenting = false;
return;
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
}
}
for (auto& pending_token : m_pending_table_character_tokens) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(pending_token.code_point());
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
}
m_insertion_mode = m_original_insertion_mode;
process_using_the_rules_for(m_insertion_mode, token);
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_table_body(HTMLToken& token)
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
{
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::tr) {
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
clear_the_stack_back_to_a_table_body_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
m_insertion_mode = InsertionMode::InRow;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::th, HTML::TagNames::td)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support "td" and "th" start tags during "in table body" This makes it possible to load Google Image Search results. You can't see the images yet, but it's still something. :^)
2020-06-01 22:08:48 +02:00
clear_the_stack_back_to_a_table_body_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(HTMLToken::make_start_tag(HTML::TagNames::tr));
LibWeb: Support "td" and "th" start tags during "in table body" This makes it possible to load Google Image Search results. You can't see the images yet, but it's still something. :^)
2020-06-01 22:08:48 +02:00
m_insertion_mode = InsertionMode::InRow;
process_using_the_rules_for(m_insertion_mode, token);
return;
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead)) {
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(token.tag_name())) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
clear_the_stack_back_to_a_table_body_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
m_insertion_mode = InsertionMode::InTable;
return;
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if ((token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead))
|| (token.is_end_tag() && token.tag_name() == HTML::TagNames::table)) {
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::tbody)
LibWeb: A </table> inside <tbody> is not a parse error This condition was backwards. Fixes parsing of google.com.
2020-06-21 17:30:18 +02:00
&& !m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::thead)
&& !m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::tfoot)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
clear_the_stack_back_to_a_table_body_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
m_insertion_mode = InsertionMode::InTable;
process_using_the_rules_for(InsertionMode::InTable, token);
return;
}
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::body, HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::html, HTML::TagNames::td, HTML::TagNames::th, HTML::TagNames::tr)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
return;
}
process_using_the_rules_for(InsertionMode::InTable, token);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_table(HTMLToken& token)
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
{
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (token.is_character() && current_node().local_name().is_one_of(HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr)) {
LibWeb: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
m_pending_table_character_tokens.clear();
m_original_insertion_mode = m_insertion_mode;
m_insertion_mode = InsertionMode::InTableText;
process_using_the_rules_for(InsertionMode::InTableText, token);
return;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
if (token.is_comment()) {
insert_comment(token);
return;
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::caption) {
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
clear_the_stack_back_to_a_table_context();
m_list_of_active_formatting_elements.add_marker();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
m_insertion_mode = InsertionMode::InCaption;
return;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::colgroup) {
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
clear_the_stack_back_to_a_table_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
m_insertion_mode = InsertionMode::InColumnGroup;
return;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::col) {
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
clear_the_stack_back_to_a_table_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(HTMLToken::make_start_tag(HTML::TagNames::colgroup));
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
m_insertion_mode = InsertionMode::InColumnGroup;
process_using_the_rules_for(m_insertion_mode, token);
return;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead)) {
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
clear_the_stack_back_to_a_table_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Implement enough parsing to parse the HTML spec front page :^) We can now actually open http://html.spec.whatwg.org/ in Browser.
2020-05-30 13:07:47 +02:00
m_insertion_mode = InsertionMode::InTableBody;
return;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::td, HTML::TagNames::th, HTML::TagNames::tr)) {
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
clear_the_stack_back_to_a_table_context();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(HTMLToken::make_start_tag(HTML::TagNames::tbody));
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
m_insertion_mode = InsertionMode::InTableBody;
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
process_using_the_rules_for(m_insertion_mode, token);
LibWeb: Implement more table support in the new HTML parser This is enough to parse the Google front page! (Note: I did have to hack the tokenizer while parsing Google, in order to avoid named character references screwing everything up. We'll fix that too soon enough!)
2020-05-28 00:27:46 +02:00
return;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::table) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::table))
return;
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::table);
reset_the_insertion_mode_appropriately();
process_using_the_rules_for(m_insertion_mode, token);
return;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::table) {
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::table)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
return;
}
LibWeb: Add a StackOfOpenElements helper for "popping until a tag name"
2020-05-28 18:09:31 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::table);
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
reset_the_insertion_mode_appropriately();
return;
}
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::body, HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::html, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
return;
}
if ((token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::style, HTML::TagNames::script, HTML::TagNames::template_))
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
|| (token.is_end_tag() && token.tag_name() == HTML::TagNames::template_)) {
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::input) {
auto type_attribute = token.attribute(HTML::AttributeNames::type);
if (type_attribute.is_null() || !type_attribute.equals_ignoring_case("hidden")) {
goto AnythingElse;
}
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
// FIXME: Is this the correct interpretation of "Pop that input element off the stack of open elements."?
// Because this wording is the first time it's seen in the spec.
// Other times it's worded as: "Immediately pop the current node off the stack of open elements."
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
token.acknowledge_self_closing_flag_if_set();
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::form) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
if (m_form_element || m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
return;
}
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
m_form_element = verify_cast<HTMLFormElement>(*insert_html_element(token));
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
// FIXME: See previous FIXME, as this is the same situation but for form.
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
return;
}
if (token.is_end_of_file()) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
AnythingElse:
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Fully implement HTML parser "in table" insertion mode Also fixes some little mistakes in the "in body" insertion mode that I found whilst cross-referencing.
2020-06-13 07:36:09 +01:00
m_foster_parenting = true;
process_using_the_rules_for(InsertionMode::InBody, token);
m_foster_parenting = false;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_select_in_table(HTMLToken& token)
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
{
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr, HTML::TagNames::td, HTML::TagNames::th)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::select);
reset_the_insertion_mode_appropriately();
process_using_the_rules_for(m_insertion_mode, token);
return;
}
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr, HTML::TagNames::td, HTML::TagNames::th)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
if (!m_stack_of_open_elements.has_in_table_scope(token.tag_name()))
return;
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::select);
reset_the_insertion_mode_appropriately();
process_using_the_rules_for(m_insertion_mode, token);
return;
}
process_using_the_rules_for(InsertionMode::InSelect, token);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_select(HTMLToken& token)
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
{
if (token.is_character()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
if (token.code_point() == 0) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
if (token.is_comment()) {
insert_comment(token);
return;
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::option) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::option) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::optgroup) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::option) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::optgroup) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::optgroup) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::option && node_before_current_node().local_name() == HTML::TagNames::optgroup)
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::optgroup) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
} else {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::option) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() == HTML::TagNames::option) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
} else {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::select) {
LibWeb: Fix broken parsing of </select> during "in select" insertion
2020-06-15 19:57:20 +02:00
if (!m_stack_of_open_elements.has_in_select_scope(HTML::TagNames::select)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::select);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
reset_the_insertion_mode_appropriately();
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::select) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
if (!m_stack_of_open_elements.has_in_select_scope(HTML::TagNames::select)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
}
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::select);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
reset_the_insertion_mode_appropriately();
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::input, HTML::TagNames::keygen, HTML::TagNames::textarea)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!m_stack_of_open_elements.has_in_select_scope(HTML::TagNames::select)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::select);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
reset_the_insertion_mode_appropriately();
process_using_the_rules_for(m_insertion_mode, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::script, HTML::TagNames::template_)) {
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::template_) {
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_end_of_file()) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_caption(HTMLToken& token)
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
{
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::caption) {
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::caption)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
return;
}
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::caption)
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::caption);
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
m_insertion_mode = InsertionMode::InTable;
return;
}
if ((token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr))
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
|| (token.is_end_tag() && token.tag_name() == HTML::TagNames::table)) {
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::caption)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
return;
}
generate_implied_end_tags();
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::caption)
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::caption);
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
m_insertion_mode = InsertionMode::InTable;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
if (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::body, HTML::TagNames::col, HTML::TagNames::colgroup, HTML::TagNames::html, HTML::TagNames::tbody, HTML::TagNames::td, HTML::TagNames::tfoot, HTML::TagNames::th, HTML::TagNames::thead, HTML::TagNames::tr)) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
return;
}
process_using_the_rules_for(InsertionMode::InBody, token);
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_column_group(HTMLToken& token)
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
{
if (token.is_character() && token.is_parser_whitespace()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
return;
}
if (token.is_comment()) {
insert_comment(token);
return;
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::col) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
(void)m_stack_of_open_elements.pop();
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
token.acknowledge_self_closing_flag_if_set();
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::colgroup) {
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::colgroup) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
return;
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
m_insertion_mode = InsertionMode::InTable;
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::col) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
return;
}
if ((token.is_start_tag() || token.is_end_tag()) && token.tag_name() == HTML::TagNames::template_) {
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_end_of_file()) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (current_node().local_name() != HTML::TagNames::colgroup) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
return;
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
m_insertion_mode = InsertionMode::InTable;
process_using_the_rules_for(m_insertion_mode, token);
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_template(HTMLToken& token)
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
{
if (token.is_character() || token.is_comment() || token.is_doctype()) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::base, HTML::TagNames::basefont, HTML::TagNames::bgsound, HTML::TagNames::link, HTML::TagNames::meta, HTML::TagNames::noframes, HTML::TagNames::script, HTML::TagNames::style, HTML::TagNames::template_, HTML::TagNames::title)) {
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::template_) {
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::caption, HTML::TagNames::colgroup, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead)) {
m_stack_of_template_insertion_modes.take_last();
m_stack_of_template_insertion_modes.append(InsertionMode::InTable);
m_insertion_mode = InsertionMode::InTable;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::col) {
m_stack_of_template_insertion_modes.take_last();
m_stack_of_template_insertion_modes.append(InsertionMode::InColumnGroup);
m_insertion_mode = InsertionMode::InColumnGroup;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::tr) {
m_stack_of_template_insertion_modes.take_last();
m_stack_of_template_insertion_modes.append(InsertionMode::InTableBody);
m_insertion_mode = InsertionMode::InTableBody;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
if (token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::td, HTML::TagNames::th)) {
m_stack_of_template_insertion_modes.take_last();
m_stack_of_template_insertion_modes.append(InsertionMode::InRow);
m_insertion_mode = InsertionMode::InRow;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
if (token.is_start_tag()) {
m_stack_of_template_insertion_modes.take_last();
m_stack_of_template_insertion_modes.append(InsertionMode::InBody);
m_insertion_mode = InsertionMode::InBody;
process_using_the_rules_for(m_insertion_mode, token);
return;
}
if (token.is_end_tag()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
if (token.is_end_of_file()) {
if (!m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
stop_parsing();
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
return;
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
}
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::template_);
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
m_stack_of_template_insertion_modes.take_last();
reset_the_insertion_mode_appropriately();
process_using_the_rules_for(m_insertion_mode, token);
}
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_in_frameset(HTMLToken& token)
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
{
if (token.is_character() && token.is_parser_whitespace()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
if (token.is_comment()) {
insert_comment(token);
return;
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::frameset) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::frameset) {
// FIXME: If the current node is the root html element, then this is a parse error; ignore the token. (fragment case)
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (!m_parsing_fragment && current_node().local_name() != HTML::TagNames::frameset) {
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
m_insertion_mode = InsertionMode::AfterFrameset;
}
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::frame) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_html_element(token);
(void)m_stack_of_open_elements.pop();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
token.acknowledge_self_closing_flag_if_set();
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::noframes) {
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_end_of_file()) {
LibWeb: Implement Attribute closer to the spec and with an IDL file Note our Attribute class is what the spec refers to as just "Attr". The main differences between the existing implementation and the spec are just that the spec defines more fields. Attributes can contain namespace URIs and prefixes. However, note that these are not parsed in HTML documents unless the document content-type is XML. So for now, these are initialized to null. Web pages are able to set the namespace via JavaScript (setAttributeNS), so these fields may be filled in when the corresponding APIs are implemented. The main change to be aware of is that an attribute is a node. This has implications on how attributes are stored in the Element class. Nodes are non-copyable and non-movable because these constructors are deleted by the EventTarget base class. This means attributes cannot be stored in a Vector or HashMap as these containers assume copyability / movability. So for now, the Vector holding attributes is changed to hold RefPtrs to attributes instead. This might change when attribute storage is implemented according to the spec (by way of NamedNodeMap).
2021-10-15 09:57:07 -04:00
// FIXME: If the current node is not the root html element, then this is a parse error.
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
stop_parsing();
return;
}
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_after_frameset(HTMLToken& token)
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
{
if (token.is_character() && token.is_parser_whitespace()) {
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
insert_character(token.code_point());
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
if (token.is_comment()) {
insert_comment(token);
return;
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::html) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::html) {
m_insertion_mode = InsertionMode::AfterAfterFrameset;
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::noframes) {
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
if (token.is_end_of_file()) {
stop_parsing();
return;
}
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::handle_after_after_frameset(HTMLToken& token)
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
{
if (token.is_comment()) {
LibWeb: User getter and setter for Comment type HTMLTokens
2021-07-14 23:32:18 +02:00
auto comment = adopt_ref(*new DOM::Comment(document(), token.comment()));
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
document().append_child(move(comment));
return;
}
if (token.is_doctype() || token.is_parser_whitespace() || (token.is_start_tag() && token.tag_name() == HTML::TagNames::html)) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
if (token.is_end_of_file()) {
stop_parsing();
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::noframes) {
process_using_the_rules_for(InsertionMode::InHead, token);
return;
}
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::process_using_the_rules_for_foreign_content(HTMLToken& token)
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
{
if (token.is_character()) {
if (token.code_point() == 0) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
insert_character(0xFFFD);
return;
}
if (token.is_parser_whitespace()) {
insert_character(token.code_point());
return;
}
insert_character(token.code_point());
m_frameset_ok = false;
return;
}
if (token.is_comment()) {
insert_comment(token);
return;
}
if (token.is_doctype()) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
return;
}
if ((token.is_start_tag() && token.tag_name().is_one_of(HTML::TagNames::b, HTML::TagNames::big, HTML::TagNames::blockquote, HTML::TagNames::body, HTML::TagNames::br, HTML::TagNames::center, HTML::TagNames::code, HTML::TagNames::dd, HTML::TagNames::div, HTML::TagNames::dl, HTML::TagNames::dt, HTML::TagNames::em, HTML::TagNames::embed, HTML::TagNames::h1, HTML::TagNames::h2, HTML::TagNames::h3, HTML::TagNames::h4, HTML::TagNames::h5, HTML::TagNames::h6, HTML::TagNames::head, HTML::TagNames::hr, HTML::TagNames::i, HTML::TagNames::img, HTML::TagNames::li, HTML::TagNames::listing, HTML::TagNames::menu, HTML::TagNames::meta, HTML::TagNames::nobr, HTML::TagNames::ol, HTML::TagNames::p, HTML::TagNames::pre, HTML::TagNames::ruby, HTML::TagNames::s, HTML::TagNames::small, HTML::TagNames::span, HTML::TagNames::strong, HTML::TagNames::strike, HTML::TagNames::sub, HTML::TagNames::sup, HTML::TagNames::table, HTML::TagNames::tt, HTML::TagNames::u, HTML::TagNames::ul, HTML::TagNames::var))
LibWeb: Improvements to error handling in HTML foreign content parsing Follow the spec more closely when encountering an invalid start or end tag during foreign content parsing.
2021-09-14 23:49:45 +02:00
|| (token.is_start_tag() && token.tag_name() == HTML::TagNames::font && (token.has_attribute(HTML::AttributeNames::color) || token.has_attribute(HTML::AttributeNames::face) || token.has_attribute(HTML::AttributeNames::size)))
|| (token.is_end_tag() && token.tag_name().is_one_of(HTML::TagNames::br, HTML::TagNames::p))) {
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Improvements to error handling in HTML foreign content parsing Follow the spec more closely when encountering an invalid start or end tag during foreign content parsing.
2021-09-14 23:49:45 +02:00
// While the current node is not a MathML text integration point, an HTML integration point, or an element in the HTML namespace, pop elements from the stack of open elements.
while (!is_mathml_text_integration_point(current_node())
&& !is_html_integration_point(current_node())
&& current_node().namespace_() != Namespace::HTML) {
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
}
LibWeb: Improvements to error handling in HTML foreign content parsing Follow the spec more closely when encountering an invalid start or end tag during foreign content parsing.
2021-09-14 23:49:45 +02:00
// Reprocess the token according to the rules given in the section corresponding to the current insertion mode in HTML content.
process_using_the_rules_for(m_insertion_mode, token);
return;
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
}
LibWeb: Improvements to error handling in HTML foreign content parsing Follow the spec more closely when encountering an invalid start or end tag during foreign content parsing.
2021-09-14 23:49:45 +02:00
// Any other start tag
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
if (token.is_start_tag()) {
if (adjusted_current_node().namespace_() == Namespace::MathML) {
adjust_mathml_attributes(token);
} else if (adjusted_current_node().namespace_() == Namespace::SVG) {
adjust_svg_tag_names(token);
adjust_svg_attributes(token);
}
adjust_foreign_attributes(token);
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)insert_foreign_element(token, adjusted_current_node().namespace_());
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
if (token.is_self_closing()) {
if (token.tag_name() == SVG::TagNames::script && current_node().namespace_() == Namespace::SVG) {
token.acknowledge_self_closing_flag_if_set();
goto ScriptEndTag;
}
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
token.acknowledge_self_closing_flag_if_set();
}
return;
}
if (token.is_end_tag() && current_node().namespace_() == Namespace::SVG && current_node().tag_name() == SVG::TagNames::script) {
ScriptEndTag:
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
TODO();
}
if (token.is_end_tag()) {
LibWeb: Fully implement end tag parsing in foreign content Required to view the Spotify home page
2021-01-02 23:02:23 +00:00
RefPtr<DOM::Element> node = current_node();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
// FIXME: Not sure if this is the correct to_lowercase, as the specification says "to ASCII lowercase"
LibWeb: Fully implement end tag parsing in foreign content Required to view the Spotify home page
2021-01-02 23:02:23 +00:00
if (node->tag_name().to_lowercase() != token.tag_name())
LibWeb: Utilize SourceLocation for HTMLDocumentParser logging
2021-04-24 20:23:27 -07:00
log_parse_error();
LibWeb: Fully implement end tag parsing in foreign content Required to view the Spotify home page
2021-01-02 23:02:23 +00:00
for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
if (node == m_stack_of_open_elements.first()) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
return;
}
// FIXME: See the above FIXME
LibWeb: Fully implement end tag parsing in foreign content Required to view the Spotify home page
2021-01-02 23:02:23 +00:00
if (node->tag_name().to_lowercase() == token.tag_name()) {
while (current_node() != node)
LibWeb: Cast unused smart-pointer return values to void
2021-12-02 12:54:34 +00:00
(void)m_stack_of_open_elements.pop();
(void)m_stack_of_open_elements.pop();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
return;
}
LibWeb: Fully implement end tag parsing in foreign content Required to view the Spotify home page
2021-01-02 23:02:23 +00:00
node = m_stack_of_open_elements.elements().at(i - 1);
if (node->namespace_() != Namespace::HTML)
continue;
process_using_the_rules_for(m_insertion_mode, token);
return;
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
}
}
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY_NOT_REACHED();
LibWeb: Add initial implementation of foreign content parsing Plus sneak in a FIXME for the list of active formatting elements and a test for Element.namespaceURI
2020-10-12 01:51:28 +01:00
}
LibWeb: Implement "select" portion of reset_the_insertion_mode_appropriately Required by Dromaeo. With this, it no longer crashes.
2021-04-06 21:56:10 +01:00
// https://html.spec.whatwg.org/multipage/parsing.html#reset-the-insertion-mode-appropriately
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
void HTMLParser::reset_the_insertion_mode_appropriately()
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
{
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
bool last = i == 0;
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
// NOTE: When parsing fragments, we substitute the context element for the root of the stack of open elements.
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
RefPtr<DOM::Element> node;
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
if (last && m_parsing_fragment) {
node = m_context_element;
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
} else {
node = m_stack_of_open_elements.elements().at(i);
}
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::select) {
LibWeb: Implement "select" portion of reset_the_insertion_mode_appropriately Required by Dromaeo. With this, it no longer crashes.
2021-04-06 21:56:10 +01:00
if (!last) {
for (ssize_t j = i; j > 0; --j) {
auto& ancestor = m_stack_of_open_elements.elements().at(j - 1);
if (is<HTMLTemplateElement>(ancestor))
break;
if (is<HTMLTableElement>(ancestor)) {
m_insertion_mode = InsertionMode::InSelectInTable;
return;
}
}
}
m_insertion_mode = InsertionMode::InSelect;
return;
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (!last && node->local_name().is_one_of(HTML::TagNames::td, HTML::TagNames::th)) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InCell;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::tr) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InRow;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name().is_one_of(HTML::TagNames::tbody, HTML::TagNames::thead, HTML::TagNames::tfoot)) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InTableBody;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::caption) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InCaption;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::colgroup) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InColumnGroup;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::table) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InTable;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::template_) {
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
m_insertion_mode = m_stack_of_template_insertion_modes.last();
return;
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (!last && node->local_name() == HTML::TagNames::head) {
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
m_insertion_mode = InsertionMode::InHead;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::body) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InBody;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::frameset) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InFrameset;
return;
}
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (node->local_name() == HTML::TagNames::html) {
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
if (!m_head_element) {
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
m_insertion_mode = InsertionMode::BeforeHead;
return;
}
m_insertion_mode = InsertionMode::AfterHead;
return;
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
}
}
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(m_parsing_fragment);
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InBody;
LibWeb: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
const char* HTMLParser::insertion_mode_name() const
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
switch (m_insertion_mode) {
#define __ENUMERATE_INSERTION_MODE(mode) \
case InsertionMode::mode: \
return #mode;
ENUMERATE_INSERTION_MODES
#undef __ENUMERATE_INSERTION_MODE
}
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY_NOT_REACHED();
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
DOM::Document& HTMLParser::document()
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
{
return *m_document;
}
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
NonnullRefPtrVector<DOM::Node> HTMLParser::parse_html_fragment(DOM::Element& context_element, StringView markup)
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
{
LibWeb: Make HTMLDocumentParser take an existing document We shouldn't really be creating the document objects inside the parser, since that makes it hard to hook up e.g JavaScript bindings early on.
2020-12-13 16:59:22 +01:00
auto temp_document = DOM::Document::create();
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
HTMLParser parser(*temp_document, markup, "utf-8");
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
parser.m_context_element = context_element;
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
parser.m_parsing_fragment = true;
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
parser.document().set_quirks_mode(context_element.document().mode());
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (context_element.local_name().is_one_of(HTML::TagNames::title, HTML::TagNames::textarea)) {
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::RCDATA);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
} else if (context_element.local_name().is_one_of(HTML::TagNames::style, HTML::TagNames::xmp, HTML::TagNames::iframe, HTML::TagNames::noembed, HTML::TagNames::noframes)) {
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::RAWTEXT);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
} else if (context_element.local_name().is_one_of(HTML::TagNames::script)) {
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::ScriptData);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
} else if (context_element.local_name().is_one_of(HTML::TagNames::noscript)) {
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
if (context_element.document().is_scripting_enabled())
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::RAWTEXT);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
} else if (context_element.local_name().is_one_of(HTML::TagNames::plaintext)) {
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::PLAINTEXT);
}
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
auto root = create_element(context_element.document(), HTML::TagNames::html, Namespace::HTML);
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
parser.document().append_child(root);
parser.m_stack_of_open_elements.push(root);
LibWeb: Rename Element::tag_name() => local_name() To prepare for fully qualified tag names, let's call this local_name. Note that we still keep an Element::tag_name() around since that's what the JS bindings end up calling into for the Element.tagName property.
2020-07-23 18:18:13 +02:00
if (context_element.local_name() == HTML::TagNames::template_) {
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-19 22:30:33 +01:00
parser.m_stack_of_template_insertion_modes.append(InsertionMode::InTemplate);
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
}
// FIXME: Create a start tag token whose name is the local name of context and whose attributes are the attributes of context.
LibWeb: Assert we're parsing a fragment on fragment cases The specification says that parts labelled as a "fragment case" will only occur when parsing a fragment. It says that if it occurs when not parsing a fragment, then it is a specification error. We should probably assume at this point that it's an implementation error. This fixes a few little mistakes that were caught out by this. Also moves the context element outside insertion mode reset, as other (unimplemented) parts refer to it, such as "adjusted current node". Also cleans up insertion mode reset.
2020-07-21 19:03:05 +01:00
parser.reset_the_insertion_mode_appropriately();
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
for (auto* form_candidate = &context_element; form_candidate; form_candidate = form_candidate->parent_element()) {
if (is<HTMLFormElement>(*form_candidate)) {
AK: Rename downcast<T> => verify_cast<T> This makes it much clearer what this cast actually does: it will VERIFY that the thing we're casting is a T (using is<T>()).
2021-06-24 19:53:42 +02:00
parser.m_form_element = verify_cast<HTMLFormElement>(*form_candidate);
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
break;
}
}
parser.run(context_element.document().url());
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
NonnullRefPtrVector<DOM::Node> children;
while (RefPtr<DOM::Node> child = root->first_child()) {
LibWeb: Implement fragment parsing and use it for Element.innerHTML This patch implements most of the HTML fragment parsing algorithm and ports Element::set_inner_html() to it. This was the last remaining user of the old HTML parser. :^)
2020-06-25 23:42:08 +02:00
root->remove_child(*child);
context_element.document().adopt_node(*child);
children.append(*child);
}
return children;
}
LibWeb: Implement encoding sniffing algorithm This patch implements the HTML specification's "encoding sniffing algorithm", which is used when no encoding can be obtained from the Content-Type header (either because it doesn't contain a charset=...) value or the file has not been opened via HTTP (as with local files). It also modifies the creator of the HTMLDocumentParser to use the new HTMLDocumentParser::create_with_uncertain_encoding static method, which runs the encoding sniffing algorithm before instantiating the parser. This now allows us to load local HTML pages (or remote pages without a charset specified in the 'Content-Type' header) with a non-UTF-8 encoding such as 'windows-1252'. This would previously crash the browser. :^)
2021-05-12 10:47:12 +02:00
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
NonnullOwnPtr<HTMLParser> HTMLParser::create_with_uncertain_encoding(DOM::Document& document, const ByteBuffer& input)
LibWeb: Implement encoding sniffing algorithm This patch implements the HTML specification's "encoding sniffing algorithm", which is used when no encoding can be obtained from the Content-Type header (either because it doesn't contain a charset=...) value or the file has not been opened via HTTP (as with local files). It also modifies the creator of the HTMLDocumentParser to use the new HTMLDocumentParser::create_with_uncertain_encoding static method, which runs the encoding sniffing algorithm before instantiating the parser. This now allows us to load local HTML pages (or remote pages without a charset specified in the 'Content-Type' header) with a non-UTF-8 encoding such as 'windows-1252'. This would previously crash the browser. :^)
2021-05-12 10:47:12 +02:00
{
if (document.has_encoding())
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
return make<HTMLParser>(document, input, document.encoding().value());
LibWeb: Implement Attribute closer to the spec and with an IDL file Note our Attribute class is what the spec refers to as just "Attr". The main differences between the existing implementation and the spec are just that the spec defines more fields. Attributes can contain namespace URIs and prefixes. However, note that these are not parsed in HTML documents unless the document content-type is XML. So for now, these are initialized to null. Web pages are able to set the namespace via JavaScript (setAttributeNS), so these fields may be filled in when the corresponding APIs are implemented. The main change to be aware of is that an attribute is a node. This has implications on how attributes are stored in the Element class. Nodes are non-copyable and non-movable because these constructors are deleted by the EventTarget base class. This means attributes cannot be stored in a Vector or HashMap as these containers assume copyability / movability. So for now, the Vector holding attributes is changed to hold RefPtrs to attributes instead. This might change when attribute storage is implemented according to the spec (by way of NamedNodeMap).
2021-10-15 09:57:07 -04:00
auto encoding = run_encoding_sniffing_algorithm(document, input);
LibWeb: Implement encoding sniffing algorithm This patch implements the HTML specification's "encoding sniffing algorithm", which is used when no encoding can be obtained from the Content-Type header (either because it doesn't contain a charset=...) value or the file has not been opened via HTTP (as with local files). It also modifies the creator of the HTMLDocumentParser to use the new HTMLDocumentParser::create_with_uncertain_encoding static method, which runs the encoding sniffing algorithm before instantiating the parser. This now allows us to load local HTML pages (or remote pages without a charset specified in the 'Content-Type' header) with a non-UTF-8 encoding such as 'windows-1252'. This would previously crash the browser. :^)
2021-05-12 10:47:12 +02:00
dbgln("The encoding sniffing algorithm returned encoding '{}'", encoding);
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
return make<HTMLParser>(document, input, encoding);
LibWeb: Implement encoding sniffing algorithm This patch implements the HTML specification's "encoding sniffing algorithm", which is used when no encoding can be obtained from the Content-Type header (either because it doesn't contain a charset=...) value or the file has not been opened via HTTP (as with local files). It also modifies the creator of the HTMLDocumentParser to use the new HTMLDocumentParser::create_with_uncertain_encoding static method, which runs the encoding sniffing algorithm before instantiating the parser. This now allows us to load local HTML pages (or remote pages without a charset specified in the 'Content-Type' header) with a non-UTF-8 encoding such as 'windows-1252'. This would previously crash the browser. :^)
2021-05-12 10:47:12 +02:00
}
LibWeb: Implement HTML fragment serialisation and use it in innerHTML The previous implementation was about a half implementation and was tied to Element::innerHTML. This separates it and puts it into HTMLDocumentParser, as this is in the parsing section of the spec. This provides a near finished HTML fragment serialisation algorithm, bar namespaces in attributes and the `is` value.
2021-09-13 22:42:15 +01:00
// https://html.spec.whatwg.org/multipage/parsing.html#html-fragment-serialisation-algorithm
LibWeb: Rename HTMLDocumentParser => HTMLParser
2021-09-25 23:15:48 +02:00
String HTMLParser::serialize_html_fragment(DOM::Node const& node)
LibWeb: Implement HTML fragment serialisation and use it in innerHTML The previous implementation was about a half implementation and was tied to Element::innerHTML. This separates it and puts it into HTMLDocumentParser, as this is in the parsing section of the spec. This provides a near finished HTML fragment serialisation algorithm, bar namespaces in attributes and the `is` value.
2021-09-13 22:42:15 +01:00
{
// The algorithm takes as input a DOM Element, Document, or DocumentFragment referred to as the node.
VERIFY(node.is_element() || node.is_document() || node.is_document_fragment());
NonnullRefPtr<DOM::Node> actual_node = node;
if (is<DOM::Element>(node)) {
auto& element = verify_cast<DOM::Element>(node);
// 1. If the node serializes as void, then return the empty string.
// (NOTE: serializes as void is defined only on elements in the spec)
if (element.serializes_as_void())
return String::empty();
// 3. If the node is a template element, then let the node instead be the template element's template contents (a DocumentFragment node).
// (NOTE: This is out of order of the spec to avoid another dynamic cast. The second step just creates a string builder, so it shouldn't matter)
if (is<HTML::HTMLTemplateElement>(element))
actual_node = verify_cast<HTML::HTMLTemplateElement>(element).content();
}
enum class AttributeMode {
No,
Yes,
};
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
auto escape_string = [](StringView string, AttributeMode attribute_mode) -> String {
LibWeb: Implement HTML fragment serialisation and use it in innerHTML The previous implementation was about a half implementation and was tied to Element::innerHTML. This separates it and puts it into HTMLDocumentParser, as this is in the parsing section of the spec. This provides a near finished HTML fragment serialisation algorithm, bar namespaces in attributes and the `is` value.
2021-09-13 22:42:15 +01:00
// https://html.spec.whatwg.org/multipage/parsing.html#escapingString
StringBuilder builder;
for (auto& ch : string) {
// 1. Replace any occurrence of the "&" character by the string "&amp;".
if (ch == '&')
builder.append("&amp;");
// 2. Replace any occurrences of the U+00A0 NO-BREAK SPACE character by the string "&nbsp;".
else if (ch == '\xA0')
builder.append("&nbsp;");
// 3. If the algorithm was invoked in the attribute mode, replace any occurrences of the """ character by the string "&quot;".
else if (ch == '"' && attribute_mode == AttributeMode::Yes)
builder.append("&quot;");
// 4. If the algorithm was not invoked in the attribute mode, replace any occurrences of the "<" character by the string "&lt;", and any occurrences of the ">" character by the string "&gt;".
else if (ch == '<' && attribute_mode == AttributeMode::No)
builder.append("&lt;");
else if (ch == '>' && attribute_mode == AttributeMode::No)
builder.append("&gt;");
else
builder.append(ch);
}
return builder.to_string();
};
// 2. Let s be a string, and initialize it to the empty string.
StringBuilder builder;
// 4. For each child node of the node, in tree order, run the following steps:
actual_node->for_each_child([&](DOM::Node& current_node) {
// 1. Let current node be the child node being processed.
// 2. Append the appropriate string from the following list to s:
if (is<DOM::Element>(current_node)) {
// -> If current node is an Element
auto& element = verify_cast<DOM::Element>(current_node);
// 1. If current node is an element in the HTML namespace, the MathML namespace, or the SVG namespace, then let tagname be current node's local name.
// Otherwise, let tagname be current node's qualified name.
String tag_name;
if (element.namespace_().is_one_of(Namespace::HTML, Namespace::MathML, Namespace::SVG))
tag_name = element.local_name();
else
tag_name = element.qualified_name();
// 2. Append a U+003C LESS-THAN SIGN character (<), followed by tagname.
builder.append('<');
builder.append(tag_name);
// FIXME: 3. If current node's is value is not null, and the element does not have an is attribute in its attribute list,
// then append the string " is="", followed by current node's is value escaped as described below in attribute mode,
// followed by a U+0022 QUOTATION MARK character (").
// 4. For each attribute that the element has, append a U+0020 SPACE character, the attribute's serialized name as described below, a U+003D EQUALS SIGN character (=),
// a U+0022 QUOTATION MARK character ("), the attribute's value, escaped as described below in attribute mode, and a second U+0022 QUOTATION MARK character (").
// NOTE: The order of attributes is implementation-defined. The only constraint is that the order must be stable.
element.for_each_attribute([&](auto& name, auto& value) {
builder.append(' ');
// An attribute's serialized name for the purposes of the previous paragraph must be determined as follows:
// FIXME: -> If the attribute has no namespace:
// The attribute's serialized name is the attribute's local name.
// (We currently always do this)
builder.append(name);
// FIXME: -> If the attribute is in the XML namespace:
// The attribute's serialized name is the string "xml:" followed by the attribute's local name.
// FIXME: -> If the attribute is in the XMLNS namespace and the attribute's local name is xmlns:
// The attribute's serialized name is the string "xmlns".
// FIXME: -> If the attribute is in the XMLNS namespace and the attribute's local name is not xmlns:
// The attribute's serialized name is the string "xmlns:" followed by the attribute's local name.
// FIXME: -> If the attribute is in the XLink namespace:
// The attribute's serialized name is the string "xlink:" followed by the attribute's local name.
// FIXME: -> If the attribute is in some other namespace:
// The attribute's serialized name is the attribute's qualified name.
builder.append("=\"");
builder.append(escape_string(value, AttributeMode::Yes));
builder.append('"');
});
// 5. Append a U+003E GREATER-THAN SIGN character (>).
builder.append('>');
// 6. If current node serializes as void, then continue on to the next child node at this point.
if (element.serializes_as_void())
return IterationDecision::Continue;
// 7. Append the value of running the HTML fragment serialization algorithm on the current node element (thus recursing into this algorithm for that element),
// followed by a U+003C LESS-THAN SIGN character (<), a U+002F SOLIDUS character (/), tagname again, and finally a U+003E GREATER-THAN SIGN character (>).
builder.append(serialize_html_fragment(element));
builder.append("</");
builder.append(tag_name);
builder.append('>');
return IterationDecision::Continue;
}
if (is<DOM::Text>(current_node)) {
// -> If current node is a Text node
auto& text_node = verify_cast<DOM::Text>(current_node);
auto* parent = current_node.parent();
if (is<DOM::Element>(parent)) {
auto& parent_element = verify_cast<DOM::Element>(*parent);
// 1. If the parent of current node is a style, script, xmp, iframe, noembed, noframes, or plaintext element,
// or if the parent of current node is a noscript element and scripting is enabled for the node, then append the value of current node's data IDL attribute literally.
if (parent_element.local_name().is_one_of(HTML::TagNames::style, HTML::TagNames::script, HTML::TagNames::xmp, HTML::TagNames::iframe, HTML::TagNames::noembed, HTML::TagNames::noframes, HTML::TagNames::plaintext)
|| (parent_element.local_name() == HTML::TagNames::noscript && !parent_element.is_scripting_disabled())) {
builder.append(text_node.data());
return IterationDecision::Continue;
}
}
// 2. Otherwise, append the value of current node's data IDL attribute, escaped as described below.
builder.append(escape_string(text_node.data(), AttributeMode::No));
return IterationDecision::Continue;
}
if (is<DOM::Comment>(current_node)) {
// -> If current node is a Comment
auto& comment_node = verify_cast<DOM::Comment>(current_node);
// 1. Append the literal string "<!--" (U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK, U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS),
// followed by the value of current node's data IDL attribute, followed by the literal string "-->" (U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS, U+003E GREATER-THAN SIGN).
builder.append("<!--");
builder.append(comment_node.data());
builder.append("-->");
return IterationDecision::Continue;
}
if (is<DOM::ProcessingInstruction>(current_node)) {
// -> If current node is a ProcessingInstruction
auto& processing_instruction_node = verify_cast<DOM::ProcessingInstruction>(current_node);
// 1. Append the literal string "<?" (U+003C LESS-THAN SIGN, U+003F QUESTION MARK), followed by the value of current node's target IDL attribute,
// followed by a single U+0020 SPACE character, followed by the value of current node's data IDL attribute, followed by a single U+003E GREATER-THAN SIGN character (>).
builder.append("<?");
builder.append(processing_instruction_node.target());
builder.append(' ');
builder.append(processing_instruction_node.data());
builder.append('>');
return IterationDecision::Continue;
}
if (is<DOM::DocumentType>(current_node)) {
// -> If current node is a DocumentType
auto& document_type_node = verify_cast<DOM::DocumentType>(current_node);
// 1. Append the literal string "<!DOCTYPE" (U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK, U+0044 LATIN CAPITAL LETTER D, U+004F LATIN CAPITAL LETTER O,
// U+0043 LATIN CAPITAL LETTER C, U+0054 LATIN CAPITAL LETTER T, U+0059 LATIN CAPITAL LETTER Y, U+0050 LATIN CAPITAL LETTER P, U+0045 LATIN CAPITAL LETTER E),
// followed by a space (U+0020 SPACE), followed by the value of current node's name IDL attribute, followed by the literal string ">" (U+003E GREATER-THAN SIGN).
builder.append("<!DOCTYPE ");
builder.append(document_type_node.name());
builder.append('>');
return IterationDecision::Continue;
}
return IterationDecision::Continue;
});
// 5. Return s.
return builder.to_string();
}
LibWeb: Start building the tree building part of the new HTML parser This patch adds a new HTMLDocumentParser class. It keeps a tokenizer object internally and feeds itself with one token at a time from it. The names and idioms in this class are expressed as closely to the actual HTML parsing spec as possible, to make development as easy and bug free as possible. :^) This is going to become pretty large, but it's pretty cool!
2020-05-24 00:14:23 +02:00
}
Reference in a new issue Copy permalink