Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / parser / syntax.lucb

#==============================================================================================
#
#   syntax - the nodes of a CSS <syntax> definition (`*`, idents, types, `+`, `#`, `|`)
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/Syntax.cpp (lines 1-151) and the inline members of
#       Syntax.h (lines 1-158). SyntaxNode is an OwnPtr'd hierarchy without a GC header: each
#       node carries its vtable and class id (types_syntax), set by the most-derived
#       constructor as the C++ vptr is, and `create` allocates the node in managed memory.
#
#       Copyright (c) 2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: SyntaxNode ==============================================================================

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:29 Web::CSS::Parser::SyntaxNode::type.
pub func css_syntax_node_type(this: CssSyntaxNode*) -> CssSyntaxNodeNodeType:
    return this.m_type

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:32 Web::CSS::Parser::SyntaxNode::to_string (virtual).
pub func css_syntax_node_to_string_impl(this: CssSyntaxNode*) -> ak.String:
    _ = this
    trap("pure virtual: Web::CSS::Parser::SyntaxNode::to_string")

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:33 Web::CSS::Parser::SyntaxNode::dump (virtual).
pub func css_syntax_node_dump_string_builder_impl(this: CssSyntaxNode*, arg0: ak.StringBuilder*, indent: i32):
    _ = this
    _ = arg0
    _ = indent
    trap("pure virtual: Web::CSS::Parser::SyntaxNode::dump")

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:13 Web::CSS::Parser::SyntaxNode::dump.
pub func css_syntax_node_dump(this: CssSyntaxNode*) -> ak.String:
    var builder = ak.string_builder_new()
    css_syntax_node_dump_string_builder(this, &builder, 0)
    return ak.string_builder_to_string_without_validation(&builder)

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:37 Web::CSS::Parser::SyntaxNode::SyntaxNode.
pub func css_syntax_node_construct(this: CssSyntaxNode*, type_: CssSyntaxNodeNodeType):
    this.m_type = type_

## The node's vtable and class id: what the C++ vptr of the most-derived class gives it.
func css_syntax_node_set_class(this: CssSyntaxNode*, vtable: const CssSyntaxNodeVTable*, info: const ak.ClassInfo*):
    this.vtable = vtable
    this.class_id = info.first_id

## `builder.appendff("{: >{}}<text>", "", indent, arguments...)`: the dump line's indentation.
func css_syntax_node_dump_indent(builder: ak.StringBuilder*, indent: i32):
    dump_appendff(builder, "{: >{}}", [ak.arg_str(""), ak.arg_i64((i64)indent)])

# mark: UniversalSyntaxNode =====================================================================

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:49 Web::CSS::Parser::UniversalSyntaxNode::create.
pub func css_universal_syntax_node_create() -> CssUniversalSyntaxNode*:
    let this = &(new CssUniversalSyntaxNode[1] --- else trap("out of memory"))[0]
    css_universal_syntax_node_construct(this)
    return this

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:20 Web::CSS::Parser::UniversalSyntaxNode::UniversalSyntaxNode.
pub func css_universal_syntax_node_construct(this: CssUniversalSyntaxNode*):
    css_syntax_node_construct(this.css_syntax_node(), CssSyntaxNodeNodeType.universal)
    css_syntax_node_set_class(this.css_syntax_node(), (const CssSyntaxNodeVTable*)&css_universal_syntax_node_vtable, &css_universal_syntax_node_class)

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:27 Web::CSS::Parser::UniversalSyntaxNode::to_string (override).
pub func css_universal_syntax_node_to_string_impl(base: CssSyntaxNode*) -> ak.String:
    _ = base
    return ak.string_from_str("*")

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:32 Web::CSS::Parser::UniversalSyntaxNode::dump (override).
pub func css_universal_syntax_node_dump_string_builder_impl(base: CssSyntaxNode*, builder: ak.StringBuilder*, indent: i32):
    _ = base
    css_syntax_node_dump_indent(builder, indent)
    ak.string_builder_append_string_view(builder, ak.sv("Universal\n"))

# mark: TypeSyntaxNode ==========================================================================

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:37 Web::CSS::Parser::TypeSyntaxNode::create.
pub func css_type_syntax_node_create(type_name: ak.FlyString) -> CssTypeSyntaxNode*:
    let value_type = css_value_type_from_string(ak.fly_string_bytes_as_string_view(&type_name))
    let this = &(new CssTypeSyntaxNode[1] --- else trap("out of memory"))[0]
    css_type_syntax_node_construct(this, type_name, value_type)
    return this

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:43 Web::CSS::Parser::TypeSyntaxNode::TypeSyntaxNode.
pub func css_type_syntax_node_construct(this: CssTypeSyntaxNode*, type_name: ak.FlyString, value_type: CssValueType?):
    css_syntax_node_construct(this.css_syntax_node(), CssSyntaxNodeNodeType.type_)
    css_syntax_node_set_class(this.css_syntax_node(), (const CssSyntaxNodeVTable*)&css_type_syntax_node_vtable, &css_type_syntax_node_class)
    this.m_type_name = type_name
    this.m_value_type = value_type

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:89 Web::CSS::Parser::TypeSyntaxNode::type_name.
pub func css_type_syntax_node_type_name(this: CssTypeSyntaxNode*) -> ak.FlyString:
    return this.m_type_name

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:90 Web::CSS::Parser::TypeSyntaxNode::value_type.
pub func css_type_syntax_node_value_type(this: CssTypeSyntaxNode*) -> CssValueType?:
    return this.m_value_type

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:52 Web::CSS::Parser::TypeSyntaxNode::to_string (override).
pub func css_type_syntax_node_to_string_impl(base: CssSyntaxNode*) -> ak.String:
    let this = (CssTypeSyntaxNode*)base
    return css_string_formatted("<{}>", [css_arg_fly_string(&this.m_type_name)])

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:57 Web::CSS::Parser::TypeSyntaxNode::dump (override).
pub func css_type_syntax_node_dump_string_builder_impl(base: CssSyntaxNode*, builder: ak.StringBuilder*, indent: i32):
    let this = (CssTypeSyntaxNode*)base
    css_syntax_node_dump_indent(builder, indent)
    dump_appendff(builder, "Type: {}\n", [css_arg_fly_string(&this.m_type_name)])

# mark: IdentSyntaxNode =========================================================================

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:65 Web::CSS::Parser::IdentSyntaxNode::create.
pub func css_ident_syntax_node_create(ident: ak.FlyString, case_sensitivity: ak.CaseSensitivity) -> CssIdentSyntaxNode*:
    let this = &(new CssIdentSyntaxNode[1] --- else trap("out of memory"))[0]
    css_ident_syntax_node_construct(this, ident, case_sensitivity)
    return this

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:62 Web::CSS::Parser::IdentSyntaxNode::IdentSyntaxNode.
pub func css_ident_syntax_node_construct(this: CssIdentSyntaxNode*, ident: ak.FlyString, case_sensitivity: ak.CaseSensitivity):
    css_syntax_node_construct(this.css_syntax_node(), CssSyntaxNodeNodeType.ident)
    css_syntax_node_set_class(this.css_syntax_node(), (const CssSyntaxNodeVTable*)&css_ident_syntax_node_vtable, &css_ident_syntax_node_class)
    this.m_ident = ident
    this.m_case_sensitivity = case_sensitivity

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:71 Web::CSS::Parser::IdentSyntaxNode::ident.
pub func css_ident_syntax_node_ident(this: CssIdentSyntaxNode*) -> ak.FlyString:
    return this.m_ident

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:72 Web::CSS::Parser::IdentSyntaxNode::case_sensitivity.
pub func css_ident_syntax_node_case_sensitivity(this: CssIdentSyntaxNode*) -> ak.CaseSensitivity:
    return this.m_case_sensitivity

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:71 Web::CSS::Parser::IdentSyntaxNode::to_string (override).
pub func css_ident_syntax_node_to_string_impl(base: CssSyntaxNode*) -> ak.String:
    let this = (CssIdentSyntaxNode*)base
    return css_syntax.serialize_an_identifier_string_view(ak.fly_string_bytes_as_string_view(&this.m_ident))

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:76 Web::CSS::Parser::IdentSyntaxNode::dump (override).
pub func css_ident_syntax_node_dump_string_builder_impl(base: CssSyntaxNode*, builder: ak.StringBuilder*, indent: i32):
    let this = (CssIdentSyntaxNode*)base
    css_syntax_node_dump_indent(builder, indent)
    dump_appendff(builder, "Ident: {}\n", [css_arg_fly_string(&this.m_ident)])

# mark: MultiplierSyntaxNode ====================================================================

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:104 Web::CSS::Parser::MultiplierSyntaxNode::create.
pub func css_multiplier_syntax_node_create(child: CssSyntaxNode*) -> CssMultiplierSyntaxNode*:
    let this = &(new CssMultiplierSyntaxNode[1] --- else trap("out of memory"))[0]
    css_multiplier_syntax_node_construct(this, child)
    return this

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:81 Web::CSS::Parser::MultiplierSyntaxNode::MultiplierSyntaxNode.
pub func css_multiplier_syntax_node_construct(this: CssMultiplierSyntaxNode*, child: CssSyntaxNode*):
    css_syntax_node_construct(this.css_syntax_node(), CssSyntaxNodeNodeType.multiplier)
    css_syntax_node_set_class(this.css_syntax_node(), (const CssSyntaxNodeVTable*)&css_multiplier_syntax_node_vtable, &css_multiplier_syntax_node_class)
    this.m_child = child

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:110 Web::CSS::Parser::MultiplierSyntaxNode::child.
pub func css_multiplier_syntax_node_child(this: CssMultiplierSyntaxNode*) -> CssSyntaxNode*:
    return this.m_child

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:89 Web::CSS::Parser::MultiplierSyntaxNode::to_string (override).
pub func css_multiplier_syntax_node_to_string_impl(base: CssSyntaxNode*) -> ak.String:
    let this = (CssMultiplierSyntaxNode*)base
    let child = css_syntax_node_to_string(this.m_child)
    return css_string_formatted("{}+", [css_arg_string(&child)])

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:94 Web::CSS::Parser::MultiplierSyntaxNode::dump (override).
pub func css_multiplier_syntax_node_dump_string_builder_impl(base: CssSyntaxNode*, builder: ak.StringBuilder*, indent: i32):
    let this = (CssMultiplierSyntaxNode*)base
    css_syntax_node_dump_indent(builder, indent)
    ak.string_builder_append_string_view(builder, ak.sv("Multiplier:\n"))
    css_syntax_node_dump_string_builder(this.m_child, builder, indent + 2)

# mark: CommaSeparatedMultiplierSyntaxNode ======================================================

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:123 Web::CSS::Parser::CommaSeparatedMultiplierSyntaxNode::create.
pub func css_comma_separated_multiplier_syntax_node_create(child: CssSyntaxNode*) -> CssCommaSeparatedMultiplierSyntaxNode*:
    let this = &(new CssCommaSeparatedMultiplierSyntaxNode[1] --- else trap("out of memory"))[0]
    css_comma_separated_multiplier_syntax_node_construct(this, child)
    return this

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:100 Web::CSS::Parser::CommaSeparatedMultiplierSyntaxNode::CommaSeparatedMultiplierSyntaxNode.
pub func css_comma_separated_multiplier_syntax_node_construct(this: CssCommaSeparatedMultiplierSyntaxNode*, child: CssSyntaxNode*):
    css_syntax_node_construct(this.css_syntax_node(), CssSyntaxNodeNodeType.comma_separated_multiplier)
    css_syntax_node_set_class(this.css_syntax_node(), (const CssSyntaxNodeVTable*)&css_comma_separated_multiplier_syntax_node_vtable,
                              &css_comma_separated_multiplier_syntax_node_class)
    this.m_child = child

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:129 Web::CSS::Parser::CommaSeparatedMultiplierSyntaxNode::child.
pub func css_comma_separated_multiplier_syntax_node_child(this: CssCommaSeparatedMultiplierSyntaxNode*) -> CssSyntaxNode*:
    return this.m_child

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:108 Web::CSS::Parser::CommaSeparatedMultiplierSyntaxNode::to_string (override).
pub func css_comma_separated_multiplier_syntax_node_to_string_impl(base: CssSyntaxNode*) -> ak.String:
    let this = (CssCommaSeparatedMultiplierSyntaxNode*)base
    let child = css_syntax_node_to_string(this.m_child)
    return css_string_formatted("{}#", [css_arg_string(&child)])

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:113 Web::CSS::Parser::CommaSeparatedMultiplierSyntaxNode::dump (override).
pub func css_comma_separated_multiplier_syntax_node_dump_string_builder_impl(base: CssSyntaxNode*, builder: ak.StringBuilder*, indent: i32):
    let this = (CssCommaSeparatedMultiplierSyntaxNode*)base
    css_syntax_node_dump_indent(builder, indent)
    ak.string_builder_append_string_view(builder, ak.sv("CommaSeparatedMultiplier:\n"))
    css_syntax_node_dump_string_builder(this.m_child, builder, indent + 2)

# mark: AlternativesSyntaxNode ==================================================================

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:142 Web::CSS::Parser::AlternativesSyntaxNode::create.
pub func css_alternatives_syntax_node_create(children: ak.Vector[CssSyntaxNode*]) -> CssAlternativesSyntaxNode*:
    let this = &(new CssAlternativesSyntaxNode[1] --- else trap("out of memory"))[0]
    css_alternatives_syntax_node_construct(this, children)
    return this

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:119 Web::CSS::Parser::AlternativesSyntaxNode::AlternativesSyntaxNode.
pub func css_alternatives_syntax_node_construct(this: CssAlternativesSyntaxNode*, children: ak.Vector[CssSyntaxNode*]):
    css_syntax_node_construct(this.css_syntax_node(), CssSyntaxNodeNodeType.alternatives)
    css_syntax_node_set_class(this.css_syntax_node(), (const CssSyntaxNodeVTable*)&css_alternatives_syntax_node_vtable, &css_alternatives_syntax_node_class)
    this.m_children = children

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.h:148 Web::CSS::Parser::AlternativesSyntaxNode::children.
pub func css_alternatives_syntax_node_children_2(this: CssAlternativesSyntaxNode*) -> const (CssSyntaxNode*)[]:
    return ak.vector_span_const(&this.m_children)

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:127 Web::CSS::Parser::AlternativesSyntaxNode::to_string (override).
pub func css_alternatives_syntax_node_to_string_impl(base: CssSyntaxNode*) -> ak.String:
    let this = (CssAlternativesSyntaxNode*)base
    var builder = ak.string_builder_new()

    var first = true
    for child in ak.vector_span_const(&this.m_children):
        if first:
            first = false
        else:
            ak.string_builder_append_string_view(&builder, ak.sv(" | "))
        let child_string = css_syntax_node_to_string(child)
        ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&child_string))

    return ak.string_builder_to_string_without_validation(&builder)

## Ported from Libraries/LibWeb/CSS/Parser/Syntax.cpp:144 Web::CSS::Parser::AlternativesSyntaxNode::dump (override).
pub func css_alternatives_syntax_node_dump_string_builder_impl(base: CssSyntaxNode*, builder: ak.StringBuilder*, indent: i32):
    let this = (CssAlternativesSyntaxNode*)base
    css_syntax_node_dump_indent(builder, indent)
    ak.string_builder_append_string_view(builder, ak.sv("Alternatives:\n"))
    for child in ak.vector_span_const(&this.m_children):
        css_syntax_node_dump_string_builder(child, builder, indent + 2)