dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / css / parser / value_parsing_8.lucb
#==============================================================================================
#
# value_parsing_8 - parsing CSS values: font-style and the font-variant-* values
#
# DESCRIPTION:
# Port of LibWeb/CSS/Parser/ValueParsing.cpp (lines 3601-3940): <'font-style'>,
# <'font-variant-alternates'> (its feature-value functions), and the keyword tuples of
# <'font-variant-east-asian'>, <'font-variant-numeric'> and <'font-variant-ligatures'>.
#
# Copyright (c) 2018-2024, Andreas Kling <andreas@ladybird.org>
# Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
# (the full list of ValueParsing.cpp's copyright holders is in value_parsing_1)
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: font-style ==============================================================================
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3601 Web::CSS::Parser::Parser::parse_font_style_value.
pub func css_parser_parse_font_style_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# https://drafts.csswg.org/css-fonts/#font-style-prop
# normal | italic | left | right | oblique <angle [-90deg,90deg]>?
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
let keyword_value = css_parser_parse_keyword_value(this, tokens) else return none
if css_data.keyword_to_font_style_keyword(css_style_value_to_keyword(keyword_value)) == none:
return none
let font_style = css_data.keyword_to_font_style_keyword(css_style_value_to_keyword(keyword_value)) else return none
if css_syntax.token_stream_has_next_token(tokens) and css_style_value_to_keyword(keyword_value) == css_data.Keyword.oblique:
if let angle_value = css_parser_parse_angle_value(this, tokens, CssNumericRange(min = -90.0, max = 90.0)):
css_syntax.state_transaction_commit(&transaction)
return css_font_style_style_value_create(font_style, angle_value).css_style_value()
css_syntax.state_transaction_commit(&transaction)
return css_font_style_style_value_create(font_style).css_style_value()
# mark: font-variant-alternates =================================================================
## `FunctionStyleValue::create(name, StyleValueList::create(move(feature_value_names), StyleValueList::Separator::Comma))`.
func css_feature_value_function(name: str, feature_value_names: ak.Vector[CssStyleValue*]) -> CssStyleValue*:
return css_function_style_value_create(ak.fly_string_from_str(name), css_style_value_list_create(feature_value_names, CssStyleValueListSeparator.comma).css_style_value()).css_style_value()
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3627 Web::CSS::Parser::Parser::parse_font_variant_alternates_value.
pub func css_parser_parse_font_variant_alternates_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# 6.8 https://drafts.csswg.org/css-fonts/#font-variant-alternates-prop
# [ stylistic(<feature-value-name>) || historical-forms || styleset(<feature-value-name>#) || character-variant(<feature-value-name>#) || swash(<feature-value-name>) || ornaments(<feature-value-name>) || annotation(<feature-value-name>) ]
# <feature-value-name> = <ident>
var stylistic: CssStyleValue*? = none
var historical_forms: CssStyleValue*? = none
var styleset: CssStyleValue*? = none
var character_variant: CssStyleValue*? = none
var swash: CssStyleValue*? = none
var ornaments: CssStyleValue*? = none
var annotation: CssStyleValue*? = none
while css_syntax.token_stream_has_next_token(tokens):
css_syntax.token_stream_discard_whitespace(tokens)
# historical-forms
if let maybe_historical_forms = css_parser_parse_specific_keyword_value(this, tokens, css_data.Keyword.historical_forms):
if historical_forms != none:
return none
historical_forms = maybe_historical_forms
continue
let next = css_syntax.token_stream_next_token(tokens)
if not css_syntax.component_value_is_function(&next):
break
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
let function_token = css_syntax.token_stream_consume_a_token(tokens)
let function = css_syntax.component_value_function(&function_token)
var argument_token_stream = css_syntax.token_stream_create(function.value)
let arguments = css_parser_parse_a_comma_separated_list_of_component_values(this, &argument_token_stream)
if ak.vector_size(&arguments) == 0:
break
var feature_value_names = ak.Vector[CssStyleValue*]()
ak.vector_ensure_capacity(&feature_value_names, ak.vector_size(&arguments))
for argument_values in ak.vector_span_const(&arguments):
var argument_tokens = css_syntax.token_stream_create(argument_values)
var no_blacklist: const ak.StringView[]
let ident = css_parser_parse_custom_ident_value(this, &argument_tokens, no_blacklist)
css_syntax.token_stream_discard_whitespace(&argument_tokens)
if ident == none or css_syntax.token_stream_has_next_token(&argument_tokens):
return none
ak.vector_append_t(&feature_value_names, (ident else trap("VERIFY: an ident")).css_style_value())
# stylistic(<feature-value-name>)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("stylistic")):
if ak.vector_size(&feature_value_names) != 1 or stylistic != none:
return none
css_syntax.state_transaction_commit(&transaction)
stylistic = css_feature_value_function("stylistic", feature_value_names)
continue
# styleset(<feature-value-name>#)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("styleset")):
if styleset != none:
return none
css_syntax.state_transaction_commit(&transaction)
styleset = css_feature_value_function("styleset", feature_value_names)
continue
# character-variant(<feature-value-name>#)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("character-variant")):
if character_variant != none:
return none
css_syntax.state_transaction_commit(&transaction)
character_variant = css_feature_value_function("character-variant", feature_value_names)
continue
# swash(<feature-value-name>)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("swash")):
if ak.vector_size(&feature_value_names) != 1 or swash != none:
return none
css_syntax.state_transaction_commit(&transaction)
swash = css_feature_value_function("swash", feature_value_names)
continue
# ornaments(<feature-value-name>)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("ornaments")):
if ak.vector_size(&feature_value_names) != 1 or ornaments != none:
return none
css_syntax.state_transaction_commit(&transaction)
ornaments = css_feature_value_function("ornaments", feature_value_names)
continue
# annotation(<feature-value-name>)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("annotation")):
if ak.vector_size(&feature_value_names) != 1 or annotation != none:
return none
css_syntax.state_transaction_commit(&transaction)
annotation = css_feature_value_function("annotation", feature_value_names)
continue
break
var values = ak.Vector[CssStyleValue*]()
if let value = stylistic:
ak.vector_append_t(&values, value)
if let value = historical_forms:
ak.vector_append_t(&values, value)
if let value = styleset:
ak.vector_append_t(&values, value)
if let value = character_variant:
ak.vector_append_t(&values, value)
if let value = swash:
ak.vector_append_t(&values, value)
if let value = ornaments:
ak.vector_append_t(&values, value)
if let value = annotation:
ak.vector_append_t(&values, value)
if ak.vector_is_empty(&values):
return none
return css_style_value_list_create(values, CssStyleValueListSeparator.space).css_style_value()
# mark: Keyword tuples ==========================================================================
## `any_of(tuple, [](auto& value) { return value != nullptr; })`.
func css_style_value_tuple_has_any(tuple: const ak.Vector[CssStyleValue*?]*) -> bool:
for value in ak.vector_span_const(tuple):
if value != none:
return true
return false
## One step of the keyword-tuple parsers: store `value` in the tuple slot `index` unless it is already set.
## Answers false when the slot was taken (the C++ returns nullptr); commits the keyword's transaction otherwise.
func css_style_value_tuple_claim(tuple: ak.Vector[CssStyleValue*?]*, index: usize, value: CssStyleValue*, keyword_transaction: css_syntax.StateTransaction*) -> bool:
if *ak.vector_at(tuple, index) != none:
return false
css_syntax.state_transaction_commit(keyword_transaction)
*ak.vector_at(tuple, index) = value
return true
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3766 Web::CSS::Parser::Parser::parse_font_variant_east_asian_value.
pub func css_parser_parse_font_variant_east_asian_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# 6.10 https://drafts.csswg.org/css-fonts/#propdef-font-variant-east-asian
# [ <east-asian-variant-values> || <east-asian-width-values> || ruby ]
# <east-asian-variant-values> = [ jis78 | jis83 | jis90 | jis04 | simplified | traditional ]
# <east-asian-width-values> = [ full-width | proportional-width ]
var tuple = css_empty_style_value_tuple(3)
while css_syntax.token_stream_has_next_token(tokens):
var keyword_transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&keyword_transaction)
let maybe_value = css_parser_parse_keyword_value(this, tokens) else break
if css_style_value_to_keyword(maybe_value) == css_data.Keyword.ruby:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_east_asian_ruby, maybe_value, &keyword_transaction):
return none
continue
if css_data.keyword_to_east_asian_width(css_style_value_to_keyword(maybe_value)) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_east_asian_width, maybe_value, &keyword_transaction):
return none
continue
if css_data.keyword_to_east_asian_variant(css_style_value_to_keyword(maybe_value)) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_east_asian_variant, maybe_value, &keyword_transaction):
return none
continue
break
if not css_style_value_tuple_has_any(&tuple):
return none
return css_tuple_style_value_create(tuple).css_style_value()
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3814 Web::CSS::Parser::Parser::parse_font_variant_numeric_value.
pub func css_parser_parse_font_variant_numeric_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# 6.7 https://drafts.csswg.org/css-fonts/#propdef-font-variant-numeric
# [ <numeric-figure-values> || <numeric-spacing-values> || <numeric-fraction-values> || ordinal || slashed-zero]
# <numeric-figure-values> = [ lining-nums | oldstyle-nums ]
# <numeric-spacing-values> = [ proportional-nums | tabular-nums ]
# <numeric-fraction-values> = [ diagonal-fractions | stacked-fractions ]
var tuple = css_empty_style_value_tuple(5)
while css_syntax.token_stream_has_next_token(tokens):
var keyword_transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&keyword_transaction)
let maybe_value = css_parser_parse_keyword_value(this, tokens) else break
let keyword = css_style_value_to_keyword(maybe_value)
if css_data.keyword_to_numeric_figure_value(keyword) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_figure, maybe_value, &keyword_transaction):
return none
continue
if css_data.keyword_to_numeric_spacing_value(keyword) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_spacing, maybe_value, &keyword_transaction):
return none
continue
if css_data.keyword_to_numeric_fraction_value(keyword) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_fraction, maybe_value, &keyword_transaction):
return none
continue
if keyword == css_data.Keyword.ordinal:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_ordinal, maybe_value, &keyword_transaction):
return none
continue
if keyword == css_data.Keyword.slashed_zero:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_numeric_slashed_zero, maybe_value, &keyword_transaction):
return none
continue
break
if not css_style_value_tuple_has_any(&tuple):
return none
return css_tuple_style_value_create(tuple).css_style_value()
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3881 Web::CSS::Parser::Parser::parse_font_variant_ligatures_value.
pub func css_parser_parse_font_variant_ligatures_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# 6.4 https://drafts.csswg.org/css-fonts/#propdef-font-variant-ligatures
# [ <common-lig-values> || <discretionary-lig-values> || <historical-lig-values> || <contextual-alt-values> ]
# <common-lig-values> = [ common-ligatures | no-common-ligatures ]
# <discretionary-lig-values> = [ discretionary-ligatures | no-discretionary-ligatures ]
# <historical-lig-values> = [ historical-ligatures | no-historical-ligatures ]
# <contextual-alt-values> = [ contextual | no-contextual ]
var tuple = css_empty_style_value_tuple(4)
while css_syntax.token_stream_has_next_token(tokens):
var keyword_transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&keyword_transaction)
let maybe_value = css_parser_parse_keyword_value(this, tokens) else break
let keyword = css_style_value_to_keyword(maybe_value)
if css_data.keyword_to_common_lig_value(keyword) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_common, maybe_value, &keyword_transaction):
return none
continue
if css_data.keyword_to_discretionary_lig_value(keyword) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_discretionary, maybe_value, &keyword_transaction):
return none
continue
if css_data.keyword_to_historical_lig_value(keyword) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_historical, maybe_value, &keyword_transaction):
return none
continue
if css_data.keyword_to_contextual_alt_value(keyword) != none:
if not css_style_value_tuple_claim(&tuple, css_tuple_style_value_indices_font_variant_ligatures_contextual, maybe_value, &keyword_transaction):
return none
continue
break
if not css_style_value_tuple_has_any(&tuple):
return none
return css_tuple_style_value_create(tuple).css_style_value()