Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / boolean_expression.lucb

#==============================================================================================
#
#   boolean_expression - CSS::BooleanExpression: the <boolean-expr> tree of @media, @supports,
#                        @container and if() conditions, in Kleene three-valued logic
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/BooleanExpression.cpp (lines 1-142) and the inline members of
#       BooleanExpression.h (lines 15-229): MatchResult's operators, the abstract
#       BooleanExpression, GeneralEnclosed, the not / parenthesized / and / or nodes and the
#       constant node. Expressions are managed blobs (C++ NonnullOwnPtr), each with the class id
#       and vtable of its most-derived class.
#
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: MatchResult =============================================================================

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:23 Web::CSS::operator&&.
pub func css_and(a: CssMatchResult, b: CssMatchResult) -> CssMatchResult:
    # If either is false, false.
    if a == CssMatchResult.false_ or b == CssMatchResult.false_:
        return CssMatchResult.false_
    # If both are true, true.
    if a == CssMatchResult.true_ and b == CssMatchResult.true_:
        return CssMatchResult.true_
    # Otherwise, unknown.
    return CssMatchResult.unknown

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:35 Web::CSS::operator||.
pub func css_or(a: CssMatchResult, b: CssMatchResult) -> CssMatchResult:
    # If either is true, true.
    if a == CssMatchResult.true_ or b == CssMatchResult.true_:
        return CssMatchResult.true_
    # If both are false, false.
    if a == CssMatchResult.false_ and b == CssMatchResult.false_:
        return CssMatchResult.false_
    # Otherwise, unknown.
    return CssMatchResult.unknown

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:47 Web::CSS::as_match_result.
pub func css_as_match_result(value: bool) -> CssMatchResult:
    return CssMatchResult.true_ if value else CssMatchResult.false_

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:52 Web::CSS::negate.
pub func css_negate(value: CssMatchResult) -> CssMatchResult:
    match value:
        .false_: return CssMatchResult.true_
        .true_: return CssMatchResult.false_
        .unknown: return CssMatchResult.unknown
        _: trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:65 Web::CSS::to_string.
pub func css_to_string_css_match_result(result: CssMatchResult) -> ak.StringView:
    match result:
        .false_: return ak.sv("false")
        .true_: return ak.sv("true")
        .unknown: return ak.sv("unknown")
        _: trap("VERIFY_NOT_REACHED")

# mark: BooleanExpression =======================================================================

## Installs the vtable and class id of the most-derived expression class (the C++ vptr).
pub func css_boolean_expression_set_class(this: CssBooleanExpression*, vtable: const CssBooleanExpressionVTable*, info: const ak.ClassInfo*):
    this.vtable = vtable
    this.class_id = info.first_id

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:12 Web::CSS::BooleanExpression::evaluate_to_boolean.
pub func css_boolean_expression_evaluate_to_boolean(this: CssBooleanExpression*, document: DomDocument*?) -> bool:
    return css_boolean_expression_evaluate(this, document) == CssMatchResult.true_

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:17 Web::CSS::BooleanExpression::indent.
pub func css_boolean_expression_indent(builder: ak.StringBuilder*, levels: i32):
    ak.string_builder_append_repeated_string_view(builder, ak.sv("  "), (usize)levels)

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:87 Web::CSS::BooleanExpression::evaluate (virtual).
pub func css_boolean_expression_evaluate_impl(this: CssBooleanExpression*, arg0: DomDocument*?) -> CssMatchResult:
    trap("pure virtual: Web::CSS::BooleanExpression::evaluate")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:88 Web::CSS::BooleanExpression::to_string (virtual).
pub func css_boolean_expression_to_string_impl(this: CssBooleanExpression*) -> ak.String:
    trap("pure virtual: Web::CSS::BooleanExpression::to_string")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:89 Web::CSS::BooleanExpression::dump (virtual).
pub func css_boolean_expression_dump_impl(this: CssBooleanExpression*, arg0: ak.StringBuilder*, indent_levels: i32):
    trap("pure virtual: Web::CSS::BooleanExpression::dump")

## `String::join(separator, children)` over expressions (Formatter<BooleanExpression> is their to_string()).
func css_boolean_expression_join(separator: str, children: const ak.Vector[CssBooleanExpression*]*) -> ak.String:
    var builder = ak.string_builder_new()
    var first = true
    for child in ak.vector_span_const(children):
        if not first:
            ak.string_builder_append(&builder, separator)
        first = false
        let child_string = css_boolean_expression_to_string(child)
        ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&child_string))
    return ak.string_builder_to_string(&builder) else trap("MUST: String::join")

# mark: GeneralEnclosed =========================================================================

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:95 Web::CSS::GeneralEnclosed::create.
pub func css_general_enclosed_create(serialized_contents: ak.String, matches: CssMatchResult = CssMatchResult.unknown) -> CssGeneralEnclosed*:
    let this = &(new CssGeneralEnclosed[1] --- else trap("out of memory"))[0]
    css_general_enclosed_construct(this, serialized_contents, matches)
    return this

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:101 Web::CSS::GeneralEnclosed::evaluate (override).
pub func css_general_enclosed_evaluate_impl(base: CssBooleanExpression*, arg0: DomDocument*?) -> CssMatchResult:
    let this = (CssGeneralEnclosed*)base
    return this.m_matches

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:102 Web::CSS::GeneralEnclosed::to_string (override).
pub func css_general_enclosed_to_string_impl(base: CssBooleanExpression*) -> ak.String:
    let this = (CssGeneralEnclosed*)base
    return this.m_serialized_contents

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:22 Web::CSS::GeneralEnclosed::dump (override).
pub func css_general_enclosed_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
    css_boolean_expression_indent(builder, indent_levels)
    let string = css_boolean_expression_to_string(base)
    ak.string_builder_append(builder, "GeneralEnclosed: ")
    ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&string))
    ak.string_builder_append(builder, "\n")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:106 Web::CSS::GeneralEnclosed::GeneralEnclosed.
pub func css_general_enclosed_construct(this: CssGeneralEnclosed*, serialized_contents: ak.String, matches: CssMatchResult):
    css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_general_enclosed_vtable, &css_general_enclosed_class)
    this.m_serialized_contents = serialized_contents
    this.m_matches = matches

# mark: BooleanNotExpression ====================================================================

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:118 Web::CSS::BooleanNotExpression::create.
pub func css_boolean_not_expression_create(child: CssBooleanExpression*) -> CssBooleanNotExpression*:
    let this = &(new CssBooleanNotExpression[1] --- else trap("out of memory"))[0]
    css_boolean_not_expression_construct(this, child)
    return this

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:28 Web::CSS::BooleanNotExpression::evaluate (override).
pub func css_boolean_not_expression_evaluate_impl(base: CssBooleanExpression*, document: DomDocument*?) -> CssMatchResult:
    let this = (CssBooleanNotExpression*)base
    # https://drafts.csswg.org/css-values-5/#boolean-logic
    # `not test` evaluates to true if its contained test is false, false if it’s true, and unknown if it’s unknown.
    match css_boolean_expression_evaluate(this.m_child, document):
        .false_: return CssMatchResult.true_
        .true_: return CssMatchResult.false_
        .unknown: return CssMatchResult.unknown
        _: trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:43 Web::CSS::BooleanNotExpression::to_string (override).
pub func css_boolean_not_expression_to_string_impl(base: CssBooleanExpression*) -> ak.String:
    let this = (CssBooleanNotExpression*)base
    var builder = ak.string_builder_new()
    let child = css_boolean_expression_to_string(this.m_child)
    ak.string_builder_append(&builder, "not ")
    ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&child))
    return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:48 Web::CSS::BooleanNotExpression::dump (override).
pub func css_boolean_not_expression_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
    let this = (CssBooleanNotExpression*)base
    css_boolean_expression_indent(builder, indent_levels)
    ak.string_builder_append(builder, "NOT:\n")
    css_boolean_expression_dump(this.m_child, builder, indent_levels + 1)

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:129 Web::CSS::BooleanNotExpression::BooleanNotExpression.
pub func css_boolean_not_expression_construct(this: CssBooleanNotExpression*, child: CssBooleanExpression*):
    css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_boolean_not_expression_vtable, &css_boolean_not_expression_class)
    this.m_child = child

# mark: BooleanExpressionInParens ===============================================================

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:139 Web::CSS::BooleanExpressionInParens::create.
pub func css_boolean_expression_in_parens_create(child: CssBooleanExpression*) -> CssBooleanExpressionInParens*:
    let this = &(new CssBooleanExpressionInParens[1] --- else trap("out of memory"))[0]
    css_boolean_expression_in_parens_construct(this, child)
    return this

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:55 Web::CSS::BooleanExpressionInParens::evaluate (override).
pub func css_boolean_expression_in_parens_evaluate_impl(base: CssBooleanExpression*, document: DomDocument*?) -> CssMatchResult:
    let this = (CssBooleanExpressionInParens*)base
    return css_boolean_expression_evaluate(this.m_child, document)

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:60 Web::CSS::BooleanExpressionInParens::to_string (override).
pub func css_boolean_expression_in_parens_to_string_impl(base: CssBooleanExpression*) -> ak.String:
    let this = (CssBooleanExpressionInParens*)base
    var builder = ak.string_builder_new()
    let child = css_boolean_expression_to_string(this.m_child)
    ak.string_builder_append(&builder, "(")
    ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&child))
    ak.string_builder_append(&builder, ")")
    return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:65 Web::CSS::BooleanExpressionInParens::dump (override).
pub func css_boolean_expression_in_parens_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
    let this = (CssBooleanExpressionInParens*)base
    css_boolean_expression_indent(builder, indent_levels)
    ak.string_builder_append(builder, "(\n")
    css_boolean_expression_dump(this.m_child, builder, indent_levels + 1)
    css_boolean_expression_indent(builder, indent_levels)
    ak.string_builder_append(builder, ")\n")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:150 Web::CSS::BooleanExpressionInParens::BooleanExpressionInParens.
pub func css_boolean_expression_in_parens_construct(this: CssBooleanExpressionInParens*, child: CssBooleanExpression*):
    css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_boolean_expression_in_parens_vtable, &css_boolean_expression_in_parens_class)
    this.m_child = child

# mark: BooleanAndExpression ====================================================================

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:160 Web::CSS::BooleanAndExpression::create.
pub func css_boolean_and_expression_create(children: ak.Vector[CssBooleanExpression*]) -> CssBooleanAndExpression*:
    let this = &(new CssBooleanAndExpression[1] --- else trap("out of memory"))[0]
    css_boolean_and_expression_construct(this, children)
    return this

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:74 Web::CSS::BooleanAndExpression::evaluate (override).
pub func css_boolean_and_expression_evaluate_impl(base: CssBooleanExpression*, document: DomDocument*?) -> CssMatchResult:
    let this = (CssBooleanAndExpression*)base
    # https://drafts.csswg.org/css-values-5/#boolean-logic
    # Multiple tests connected with `and` evaluate to true if all of those tests are true, false if any of them are
    # false, and unknown otherwise (i.e. if at least one unknown, but no false).
    var true_results: usize = 0
    for child in ak.vector_span(&this.m_children):
        let child_match = css_boolean_expression_evaluate(child, document)
        if child_match == CssMatchResult.false_:
            return CssMatchResult.false_
        if child_match == CssMatchResult.true_:
            true_results += 1

    if true_results == ak.vector_size(&this.m_children):
        return CssMatchResult.true_
    return CssMatchResult.unknown

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:92 Web::CSS::BooleanAndExpression::to_string (override).
pub func css_boolean_and_expression_to_string_impl(base: CssBooleanExpression*) -> ak.String:
    let this = (CssBooleanAndExpression*)base
    return css_boolean_expression_join(" and ", &this.m_children)

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:97 Web::CSS::BooleanAndExpression::dump (override).
pub func css_boolean_and_expression_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
    let this = (CssBooleanAndExpression*)base
    css_boolean_expression_indent(builder, indent_levels)
    ak.string_builder_append(builder, "AND:\n")
    for child in ak.vector_span(&this.m_children):
        css_boolean_expression_dump(child, builder, indent_levels + 1)

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:171 Web::CSS::BooleanAndExpression::BooleanAndExpression.
pub func css_boolean_and_expression_construct(this: CssBooleanAndExpression*, children: ak.Vector[CssBooleanExpression*]):
    css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_boolean_and_expression_vtable, &css_boolean_and_expression_class)
    this.m_children = children

# mark: BooleanOrExpression =====================================================================

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:181 Web::CSS::BooleanOrExpression::create.
pub func css_boolean_or_expression_create(children: ak.Vector[CssBooleanExpression*]) -> CssBooleanOrExpression*:
    let this = &(new CssBooleanOrExpression[1] --- else trap("out of memory"))[0]
    css_boolean_or_expression_construct(this, children)
    return this

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:105 Web::CSS::BooleanOrExpression::evaluate (override).
pub func css_boolean_or_expression_evaluate_impl(base: CssBooleanExpression*, document: DomDocument*?) -> CssMatchResult:
    let this = (CssBooleanOrExpression*)base
    # https://drafts.csswg.org/css-values-5/#boolean-logic
    # Multiple tests connected with `or` evaluate to true if any of those tests are true, false if all of them are
    # false, and unknown otherwise (i.e. at least one unknown, but no true).
    var false_results: usize = 0
    for child in ak.vector_span(&this.m_children):
        let child_match = css_boolean_expression_evaluate(child, document)
        if child_match == CssMatchResult.true_:
            return CssMatchResult.true_
        if child_match == CssMatchResult.false_:
            false_results += 1

    if false_results == ak.vector_size(&this.m_children):
        return CssMatchResult.false_
    return CssMatchResult.unknown

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:123 Web::CSS::BooleanOrExpression::to_string (override).
pub func css_boolean_or_expression_to_string_impl(base: CssBooleanExpression*) -> ak.String:
    let this = (CssBooleanOrExpression*)base
    return css_boolean_expression_join(" or ", &this.m_children)

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:128 Web::CSS::BooleanOrExpression::dump (override).
pub func css_boolean_or_expression_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
    let this = (CssBooleanOrExpression*)base
    css_boolean_expression_indent(builder, indent_levels)
    ak.string_builder_append(builder, "OR:\n")
    for child in ak.vector_span(&this.m_children):
        css_boolean_expression_dump(child, builder, indent_levels + 1)

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:192 Web::CSS::BooleanOrExpression::BooleanOrExpression.
pub func css_boolean_or_expression_construct(this: CssBooleanOrExpression*, children: ak.Vector[CssBooleanExpression*]):
    css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_boolean_or_expression_vtable, &css_boolean_or_expression_class)
    this.m_children = children

# mark: ConstantBooleanExpression ===============================================================

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:202 Web::CSS::ConstantBooleanExpression::create.
pub func css_constant_boolean_expression_create(value: CssMatchResult) -> CssConstantBooleanExpression*:
    let this = &(new CssConstantBooleanExpression[1] --- else trap("out of memory"))[0]
    css_constant_boolean_expression_construct(this, value)
    return this

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:208 Web::CSS::ConstantBooleanExpression::evaluate (override).
pub func css_constant_boolean_expression_evaluate_impl(base: CssBooleanExpression*, arg0: DomDocument*?) -> CssMatchResult:
    let this = (CssConstantBooleanExpression*)base
    return this.m_value

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:209 Web::CSS::ConstantBooleanExpression::to_string (override).
pub func css_constant_boolean_expression_to_string_impl(base: CssBooleanExpression*) -> ak.String:
    let this = (CssConstantBooleanExpression*)base
    return ak.string_from_utf8(css_to_string_css_match_result(this.m_value)) else trap("MUST: String::from_utf8")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.cpp:136 Web::CSS::ConstantBooleanExpression::dump (override).
pub func css_constant_boolean_expression_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
    css_boolean_expression_indent(builder, indent_levels)
    let string = css_boolean_expression_to_string(base)
    ak.string_builder_append(builder, "CONSTANT: ")
    ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&string))
    ak.string_builder_append(builder, "\n")

## Ported from Libraries/LibWeb/CSS/BooleanExpression.h:213 Web::CSS::ConstantBooleanExpression::ConstantBooleanExpression.
pub func css_constant_boolean_expression_construct(this: CssConstantBooleanExpression*, value: CssMatchResult):
    css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_constant_boolean_expression_vtable, &css_constant_boolean_expression_class)
    this.m_value = value