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

2797 lines
104 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: 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/HTMLFormElement.h>
#include <LibWeb/DOM/HTMLHeadElement.h>
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
#include <LibWeb/DOM/HTMLScriptElement.h>
LibWeb: Start implementing character token parsing Now that we've gotten rid of the misguided character buffering in the tokenizer, it actually spits out character tokens that we have to deal with in the parser. This patch implements enough to bring us back to speed with simple.html
2020-05-24 19:51:50 +02:00
#include <LibWeb/DOM/Text.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/Parser/HTMLDocumentParser.h>
#include <LibWeb/Parser/HTMLToken.h>
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: 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
namespace Web {
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: 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
RefPtr<Document> parse_html_document(const StringView& data, const URL& url, const String& encoding)
{
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: 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
m_document = adopt(*new 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: 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: 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
m_document->dispatch_event(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
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: 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: 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
QuirksMode HTMLDocumentParser::which_quirks_mode(const HTMLToken& doctype_token) const
{
if (doctype_token.m_doctype.force_quirks)
return QuirksMode::Yes;
// NOTE: The tokenizer puts the name into lower case for us.
if (doctype_token.m_doctype.name.to_string() != "html")
return QuirksMode::Yes;
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//"))
return QuirksMode::Yes;
if (public_identifier.equals_ignoring_case("-/W3C/DTD HTML 4.0 Transitional/EN"))
return QuirksMode::Yes;
if (public_identifier.equals_ignoring_case("HTML"))
return QuirksMode::Yes;
if (system_identifier.equals_ignoring_case("http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"))
return QuirksMode::Yes;
for (auto& public_id : s_quirks_public_ids) {
if (public_identifier.starts_with(public_id, CaseSensitivity::CaseInsensitive))
return QuirksMode::Yes;
}
if (doctype_token.m_doctype.missing_system_identifier) {
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Frameset//", CaseSensitivity::CaseInsensitive))
return QuirksMode::Yes;
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Transitional//", CaseSensitivity::CaseInsensitive))
return QuirksMode::Yes;
}
if (public_identifier.starts_with("-//W3C//DTD XHTML 1.0 Frameset//", CaseSensitivity::CaseInsensitive))
return QuirksMode::Limited;
if (public_identifier.starts_with("-//W3C//DTD XHTML 1.0 Transitional//", CaseSensitivity::CaseInsensitive))
return QuirksMode::Limited;
if (!doctype_token.m_doctype.missing_system_identifier) {
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Frameset//", CaseSensitivity::CaseInsensitive))
return QuirksMode::Limited;
if (public_identifier.starts_with("-//W3C//DTD HTML 4.01 Transitional//", CaseSensitivity::CaseInsensitive))
return QuirksMode::Limited;
}
return QuirksMode::No;
}
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()) {
auto comment = adopt(*new Comment(document(), token.m_comment_or_character.data.to_string()));
document().append_child(move(comment));
return;
}
if (token.is_doctype()) {
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 doctype = adopt(*new DocumentType(document()));
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: 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(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()) {
auto comment = adopt(*new Comment(document(), token.m_comment_or_character.data.to_string()));
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: 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 = create_element_for(token);
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
auto element = create_element(document(), HTML::TagNames::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: 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
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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
Element& HTMLDocumentParser::node_before_current_node()
{
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 more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
if (m_foster_parenting && target.tag_name().is_one_of(HTML::TagNames::table, HTML::TagNames::tbody, HTML::TagNames::tfoot, HTML::TagNames::thead, HTML::TagNames::tr)) {
// FIXME: There's a bunch of steps for <template> elements here.
auto last_table = m_stack_of_open_elements.last_element_with_tag_name(HTML::TagNames::table);
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_table) {
ASSERT(m_parsing_fragment);
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 more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
if (last_table->parent_node())
return { last_table->parent_node(), last_table };
return { m_stack_of_open_elements.element_before(*last_table), nullptr };
}
return { target, nullptr };
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 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
NonnullRefPtr<Element> HTMLDocumentParser::create_element_for(const 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
{
auto element = create_element(document(), token.tag_name());
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 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
RefPtr<Element> HTMLDocumentParser::insert_html_element(const 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
{
auto adjusted_insertion_location = find_appropriate_place_for_inserting_node();
auto element = create_element_for(token);
// 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;
}
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);
m_head_element = to<HTMLHeadElement>(element);
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: 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
m_head_element = to<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: Implement more of the foster parenting algorithm in the parser
2020-06-21 17:00:55 +02:00
adjusted_insertion_location.parent->insert_before(adopt(*new 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()) {
insert_character(token.codepoint());
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();
auto element = create_element_for(token);
auto& script_element = to<HTMLScriptElement>(*element);
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
// FIXME: Support this properly
insert_html_element(token);
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: Hack the parser to dodge <template> elements in <head> for now
2020-05-30 19:23:04 +02:00
// FIXME: Support this properly
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
ASSERT(current_node().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
m_stack_of_open_elements.pop();
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: 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
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())
return to<Text>(adjusted_insertion_location.parent->last_child());
LibWeb: Buffer text node character insertions in the new parser Instead of appending character-at-a-time, we now buffer character insertions in a StringBuilder, and flush them to the relevant node whenever we start inserting into a new node (and when parsing ends.)
2020-06-03 21:53:08 +02:00
auto new_text_node = adopt(*new 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()) {
insert_character(token.codepoint());
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
while (current_node().tag_name() != exception && current_node().tag_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: 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);
if (current_node().tag_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();
insertion_location.append_child(adopt(*new Comment(document(), data)));
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()) {
auto comment = adopt(*new Comment(document(), token.m_comment_or_character.data.to_string()));
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;
RefPtr<Element> 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
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: 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
auto new_element = insert_html_element(HTMLToken::make_start_tag(entry->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
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.
if (current_node().tag_name() == subject && !m_list_of_active_formatting_elements.contains(current_node())) {
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: 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
RefPtr<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()) {
if (token.codepoint() == 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();
insert_character(token.codepoint());
return;
}
LibWeb: Yet more work towards parsing www/welcome.html :^)
2020-05-24 22:21:25 +02:00
reconstruct_the_active_formatting_elements();
insert_character(token.codepoint());
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: 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_stack_of_open_elements.elements().at(1).tag_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
|| m_stack_of_open_elements.elements().at(1).tag_name() != HTML::TagNames::body) {
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: Handle end-of-file token during "in body" insertion mode
2020-05-30 12:40:12 +02:00
// FIXME: If the stack of template insertion modes is not empty,
// then process the token using the rules for the "in template" insertion mode.
// FIXME: If there is a node in the stack of open elements that is not either
// a dd element, a dt element, an li element, an optgroup element, an option element,
// a p element, an rb element, an rp element, an rt element, an rtc element,
// a tbody element, a td element, a tfoot element, a th element, a thead element,
// a tr element, the body element, or the html element, then this is a parse error.
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!node.tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!node.tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (current_node().tag_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();
if (next_token.has_value() && next_token.value().is_character() && next_token.value().codepoint() == '\n') {
// 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: Parse "form" tags during the "in body" insertion mode
2020-05-30 11:13:57 +02:00
m_form_element = to<HTMLFormElement>(*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_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) {
RefPtr<Element> node = m_stack_of_open_elements.elements()[i];
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_name() == HTML::TagNames::li) {
generate_implied_end_tags(HTML::TagNames::li);
if (current_node().tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (is_special_tag(node->tag_name()) && !node->tag_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) {
RefPtr<Element> node = m_stack_of_open_elements.elements()[i];
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_name() == HTML::TagNames::dd) {
generate_implied_end_tags(HTML::TagNames::dd);
if (current_node().tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_name() == HTML::TagNames::dt) {
generate_implied_end_tags(HTML::TagNames::dt);
if (current_node().tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (is_special_tag(node->tag_name()) && !node->tag_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();
if (current_node().tag_name() != token.tag_name()) {
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (current_node().tag_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);
if (current_node().tag_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();
dbg() << "Expected <li> current node, but had <" << current_node().tag_name() << ">";
}
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());
if (current_node().tag_name() != token.tag_name()) {
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();
if (current_node().tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (popped_element->tag_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();
if (current_node().tag_name() != token.tag_name()) {
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;
if (next_token.has_value() && next_token.value().is_character() && next_token.value().codepoint() == '\n') {
// 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)) {
if (current_node().tag_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();
if (current_node().tag_name() != HTML::TagNames::ruby)
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);
if (current_node().tag_name() != HTML::TagNames::rtc || current_node().tag_name() != HTML::TagNames::ruby)
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);
// FIXME: this should insert a foreign element, but lets just insert it normally for now :^)
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
insert_html_element(token);
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
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);
// FIXME: this should insert a foreign element, but lets just insert it normally for now :^)
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
insert_html_element(token);
LibWeb: Update parser with more insertion modes :^) Implements handling of InHeadNoScript, InSelectInTable, InTemplate, InFrameset, AfterFrameset, and AfterAfterFrameset.
2020-06-21 06:58:03 +02:00
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: 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
RefPtr<Element> node;
for (ssize_t i = m_stack_of_open_elements.elements().size() - 1; i >= 0; --i) {
node = m_stack_of_open_elements.elements()[i];
if (node->tag_name() == token.tag_name()) {
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: Add missing special tag case in the "in body" insertion mode
2020-05-30 18:19:15 +02:00
if (is_special_tag(node->tag_name())) {
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()) {
insert_character(token.codepoint());
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (current_node().tag_name() == HTML::TagNames::script)
LibWeb: Handle EOF tokens during "text" insertion
2020-06-06 16:32:27 +02:00
to<HTMLScriptElement>(current_node()).set_already_started({}, true);
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: 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
NonnullRefPtr<HTMLScriptElement> script = to<HTMLScriptElement>(current_node());
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
while (!current_node().tag_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
if (current_node().tag_name() == HTML::TagNames::html)
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
while (!current_node().tag_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
if (current_node().tag_name() == HTML::TagNames::html)
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
while (!current_node().tag_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
if (current_node().tag_name() == HTML::TagNames::html)
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (!current_node().tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
while (!current_node().tag_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();
if (current_node().tag_name() != token.tag_name()) {
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()) {
if (token.codepoint() == 0) {
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()) {
// FIXME: If any of the tokens in the pending table character tokens list
// 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.
TODO();
}
}
for (auto& pending_token : m_pending_table_character_tokens) {
insert_character(pending_token.codepoint());
}
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_character() && current_node().tag_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;
}
m_form_element = to<HTMLFormElement>(insert_html_element(token));
// 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()) {
if (token.codepoint() == 0) {
PARSE_ERROR();
return;
}
insert_character(token.codepoint());
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) {
if (current_node().tag_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) {
if (current_node().tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (current_node().tag_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) {
if (current_node().tag_name() == HTML::TagNames::option && node_before_current_node().tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (current_node().tag_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) {
if (current_node().tag_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();
if (current_node().tag_name() != HTML::TagNames::caption)
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();
if (current_node().tag_name() != HTML::TagNames::caption)
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()) {
insert_character(token.codepoint());
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) {
if (current_node().tag_name() != HTML::TagNames::colgroup) {
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;
}
if (current_node().tag_name() != HTML::TagNames::colgroup) {
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()) {
insert_character(token.codepoint());
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: 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_parsing_fragment && current_node().tag_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()) {
insert_character(token.codepoint());
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()) {
auto comment = adopt(*new Comment(document(), token.m_comment_or_character.data.to_string()));
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.
RefPtr<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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_name() == HTML::TagNames::select) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
TODO();
}
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 && node->tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_name() == HTML::TagNames::template_) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
TODO();
}
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 && node->tag_name() == HTML::TagNames::head) {
m_insertion_mode = InsertionMode::InHead;
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->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
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (node->tag_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();
}
Document& HTMLDocumentParser::document()
{
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
NonnullRefPtrVector<Node> HTMLDocumentParser::parse_html_fragment(Element& context_element, const StringView& markup)
{
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
if (context_element.tag_name().is_one_of(HTML::TagNames::title, HTML::TagNames::textarea)) {
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::RCDATA);
} else if (context_element.tag_name().is_one_of(HTML::TagNames::style, HTML::TagNames::xmp, HTML::TagNames::iframe, HTML::TagNames::noembed, HTML::TagNames::noframes)) {
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::RAWTEXT);
} else if (context_element.tag_name().is_one_of(HTML::TagNames::script)) {
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::ScriptData);
} else if (context_element.tag_name().is_one_of(HTML::TagNames::noscript)) {
if (context_element.document().is_scripting_enabled())
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::RAWTEXT);
} else if (context_element.tag_name().is_one_of(HTML::TagNames::plaintext)) {
parser.m_tokenizer.switch_to({}, HTMLTokenizer::State::PLAINTEXT);
}
auto root = create_element(context_element.document(), HTML::TagNames::html);
parser.document().append_child(root);
parser.m_stack_of_open_elements.push(root);
if (context_element.tag_name() == HTML::TagNames::template_) {
TODO();
}
// 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)) {
parser.m_form_element = to<HTMLFormElement>(*form_candidate);
break;
}
}
parser.run(context_element.document().url());
NonnullRefPtrVector<Node> children;
while (RefPtr<Node> child = root->first_child()) {
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