dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / css / parser / property_parsing_6.lucb
#==============================================================================================
#
# property_parsing_6 - parsing property values: shadows, shape-outside, rotate,
# stroke-dasharray, content
#
# DESCRIPTION:
# Port of LibWeb/CSS/Parser/PropertyParsing.cpp (lines 1821-2169).
#
#==============================================================================================
# mark: Shadows =================================================================================
## The captures of parse_shadow_value's per-shadow lambda.
struct CssParserParseShadowValueCaptures:
var this: CssParser*
var shadow_type: CssShadowStyleValueShadowType
## `[this, shadow_type](auto& tokens) { return parse_single_shadow_value(tokens, shadow_type); }`.
func css_parser_parse_single_shadow_callback(context: void*?, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
let captures = (CssParserParseShadowValueCaptures*)(context else trap("no captures"))
return css_parser_parse_single_shadow_value(captures.this, tokens, captures.shadow_type)
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:1821 Web::CSS::Parser::Parser::parse_shadow_value.
pub func css_parser_parse_shadow_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, shadow_type: CssShadowStyleValueShadowType) -> CssStyleValue*?:
# "none"
if let none_ = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_):
return none_
var captures = CssParserParseShadowValueCaptures(this = this, shadow_type = shadow_type)
return (CssStyleValue*?)css_parser_parse_comma_separated_value_list(this, tokens, ak.Function1[css_syntax.TokenStream[css_syntax.ComponentValue]*, CssStyleValue*?](
call = css_parser_parse_single_shadow_callback, context = &captures))
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:1832 Web::CSS::Parser::Parser::parse_single_shadow_value.
pub func css_parser_parse_single_shadow_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, shadow_type: CssShadowStyleValueShadowType) -> CssStyleValue*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
var color: CssStyleValue*? = none
var offset_x: CssStyleValue*? = none
var offset_y: CssStyleValue*? = none
var blur_radius: CssStyleValue*? = none
var spread_distance: CssStyleValue*? = none
var placement: CssShadowPlacement? = none
while css_syntax.token_stream_has_next_token(tokens):
if let maybe_color = css_parser_parse_color_value(this, tokens):
if color != none:
return none
color = maybe_color
css_syntax.token_stream_discard_whitespace(tokens)
continue
let token = css_syntax.token_stream_next_token(tokens)
if let maybe_offset_x = css_parser_parse_length_value(this, tokens, css_infinite_range):
# horizontal offset
if offset_x != none:
return none
offset_x = maybe_offset_x
# vertical offset
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
return none
let maybe_offset_y = css_parser_parse_length_value(this, tokens, css_infinite_range) else return none
offset_y = maybe_offset_y
# blur radius (optional)
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
break
let maybe_blur_radius = css_parser_parse_length_value(this, tokens, css_non_negative_range) else continue
blur_radius = maybe_blur_radius
# spread distance (optional)
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
break
let maybe_spread_distance = css_parser_parse_length_value(this, tokens, css_infinite_range) else continue
if shadow_type == CssShadowStyleValueShadowType.text:
return none
spread_distance = maybe_spread_distance
css_syntax.token_stream_discard_whitespace(tokens)
continue
if shadow_type == CssShadowStyleValueShadowType.normal and css_syntax.component_value_is_ident(&token, ak.sv("inset")):
if placement != none:
return none
placement = CssShadowPlacement.inner
css_syntax.token_stream_discard_a_token(tokens) # inset
css_syntax.token_stream_discard_whitespace(tokens)
continue
if css_syntax.component_value_is(&token, .comma):
break
return none
# x/y offsets are required
if offset_x == none or offset_y == none:
return none
# Placement is outer by default
if placement == none:
placement = CssShadowPlacement.outer
css_syntax.state_transaction_commit(&transaction)
return css_shadow_style_value_create(shadow_type, color, offset_x else trap("release_nonnull"), offset_y else trap("release_nonnull"), blur_radius, spread_distance,
placement else trap("release_value")).css_style_value()
# mark: shape-outside ===========================================================================
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:1923 Web::CSS::Parser::Parser::parse_shape_outside_value.
pub func css_parser_parse_shape_outside_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# none | [ <basic-shape> || <shape-box> ] | <image>
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
# none
if let maybe_none = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_):
css_syntax.state_transaction_commit(&transaction)
return maybe_none
# <image>
if let maybe_image = css_parser_parse_image_value(this, tokens):
css_syntax.state_transaction_commit(&transaction)
return maybe_image.css_style_value()
# [ <basic-shape> || <shape-box> ]
var basic_shape_value: CssStyleValue*? = none
var shape_box_value: CssStyleValue*? = none
while css_syntax.token_stream_has_next_token(tokens):
if let maybe_basic_shape_value = css_parser_parse_basic_shape_value(this, tokens):
if basic_shape_value != none:
return none
basic_shape_value = maybe_basic_shape_value
continue
if let maybe_keyword_value = css_parser_parse_keyword_value(this, tokens):
if shape_box_value != none:
return none
if css_data.keyword_to_shape_box(css_style_value_to_keyword(maybe_keyword_value)) == none:
return none
shape_box_value = maybe_keyword_value
continue
return none
if basic_shape_value == none and shape_box_value == none:
return none
css_syntax.state_transaction_commit(&transaction)
if let basic_shape = basic_shape_value:
if let shape_box = shape_box_value:
return css_style_value_list_of(css_style_values_of([basic_shape, shape_box]), CssStyleValueListSeparator.space)
return basic_shape
return shape_box_value
# mark: rotate ==================================================================================
## `TransformationStyleValue::create(PropertyID::Rotate, function, values)` as a StyleValue.
func css_rotate_transformation(function: css_data.TransformFunction, values: const (CssStyleValue*)[]) -> CssStyleValue*:
return css_transformation_style_value_create(css_data.PropertyId.rotate, function, css_style_values_of(values)).css_style_value()
## The `parse_one_of_xyz` lambda of parse_rotate_value.
func css_parse_one_of_xyz(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> css_syntax.ComponentValue?:
var xyz_transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&xyz_transaction)
css_syntax.token_stream_discard_whitespace(tokens)
let axis = css_syntax.token_stream_consume_a_token(tokens)
if css_syntax.component_value_is_ident(&axis, ak.sv("x")) or css_syntax.component_value_is_ident(&axis, ak.sv("y")) or css_syntax.component_value_is_ident(&axis, ak.sv("z")):
css_syntax.state_transaction_commit(&xyz_transaction)
return axis
return none
## The `parse_three_numbers` lambda of parse_rotate_value.
func css_parser_parse_three_numbers(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> ak.Vector[CssStyleValue*]?:
var numbers_transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&numbers_transaction)
var numbers = ak.Vector[CssStyleValue*]()
for _ in 0..<3:
if let number = css_parser_parse_number_value(this, tokens, css_infinite_range):
ak.vector_append_t(&numbers, number)
else:
return none
css_syntax.state_transaction_commit(&numbers_transaction)
return numbers
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:1978 Web::CSS::Parser::Parser::parse_rotate_value.
# https://drafts.csswg.org/css-transforms-2/#propdef-rotate
pub func css_parser_parse_rotate_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# none | <angle> | [ x | y | z | <number>{3} ] && <angle>
# none
if let none_ = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_):
return none_
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
var angle = css_parser_parse_angle_value(this, tokens, css_infinite_range)
css_syntax.token_stream_discard_whitespace(tokens)
# <angle>
if let angle_value = angle:
if not css_syntax.token_stream_has_next_token(tokens):
css_syntax.state_transaction_commit(&transaction)
return css_rotate_transformation(css_data.TransformFunction.rotate, [angle_value])
# NB: The `parse_one_of_xyz` lambda is css_parse_one_of_xyz.
# [ x | y | z ] && <angle>
if let axis = css_parse_one_of_xyz(tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if angle == none:
angle = css_parser_parse_angle_value(this, tokens, css_infinite_range)
if let angle_value = angle:
css_syntax.state_transaction_commit(&transaction)
if css_syntax.component_value_is_ident(&axis, ak.sv("x")):
return css_rotate_transformation(css_data.TransformFunction.rotate_x, [angle_value])
if css_syntax.component_value_is_ident(&axis, ak.sv("y")):
return css_rotate_transformation(css_data.TransformFunction.rotate_y, [angle_value])
if css_syntax.component_value_is_ident(&axis, ak.sv("z")):
return css_rotate_transformation(css_data.TransformFunction.rotate_z, [angle_value])
trap("VERIFY_NOT_REACHED")
return none
# NB: The `parse_three_numbers` lambda is css_parser_parse_three_numbers.
# <number>{3} && <angle>
if let numbers = css_parser_parse_three_numbers(this, tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if angle == none:
angle = css_parser_parse_angle_value(this, tokens, css_infinite_range)
if let angle_value = angle:
css_syntax.state_transaction_commit(&transaction)
return css_rotate_transformation(css_data.TransformFunction.rotate3_d, [*ak.vector_at_const(&numbers, 0), *ak.vector_at_const(&numbers, 1), *ak.vector_at_const(&numbers, 2), angle_value])
return none
return none
# mark: stroke-dasharray ========================================================================
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:2064 Web::CSS::Parser::Parser::parse_stroke_dasharray_value.
pub func css_parser_parse_stroke_dasharray_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# https://svgwg.org/svg2-draft/painting.html#StrokeDashing
# Value: none | <dasharray>
if let none_ = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_):
return none_
# https://svgwg.org/svg2-draft/painting.html#DataTypeDasharray
# <dasharray> = [ [ <length-percentage> | <number> ]+ ]#
var dashes = ak.Vector[CssStyleValue*]()
while css_syntax.token_stream_has_next_token(tokens):
css_syntax.token_stream_discard_whitespace(tokens)
# A <dasharray> is a list of comma and/or white space separated <number> or <length-percentage> values. A <number> value represents a value in user units.
# If any value in the list is negative, the <dasharray> value is invalid.
if let value = css_parser_parse_number_value(this, tokens, css_non_negative_range):
ak.vector_append_t(&dashes, value)
else:
let length_percentage = css_parser_parse_length_percentage_value(this, tokens, css_non_negative_range, css_non_negative_range) else return none
ak.vector_append_t(&dashes, length_percentage)
css_syntax.token_stream_discard_whitespace(tokens)
if css_syntax.token_stream_has_next_token(tokens) and css_next_token_is(tokens, .comma):
css_syntax.token_stream_discard_a_token(tokens)
return css_style_value_list_of(dashes, CssStyleValueListSeparator.comma)
# mark: content =================================================================================
## The `is_single_value_keyword` lambda of parse_content_value.
func css_content_is_single_value_keyword(keyword: css_data.Keyword) -> bool:
match keyword:
.none_, .normal:
return true
_:
return false
## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:2099 Web::CSS::Parser::Parser::parse_content_value.
pub func css_parser_parse_content_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
# FIXME: `content` accepts several kinds of function() type, which we don't handle in property_accepts_value() yet.
# NB: The `is_single_value_keyword` lambda is css_content_is_single_value_keyword.
if let none_ = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_):
return none_
if let normal = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.normal):
return normal
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
var content_values = ak.Vector[CssStyleValue*]()
var alt_text_values = ak.Vector[CssStyleValue*]()
var in_alt_text = false
css_syntax.token_stream_discard_whitespace(tokens)
while css_syntax.token_stream_has_next_token(tokens):
if css_next_token_is_delim(tokens, (u32)'/'):
if in_alt_text or ak.vector_is_empty(&content_values):
return none
in_alt_text = true
css_syntax.token_stream_discard_a_token(tokens) # /
css_syntax.token_stream_discard_whitespace(tokens)
continue
if let style_value = css_parser_parse_css_value_for_property(this, css_data.PropertyId.content, tokens):
if css_content_is_single_value_keyword(css_style_value_to_keyword(style_value)):
return none
if in_alt_text:
# https://drafts.csswg.org/css-content-3/#content-property
# / [ <string> | <counter> | <attr()> ]+
# NB: <attr()> is handled as an arbitrary substitution function and does not reach this code path.
if not css_style_value_is_string(style_value) and not css_style_value_is_counter(style_value):
return none
ak.vector_append_t(&alt_text_values, style_value)
else:
ak.vector_append_t(&content_values, style_value)
css_syntax.token_stream_discard_whitespace(tokens)
continue
return none
if ak.vector_is_empty(&content_values):
return none
if in_alt_text and ak.vector_is_empty(&alt_text_values):
return none
var alt_text: CssStyleValueList*? = none
if not ak.vector_is_empty(&alt_text_values):
alt_text = css_style_value_list_create(alt_text_values, CssStyleValueListSeparator.space)
css_syntax.state_transaction_commit(&transaction)
return css_content_style_value_create(css_style_value_list_create(content_values, CssStyleValueListSeparator.space), alt_text).css_style_value()