From e54531244fc9791ce5adab65e33b4512bd5baaf6 Mon Sep 17 00:00:00 2001 From: Sam Atkins Date: Fri, 23 Jul 2021 13:06:31 +0100 Subject: [PATCH] LibWeb: Define proper debug symbols for CSS Parser and Tokenizer You can now turn debug logging for them on using `CSS_PARSER_DEBUG` and `CSS_TOKENIZER_DEBUG`. --- AK/Debug.h.in | 8 +++ Meta/CMake/all_the_debug_macros.cmake | 2 + .../Libraries/LibWeb/CSS/Parser/Parser.cpp | 57 +++++++++---------- .../Libraries/LibWeb/CSS/Parser/Tokenizer.cpp | 51 ++++++++--------- 4 files changed, 63 insertions(+), 55 deletions(-) diff --git a/AK/Debug.h.in b/AK/Debug.h.in index 5b0d8178d3..94b976fd29 100644 --- a/AK/Debug.h.in +++ b/AK/Debug.h.in @@ -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 diff --git a/Meta/CMake/all_the_debug_macros.cmake b/Meta/CMake/all_the_debug_macros.cmake index baeb3591e8..bf5c102a80 100644 --- a/Meta/CMake/all_the_debug_macros.cmake +++ b/Meta/CMake/all_the_debug_macros.cmake @@ -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) diff --git a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp index f9d9929f06..121433b6f4 100644 --- a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp +++ b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp @@ -6,6 +6,7 @@ * SPDX-License-Identifier: BSD-2-Clause */ +#include #include #include #include @@ -21,11 +22,9 @@ #include #include -#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 Parser::parse_as_stylesheet() template NonnullRefPtr Parser::parse_as_stylesheet(TokenStream& 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 rules; @@ -184,7 +183,7 @@ NonnullRefPtrVector Parser::parse_a_selector() template NonnullRefPtrVector Parser::parse_a_selector(TokenStream& 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 selectors; @@ -207,7 +206,7 @@ NonnullRefPtrVector Parser::parse_a_relative_selector() template NonnullRefPtrVector Parser::parse_a_relative_selector(TokenStream& 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 Parser::parse_a_relative_selector(TokenStream& template RefPtr Parser::parse_single_selector(TokenStream& 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 Parser::consume_a_list_of_rules(bool top_level) template NonnullRefPtrVector Parser::consume_a_list_of_rules(TokenStream& 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 rules; @@ -625,7 +624,7 @@ NonnullRefPtr Parser::consume_an_at_rule() template NonnullRefPtr Parser::consume_an_at_rule(TokenStream& 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 Parser::consume_a_qualified_rule() template RefPtr Parser::consume_a_qualified_rule(TokenStream& tokens) { - dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_qualified_rule"); + dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_qualified_rule"); NonnullRefPtr rule = create(StyleRule::Type::Qualified); @@ -695,7 +694,7 @@ RefPtr Parser::consume_a_qualified_rule(TokenStream& tokens) template<> StyleComponentValueRule Parser::consume_a_component_value(TokenStream& 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 StyleComponentValueRule Parser::consume_a_component_value(TokenStream& 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 Parser::consume_a_simple_block() template NonnullRefPtr Parser::consume_a_simple_block(TokenStream& 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 Parser::consume_a_function() template NonnullRefPtr Parser::consume_a_function(TokenStream& 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 Parser::consume_a_declaration() template Optional Parser::consume_a_declaration(TokenStream& 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 Parser::consume_a_list_of_declarations() template Vector Parser::consume_a_list_of_declarations(TokenStream& tokens) { - dbgln_if(CSS_PARSER_TRACE, "Parser::consume_a_list_of_declarations"); + dbgln_if(CSS_PARSER_DEBUG, "Parser::consume_a_list_of_declarations"); Vector list; @@ -920,7 +919,7 @@ RefPtr Parser::parse_as_rule() template RefPtr Parser::parse_as_rule(TokenStream& tokens) { - dbgln_if(CSS_PARSER_TRACE, "Parser::parse_as_rule"); + dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_as_rule"); RefPtr rule; @@ -959,7 +958,7 @@ NonnullRefPtrVector Parser::parse_as_list_of_rules() template NonnullRefPtrVector Parser::parse_as_list_of_rules(TokenStream& 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 rules; @@ -981,7 +980,7 @@ Optional Parser::parse_as_declaration() template Optional Parser::parse_as_declaration(TokenStream& 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 Parser::parse_as_list_of_declarations() template RefPtr Parser::parse_as_list_of_declarations(TokenStream& 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 Parser::parse_as_component_value() template Optional Parser::parse_as_component_value(TokenStream& 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 Parser::parse_as_list_of_component_values() template Vector Parser::parse_as_list_of_component_values(TokenStream& 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 rules; @@ -1096,7 +1095,7 @@ Vector> Parser::parse_as_comma_separated_list_of template Vector> Parser::parse_as_comma_separated_list_of_component_values(TokenStream& 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> lists; lists.append({}); @@ -1146,7 +1145,7 @@ Optional Parser::parse_url_function(ParsingContext const& context, StyleCom RefPtr Parser::convert_to_rule(NonnullRefPtr 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 Parser::convert_to_rule(NonnullRefPtr rule) RefPtr Parser::convert_to_declaration(NonnullRefPtr 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 Parser::convert_to_declaration(NonnullRefPtr 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 Parser::parse_image_value(ParsingContext const& context, Styl RefPtr Parser::parse_css_value(PropertyID property_id, TokenStream& tokens) { - dbgln_if(CSS_PARSER_TRACE, "Parser::parse_css_value"); + dbgln_if(CSS_PARSER_DEBUG, "Parser::parse_css_value"); Vector component_values; @@ -1663,7 +1662,7 @@ RefPtr Parser::parse_css_value(PropertyID property_id, TokenStream 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 Parser::parse_css_value(ParsingContext const& context, Proper Optional Parser::parse_nth_child_pattern(TokenStream& 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; diff --git a/Userland/Libraries/LibWeb/CSS/Parser/Tokenizer.cpp b/Userland/Libraries/LibWeb/CSS/Parser/Tokenizer.cpp index 4e7d53cdc6..87c51ae0b7 100644 --- a/Userland/Libraries/LibWeb/CSS/Parser/Tokenizer.cpp +++ b/Userland/Libraries/LibWeb/CSS/Parser/Tokenizer.cpp @@ -5,20 +5,19 @@ */ #include +#include #include #include #include #include -#define CSS_TOKENIZER_TRACE 0 - //U+FFFD REPLACEMENT CHARACTER (�) #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); }