Luce packages
LuceLuce BaseLuciaOS

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()