system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-21 18:15:58 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

LibWeb: Define proper debug symbols for CSS Parser and Tokenizer

Browse source 
You can now turn debug logging for them on using `CSS_PARSER_DEBUG` and
`CSS_TOKENIZER_DEBUG`.
This commit is contained in:
Sam Atkins 2021-07-23 13:06:31 +01:00 committed by Andreas Kling
parent af045cee22
commit e54531244f
4 changed files with 63 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
AK/Debug.h.in
View file

@ -62,6 +62,14 @@
#cmakedefine01 CSS_LOADER_DEBUG
#endif
#ifndef CSS_PARSER_DEBUG
#cmakedefine01 CSS_PARSER_DEBUG
#endif
#ifndef CSS_TOKENIZER_DEBUG
#cmakedefine01 CSS_TOKENIZER_DEBUG
#endif
#ifndef CURSOR_TOOL_DEBUG
#cmakedefine01 CURSOR_TOOL_DEBUG
#endif

2
Meta/CMake/all_the_debug_macros.cmake
View file

@ -22,6 +22,8 @@ set(CPP_LANGUAGE_SERVER_DEBUG ON)
set(CRYPTO_DEBUG ON)
set(CSOCKET_DEBUG ON)
set(CSS_LOADER_DEBUG ON)
set(CSS_PARSER_DEBUG ON)
set(CSS_TOKENIZER_DEBUG ON)
set(CURSOR_TOOL_DEBUG ON)
set(DDS_DEBUG ON)
set(DEBUG_AUTOCOMPLETE ON)

57
Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp
View file

@ -6,6 +6,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Debug.h>
#include <AK/NonnullRefPtrVector.h>
#include <AK/SourceLocation.h>
#include <LibWeb/CSS/CSSStyleDeclaration.h>
@ -21,11 +22,9 @@
#include <LibWeb/DOM/Document.h>
#include <LibWeb/Dump.h>
#define CSS_PARSER_TRACE 1
static void log_parse_error(const SourceLocation& location = SourceLocation::current())
{
dbgln_if(CSS_PARSER_TRACE, "Parse error (CSS) {}", location);
dbgln_if(CSS_PARSER_DEBUG, "Parse error (CSS) {}", location);
}
namespace Web::CSS {
@ -160,7 +159,7 @@ NonnullRefPtr<CSSStyleSheet> Parser::parse_as_stylesheet()
template<typename T>
NonnullRefPtr<CSSStyleSheet> Parser::parse_as_stylesheet(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_stylesheet");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_stylesheet");
auto parser_rules = consume_a_list_of_rules(tokens, true);
NonnullRefPtrVector<CSSRule> rules;
@ -184,7 +183,7 @@ NonnullRefPtrVector<Selector> Parser::parse_a_selector()
template<typename T>
NonnullRefPtrVector<Selector> Parser::parse_a_selector(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_a_selector");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_a_selector");
auto comma_separated_lists = parse_as_comma_separated_list_of_component_values(tokens);
NonnullRefPtrVector<Selector> selectors;
@ -207,7 +206,7 @@ NonnullRefPtrVector<Selector> Parser::parse_a_relative_selector()
template<typename T>
NonnullRefPtrVector<Selector> Parser::parse_a_relative_selector(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_a_relative_selector");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_a_relative_selector");
auto comma_separated_lists = parse_as_comma_separated_list_of_component_values(tokens);
@ -226,7 +225,7 @@ NonnullRefPtrVector<Selector> Parser::parse_a_relative_selector(TokenStream<T>&
template<typename T>
RefPtr<Selector> Parser::parse_single_selector(TokenStream<T>& tokens, bool is_relative)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_single_selector");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_single_selector");
// FIXME: Bring this all in line with the spec. https://www.w3.org/TR/selectors-4/
@ -572,7 +571,7 @@ NonnullRefPtrVector<StyleRule> Parser::consume_a_list_of_rules(bool top_level)
template<typename T>
NonnullRefPtrVector<StyleRule> Parser::consume_a_list_of_rules(TokenStream<T>& tokens, bool top_level)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_list_of_rules");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_list_of_rules");
NonnullRefPtrVector<StyleRule> rules;
@ -625,7 +624,7 @@ NonnullRefPtr<StyleRule> Parser::consume_an_at_rule()
template<typename T>
NonnullRefPtr<StyleRule> Parser::consume_an_at_rule(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_an_at_rule");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_an_at_rule");
auto& name_ident = tokens.next_token();
VERIFY(name_ident.is(Token::Type::AtKeyword));
@ -665,7 +664,7 @@ RefPtr<StyleRule> Parser::consume_a_qualified_rule()
template<typename T>
RefPtr<StyleRule> Parser::consume_a_qualified_rule(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_qualified_rule");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_qualified_rule");
NonnullRefPtr<StyleRule> rule = create<StyleRule>(StyleRule::Type::Qualified);
@ -695,7 +694,7 @@ RefPtr<StyleRule> Parser::consume_a_qualified_rule(TokenStream<T>& tokens)
template<>
StyleComponentValueRule Parser::consume_a_component_value(TokenStream<StyleComponentValueRule>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_component_value - shortcut: '{}'", tokens.peek_token().to_debug_string());
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_component_value - shortcut: '{}'", tokens.peek_token().to_debug_string());
return tokens.next_token();
}
@ -703,7 +702,7 @@ StyleComponentValueRule Parser::consume_a_component_value(TokenStream<StyleCompo
template<typename T>
StyleComponentValueRule Parser::consume_a_component_value(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_component_value");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_component_value");
auto& token = tokens.next_token();
@ -729,7 +728,7 @@ NonnullRefPtr<StyleBlockRule> Parser::consume_a_simple_block()
template<typename T>
NonnullRefPtr<StyleBlockRule> Parser::consume_a_simple_block(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_simple_block");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_simple_block");
auto ending_token = ((Token)tokens.current_token()).mirror_variant();
@ -762,7 +761,7 @@ NonnullRefPtr<StyleFunctionRule> Parser::consume_a_function()
template<typename T>
NonnullRefPtr<StyleFunctionRule> Parser::consume_a_function(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_function");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_function");
auto name_ident = tokens.current_token();
VERIFY(name_ident.is(Token::Type::Function));
@ -795,7 +794,7 @@ Optional<StyleDeclarationRule> Parser::consume_a_declaration()
template<typename T>
Optional<StyleDeclarationRule> Parser::consume_a_declaration(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_declaration");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_declaration");
auto& token = tokens.next_token();
@ -857,7 +856,7 @@ Vector<DeclarationOrAtRule> Parser::consume_a_list_of_declarations()
template<typename T>
Vector<DeclarationOrAtRule> Parser::consume_a_list_of_declarations(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_list_of_declarations");
dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_list_of_declarations");
Vector<DeclarationOrAtRule> list;
@ -920,7 +919,7 @@ RefPtr<CSSRule> Parser::parse_as_rule()
template<typename T>
RefPtr<CSSRule> Parser::parse_as_rule(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_rule");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_rule");
RefPtr<CSSRule> rule;
@ -959,7 +958,7 @@ NonnullRefPtrVector<CSSRule> Parser::parse_as_list_of_rules()
template<typename T>
NonnullRefPtrVector<CSSRule> Parser::parse_as_list_of_rules(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_list_of_rules");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_list_of_rules");
auto parsed_rules = consume_a_list_of_rules(tokens, false);
NonnullRefPtrVector<CSSRule> rules;
@ -981,7 +980,7 @@ Optional<StyleProperty> Parser::parse_as_declaration()
template<typename T>
Optional<StyleProperty> Parser::parse_as_declaration(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_declaration");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_declaration");
tokens.skip_whitespace();
@ -1006,7 +1005,7 @@ RefPtr<CSSStyleDeclaration> Parser::parse_as_list_of_declarations()
template<typename T>
RefPtr<CSSStyleDeclaration> Parser::parse_as_list_of_declarations(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_list_of_declarations");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_list_of_declarations");
auto declarations_and_at_rules = consume_a_list_of_declarations(tokens);
@ -1043,7 +1042,7 @@ Optional<StyleComponentValueRule> Parser::parse_as_component_value()
template<typename T>
Optional<StyleComponentValueRule> Parser::parse_as_component_value(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_component_value");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_component_value");
tokens.skip_whitespace();
@ -1073,7 +1072,7 @@ Vector<StyleComponentValueRule> Parser::parse_as_list_of_component_values()
template<typename T>
Vector<StyleComponentValueRule> Parser::parse_as_list_of_component_values(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_list_of_component_values");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_list_of_component_values");
Vector<StyleComponentValueRule> rules;
@ -1096,7 +1095,7 @@ Vector<Vector<StyleComponentValueRule>> Parser::parse_as_comma_separated_list_of
template<typename T>
Vector<Vector<StyleComponentValueRule>> Parser::parse_as_comma_separated_list_of_component_values(TokenStream<T>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_comma_separated_list_of_component_values");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_comma_separated_list_of_component_values");
Vector<Vector<StyleComponentValueRule>> lists;
lists.append({});
@ -1146,7 +1145,7 @@ Optional<URL> Parser::parse_url_function(ParsingContext const& context, StyleCom
RefPtr<CSSRule> Parser::convert_to_rule(NonnullRefPtr<StyleRule> rule)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::convert_to_rule");
dbgln_if(CSS_PARSER_DEBUG, "Parser::convert_to_rule");
if (rule->m_type == StyleRule::Type::At) {
if (rule->m_name.equals_ignoring_case("import"sv) && !rule->prelude().is_empty()) {
@ -1192,7 +1191,7 @@ RefPtr<CSSRule> Parser::convert_to_rule(NonnullRefPtr<StyleRule> rule)
RefPtr<CSSStyleDeclaration> Parser::convert_to_declaration(NonnullRefPtr<StyleBlockRule> block)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::convert_to_declaration");
dbgln_if(CSS_PARSER_DEBUG, "Parser::convert_to_declaration");
if (!block->is_curly())
return {};
@ -1203,7 +1202,7 @@ RefPtr<CSSStyleDeclaration> Parser::convert_to_declaration(NonnullRefPtr<StyleBl
Optional<StyleProperty> Parser::convert_to_style_property(StyleDeclarationRule& declaration)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::convert_to_style_property");
dbgln_if(CSS_PARSER_DEBUG, "Parser::convert_to_style_property");
auto& property_name = declaration.m_name;
auto property_id = property_id_from_string(property_name);
@ -1634,7 +1633,7 @@ RefPtr<StyleValue> Parser::parse_image_value(ParsingContext const& context, Styl
RefPtr<StyleValue> Parser::parse_css_value(PropertyID property_id, TokenStream<StyleComponentValueRule>& tokens)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_css_value");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_css_value");
Vector<StyleComponentValueRule> component_values;
@ -1663,7 +1662,7 @@ RefPtr<StyleValue> Parser::parse_css_value(PropertyID property_id, TokenStream<S
RefPtr<StyleValue> Parser::parse_css_value(ParsingContext const& context, PropertyID property_id, StyleComponentValueRule const& component_value)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_css_value '{}'", component_value.to_debug_string());
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_css_value '{}'", component_value.to_debug_string());
// FIXME: Figure out if we still need takes_integer_value, and if so, move this information
// into Properties.json.
auto takes_integer_value = [](PropertyID property_id) -> bool {
@ -1704,7 +1703,7 @@ RefPtr<StyleValue> Parser::parse_css_value(ParsingContext const& context, Proper
Optional<Selector::SimpleSelector::NthChildPattern> Parser::parse_nth_child_pattern(TokenStream<StyleComponentValueRule>& values)
{
dbgln_if(CSS_PARSER_TRACE, "Parser::parse_nth_child_pattern");
dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_nth_child_pattern");
Selector::SimpleSelector::NthChildPattern pattern;

51
Userland/Libraries/LibWeb/CSS/Parser/Tokenizer.cpp
View file

@ -5,20 +5,19 @@
*/
#include <AK/CharacterTypes.h>
#include <AK/Debug.h>
#include <AK/SourceLocation.h>
#include <AK/Vector.h>
#include <LibTextCodec/Decoder.h>
#include <LibWeb/CSS/Parser/Tokenizer.h>
#define CSS_TOKENIZER_TRACE 0
//U+FFFD REPLACEMENT CHARACTER (<28>)
#define REPLACEMENT_CHARACTER 0xFFFD
static const u32 TOKENIZER_EOF = 0xFFFFFFFF;
static inline void log_parse_error(const SourceLocation& location = SourceLocation::current())
{
dbgln_if(CSS_TOKENIZER_TRACE, "Parse error (css tokenization) {} ", location);
dbgln_if(CSS_TOKENIZER_DEBUG, "Parse error (css tokenization) {} ", location);
}
static inline bool is_eof(u32 code_point)
@ -219,7 +218,7 @@ u32 Tokenizer::next_code_point()
return TOKENIZER_EOF;
m_prev_utf8_iterator = m_utf8_iterator;
++m_utf8_iterator;
dbgln_if(CSS_TOKENIZER_TRACE, "(Tokenizer) Next code_point: {:c}", (char)*m_prev_utf8_iterator);
dbgln_if(CSS_TOKENIZER_DEBUG, "(Tokenizer) Next code_point: {:c}", (char)*m_prev_utf8_iterator);
return *m_prev_utf8_iterator;
}
@ -716,7 +715,7 @@ Token Tokenizer::consume_a_token()
}
if (is_whitespace(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is whitespace");
dbgln_if(CSS_TOKENIZER_DEBUG, "is whitespace");
auto next = peek_code_point();
while (is_whitespace(next)) {
@ -728,12 +727,12 @@ Token Tokenizer::consume_a_token()
}
if (is_quotation_mark(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is quotation mark");
dbgln_if(CSS_TOKENIZER_DEBUG, "is quotation mark");
return consume_string_token(input);
}
if (is_number_sign(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is number sign");
dbgln_if(CSS_TOKENIZER_DEBUG, "is number sign");
auto next_input = peek_code_point();
auto maybe_escape = peek_twin();
@ -754,22 +753,22 @@ Token Tokenizer::consume_a_token()
}
if (is_apostrophe(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is apostrophe");
dbgln_if(CSS_TOKENIZER_DEBUG, "is apostrophe");
return consume_string_token(input);
}
if (is_left_paren(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is left paren");
dbgln_if(CSS_TOKENIZER_DEBUG, "is left paren");
return create_new_token(Token::Type::OpenParen);
}
if (is_right_paren(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is right paren");
dbgln_if(CSS_TOKENIZER_DEBUG, "is right paren");
return create_new_token(Token::Type::CloseParen);
}
if (is_plus_sign(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is plus sign");
dbgln_if(CSS_TOKENIZER_DEBUG, "is plus sign");
if (starts_with_a_number()) {
reconsume_current_input_code_point();
return consume_a_numeric_token();
@ -779,12 +778,12 @@ Token Tokenizer::consume_a_token()
}
if (is_comma(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is comma");
dbgln_if(CSS_TOKENIZER_DEBUG, "is comma");
return create_new_token(Token::Type::Comma);
}
if (is_hyphen_minus(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is hyphen minus");
dbgln_if(CSS_TOKENIZER_DEBUG, "is hyphen minus");
if (starts_with_a_number()) {
reconsume_current_input_code_point();
return consume_a_numeric_token();
@ -807,7 +806,7 @@ Token Tokenizer::consume_a_token()
}
if (is_full_stop(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is full stop");
dbgln_if(CSS_TOKENIZER_DEBUG, "is full stop");
if (starts_with_a_number()) {
reconsume_current_input_code_point();
return consume_a_numeric_token();
@ -817,17 +816,17 @@ Token Tokenizer::consume_a_token()
}
if (is_colon(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is colon");
dbgln_if(CSS_TOKENIZER_DEBUG, "is colon");
return create_new_token(Token::Type::Colon);
}
if (is_semicolon(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is semicolon");
dbgln_if(CSS_TOKENIZER_DEBUG, "is semicolon");
return create_new_token(Token::Type::Semicolon);
}
if (is_less_than_sign(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is less than");
dbgln_if(CSS_TOKENIZER_DEBUG, "is less than");
auto maybe_cdo = peek_triplet();
if (is_exclamation_mark(maybe_cdo.first) && is_hyphen_minus(maybe_cdo.second) && is_hyphen_minus(maybe_cdo.third)) {
@ -842,7 +841,7 @@ Token Tokenizer::consume_a_token()
}
if (is_at(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is at");
dbgln_if(CSS_TOKENIZER_DEBUG, "is at");
if (would_start_an_identifier()) {
auto name = consume_a_name();
@ -853,12 +852,12 @@ Token Tokenizer::consume_a_token()
}
if (is_open_square_bracket(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is open square");
dbgln_if(CSS_TOKENIZER_DEBUG, "is open square");
return create_new_token(Token::Type::OpenSquare);
}
if (is_reverse_solidus(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is reverse solidus");
dbgln_if(CSS_TOKENIZER_DEBUG, "is reverse solidus");
if (is_valid_escape_sequence({ input, peek_code_point() })) {
reconsume_current_input_code_point();
return consume_an_ident_like_token();
@ -869,33 +868,33 @@ Token Tokenizer::consume_a_token()
}
if (is_closed_square_bracket(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is closed square");
dbgln_if(CSS_TOKENIZER_DEBUG, "is closed square");
return create_new_token(Token::Type::CloseSquare);
}
if (is_open_curly_bracket(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is open curly");
dbgln_if(CSS_TOKENIZER_DEBUG, "is open curly");
return create_new_token(Token::Type::OpenCurly);
}
if (is_closed_curly_bracket(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is closed curly");
dbgln_if(CSS_TOKENIZER_DEBUG, "is closed curly");
return create_new_token(Token::Type::CloseCurly);
}
if (is_ascii_digit(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is digit");
dbgln_if(CSS_TOKENIZER_DEBUG, "is digit");
reconsume_current_input_code_point();
return consume_a_numeric_token();
}
if (is_name_start_code_point(input)) {
dbgln_if(CSS_TOKENIZER_TRACE, "is name start");
dbgln_if(CSS_TOKENIZER_DEBUG, "is name start");
reconsume_current_input_code_point();
return consume_an_ident_like_token();
}
dbgln_if(CSS_TOKENIZER_TRACE, "is delimiter");
dbgln_if(CSS_TOKENIZER_DEBUG, "is delimiter");
return create_value_token(Token::Type::Delim, input);
}