mirrors/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-24 02:03:06 -05:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibWeb/Parser/HTMLDocumentParser.cpp

2181 lines
78 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: 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
{
}
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
{
m_document = adopt(*new Document);
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) {
dbg() << "Stop parsing! :^)";
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: 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
}
}
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());
document().append_child(move(doctype));
LibWeb: Fully implement all DOCTYPE tokenizer states Also fixes TagOpen having a seperate emit and reconsume in ANYTHING_ELSE.
2020-06-11 05:00:45 +01:00
document().set_quirks_mode(token.m_doctype.force_quirks);
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();
document().set_quirks_mode(true);
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: 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
RefPtr<Node> HTMLDocumentParser::find_appropriate_place_for_inserting_node()
{
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: 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 (m_foster_parenting) {
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
}
return target;
}
NonnullRefPtr<Element> HTMLDocumentParser::create_element_for(HTMLToken& token)
{
auto element = create_element(document(), token.tag_name());
for (auto& attribute : token.m_tag.attributes) {
element->set_attribute(attribute.name_builder.to_string(), attribute.value_builder.to_string());
}
return element;
}
RefPtr<Element> HTMLDocumentParser::insert_html_element(HTMLToken& token)
{
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`
adjusted_insertion_location->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(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:
HTMLToken fake_head_token;
fake_head_token.m_type = HTMLToken::Type::StartTag;
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
fake_head_token.m_tag.tag_name.append(HTML::TagNames::head);
LibWeb: Handle additional parser inputs in "initial" and "before html".
2020-05-27 01:49:40 +02:00
m_head_element = to<HTMLHeadElement>(insert_html_element(fake_head_token));
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();
adjusted_insertion_location->append_child(adopt(*new Comment(document(), data)));
}
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: 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();
}
adjusted_insertion_location->append_child(element, false);
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: Flesh out the "in head" insertion mode and add missing cases
2020-05-30 12:28:12 +02:00
TODO();
}
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;
}
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
}
void HTMLDocumentParser::handle_in_head_noscript(HTMLToken&)
{
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: 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();
if (adjusted_insertion_location->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;
if (adjusted_insertion_location->last_child() && adjusted_insertion_location->last_child()->is_text())
return to<Text>(adjusted_insertion_location->last_child());
auto new_text_node = adopt(*new Text(document(), ""));
adjusted_insertion_location->append_child(new_text_node);
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: 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: 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:
HTMLToken fake_body_token;
fake_body_token.m_type = HTMLToken::Type::StartTag;
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
fake_body_token.m_tag.tag_name.append(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
insert_html_element(fake_body_token);
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()) {
TODO();
}
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;
}
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();
return;
LibWeb: Implement more of the "after body" insertion mode
2020-05-28 18:52:32 +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::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: Turn a bunch of ASSERT_NOT_REACHED() in the parser into TODO()
2020-05-30 10:35:25 +02:00
TODO();
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
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!
HTMLToken fake_token;
fake_token.m_type = HTMLToken::Type::StartTag;
fake_token.m_tag.tag_name.append(entry->tag_name());
auto new_element = insert_html_element(fake_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
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) {
if (current_node().has_attribute(attribute.name_builder.string_view()))
continue;
current_node().set_attribute(attribute.name_builder.to_string(), attribute.value_builder.to_string());
}
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: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
|| node_before_current_node().tag_name() != HTML::TagNames::body
|| 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;
}
m_frameset_ok = false;
for (auto& attribute : token.m_tag.attributes) {
if (node_before_current_node().has_attribute(attribute.name_builder.string_view()))
continue;
node_before_current_node().set_attribute(attribute.name_builder.to_string(), attribute.value_builder.to_string());
}
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: 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;
if (!node || m_stack_of_open_elements.has_in_scope(*node)) {
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();
HTMLToken fake_p_token;
fake_p_token.m_type = HTMLToken::Type::StartTag;
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
fake_p_token.m_tag.tag_name.append(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
insert_html_element(fake_p_token);
}
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: 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().equals_ignoring_case("image")) {
// 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: 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();
}
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: 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_start_tag() && token.tag_name() == "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();
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
}
if (token.is_start_tag() && token.tag_name() == "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();
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::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: 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: 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: 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.
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();
}
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();
}
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();
}
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: 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, HTML::TagNames::tr)) {
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)) {
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)) {
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: 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;
}
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();
HTMLToken fake_tr_token;
fake_tr_token.m_type = HTMLToken::Type::StartTag;
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
fake_tr_token.m_tag.tag_name.append(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
insert_html_element(fake_tr_token);
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: 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
// FIXME: If the stack of open elements does not have a tbody, thead, or tfoot element in table scope, this is a parse error; ignore the token.
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();
HTMLToken fake_colgroup_token;
fake_colgroup_token.m_type = HTMLToken::Type::StartTag;
fake_colgroup_token.m_tag.tag_name.append(HTML::TagNames::colgroup);
insert_html_element(fake_colgroup_token);
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();
HTMLToken fake_tbody_token;
fake_tbody_token.m_type = HTMLToken::Type::StartTag;
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
fake_tbody_token.m_tag.tag_name.append(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
insert_html_element(fake_tbody_token);
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_))
|| (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() == 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)
{
(void)token;
TODO();
}
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) {
if (m_stack_of_open_elements.has_in_select_scope(HTML::TagNames::select)) {
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: 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: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
return;
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
m_stack_of_open_elements.pop_until_an_element_with_tag_name_has_been_popped(HTML::TagNames::select);
LibWeb: Support parsing "select" elements (outside of tables)
2020-05-30 19:58:52 +02:00
reset_the_insertion_mode_appropriately();
return;
}
LibWeb: Use HTML::TagNames globals in the new HTML parser
2020-06-07 23:53:16 +02:00
if (token.is_start_tag() && token.tag_name().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: 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)) {
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))
|| (token.is_end_tag() && token.tag_name() == HTML::TagNames::table)) {
if (!m_stack_of_open_elements.has_in_table_scope(HTML::TagNames::caption)) {
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: Start fleshing out the "in table" parser insertion mode
2020-05-25 20:30:34 +02:00
void HTMLDocumentParser::reset_the_insertion_mode_appropriately()
{
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) {
RefPtr<Element> node = m_stack_of_open_elements.elements().at(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::select) {
LibWeb: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
TODO();
}
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::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: 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: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
m_insertion_mode = InsertionMode::InFrameset;
if (m_parsing_fragment) {
TODO();
}
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: Flesh out "reset the insertion mode appropriately" algorithm
2020-05-28 00:26:33 +02:00
TODO();
}
}
m_insertion_mode = InsertionMode::InBody;
if (m_parsing_fragment) {
TODO();
}
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;
}
}
Reference in a new issue Copy permalink