Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/CSS/Parser/Parser.h

288 lines
15 KiB
C
Raw Normal View History

LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
/*
Everywhere: Use "the SerenityOS developers." in copyright headers We had some inconsistencies before: - Sometimes "The", sometimes "the" - Sometimes trailing ".", sometimes no trailing "." I picked the most common one (lowecase "the", trailing ".") and applied it to all copyright headers. By using the exact same string everywhere we can ensure nothing gets missed during a global search (and replace), and that these inconsistencies are not spread any further (as copyright headers are commonly copied to new files).
2021-04-28 22:46:44 +02:00
* Copyright (c) 2020-2021, the SerenityOS developers.
Everywhere: Use my shiny new serenityos.org email :^)
2021-09-03 11:14:37 +01:00
* Copyright (c) 2021, Sam Atkins <atkinssj@serenityos.org>
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
*/
#pragma once
#include <AK/NonnullOwnPtrVector.h>
LibWeb: Make CSS::Selector reference counted The end goal is to make the PseudoClass::not_selector be a Selector instead of a String that is repeatedly re-parsed. But since Selector contains a Vector of ComplexSelectors, which each have a Vector of SimpleSelectors, it's probably a good idea to not be passing them around by value anyway. :^)
2021-07-12 17:30:40 +01:00
#include <AK/NonnullRefPtrVector.h>
#include <AK/RefPtr.h>
LibWeb: Parse CSS selectors according to the spec The spec does not directly tell us how to parse selectors, so there are likely some bugs here, but I've used the spec language where possible. This is very much based on the previous selector parsing code. Any parse error inside a selector makes the entire SelectorList invalid, so nothing is returned.
2021-07-23 16:13:07 +01:00
#include <AK/Result.h>
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
#include <AK/Vector.h>
LibWeb: Parse CSS `Supports` ... according to https://www.w3.org/TR/css-conditional-3/#typedef-supports-condition This works very similarly to `@media`, but is different enough to require its own parsing. (Though, the draft of Conditional-4 currently mentions combining the two into a `@when` rule.) Made some small changes to parsing code to make this work. Notably, making `consume_a_declaration()` fail gracefully instead of `VERIFY()`ing.
2021-10-08 15:54:16 +01:00
#include <LibWeb/CSS/CSSStyleDeclaration.h>
LibWeb: Sketch out media-query parsing This does everything except actually parse the individual media queries.
2021-09-29 12:56:37 +01:00
#include <LibWeb/CSS/MediaQuery.h>
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
#include <LibWeb/CSS/Parser/DeclarationOrAtRule.h>
#include <LibWeb/CSS/Parser/StyleBlockRule.h>
#include <LibWeb/CSS/Parser/StyleComponentValueRule.h>
#include <LibWeb/CSS/Parser/StyleDeclarationRule.h>
#include <LibWeb/CSS/Parser/StyleFunctionRule.h>
LibWeb: Merge CSS Parser's QualifiedStyleRule and AtStyleRule AtStyleRule being a subclass of QualifiedStyleRule was causing problems when trying to distinguish between them. Combining them and then distinguishing between them with a Type enum makes that check simpler, and is in line with how similar checks are done elsewhere in the parser.
2021-07-03 13:36:33 +01:00
#include <LibWeb/CSS/Parser/StyleRule.h>
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
#include <LibWeb/CSS/Parser/Tokenizer.h>
#include <LibWeb/CSS/Selector.h>
LibWeb: Expose StyleValue parsing method in CSS Parser Now that StyleResolver is going to deal with StyleComponentValueRules, it will need to be able to parse those into StyleValues, using `parse_css_value()`. Also added StyleValue::is_builtin_or_dynamic(), which returns true for values that are valid anywhere - things like `initial` and `inherit`, along with `var()`, `attr()` and `calc()` - which we want to test for easily.
2021-07-18 17:12:23 +01:00
#include <LibWeb/CSS/StyleValue.h>
LibWeb: Parse CSS `Supports` ... according to https://www.w3.org/TR/css-conditional-3/#typedef-supports-condition This works very similarly to `@media`, but is different enough to require its own parsing. (Though, the draft of Conditional-4 currently mentions combining the two into a `@when` rule.) Made some small changes to parsing code to make this work. Notably, making `consume_a_declaration()` fail gracefully instead of `VERIFY()`ing.
2021-10-08 15:54:16 +01:00
#include <LibWeb/CSS/Supports.h>
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
namespace Web::CSS {
LibWeb: Convert CSS::Parser methods to return desired types This is very much stubbed out for now. Most notably is Parser::convert_rule() where most of the conversion will happen from the parser's internal rule classes to CSSRule and its children.
2021-07-09 16:34:29 +01:00
class CSSStyleSheet;
class CSSRule;
class CSSStyleRule;
struct StyleProperty;
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
enum class PropertyID;
LibWeb: Convert CSS::Parser methods to return desired types This is very much stubbed out for now. Most notably is Parser::convert_rule() where most of the conversion will happen from the parser's internal rule classes to CSSRule and its children.
2021-07-09 16:34:29 +01:00
LibWeb: Add context to new CSS parser, and deprecate the old one The new one is the same as the old one, just in the new Parser's source files. This isn't the most elegant solution but it seemed like the best option. And it's all temporary, after all.
2021-07-02 20:25:13 +01:00
class ParsingContext {
public:
LibWeb: Use default instead of an empty constructor/destructor Default implementations allow for more optimizations. See: https://pvs-studio.com/en/docs/warnings/v832/
2021-09-15 23:24:47 -07:00
ParsingContext() = default;
LibWeb: Make CSS ParsingContext's Document* be const The only reason it wasn't const before (and why we had a const_cast hack) was to support ImageStyleValue's constructor taking it, which no longer applies. `hack_count--;` :^)
2021-10-22 20:59:45 +01:00
explicit ParsingContext(DOM::Document const&);
LibWeb: Implement ImageStyleValue parsing Later we will want to make a distinction between URL and Image values, but this works for now.
2021-07-22 13:00:29 +01:00
explicit ParsingContext(DOM::ParentNode&);
LibWeb: Add context to new CSS parser, and deprecate the old one The new one is the same as the old one, just in the new Parser's source files. This isn't the most elegant solution but it seemed like the best option. And it's all temporary, after all.
2021-07-02 20:25:13 +01:00
bool in_quirks_mode() const;
LibWeb: Make CSS ParsingContext's Document* be const The only reason it wasn't const before (and why we had a const_cast hack) was to support ImageStyleValue's constructor taking it, which no longer applies. `hack_count--;` :^)
2021-10-22 20:59:45 +01:00
DOM::Document const* document() const { return m_document; }
LibWeb: Add the Web::URL namespace and move URLEncoder to it This namespace will be used for all interfaces defined in the URL specification, like URL and URLSearchParams. This has the unfortunate side-effect of requiring us to use the fully qualified AK::URL name whenever we want to refer to the AK class, so this commit also fixes all such references.
2021-09-13 00:33:23 +03:00
AK::URL complete_url(String const&) const;
LibWeb: Add context to new CSS parser, and deprecate the old one The new one is the same as the old one, just in the new Parser's source files. This isn't the most elegant solution but it seemed like the best option. And it's all temporary, after all.
2021-07-02 20:25:13 +01:00
LibWeb: Add current_property_id to CSS ParsingContext After `parse_css_value(PropertyID, TokenStream)`, we only need to know the current PropertyID when checking for property-specific quirks, which will take place in only 2 places, which happen deep down. Making the current PropertyID part of the context means that those places can check it easily, without us having to pass it to every one of the parsing functions, which otherwise do not care.
2021-09-11 20:39:44 +01:00
PropertyID current_property_id() const { return m_current_property_id; }
void set_current_property_id(PropertyID property_id) { m_current_property_id = property_id; }
LibWeb: Add context to new CSS parser, and deprecate the old one The new one is the same as the old one, just in the new Parser's source files. This isn't the most elegant solution but it seemed like the best option. And it's all temporary, after all.
2021-07-02 20:25:13 +01:00
private:
LibWeb: Make CSS ParsingContext's Document* be const The only reason it wasn't const before (and why we had a const_cast hack) was to support ImageStyleValue's constructor taking it, which no longer applies. `hack_count--;` :^)
2021-10-22 20:59:45 +01:00
DOM::Document const* m_document { nullptr };
LibWeb: Add current_property_id to CSS ParsingContext After `parse_css_value(PropertyID, TokenStream)`, we only need to know the current PropertyID when checking for property-specific quirks, which will take place in only 2 places, which happen deep down. Making the current PropertyID part of the context means that those places can check it easily, without us having to pass it to every one of the parsing functions, which otherwise do not care.
2021-09-11 20:39:44 +01:00
PropertyID m_current_property_id { PropertyID::Invalid };
LibWeb: Add context to new CSS parser, and deprecate the old one The new one is the same as the old one, just in the new Parser's source files. This isn't the most elegant solution but it seemed like the best option. And it's all temporary, after all.
2021-07-02 20:25:13 +01:00
};
LibWeb: Add TokenStream class to CSS Parser The entry points for CSS parsing in the spec are defined as accepting any of a stream of Tokens, or a stream of ComponentValues, or a String. TokenStream is an attempt to reduce the duplication of code for that.
2021-07-03 14:00:41 +01:00
template<typename T>
class TokenStream {
public:
explicit TokenStream(Vector<T> const&);
~TokenStream();
bool has_next_token();
T const& next_token();
LibWeb: Allow peeking more than 1 token ahead in CSS Parser
2021-07-28 16:27:45 +01:00
T const& peek_token(int offset = 0);
LibWeb: Add TokenStream class to CSS Parser The entry points for CSS parsing in the spec are defined as accepting any of a stream of Tokens, or a stream of ComponentValues, or a String. TokenStream is an attempt to reduce the duplication of code for that.
2021-07-03 14:00:41 +01:00
T const& current_token();
void reconsume_current_input_token();
LibWeb: Add TokenStream::rewind_to_position() Parsing media queries sometimes requires significant back-tracking, so `reconsume_current_input_token()` was not good enough. `rewind_to_position()` lets you reconsume an erbitrary number of tokens to return to an earlier point in the stream, which you previously saved from `TokenStream::position()`.
2021-09-30 17:17:21 +01:00
int position() const { return m_iterator_offset; }
void rewind_to_position(int);
LibWeb: Add TokenStream class to CSS Parser The entry points for CSS parsing in the spec are defined as accepting any of a stream of Tokens, or a stream of ComponentValues, or a String. TokenStream is an attempt to reduce the duplication of code for that.
2021-07-03 14:00:41 +01:00
void skip_whitespace();
void dump_all_tokens();
private:
Vector<T> const& m_tokens;
int m_iterator_offset { -1 };
T make_eof();
T m_eof;
};
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
class Parser {
public:
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
Parser(ParsingContext const&, StringView input, String const& encoding = "utf-8");
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
~Parser();
// The normal parser entry point, for parsing stylesheets.
LibWeb: Convert CSS::Parser methods to return desired types This is very much stubbed out for now. Most notably is Parser::convert_rule() where most of the conversion will happen from the parser's internal rule classes to CSSRule and its children.
2021-07-09 16:34:29 +01:00
NonnullRefPtr<CSSStyleSheet> parse_as_stylesheet();
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
// For the content of at-rules such as @media. It differs from "Parse a stylesheet" in the handling of <CDO-token> and <CDC-token>.
LibWeb: Convert CSS::Parser methods to return desired types This is very much stubbed out for now. Most notably is Parser::convert_rule() where most of the conversion will happen from the parser's internal rule classes to CSSRule and its children.
2021-07-09 16:34:29 +01:00
NonnullRefPtrVector<CSSRule> parse_as_list_of_rules();
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
// For use by the CSSStyleSheet#insertRule method, and similar functions which might exist, which parse text into a single rule.
LibWeb: Convert CSS::Parser methods to return desired types This is very much stubbed out for now. Most notably is Parser::convert_rule() where most of the conversion will happen from the parser's internal rule classes to CSSRule and its children.
2021-07-09 16:34:29 +01:00
RefPtr<CSSRule> parse_as_rule();
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
// Used in @supports conditions. [CSS3-CONDITIONAL]
LibWeb: Convert CSS::Parser methods to return desired types This is very much stubbed out for now. Most notably is Parser::convert_rule() where most of the conversion will happen from the parser's internal rule classes to CSSRule and its children.
2021-07-09 16:34:29 +01:00
Optional<StyleProperty> parse_as_declaration();
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
// For the contents of a style attribute, which parses text into the contents of a single style rule.
LibWeb: Make CSSStyleDeclaration an abstract class This patch moves the CSS property+value storage down to a new subclass of CSSStyleDeclaration called PropertyOwningCSSStyleDeclaration. The JavaScript wrapper for CSSStyleDeclaration now calls virtual functions on the C++ object. This is preparation for supporting computed style CSSStyleDeclaration objects which won't have internal property storage, but rather an internal element pointer. :^)
2021-09-12 19:24:01 +02:00
RefPtr<PropertyOwningCSSStyleDeclaration> parse_as_list_of_declarations();
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
// For things that need to consume a single value, like the parsing rules for attr().
Optional<StyleComponentValueRule> parse_as_component_value();
// For the contents of presentational attributes, which parse text into a single declaration’s value, or for parsing a stand-alone selector [SELECT] or list of Media Queries [MEDIAQ], as in Selectors API or the media HTML attribute.
Vector<StyleComponentValueRule> parse_as_list_of_component_values();
LibWeb: Bring CSS::Parser::parse_as_comma_separated_list...() to spec Previous implementation was returning everything in a single Vector, when what we really want is a Vector of Vectors, one for each comma- separated part of the list.
2021-07-02 19:52:07 +01:00
Vector<Vector<StyleComponentValueRule>> parse_as_comma_separated_list_of_component_values();
LibWeb: Implement CSS::Parse::parse_nth_child_pattern() This is a modified copy of the code from Selector.cpp, to work on a TokenStream instead of a String.
2021-07-08 13:44:01 +01:00
LibWeb: Implement CSS selector parsing entry points They're still using the same parsing code, so there's a lot of room for improvement, but it's good for now.
2021-07-03 12:34:25 +01:00
// Contrary to the name, these parse a comma-separated list of selectors, according to the spec.
LibWeb: Clarify naming and publicity of CSS Parser methods `parse_as_foo()` implies that the Parser's internal data is used, whereas `parse_a_foo()` implies that the passed-in data is used. Also, made all the `parse_a_foo()` methods private, as they are only required within the Parser, and this makes the API clearer to outsiders. The `parse_a(s)_foo()` naming is a little awkward, but it comes from section 5.3 of the spec, so seemed worth keeping: https://www.w3.org/TR/css-syntax-3/#parser-entry-points
2021-07-30 17:06:48 +01:00
Optional<SelectorList> parse_as_selector();
Optional<SelectorList> parse_as_relative_selector();
LibWeb: Sketch out media-query parsing This does everything except actually parse the individual media queries.
2021-09-29 12:56:37 +01:00
NonnullRefPtrVector<MediaQuery> parse_as_media_query_list();
RefPtr<MediaQuery> parse_as_media_query();
LibWeb: Parse CSS `Supports` ... according to https://www.w3.org/TR/css-conditional-3/#typedef-supports-condition This works very similarly to `@media`, but is different enough to require its own parsing. (Though, the draft of Conditional-4 currently mentions combining the two into a `@when` rule.) Made some small changes to parsing code to make this work. Notably, making `consume_a_declaration()` fail gracefully instead of `VERIFY()`ing.
2021-10-08 15:54:16 +01:00
RefPtr<Supports> parse_as_supports();
LibWeb: Implement CSS parsing convenience functions These mostly match the API in `DeprecatedCSSParser.h`. The exception is that `parse_selector()` returns a `SelectorList` instead of just one `Selector`. The only uses of that are in `ParentNode::query_selector[_all]()` which should be matching against a list, according to the spec. `parse_html_length()` is an odd case. It's used for `width="200"` cases in HTML, so is not really CSS related, but does produce a StyleValue. The values allowed in `width/height` in HTML vary per element, but they are a lot more restricted than in CSS, so it's slightly inappropriate to use the CSS parser for them, even though it's convenient. We also ignore a few functions: - `parse_line_width()` - `parse_line_style()` - `parse_color()` These are all only used in `StyleResolver`, when it is given a property value as a String. That won't happen once the old parser is removed.
2021-07-30 17:48:23 +01:00
RefPtr<StyleValue> parse_as_css_value(PropertyID);
LibWeb: Add CSS 'Supports' class The name is a little awkward, but this corresponds to the condition of a `@supports` rule or the `CSS.supports("")` function. A supports query only gets evaluated once, since its condition cannot change during runtime. (We either support something or we don't, and the spec specifically mentions that user preferences that disable features do not affect the result here.) We keep a representation of it around though, so that it can be serialized if needed. This is a little awkward since we hold onto a `StyleDeclarationRule` which should be an internal Parser class. This means making some Parser functions more public. Potentially we could evaluate the Supports inside the Parser, and have it only store a String representation of itself. But this works for now. :^)
2021-10-08 15:40:19 +01:00
// FIXME: This is a hack, while CSS::Supports is using a StyleDeclarationRule
[[nodiscard]] Optional<StyleProperty> convert_to_style_property(StyleDeclarationRule const&);
LibWeb: Clarify naming and publicity of CSS Parser methods `parse_as_foo()` implies that the Parser's internal data is used, whereas `parse_a_foo()` implies that the passed-in data is used. Also, made all the `parse_a_foo()` methods private, as they are only required within the Parser, and this makes the API clearer to outsiders. The `parse_a(s)_foo()` naming is a little awkward, but it comes from section 5.3 of the spec, so seemed worth keeping: https://www.w3.org/TR/css-syntax-3/#parser-entry-points
2021-07-30 17:06:48 +01:00
private:
LibWeb: Rename CSS::Parser::SelectorParsingResult => ParsingResult I'm going to use it for non-selector purposes too, so the name needed to change.
2021-09-12 19:29:47 +01:00
enum class ParsingResult {
LibWeb: Return SelectorParsingResult from all selector parsing functions This will allow us to know why a selector failed to parse, in situations where that matters. (Like, when a selector includes vendor prefixes...)
2021-09-12 17:42:11 +01:00
Done,
LibWeb: Ignore vendor-prefixed pseudo-element/classes in selectors Our debug logging when we fail to parse a legitimate selector, is less useful when it's hidden among selectors that don't parse because they contain vendor-prefixed pseudo-elements and classes. So, now we specifically ignore these and don't produce a log message.
2021-09-12 17:47:58 +01:00
IncludesIgnoredVendorPrefix,
LibWeb: Return SelectorParsingResult from all selector parsing functions This will allow us to know why a selector failed to parse, in situations where that matters. (Like, when a selector includes vendor prefixes...)
2021-09-12 17:42:11 +01:00
SyntaxError,
};
LibWeb: Clarify naming and publicity of CSS Parser methods `parse_as_foo()` implies that the Parser's internal data is used, whereas `parse_a_foo()` implies that the passed-in data is used. Also, made all the `parse_a_foo()` methods private, as they are only required within the Parser, and this makes the API clearer to outsiders. The `parse_a(s)_foo()` naming is a little awkward, but it comes from section 5.3 of the spec, so seemed worth keeping: https://www.w3.org/TR/css-syntax-3/#parser-entry-points
2021-07-30 17:06:48 +01:00
template<typename T>
NonnullRefPtr<CSSStyleSheet> parse_a_stylesheet(TokenStream<T>&);
template<typename T>
NonnullRefPtrVector<CSSRule> parse_a_list_of_rules(TokenStream<T>&);
template<typename T>
RefPtr<CSSRule> parse_a_rule(TokenStream<T>&);
template<typename T>
Optional<StyleProperty> parse_a_declaration(TokenStream<T>&);
template<typename T>
LibWeb: Make CSSStyleDeclaration an abstract class This patch moves the CSS property+value storage down to a new subclass of CSSStyleDeclaration called PropertyOwningCSSStyleDeclaration. The JavaScript wrapper for CSSStyleDeclaration now calls virtual functions on the C++ object. This is preparation for supporting computed style CSSStyleDeclaration objects which won't have internal property storage, but rather an internal element pointer. :^)
2021-09-12 19:24:01 +02:00
RefPtr<PropertyOwningCSSStyleDeclaration> parse_a_list_of_declarations(TokenStream<T>&);
LibWeb: Clarify naming and publicity of CSS Parser methods `parse_as_foo()` implies that the Parser's internal data is used, whereas `parse_a_foo()` implies that the passed-in data is used. Also, made all the `parse_a_foo()` methods private, as they are only required within the Parser, and this makes the API clearer to outsiders. The `parse_a(s)_foo()` naming is a little awkward, but it comes from section 5.3 of the spec, so seemed worth keeping: https://www.w3.org/TR/css-syntax-3/#parser-entry-points
2021-07-30 17:06:48 +01:00
template<typename T>
Optional<StyleComponentValueRule> parse_a_component_value(TokenStream<T>&);
template<typename T>
Vector<StyleComponentValueRule> parse_a_list_of_component_values(TokenStream<T>&);
template<typename T>
Vector<Vector<StyleComponentValueRule>> parse_a_comma_separated_list_of_component_values(TokenStream<T>&);
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
template<typename T>
LibWeb: Rename CSS::Parser::SelectorParsingResult => ParsingResult I'm going to use it for non-selector purposes too, so the name needed to change.
2021-09-12 19:29:47 +01:00
Result<SelectorList, ParsingResult> parse_a_selector(TokenStream<T>&);
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
template<typename T>
LibWeb: Rename CSS::Parser::SelectorParsingResult => ParsingResult I'm going to use it for non-selector purposes too, so the name needed to change.
2021-09-12 19:29:47 +01:00
Result<SelectorList, ParsingResult> parse_a_relative_selector(TokenStream<T>&);
LibWeb: Clarify naming and publicity of CSS Parser methods `parse_as_foo()` implies that the Parser's internal data is used, whereas `parse_a_foo()` implies that the passed-in data is used. Also, made all the `parse_a_foo()` methods private, as they are only required within the Parser, and this makes the API clearer to outsiders. The `parse_a(s)_foo()` naming is a little awkward, but it comes from section 5.3 of the spec, so seemed worth keeping: https://www.w3.org/TR/css-syntax-3/#parser-entry-points
2021-07-30 17:06:48 +01:00
template<typename T>
LibWeb: Rename CSS::Parser::SelectorParsingResult => ParsingResult I'm going to use it for non-selector purposes too, so the name needed to change.
2021-09-12 19:29:47 +01:00
Result<SelectorList, ParsingResult> parse_a_selector_list(TokenStream<T>&);
LibWeb: Clarify naming and publicity of CSS Parser methods `parse_as_foo()` implies that the Parser's internal data is used, whereas `parse_a_foo()` implies that the passed-in data is used. Also, made all the `parse_a_foo()` methods private, as they are only required within the Parser, and this makes the API clearer to outsiders. The `parse_a(s)_foo()` naming is a little awkward, but it comes from section 5.3 of the spec, so seemed worth keeping: https://www.w3.org/TR/css-syntax-3/#parser-entry-points
2021-07-30 17:06:48 +01:00
template<typename T>
LibWeb: Rename CSS::Parser::SelectorParsingResult => ParsingResult I'm going to use it for non-selector purposes too, so the name needed to change.
2021-09-12 19:29:47 +01:00
Result<SelectorList, ParsingResult> parse_a_relative_selector_list(TokenStream<T>&);
LibWeb: Sketch out media-query parsing This does everything except actually parse the individual media queries.
2021-09-29 12:56:37 +01:00
template<typename T>
NonnullRefPtrVector<MediaQuery> parse_a_media_query_list(TokenStream<T>&);
LibWeb: Parse CSS `Supports` ... according to https://www.w3.org/TR/css-conditional-3/#typedef-supports-condition This works very similarly to `@media`, but is different enough to require its own parsing. (Though, the draft of Conditional-4 currently mentions combining the two into a `@when` rule.) Made some small changes to parsing code to make this work. Notably, making `consume_a_declaration()` fail gracefully instead of `VERIFY()`ing.
2021-10-08 15:54:16 +01:00
template<typename T>
RefPtr<Supports> parse_a_supports(TokenStream<T>&);
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
LibWeb: Clarify naming and publicity of CSS Parser methods `parse_as_foo()` implies that the Parser's internal data is used, whereas `parse_a_foo()` implies that the passed-in data is used. Also, made all the `parse_a_foo()` methods private, as they are only required within the Parser, and this makes the API clearer to outsiders. The `parse_a(s)_foo()` naming is a little awkward, but it comes from section 5.3 of the spec, so seemed worth keeping: https://www.w3.org/TR/css-syntax-3/#parser-entry-points
2021-07-30 17:06:48 +01:00
Optional<Selector::SimpleSelector::ANPlusBPattern> parse_a_n_plus_b_pattern(TokenStream<StyleComponentValueRule>&);
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
[[nodiscard]] NonnullRefPtrVector<StyleRule> consume_a_list_of_rules(bool top_level);
template<typename T>
[[nodiscard]] NonnullRefPtrVector<StyleRule> consume_a_list_of_rules(TokenStream<T>&, bool top_level);
[[nodiscard]] NonnullRefPtr<StyleRule> consume_an_at_rule();
template<typename T>
[[nodiscard]] NonnullRefPtr<StyleRule> consume_an_at_rule(TokenStream<T>&);
[[nodiscard]] RefPtr<StyleRule> consume_a_qualified_rule();
template<typename T>
[[nodiscard]] RefPtr<StyleRule> consume_a_qualified_rule(TokenStream<T>&);
[[nodiscard]] Vector<DeclarationOrAtRule> consume_a_list_of_declarations();
template<typename T>
[[nodiscard]] Vector<DeclarationOrAtRule> consume_a_list_of_declarations(TokenStream<T>&);
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] Optional<StyleDeclarationRule> consume_a_declaration();
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
template<typename T>
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] Optional<StyleDeclarationRule> consume_a_declaration(TokenStream<T>&);
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] StyleComponentValueRule consume_a_component_value();
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
template<typename T>
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] StyleComponentValueRule consume_a_component_value(TokenStream<T>&);
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] NonnullRefPtr<StyleBlockRule> consume_a_simple_block();
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
template<typename T>
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] NonnullRefPtr<StyleBlockRule> consume_a_simple_block(TokenStream<T>&);
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] NonnullRefPtr<StyleFunctionRule> consume_a_function();
LibWeb: Use TokenStream in CSS Parser Each method can either be called with a TokenStream, or with no arguments to replicate the previous behaviour.
2021-07-03 15:40:06 +01:00
template<typename T>
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] NonnullRefPtr<StyleFunctionRule> consume_a_function(TokenStream<T>&);
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
LibWeb: Parse CSS `Supports` ... according to https://www.w3.org/TR/css-conditional-3/#typedef-supports-condition This works very similarly to `@media`, but is different enough to require its own parsing. (Though, the draft of Conditional-4 currently mentions combining the two into a `@when` rule.) Made some small changes to parsing code to make this work. Notably, making `consume_a_declaration()` fail gracefully instead of `VERIFY()`ing.
2021-10-08 15:54:16 +01:00
struct GeneralEnclosed {
};
[[nodiscard]] Optional<GeneralEnclosed> parse_general_enclosed();
template<typename T>
[[nodiscard]] Optional<GeneralEnclosed> parse_general_enclosed(TokenStream<T>&);
LibWeb: Convert style declarations and at rules into CSSRules
2021-07-08 21:53:22 +01:00
[[nodiscard]] RefPtr<CSSRule> convert_to_rule(NonnullRefPtr<StyleRule>);
LibWeb: Make CSSStyleDeclaration an abstract class This patch moves the CSS property+value storage down to a new subclass of CSSStyleDeclaration called PropertyOwningCSSStyleDeclaration. The JavaScript wrapper for CSSStyleDeclaration now calls virtual functions on the C++ object. This is preparation for supporting computed style CSSStyleDeclaration objects which won't have internal property storage, but rather an internal element pointer. :^)
2021-09-12 19:24:01 +02:00
[[nodiscard]] RefPtr<PropertyOwningCSSStyleDeclaration> convert_to_declaration(NonnullRefPtr<StyleBlockRule>);
LibWeb: Convert CSS::Parser methods to return desired types This is very much stubbed out for now. Most notably is Parser::convert_rule() where most of the conversion will happen from the parser's internal rule classes to CSSRule and its children.
2021-07-09 16:34:29 +01:00
LibWeb: Make CSS Parser methods non-static Past me thought making as much static as possible was a good idea, but it just makes things more verbose, and awkward if anything isn't also static.
2021-11-05 17:33:11 +00:00
Optional<float> try_parse_float(StringView string);
Optional<Color> parse_color(ParsingContext const&, StyleComponentValueRule const&);
Optional<Length> parse_length(ParsingContext const&, StyleComponentValueRule const&);
LibWeb: Support parsing some data: URLs in CSS For now, data URLs are explicitly limited to expected MIME types. For example, image-related styles accept image MIME types.
2021-10-29 08:38:50 -04:00
enum class AllowedDataUrlType {
None,
Image,
};
LibWeb: Make CSS Parser methods non-static Past me thought making as much static as possible was a good idea, but it just makes things more verbose, and awkward if anything isn't also static.
2021-11-05 17:33:11 +00:00
Optional<AK::URL> parse_url_function(ParsingContext const&, StyleComponentValueRule const&, AllowedDataUrlType = AllowedDataUrlType::None);
LibWeb: Implement CSS::parse_css_value() A lot of this is not spec-compliant and copied from the old parser. In future PRs, we can revise it.
2021-07-09 21:04:34 +01:00
LibWeb: Ignore CSS properties with vendor-prefixed values For example, this CSS previously produced a lot of log spam about the `display` properties having invalid values: ```css .foo { display: -webkit-box; display: -moz-box; display: -ms-flexbox; display: -webkit-flex; display: flex; } ``` Now, it just ignores them, because we don't need to know about it. :^)
2021-09-12 19:44:35 +01:00
Result<NonnullRefPtr<StyleValue>, ParsingResult> parse_css_value(PropertyID, TokenStream<StyleComponentValueRule>&);
LibWeb: Make CSS Parser methods non-static Past me thought making as much static as possible was a good idea, but it just makes things more verbose, and awkward if anything isn't also static.
2021-11-05 17:33:11 +00:00
RefPtr<StyleValue> parse_css_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_builtin_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_dynamic_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_length_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_numeric_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_identifier_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_color_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_string_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_image_value(ParsingContext const&, StyleComponentValueRule const&);
RefPtr<StyleValue> parse_background_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_background_image_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_single_background_position_value(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
RefPtr<StyleValue> parse_background_position_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_single_background_repeat_value(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
RefPtr<StyleValue> parse_background_repeat_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_single_background_size_value(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
RefPtr<StyleValue> parse_background_size_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_border_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_border_radius_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_border_radius_shorthand_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_box_shadow_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_flex_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_flex_flow_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_font_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_font_family_value(ParsingContext const&, Vector<StyleComponentValueRule> const&, size_t start_index = 0);
RefPtr<StyleValue> parse_list_style_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_overflow_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_text_decoration_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
RefPtr<StyleValue> parse_transform_value(ParsingContext const&, Vector<StyleComponentValueRule> const&);
LibWeb: Generate a ValueListStyleValue when parsing CSS values We skip whitespace tokens while doing this. As far as I can tell, whitespace is not useful once we get to this point, and it legally may or may not appear between any two tokens. By not including it in the ValueListStyleValue, we make the "if it has 3 parts"-type checks a lot more straightforward.
2021-07-14 16:20:06 +01:00
LibWeb: Parse calc() values in new CSS Parser This is a port of the code from DeprecatedCSSParser, to work with CSS Tokens and TokenStream. I've modified it as little as possible.
2021-07-28 16:30:59 +01:00
// calc() parsing, according to https://www.w3.org/TR/css-values-3/#calc-syntax
LibWeb: Make CSS Parser methods non-static Past me thought making as much static as possible was a good idea, but it just makes things more verbose, and awkward if anything isn't also static.
2021-11-05 17:33:11 +00:00
OwnPtr<CalculatedStyleValue::CalcSum> parse_calc_sum(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
OwnPtr<CalculatedStyleValue::CalcProduct> parse_calc_product(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
Optional<CalculatedStyleValue::CalcValue> parse_calc_value(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
OwnPtr<CalculatedStyleValue::CalcNumberSum> parse_calc_number_sum(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
OwnPtr<CalculatedStyleValue::CalcNumberProduct> parse_calc_number_product(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
Optional<CalculatedStyleValue::CalcNumberValue> parse_calc_number_value(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
OwnPtr<CalculatedStyleValue::CalcProductPartWithOperator> parse_calc_product_part_with_operator(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
OwnPtr<CalculatedStyleValue::CalcSumPartWithOperator> parse_calc_sum_part_with_operator(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
OwnPtr<CalculatedStyleValue::CalcNumberProductPartWithOperator> parse_calc_number_product_part_with_operator(ParsingContext const&, TokenStream<StyleComponentValueRule>& tokens);
OwnPtr<CalculatedStyleValue::CalcNumberSumPartWithOperator> parse_calc_number_sum_part_with_operator(ParsingContext const&, TokenStream<StyleComponentValueRule>&);
OwnPtr<CalculatedStyleValue::CalcSum> parse_calc_expression(ParsingContext const&, Vector<StyleComponentValueRule> const&);
LibWeb: Parse calc() values in new CSS Parser This is a port of the code from DeprecatedCSSParser, to work with CSS Tokens and TokenStream. I've modified it as little as possible.
2021-07-28 16:30:59 +01:00
LibWeb: Rename CSS::Parser::SelectorParsingResult => ParsingResult I'm going to use it for non-selector purposes too, so the name needed to change.
2021-09-12 19:29:47 +01:00
Result<NonnullRefPtr<Selector>, ParsingResult> parse_complex_selector(TokenStream<StyleComponentValueRule>&, bool allow_starting_combinator);
Result<Selector::CompoundSelector, ParsingResult> parse_compound_selector(TokenStream<StyleComponentValueRule>&);
LibWeb: Parse CSS selectors according to the spec The spec does not directly tell us how to parse selectors, so there are likely some bugs here, but I've used the spec language where possible. This is very much based on the previous selector parsing code. Any parse error inside a selector makes the entire SelectorList invalid, so nothing is returned.
2021-07-23 16:13:07 +01:00
Optional<Selector::Combinator> parse_selector_combinator(TokenStream<StyleComponentValueRule>&);
LibWeb: Rename CSS::Parser::SelectorParsingResult => ParsingResult I'm going to use it for non-selector purposes too, so the name needed to change.
2021-09-12 19:29:47 +01:00
Result<Selector::SimpleSelector, ParsingResult> parse_simple_selector(TokenStream<StyleComponentValueRule>&);
LibWeb: Parse CSS selectors according to the spec The spec does not directly tell us how to parse selectors, so there are likely some bugs here, but I've used the spec language where possible. This is very much based on the previous selector parsing code. Any parse error inside a selector makes the entire SelectorList invalid, so nothing is returned.
2021-07-23 16:13:07 +01:00
LibWeb: Parse media queries! :^) While not complete by any means, we are now compatible with the [level 3 spec](https://www.w3.org/TR/css3-mediaqueries/#syntax) and some parts of [level 4.](https://www.w3.org/TR/mediaqueries-4#mq-syntax) Compatibility with level 4+ requires: - Implementing the range syntax: `(800px <= width <= 1200px)` - Parsing `<general-enclosed>`, which represents syntax that is not yet used but they may use in the future.
2021-09-29 20:54:06 +01:00
NonnullRefPtr<MediaQuery> parse_media_query(TokenStream<StyleComponentValueRule>&);
OwnPtr<MediaQuery::MediaCondition> consume_media_condition(TokenStream<StyleComponentValueRule>&);
Optional<MediaQuery::MediaFeature> consume_media_feature(TokenStream<StyleComponentValueRule>&);
Optional<MediaQuery::MediaType> consume_media_type(TokenStream<StyleComponentValueRule>&);
LibWeb: Sketch out media-query parsing This does everything except actually parse the individual media queries.
2021-09-29 12:56:37 +01:00
LibWeb: Parse CSS `Supports` ... according to https://www.w3.org/TR/css-conditional-3/#typedef-supports-condition This works very similarly to `@media`, but is different enough to require its own parsing. (Though, the draft of Conditional-4 currently mentions combining the two into a `@when` rule.) Made some small changes to parsing code to make this work. Notably, making `consume_a_declaration()` fail gracefully instead of `VERIFY()`ing.
2021-10-08 15:54:16 +01:00
OwnPtr<Supports::Condition> parse_supports_condition(TokenStream<StyleComponentValueRule>&);
Optional<Supports::InParens> parse_supports_in_parens(TokenStream<StyleComponentValueRule>&);
Optional<Supports::Feature> parse_supports_feature(TokenStream<StyleComponentValueRule>&);
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
static bool has_ignored_vendor_prefix(StringView);
LibWeb: Ignore CSS properties with other people's vendor prefixes This removes some `Property '-webkit-foo' has no value.` log spam. :^)
2021-09-12 16:49:09 +01:00
LibWeb: Add context to new CSS parser, and deprecate the old one The new one is the same as the old one, just in the new Parser's source files. This isn't the most elegant solution but it seemed like the best option. And it's all temporary, after all.
2021-07-02 20:25:13 +01:00
ParsingContext m_context;
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
Tokenizer m_tokenizer;
Vector<Token> m_tokens;
LibWeb: Add TokenStream class to CSS Parser The entry points for CSS parsing in the spec are defined as accepting any of a stream of Tokens, or a stream of ComponentValues, or a String. TokenStream is an attempt to reduce the duplication of code for that.
2021-07-03 14:00:41 +01:00
TokenStream<Token> m_token_stream;
LibWeb: Import new CSS parser It's not finished or hooked up to anything yet, but let's get it into the tree so we can continue working on it. Original work by @stelar7.
2021-03-22 17:41:47 +01:00
};
}
LibWeb: Implement CSS parsing convenience functions These mostly match the API in `DeprecatedCSSParser.h`. The exception is that `parse_selector()` returns a `SelectorList` instead of just one `Selector`. The only uses of that are in `ParentNode::query_selector[_all]()` which should be matching against a list, according to the spec. `parse_html_length()` is an odd case. It's used for `width="200"` cases in HTML, so is not really CSS related, but does produce a StyleValue. The values allowed in `width/height` in HTML vary per element, but they are a lot more restricted than in CSS, so it's slightly inappropriate to use the CSS parser for them, even though it's convenient. We also ignore a few functions: - `parse_line_width()` - `parse_line_style()` - `parse_color()` These are all only used in `StyleResolver`, when it is given a property value as a String. That won't happen once the old parser is removed.
2021-07-30 17:48:23 +01:00
namespace Web {
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
RefPtr<CSS::CSSStyleSheet> parse_css(CSS::ParsingContext const&, StringView);
RefPtr<CSS::PropertyOwningCSSStyleDeclaration> parse_css_declaration(CSS::ParsingContext const&, StringView);
RefPtr<CSS::StyleValue> parse_css_value(CSS::ParsingContext const&, StringView, CSS::PropertyID property_id = CSS::PropertyID::Invalid);
Optional<CSS::SelectorList> parse_selector(CSS::ParsingContext const&, StringView);
LibWeb: Implement most of CSSStyleRule.insertRule()
2021-09-29 21:12:39 +02:00
RefPtr<CSS::CSSRule> parse_css_rule(CSS::ParsingContext const&, StringView);
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
RefPtr<CSS::MediaQuery> parse_media_query(CSS::ParsingContext const&, StringView);
NonnullRefPtrVector<CSS::MediaQuery> parse_media_query_list(CSS::ParsingContext const&, StringView);
RefPtr<CSS::Supports> parse_css_supports(CSS::ParsingContext const&, StringView);
LibWeb: Implement CSS parsing convenience functions These mostly match the API in `DeprecatedCSSParser.h`. The exception is that `parse_selector()` returns a `SelectorList` instead of just one `Selector`. The only uses of that are in `ParentNode::query_selector[_all]()` which should be matching against a list, according to the spec. `parse_html_length()` is an odd case. It's used for `width="200"` cases in HTML, so is not really CSS related, but does produce a StyleValue. The values allowed in `width/height` in HTML vary per element, but they are a lot more restricted than in CSS, so it's slightly inappropriate to use the CSS parser for them, even though it's convenient. We also ignore a few functions: - `parse_line_width()` - `parse_line_style()` - `parse_color()` These are all only used in `StyleResolver`, when it is given a property value as a String. That won't happen once the old parser is removed.
2021-07-30 17:48:23 +01:00
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
RefPtr<CSS::StyleValue> parse_html_length(DOM::Document const&, StringView);
LibWeb: Implement CSS parsing convenience functions These mostly match the API in `DeprecatedCSSParser.h`. The exception is that `parse_selector()` returns a `SelectorList` instead of just one `Selector`. The only uses of that are in `ParentNode::query_selector[_all]()` which should be matching against a list, according to the spec. `parse_html_length()` is an odd case. It's used for `width="200"` cases in HTML, so is not really CSS related, but does produce a StyleValue. The values allowed in `width/height` in HTML vary per element, but they are a lot more restricted than in CSS, so it's slightly inappropriate to use the CSS parser for them, even though it's convenient. We also ignore a few functions: - `parse_line_width()` - `parse_line_style()` - `parse_color()` These are all only used in `StyleResolver`, when it is given a property value as a String. That won't happen once the old parser is removed.
2021-07-30 17:48:23 +01:00
}
Reference in a new issue Copy permalink