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/Libraries/LibWeb/HTML/Parser/HTMLDocumentParser.cpp

2860 lines
108 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
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
LibWeb+Browser: Use the new HTML parser by default You can still run the old parser with "br -O", but the new one is good enough to be the default parser now. We'll fix issues as we go and eventually remove the old one completely. :^)
2020-06-01 19:07:38 +02:00
//#define PARSER_DEBUG
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: 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: 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: 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: 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 <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: Move the HTML parser into HTML/Parser/
2020-07-28 19:18:23 +02:00
#include <LibWeb/HTML/Parser/HTMLDocumentParser.h>
#include <LibWeb/HTML/Parser/HTMLToken.h>
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
#include <LibWeb/Namespace.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: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
#define PARSE_ERROR() \
do { \
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
dbg() << "Parse error! " << __PRETTY_FUNCTION__ << " @ " << __LINE__; \
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
} while (0)
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: 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::Document> parse_html_document(const StringView& data, const 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
{
HTMLDocumentParser parser(data, encoding);
parser.run(url);
return parser.document();
}
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
HTMLDocumentParser::HTMLDocumentParser(const StringView& input, const String& encoding)
: m_tokenizer(input, encoding)
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 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
m_document = adopt(*new DOM::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
}
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
HTMLDocumentParser::HTMLDocumentParser(const StringView& input, const String& encoding, DOM::Document& existing_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
: m_tokenizer(input, encoding)
, m_document(existing_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
HTMLDocumentParser::~HTMLDocumentParser()
{
}
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
void HTMLDocumentParser::run(const 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();
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
#ifdef PARSER_DEBUG
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
dbg() << "[" << insertion_mode_name() << "] " << token.to_string();
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
#endif
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(m_insertion_mode, 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) {
LibWeb: Move "Stop parsing!" behind PARSER_DEBUG This makes SerenityOS's IRC client a lot less chatty.
2020-07-06 10:57:16 -04:00
#ifdef PARSER_DEBUG
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
dbg() << "Stop parsing" << (m_parsing_fragment ? " fragment" : "") << "! :^)";
LibWeb: Move "Stop parsing!" behind PARSER_DEBUG This makes SerenityOS's IRC client a lot less chatty.
2020-07-06 10:57:16 -04:00
#endif
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: 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
// "The end"
LibWeb: Implement document ready state
2020-08-31 13:56:16 +01:00
m_document->set_ready_state("interactive");
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
auto scripts_to_execute_when_parsing_has_finished = m_document->take_scripts_to_execute_when_parsing_has_finished({});
for (auto& script : scripts_to_execute_when_parsing_has_finished) {
script.execute_script();
}
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
m_document->dispatch_event(DOM::Event::create("DOMContentLoaded"));
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: 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
// FIXME: These are not in the right place, they should only fire once subresources are ready.
m_document->dispatch_event(DOM::Event::create("load"));
m_document->window().dispatch_event(DOM::Event::create("load"));
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
auto scripts_to_execute_as_soon_as_possible = m_document->take_scripts_to_execute_as_soon_as_possible({});
for (auto& script : scripts_to_execute_as_soon_as_possible) {
script.execute_script();
}
LibWeb: Implement document ready state
2020-08-31 13:56:16 +01:00
m_document->set_ready_state("complete");
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: 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
void HTMLDocumentParser::process_using_the_rules_for(InsertionMode mode, HTMLToken& token)
{
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:
ASSERT_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: 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
DOM::QuirksMode HTMLDocumentParser::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
{
if (doctype_token.m_doctype.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.
if (doctype_token.m_doctype.name.to_string() != "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
auto public_identifier = doctype_token.m_doctype.public_identifier.to_string();
auto system_identifier = doctype_token.m_doctype.system_identifier.to_string();
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
}
if (doctype_token.m_doctype.missing_system_identifier) {
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
if (!doctype_token.m_doctype.missing_system_identifier) {
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: 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
void HTMLDocumentParser::handle_initial(HTMLToken& token)
{
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: 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
auto comment = adopt(*new DOM::Comment(document(), token.m_comment_or_character.data.to_string()));
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()) {
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
auto doctype = adopt(*new DOM::DocumentType(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
doctype->set_name(token.m_doctype.name.to_string());
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
doctype->set_public_id(token.m_doctype.public_identifier.to_string());
doctype->set_system_id(token.m_doctype.system_identifier.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
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
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
}
void HTMLDocumentParser::handle_before_html(HTMLToken& token)
{
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
if (token.is_doctype()) {
PARSE_ERROR();
return;
}
if (token.is_comment()) {
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
auto comment = adopt(*new DOM::Comment(document(), token.m_comment_or_character.data.to_string()));
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()) {
PARSE_ERROR();
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: 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
DOM::Element& HTMLDocumentParser::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: 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
DOM::Element& HTMLDocumentParser::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: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
HTMLDocumentParser::AdjustedInsertionLocation HTMLDocumentParser::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: 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
HTMLDocumentParser::AdjustedInsertionLocation adjusted_insertion_location;
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: 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: 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: 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)) {
// This returns the template content, so no need to check the parent is a template.
return { downcast<HTMLTemplateElement>(last_template.element)->content(), nullptr };
}
if (!last_table.element) {
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
ASSERT(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: 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->parent_node())
adjusted_insertion_location = { last_table.element->parent_node(), last_table.element };
else
adjusted_insertion_location = { m_stack_of_open_elements.element_before(*last_table.element), nullptr };
} else {
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))
return { downcast<HTMLTemplateElement>(*adjusted_insertion_location.parent).content(), nullptr };
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: Add namespace to Element
2020-10-10 02:48:05 +01:00
NonnullRefPtr<DOM::Element> HTMLDocumentParser::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: 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& attribute : token.m_tag.attributes) {
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
element->set_attribute(attribute.local_name_builder.to_string(), attribute.value_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
}
return element;
}
LibWeb: Add namespace to Element
2020-10-10 02:48:05 +01:00
RefPtr<DOM::Element> HTMLDocumentParser::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: Add namespace to Element
2020-10-10 02:48:05 +01:00
auto element = create_element_for(token, 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
// FIXME: Check if it's possible to insert `element` at `adjusted_insertion_location`
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);
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: Add namespace to Element
2020-10-10 02:48:05 +01:00
RefPtr<DOM::Element> HTMLDocumentParser::insert_html_element(const HTMLToken& token)
{
return insert_foreign_element(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
void HTMLDocumentParser::handle_before_head(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
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()) {
PARSE_ERROR();
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);
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
m_head_element = downcast<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()) {
PARSE_ERROR();
return;
}
AnythingElse:
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
m_head_element = downcast<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: Support comments in the "in head" insertion mode
2020-05-24 20:29:01 +02:00
void HTMLDocumentParser::insert_comment(HTMLToken& token)
{
auto data = token.m_comment_or_character.data.to_string();
auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
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
adjusted_insertion_location.parent->insert_before(adopt(*new DOM::Comment(document(), data)), adjusted_insertion_location.insert_before_sibling);
LibWeb: Support comments in the "in head" insertion mode
2020-05-24 20:29:01 +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
void HTMLDocumentParser::handle_in_head(HTMLToken& 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
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()) {
PARSE_ERROR();
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: Handle some more parser inputs in the "in head" insertion mode
2020-05-25 20:16:48 +02:00
insert_html_element(token);
m_stack_of_open_elements.pop();
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);
m_stack_of_open_elements.pop();
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: 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
insert_html_element(token);
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) {
insert_html_element(token);
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);
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
auto& script_element = downcast<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) {
TODO();
}
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: 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.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: Hack the parser to dodge <template> elements in <head> for now
2020-05-30 19:23:04 +02:00
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_)) {
PARSE_ERROR();
return;
}
generate_all_implied_end_tags_thoroughly();
if (current_node().local_name() != HTML::TagNames::template_)
PARSE_ERROR();
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: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
PARSE_ERROR();
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: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
m_stack_of_open_elements.pop();
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: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
void HTMLDocumentParser::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()) {
PARSE_ERROR();
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) {
m_stack_of_open_elements.pop();
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)) {
PARSE_ERROR();
return;
}
AnythingElse:
PARSE_ERROR();
m_stack_of_open_elements.pop();
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: Parse enough to handle a <style> inside a <head> :^)
2020-05-24 20:36:43 +02:00
void HTMLDocumentParser::parse_generic_raw_text_element(HTMLToken& token)
{
insert_html_element(token);
m_tokenizer.switch_to({}, HTMLTokenizer::State::RAWTEXT);
m_original_insertion_mode = m_insertion_mode;
m_insertion_mode = InsertionMode::Text;
}
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
DOM::Text* HTMLDocumentParser::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())
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 downcast<DOM::Text>(adjusted_insertion_location.parent->last_child());
auto new_text_node = adopt(*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;
}
void HTMLDocumentParser::flush_character_insertions()
{
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();
}
void HTMLDocumentParser::insert_character(u32 data)
{
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: 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
void HTMLDocumentParser::handle_after_head(HTMLToken& token)
{
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: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
PARSE_ERROR();
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: 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
insert_html_element(token);
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: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
insert_html_element(token);
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: Hack the parser to dodge <template> elements in <head> for now
2020-05-30 19:23:04 +02:00
PARSE_ERROR();
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: Implement more of the "after head" insertion mode
2020-05-31 19:27:51 +02:00
PARSE_ERROR();
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: Add a helper for creating a fake (start tag) HTML token Sometimes the parsing rules say we need to insert a fake HTML token. Let's have a convenient way of doing that!
2020-07-23 17:30:03 +02:00
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: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
void HTMLDocumentParser::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: 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.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: 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
void HTMLDocumentParser::generate_all_implied_end_tags_thoroughly()
{
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))
m_stack_of_open_elements.pop();
}
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
void HTMLDocumentParser::close_a_p_element()
{
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: 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
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: 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
void HTMLDocumentParser::handle_after_body(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
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 data = token.m_comment_or_character.data.to_string();
auto& insertion_location = m_stack_of_open_elements.first();
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
insertion_location.append_child(adopt(*new DOM::Comment(document(), data)));
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()) {
PARSE_ERROR();
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: 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
PARSE_ERROR();
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: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +02:00
PARSE_ERROR();
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
}
void HTMLDocumentParser::handle_after_after_body(HTMLToken& token)
{
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: 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
auto comment = adopt(*new DOM::Comment(document(), token.m_comment_or_character.data.to_string()));
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
PARSE_ERROR();
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: 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
void HTMLDocumentParser::reconstruct_the_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
// FIXME: This needs to care about "markers"
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: 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: 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
ssize_t index = m_list_of_active_formatting_elements.entries().size() - 1;
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 19:37:56 +02:00
RefPtr<DOM::Element> entry = m_list_of_active_formatting_elements.entries().at(index).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
ASSERT(entry);
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: Fix step within reconstruct the active elements In step 4 of the "renstruct the active formatting elements" algorithm it says: Rewind: If there are no entries before entry in the list of active formatting elements, then jump to the step labeled create. Prior to this patch, the implementation accorded to the spec only for the first loop iteration.
2020-05-26 21:39:28 +02:00
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;
}
--index;
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
entry = m_list_of_active_formatting_elements.entries().at(index).element;
ASSERT(entry);
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 (!m_stack_of_open_elements.contains(*entry))
goto Rewind;
Advance:
++index;
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
entry = m_list_of_active_formatting_elements.entries().at(index).element;
ASSERT(entry);
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:
// FIXME: Hold on to the real token!
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
auto new_element = insert_html_element(HTMLToken::make_start_tag(entry->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: 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.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: 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 (index != (ssize_t)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: 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
HTMLDocumentParser::AdoptionAgencyAlgorithmOutcome HTMLDocumentParser::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: 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_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
}
size_t outer_loop_counter = 0;
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
//OuterLoop:
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 (outer_loop_counter >= 8)
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
++outer_loop_counter;
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)) {
PARSE_ERROR();
// FIXME: If formatting element is not in the stack of open elements,
// then this is a parse error; remove the element from the list, and return.
TODO();
}
if (!m_stack_of_open_elements.has_in_scope(*formatting_element)) {
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()) {
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
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)
m_stack_of_open_elements.pop();
m_stack_of_open_elements.pop();
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 :^)
TODO();
}
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
bool HTMLDocumentParser::is_special_tag(const FlyString& tag_name)
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
{
return tag_name.is_one_of(
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
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);
LibWeb: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
}
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
void HTMLDocumentParser::handle_in_body(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
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: Handle NULL character during "in body"
2020-06-03 22:37:45 -06:00
PARSE_ERROR();
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()) {
PARSE_ERROR();
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: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
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;
for (auto& attribute : token.m_tag.attributes) {
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 (current_node().has_attribute(attribute.local_name_builder.string_view()))
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
continue;
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
current_node().set_attribute(attribute.local_name_builder.to_string(), attribute.value_builder.to_string());
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: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
PARSE_ERROR();
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_)) {
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
ASSERT(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: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
for (auto& attribute : token.m_tag.attributes) {
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 (body_element.has_attribute(attribute.local_name_builder.string_view()))
LibWeb: More parser cases in the "in body" and "after after body" modes
2020-06-01 12:38:17 +02:00
continue;
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
body_element.set_attribute(attribute.local_name_builder.to_string(), attribute.value_builder.to_string());
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: 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
PARSE_ERROR();
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: 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
ASSERT(m_parsing_fragment);
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)) {
PARSE_ERROR();
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: Parse "body" end tags during "in body"
2020-06-03 22:36:08 -06:00
PARSE_ERROR();
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: Parse "body" end tags during "in body"
2020-06-03 22:36:08 -06:00
PARSE_ERROR();
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: Handle "html" end tag during "in body"
2020-06-03 23:28:57 -06:00
PARSE_ERROR();
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: Handle "html" end tag during "in body"
2020-06-03 23:28:57 -06:00
PARSE_ERROR();
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();
insert_html_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().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: Handle more benign parse errors in the "in body" insertion mode
2020-05-27 18:18:39 +02:00
PARSE_ERROR();
m_stack_of_open_elements.pop();
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
insert_html_element(token);
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();
insert_html_element(token);
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: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
PARSE_ERROR();
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_))
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
m_form_element = downcast<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: Parse "li" start tags in the "in body" insertion mode
2020-05-29 21:44:36 +02:00
PARSE_ERROR();
}
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: 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 (is_special_tag(node->local_name()) && !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();
insert_html_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().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: 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
PARSE_ERROR();
}
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: 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
PARSE_ERROR();
}
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: 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 (is_special_tag(node->local_name()) && !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();
insert_html_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::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();
insert_html_element(token);
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: 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_ERROR();
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();
insert_html_element(token);
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())) {
PARSE_ERROR();
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: 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_ERROR();
}
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: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
PARSE_ERROR();
return;
}
generate_implied_end_tags();
if (&current_node() != node) {
PARSE_ERROR();
}
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: Handle "form" end tag during "in body" if stack of open elements does not contain "template"
2020-06-03 23:03:19 -06:00
PARSE_ERROR();
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: Handle "form" end tag during "in body" if stack of open elements does not contain "template"
2020-06-03 23:03:19 -06:00
PARSE_ERROR();
}
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: 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_ERROR();
LibWeb: Add a helper for creating a fake (start tag) HTML token Sometimes the parsing rules say we need to insert a fake HTML token. Let's have a convenient way of doing that!
2020-07-23 17:30:03 +02:00
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: 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
PARSE_ERROR();
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: 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
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
dbg() << "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())) {
PARSE_ERROR();
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: Handle "dd" and "dt" end tags during "in body"
2020-05-30 22:59:15 +02:00
PARSE_ERROR();
}
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: Handle more benign parse errors in the "in body" insertion mode
2020-05-27 18:18:39 +02:00
PARSE_ERROR();
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: Handle more benign parse errors in the "in body" insertion mode
2020-05-27 18:18:39 +02:00
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: 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
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: Handle "nobr" start tag during "in body"
2020-06-03 23:03:44 -06:00
PARSE_ERROR();
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: Use String::is_one_of() a bunch in the HTML parser
2020-05-25 12:57:20 +02:00
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())) {
PARSE_ERROR();
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: Parse end tags for "applet", "marquee", and "object" during "in body"
2020-06-03 22:33:10 -06:00
PARSE_ERROR();
}
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: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
insert_html_element(token);
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();
insert_html_element(token);
m_stack_of_open_elements.pop();
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();
insert_html_element(token);
m_stack_of_open_elements.pop();
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: Parse param/source/track start tags during "in body" insertion
2020-06-05 21:59:46 +02:00
insert_html_element(token);
m_stack_of_open_elements.pop();
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();
insert_html_element(token);
m_stack_of_open_elements.pop();
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: 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_ERROR();
token.m_tag.tag_name.clear();
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
token.m_tag.tag_name.append(HTML::TagNames::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: 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
insert_html_element(token);
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();
insert_html_element(token);
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: 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();
reconstruct_the_active_formatting_elements();
insert_html_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().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: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
PARSE_ERROR();
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: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
PARSE_ERROR();
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
dbg() << "<math> element encountered.";
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: Add namespace to Element
2020-10-10 02:48:05 +01:00
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()) {
m_stack_of_open_elements.pop();
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
dbg() << "<svg> element encountered.";
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: Add namespace to Element
2020-10-10 02:48:05 +01:00
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()) {
m_stack_of_open_elements.pop();
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: 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_ERROR();
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();
insert_html_element(token);
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: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
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) {
m_stack_of_open_elements.pop();
}
m_stack_of_open_elements.pop();
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 (is_special_tag(node->local_name())) {
LibWeb: Add missing special tag case in the "in body" insertion mode
2020-05-30 18:19:15 +02:00
PARSE_ERROR();
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
}
void HTMLDocumentParser::adjust_mathml_attributes(HTMLToken& token)
{
token.adjust_attribute_name("definitionurl", "definitionURL");
}
void HTMLDocumentParser::adjust_svg_attributes(HTMLToken& token)
{
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");
}
void HTMLDocumentParser::adjust_foreign_attributes(HTMLToken& token)
{
auto xlink_namespace = "http://www.w3.org/1999/xlink";
token.adjust_foreign_attribute("xlink:actuate", "xlink", "actuate", xlink_namespace);
token.adjust_foreign_attribute("xlink:arcrole", "xlink", "arcrole", xlink_namespace);
token.adjust_foreign_attribute("xlink:href", "xlink", "href", xlink_namespace);
token.adjust_foreign_attribute("xlink:role", "xlink", "role", xlink_namespace);
token.adjust_foreign_attribute("xlink:show", "xlink", "show", xlink_namespace);
token.adjust_foreign_attribute("xlink:title", "xlink", "title", xlink_namespace);
token.adjust_foreign_attribute("xlink:type", "xlink", "type", xlink_namespace);
auto xml_namespace = "http://www.w3.org/XML/1998/namespace";
token.adjust_foreign_attribute("xml:lang", "xml", "lang", xml_namespace);
token.adjust_foreign_attribute("xml:space", "xml", "space", xml_namespace);
auto xmlns_namespace = "http://www.w3.org/2000/xmlns/";
token.adjust_foreign_attribute("xmlns", "", "xmlns", xmlns_namespace);
token.adjust_foreign_attribute("xmlns:xlink", "xmlns", "xlink", xmlns_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: 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
void HTMLDocumentParser::increment_script_nesting_level()
{
++m_script_nesting_level;
}
void HTMLDocumentParser::decrement_script_nesting_level()
{
ASSERT(m_script_nesting_level);
--m_script_nesting_level;
}
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
void HTMLDocumentParser::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()) {
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)
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
downcast<HTMLScriptElement>(current_node()).set_already_started({}, true);
LibWeb: Handle EOF tokens during "text" insertion
2020-06-06 16:32:27 +02:00
m_stack_of_open_elements.pop();
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();
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
NonnullRefPtr<HTMLScriptElement> script = downcast<HTMLScriptElement>(current_node());
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.pop();
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);
// FIXME: 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.
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;
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
ASSERT(the_script->is_ready_to_be_parser_executed());
if (m_aborted)
return;
m_tokenizer.set_blocked(false);
// FIXME: Handle tokenizer insertion point stuff here too.
ASSERT(script_nesting_level() == 0);
increment_script_nesting_level();
the_script->execute_script();
decrement_script_nesting_level();
ASSERT(script_nesting_level() == 0);
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()) {
m_stack_of_open_elements.pop();
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: 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
void HTMLDocumentParser::clear_the_stack_back_to_a_table_context()
{
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: 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_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)
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
ASSERT(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
}
void HTMLDocumentParser::clear_the_stack_back_to_a_table_row_context()
{
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: 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_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)
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
ASSERT(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
}
void HTMLDocumentParser::clear_the_stack_back_to_a_table_body_context()
{
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: 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_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)
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
ASSERT(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
}
void HTMLDocumentParser::handle_in_row(HTMLToken& token)
{
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();
insert_html_element(token);
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: 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
PARSE_ERROR();
return;
}
clear_the_stack_back_to_a_table_row_context();
m_stack_of_open_elements.pop();
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: 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
PARSE_ERROR();
return;
}
clear_the_stack_back_to_a_table_row_context();
m_stack_of_open_elements.pop();
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())) {
PARSE_ERROR();
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();
m_stack_of_open_elements.pop();
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: 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
PARSE_ERROR();
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: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
void HTMLDocumentParser::close_the_cell()
{
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: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
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
while (!current_node().local_name().is_one_of(HTML::TagNames::td, HTML::TagNames::th))
LibWeb: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
m_stack_of_open_elements.pop();
m_stack_of_open_elements.pop();
m_list_of_active_formatting_elements.clear_up_to_the_last_marker();
m_insertion_mode = InsertionMode::InRow;
}
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
void HTMLDocumentParser::handle_in_cell(HTMLToken& token)
{
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())) {
PARSE_ERROR();
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: 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
PARSE_ERROR();
}
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)) {
ASSERT(m_parsing_fragment);
LibWeb: Parse "td" start tags during "in cell" insertion mode
2020-05-28 11:45:40 +02:00
PARSE_ERROR();
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: 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
PARSE_ERROR();
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: 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
PARSE_ERROR();
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: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
void HTMLDocumentParser::handle_in_table_text(HTMLToken& token)
{
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: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
PARSE_ERROR();
return;
}
m_pending_table_character_tokens.append(token);
return;
}
for (auto& pending_token : m_pending_table_character_tokens) {
ASSERT(pending_token.is_character());
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: Take care of a FIXME in the "in table text" insertion mode
2020-08-30 20:10:19 +02:00
PARSE_ERROR();
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: 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
void HTMLDocumentParser::handle_in_table_body(HTMLToken& token)
{
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();
insert_html_element(token);
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: 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
PARSE_ERROR();
clear_the_stack_back_to_a_table_body_context();
LibWeb: Add a helper for creating a fake (start tag) HTML token Sometimes the parsing rules say we need to insert a fake HTML token. Let's have a convenient way of doing that!
2020-07-23 17:30:03 +02:00
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())) {
PARSE_ERROR();
return;
}
clear_the_stack_back_to_a_table_body_context();
m_stack_of_open_elements.pop();
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: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
PARSE_ERROR();
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();
m_stack_of_open_elements.pop();
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: Implement more table-related insertion modes
2020-05-30 17:57:41 +02:00
PARSE_ERROR();
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: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
void HTMLDocumentParser::handle_in_table(HTMLToken& token)
{
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()) {
PARSE_ERROR();
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();
insert_html_element(token);
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();
insert_html_element(token);
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: Add a helper for creating a fake (start tag) HTML token Sometimes the parsing rules say we need to insert a fake HTML token. Let's have a convenient way of doing that!
2020-07-23 17:30:03 +02:00
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();
insert_html_element(token);
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: Add a helper for creating a fake (start tag) HTML token Sometimes the parsing rules say we need to insert a fake HTML token. Let's have a convenient way of doing that!
2020-07-23 17:30:03 +02:00
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: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
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: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
PARSE_ERROR();
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)) {
PARSE_ERROR();
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;
}
PARSE_ERROR();
insert_html_element(token);
// 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."
m_stack_of_open_elements.pop();
token.acknowledge_self_closing_flag_if_set();
return;
}
if (token.is_start_tag() && token.tag_name() == HTML::TagNames::form) {
PARSE_ERROR();
if (m_form_element || m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
return;
}
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
m_form_element = downcast<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.
m_stack_of_open_elements.pop();
return;
}
if (token.is_end_of_file()) {
process_using_the_rules_for(InsertionMode::InBody, token);
return;
}
AnythingElse:
PARSE_ERROR();
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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
void HTMLDocumentParser::handle_in_select_in_table(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_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)) {
PARSE_ERROR();
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)) {
PARSE_ERROR();
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
}
void HTMLDocumentParser::handle_in_select(HTMLToken& token)
{
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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
PARSE_ERROR();
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()) {
PARSE_ERROR();
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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
m_stack_of_open_elements.pop();
}
insert_html_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::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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
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 (current_node().local_name() == HTML::TagNames::optgroup) {
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
m_stack_of_open_elements.pop();
}
insert_html_element(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::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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
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 (current_node().local_name() == HTML::TagNames::optgroup) {
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
m_stack_of_open_elements.pop();
} else {
PARSE_ERROR();
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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
m_stack_of_open_elements.pop();
} else {
PARSE_ERROR();
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)) {
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
ASSERT(m_parsing_fragment);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
PARSE_ERROR();
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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
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.has_in_select_scope(HTML::TagNames::select)) {
ASSERT(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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
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.has_in_select_scope(HTML::TagNames::select)) {
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
ASSERT(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;
}
PARSE_ERROR();
}
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
void HTMLDocumentParser::handle_in_caption(HTMLToken& token)
{
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::caption) {
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::caption)) {
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
ASSERT(m_parsing_fragment);
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
PARSE_ERROR();
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: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
PARSE_ERROR();
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)) {
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
ASSERT(m_parsing_fragment);
LibWeb: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
PARSE_ERROR();
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: Implement HTML parser "in caption" insertion mode
2020-06-13 05:09:54 +01:00
PARSE_ERROR();
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)) {
PARSE_ERROR();
return;
}
process_using_the_rules_for(InsertionMode::InBody, token);
}
LibWeb: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
void HTMLDocumentParser::handle_in_column_group(HTMLToken& token)
{
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()) {
PARSE_ERROR();
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) {
insert_html_element(token);
m_stack_of_open_elements.pop();
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: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
PARSE_ERROR();
return;
}
m_stack_of_open_elements.pop();
m_insertion_mode = InsertionMode::InTable;
return;
}
if (token.is_end_tag() && token.tag_name() == HTML::TagNames::col) {
PARSE_ERROR();
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: Implement HTML parser "in column group" insertion mode
2020-06-13 06:22:18 +01:00
PARSE_ERROR();
return;
}
m_stack_of_open_elements.pop();
m_insertion_mode = InsertionMode::InTable;
process_using_the_rules_for(m_insertion_mode, 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
void HTMLDocumentParser::handle_in_template(HTMLToken& token)
{
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()) {
PARSE_ERROR();
return;
}
if (token.is_end_of_file()) {
if (!m_stack_of_open_elements.contains(HTML::TagNames::template_)) {
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
ASSERT(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: 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
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);
}
}
void HTMLDocumentParser::handle_in_frameset(HTMLToken& token)
{
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()) {
PARSE_ERROR();
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) {
insert_html_element(token);
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)
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 (!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) {
insert_html_element(token);
m_stack_of_open_elements.pop();
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()) {
//FIXME: If the current node is not the root html element, then this is a parse error.
stop_parsing();
return;
}
PARSE_ERROR();
}
void HTMLDocumentParser::handle_after_frameset(HTMLToken& token)
{
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()) {
PARSE_ERROR();
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;
}
PARSE_ERROR();
}
void HTMLDocumentParser::handle_after_after_frameset(HTMLToken& token)
{
if (token.is_comment()) {
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
auto comment = adopt(*new DOM::Comment(document(), token.m_comment_or_character.data.to_string()));
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;
}
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
void HTMLDocumentParser::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: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
TODO();
}
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) {
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
ASSERT(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) {
ASSERT(m_parsing_fragment);
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
}
}
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
ASSERT(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: 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
const char* HTMLDocumentParser::insertion_mode_name() const
{
switch (m_insertion_mode) {
#define __ENUMERATE_INSERTION_MODE(mode) \
case InsertionMode::mode: \
return #mode;
ENUMERATE_INSERTION_MODES
#undef __ENUMERATE_INSERTION_MODE
}
ASSERT_NOT_REACHED();
}
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
DOM::Document& HTMLDocumentParser::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
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> HTMLDocumentParser::parse_html_fragment(DOM::Element& context_element, const 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
{
HTMLDocumentParser parser(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)) {
LibWeb: Switch to using AK::is and AK::downcast
2020-07-26 17:16:18 +02:00
parser.m_form_element = downcast<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: 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