Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / tools / gen_css_values / emit_math_functions.lucb

#==============================================================================================
#
#   emit_math_functions - Parser::parse_math_function from MathFunctions.json
#
#   DESCRIPTION:
#       Port of the engine half of Meta/Generators/generate_libweb_css_math_functions.py
#       (write_implementation_file from `namespace Web::CSS::Parser` on: TYPE_CHECKS,
#       generate_calculation_type_check, parse_rounding_strategy and parse_math_function).
#       The MathFunction enum and math_function_from_string are css_data's
#       (luce-browser-css tools/gen_css). The Python writes one branch per function into
#       parse_math_function; here each branch is a function of its own, which
#       parse_math_function calls in the same order, and the ErrorReporter call every
#       branch repeats is one helper.
#
#==============================================================================================

# mark: Type checks =============================================================================

## generate_libweb_css_math_functions.py's TYPE_CHECKS: the NumericType check of a type, and
## whether it takes `percentages_resolve_as`.
func math_type_check(type_name: str) -> (str, bool):
    if type_name == "<angle>": return ("angle", true)
    if type_name == "<dimension>": return ("dimension", false)
    if type_name == "<flex>": return ("flex", true)
    if type_name == "<frequency>": return ("frequency", true)
    if type_name == "<length>": return ("length", true)
    if type_name == "<number>": return ("number", true)
    if type_name == "<percentage>": return ("percentage", false)
    if type_name == "<resolution>": return ("resolution", true)
    if type_name == "<time>": return ("time", true)
    trap(f"I don't know what '{type_name}' is!")

## Ported from generate_calculation_type_check: the `||` of the checks of `parameter_types`
## ("<number>|<dimension>") on the NumericType `variable`.
func generate_calculation_type_check(variable: str, parameter_types: str) -> str!:
    var builder: collections.Buffer
    var parts = try strings.SplitIterator.over(parameter_types, "|")
    var first = true
    while let allowed_type_name = parts.next():
        let (check, takes_percentages) = math_type_check(allowed_type_name)
        if not first:
            try builder.put_text(" or ")
        first = false
        try builder.put_text(try cat(["css_numeric_type_matches_", check, "(&", variable]))
        if takes_percentages:
            try builder.put_text(", percentages_resolve_as")
        try builder.put_text(")")
    return builder.text()

# mark: The fragment ============================================================================

## The `ErrorReporter::the().report(InvalidValueError { .value_type = "name()", ... })` line.
func put_report(out: Out*, indent: str, name: str, description: str) -> !:
    try out.line(f"{indent}css_math_function_report_invalid_value(\"{name}()\", stream, {description})")

## A `"..."_string` description.
func plain_description(text: str) -> str!:
    return try cat(["ak.string_from_str(", try literal(text), ")"])

## A `MUST(String::formatted("...", arguments...))` description.
func formatted_description(fmtstr: str, arguments: str) -> str!:
    return try cat(["css_string_formatted(", try literal(fmtstr), ", [", arguments, "])"])

## Emit generated/math_functions.lucb from MathFunctions.json.
func emit_math_functions(functions_data: const Json*) -> str!:
    var out = try Out.create()
    try put_header(&out, "math_functions", "Parser::parse_math_function: parsing the CSS math functions", [
        "Generated by tools/gen_css_values from data/css/MathFunctions.json; do not edit. The C++",
        "it stands for, at Ladybird 47c82b38d0, is the Web::CSS::Parser part of",
        "Build/Libraries/LibWeb/CSS/MathFunctions.cpp, written by",
        "Meta/Generators/generate_libweb_css_math_functions.py. The MathFunction enum and",
        "math_function_from_string of the same file are css_data's.",
        "",
        "Copyright (c) 2022-2026, Sam Atkins <sam@ladybird.org>",
        "Copyright (c) 2026-present, the Ladybird developers.",
        "Copyright (c) 2026 the luce-browser authors.",
        "SPDX-License-Identifier: BSD-2-Clause (see data/css/LICENSE)",
    ])
    try put_rounding_strategy(&out)
    try put_mark(&out, "parse_math_function")
    try out.line("## Ported from Build/Libraries/LibWeb/CSS/MathFunctions.cpp Web::CSS::Parser::Parser::parse_math_function.")
    try out.line("pub func css_parser_parse_math_function(this: CssParser*, function: const css_syntax.Function*, context: const CssCalculationContext*) -> CssCalculationNode*?:")
    try out.line("    var stream = css_syntax.token_stream_create(function.value)")
    try out.line("    let arguments = css_parser_parse_a_comma_separated_list_of_component_values(this, &stream)")
    try out.line("    let percentages_resolve_as = context.percentages_resolve_as")
    for index in 0..<functions_data.count:
        let name = functions_data.key(index)
        try out.line(f"    if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv({try literal(name)})):")
        try out.line(f"        return css_parser_parse_math_function_{try snake_casify(name)}(this, &stream, &arguments, context, percentages_resolve_as)")
    try out.blank()
    try out.line("    return none")

    for index in 0..<functions_data.count:
        try put_math_function(&out, functions_data.key(index), functions_data.at(index))
    return out.text()

## parse_rounding_strategy and the report helper.
func put_rounding_strategy(out: Out*) -> !:
    try put_mark(out, "parse_rounding_strategy")
    try out.line("## Ported from Build/Libraries/LibWeb/CSS/MathFunctions.cpp Web::CSS::Parser::parse_rounding_strategy.")
    try out.line("func css_parse_rounding_strategy(stream: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> css_data.RoundingStrategy?:")
    try out.line("    css_syntax.token_stream_discard_whitespace(stream)")
    try out.line("    if not css_syntax.token_stream_has_next_token(stream):")
    try out.line("        return none")
    try out.blank()
    try out.line("    let ident = css_syntax.token_stream_consume_a_token(stream)")
    try out.line("    if not css_syntax.component_value_is(&ident, .ident):")
    try out.line("        return none")
    try out.blank()
    try out.line("    css_syntax.token_stream_discard_whitespace(stream)")
    try out.line("    if css_syntax.token_stream_has_next_token(stream):")
    try out.line("        return none")
    try out.blank()
    try out.line("    let name = css_component_value_ident(&ident)")
    try out.line("    let maybe_keyword = css_data.keyword_from_string(ak.fly_string_bytes_as_string_view(&name)) else return none")
    try out.blank()
    try out.line("    return css_data.keyword_to_rounding_strategy(maybe_keyword)")
    try out.blank()
    try out.line("## `ErrorReporter::the().report(InvalidValueError { .value_type = \"<name>()\"_fly_string,")
    try out.line("## .value_string = stream.dump_string(), .description })`, which every branch makes.")
    try out.line("func css_math_function_report_invalid_value(value_type: str, stream: css_syntax.TokenStream[css_syntax.ComponentValue]*, description: ak.String):")
    try out.line("    css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_value_error(CssInvalidValueError(")
    try out.line("        value_type = ak.fly_string_from_str(value_type),")
    try out.line("        value_string = css_syntax.token_stream_dump_string(stream),")
    try out.line("        description = description,")
    try out.line("    )))")

## The branch of one math function: a function of its own.
func put_math_function(out: Out*, name: str, function_data: const Json*) -> !:
    let parameters = function_data.get("parameters") else trap("a math function without parameters")
    var requires_same_parameters = true
    if let parameter_validation_rule = function_data.get("parameter-validation"):
        requires_same_parameters = parameter_validation_rule.string() == "same"
    let name_titlecase = try title_casify(name)
    let create = try cat(["css_", try luce_snake(name_titlecase), "_calculation_node_create"])

    try out.blank()
    try out.line(f"## The `{name}` branch of parse_math_function.")
    try out.line(f"func css_parser_parse_math_function_{try snake_casify(name)}(this: CssParser*, stream: css_syntax.TokenStream[css_syntax.ComponentValue]*, arguments: const ak.Vector[ak.Vector[css_syntax.ComponentValue]]*, context: const CssCalculationContext*, percentages_resolve_as: CssValueType?) -> CssCalculationNode*?:")

    var is_variadic = false
    if let variadic = function_data.get("is-variadic"):
        is_variadic = variadic.text == "true"
    if is_variadic:
        try put_variadic_function(out, name, parameters, requires_same_parameters, create)
    else:
        try put_fixed_function(out, name, parameters, requires_same_parameters, create)

## A variadic function: every argument is a calculation of an accepted type.
func put_variadic_function(out: Out*, name: str, parameters: const Json*, requires_same_parameters: bool, create: str) -> !:
    try out.line("    var determined_argument_type: CssNumericType? = none")
    try out.line("    var parsed_arguments = ak.Vector[CssCalculationNode*]()")
    try out.line("    ak.vector_ensure_capacity(&parsed_arguments, ak.vector_size(arguments))")
    try out.blank()
    try out.line("    for argument in ak.vector_span_const(arguments):")
    try out.line("        var tokens = css_syntax.token_stream_create(argument)")
    try out.line("        let maybe_calculation_node = css_parser_parse_a_calculation(this, &tokens, *context)")
    try out.line("        if maybe_calculation_node == none:")
    try put_report(out, "            ", name, try formatted_description("Argument #{} is not a valid calculation.", "ak.arg_u64((u64)ak.vector_size(&parsed_arguments))"))
    try out.line("            return none")
    try out.line("        let calculation_node = maybe_calculation_node else trap(\"VERIFY: a calculation\")")
    try out.blank()
    try out.line("        let maybe_argument_type = css_calculation_node_numeric_type(calculation_node)")
    try out.line("        if maybe_argument_type == none:")
    try put_report(out, "            ", name, try formatted_description("Argument #{} couldn't determine its type.", "ak.arg_u64((u64)ak.vector_size(&parsed_arguments))"))
    try out.line("            return none")
    try out.line("        let argument_type = maybe_argument_type else trap(\"VERIFY: a type\")")
    try out.blank()
    assert(parameters.count == 1)
    let parameter_type_string = parameters.at(0).get("type") else trap("a parameter without a type")
    let type_check = try generate_calculation_type_check("argument_type", parameter_type_string.string())
    try out.line(f"        if not ({type_check}):")
    try out.line("            let dumped = css_numeric_type_dump(&argument_type)")
    try put_report(out, "            ", name, try formatted_description("Argument #{} type ({}) is not an accepted type.",
                                                                        "ak.arg_u64((u64)ak.vector_size(&parsed_arguments)), css_arg_string(&dumped)"))
    try out.line("            return none")
    try out.blank()
    try out.line("        if let previous_type = determined_argument_type:")
    if requires_same_parameters:
        try out.line("            if previous_type != argument_type:")
        try out.line("                let dumped = css_numeric_type_dump(&argument_type)")
        try out.line("                let previous_dumped = css_numeric_type_dump(&previous_type)")
        try put_report(out, "                ", name, try formatted_description("Argument #{} type ({}) doesn't match type of previous arguments ({}).",
                                                                                "ak.arg_u64((u64)ak.vector_size(&parsed_arguments)), css_arg_string(&dumped), css_arg_string(&previous_dumped)"))
        try out.line("                return none")
    else:
        try out.line("            if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type):")
        try out.line("                determined_argument_type = consistent_type")
        try out.line("            else:")
        try out.line("                let dumped = css_numeric_type_dump(&argument_type)")
        try out.line("                let previous_dumped = css_numeric_type_dump(&previous_type)")
        try put_report(out, "                ", name, try formatted_description("Argument #{} type ({}) is not consistent with type of previous arguments ({}).",
                                                                                "ak.arg_u64((u64)ak.vector_size(&parsed_arguments)), css_arg_string(&dumped), css_arg_string(&previous_dumped)"))
        try out.line("                return none")
    try out.line("        else:")
    try out.line("            determined_argument_type = argument_type")
    try out.blank()
    try out.line("        ak.vector_append_t(&parsed_arguments, calculation_node)")
    try out.blank()
    try out.line(f"    return {create}(parsed_arguments).css_calculation_node()")

## A function with specified parameters.
func put_fixed_function(out: Out*, name: str, parameters: const Json*, requires_same_parameters: bool, create: str) -> !:
    var min_argument_count: usize = 0
    for index in 0..<parameters.count:
        if let required = parameters.at(index).get("required"):
            if required.text == "true":
                min_argument_count += 1
    let max_argument_count = parameters.count

    if name == "random":
        try out.line("    if not css_parser_context_allows_random_functions(this):")
        try out.line("        return none")
        try out.blank()
        try out.line("    this.m_random_function_index += 1")
        try out.blank()

    try out.line(f"    if ak.vector_size(arguments) < {min_argument_count} or ak.vector_size(arguments) > {max_argument_count}:")
    try put_report(out, "        ", name, try formatted_description(try cat(["Wrong number of arguments {}, expected between ", try decimal(min_argument_count), " and ", try decimal(max_argument_count), " inclusive."]),
                                                                    "ak.arg_u64((u64)ak.vector_size(arguments))"))
    try out.line("        return none")
    try out.line("    var argument_index: usize = 0")
    try out.line("    var determined_argument_type: CssNumericType? = none")

    for parameter_index in 0..<parameters.count:
        let parameter = parameters.at(parameter_index)
        let parameter_type_string = (parameter.get("type") else trap("a parameter without a type")).string()
        let parameter_required = (parameter.get("required") else trap("a parameter without required")).text == "true"
        let parameter_name = (parameter.get("name") else trap("a parameter without a name")).string()
        let index = try decimal(parameter_index)

        var parameter_is_calculation = false
        var parameter_declaration: str
        var parse_function: str
        if parameter_type_string == "<rounding-strategy>":
            parse_function = try cat(["css_parse_rounding_strategy(&tokens_", index, ")"])
            if let default_value = parameter.get("default"):
                parameter_declaration = try cat(["var parameter_", index, " = css_data.RoundingStrategy.", try luce_case(try title_casify(default_value.string()))])
            else:
                parameter_declaration = try cat(["var parameter_", index, ": css_data.RoundingStrategy"])
        elif parameter_type_string == "<random-value-sharing>":
            parse_function = try cat(["css_parser_parse_random_value_sharing(this, &tokens_", index, ")"])
            parameter_declaration = try cat(["var parameter_", index, ": CssRandomValueSharingStyleValue*? = css_random_value_sharing_style_value_create_auto(css_parser_random_value_sharing_auto_name(this), false)"])
        else:
            # NOTE: This assumes everything not handled above is a calculation node of some kind.
            parameter_is_calculation = true
            parse_function = try cat(["css_parser_parse_a_calculation(this, &tokens_", index, ", *context)"])
            if let default_value = parameter.get("default"):
                parameter_declaration = try cat(["var parameter_", index, " = (CssCalculationNode*?)css_numeric_calculation_node_from_keyword(css_data.Keyword.",
                                                 try luce_case(try title_casify(default_value.string())), ", *context)"])
            else:
                parameter_declaration = try cat(["var parameter_", index, ": CssCalculationNode*? = none"])

        try out.blank()
        try out.line(f"    {parameter_declaration}")
        if parameter_required:
            try out.line("    if argument_index >= ak.vector_size(arguments):")
            try put_report(out, "        ", name, try plain_description(try cat(["Missing required argument '", parameter_name, "'."])))
            try out.line("        return none")
            try out.line("    else:")
        else:
            try out.line("    if argument_index < ak.vector_size(arguments):")
        try out.line(f"        var tokens_{index} = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))")
        try out.line(f"        if let parsed_argument_{index} = {parse_function}:")
        try out.line(f"            parameter_{index} = parsed_argument_{index}")
        try out.line("            argument_index += 1")
        if parameter_required:
            try out.line("        else:")
            try put_report(out, "            ", name, try plain_description(try cat(["Failed to parse required argument '", parameter_name, "'."])))
            try out.line("            return none")

        if parameter_is_calculation:
            let variable = try cat(["argument_type_", index])
            let type_check = try generate_calculation_type_check(variable, parameter_type_string)
            try out.blank()
            try out.line(f"    if let parameter_value_{index} = parameter_{index}:")
            try out.line(f"        let maybe_argument_type_{index} = css_calculation_node_numeric_type(parameter_value_{index})")
            try out.line(f"        if maybe_argument_type_{index} == none:")
            try put_report(out, "            ", name, try plain_description(try cat(["Argument '", parameter_name, "' couldn't determine its type."])))
            try out.line("            return none")
            try out.line(f"        let {variable} = maybe_argument_type_{index} else trap(\"VERIFY: a type\")")
            try out.blank()
            try out.line(f"        if not ({type_check}):")
            try out.line(f"            let dumped = css_numeric_type_dump(&{variable})")
            try put_report(out, "            ", name, try formatted_description(try cat(["Argument '", parameter_name, "' type ({}) is not an accepted type."]), "css_arg_string(&dumped)"))
            try out.line("            return none")
            try out.blank()
            try out.line("        if let previous_type = determined_argument_type:")
            if requires_same_parameters:
                try out.line(f"            if previous_type != {variable}:")
                try out.line(f"                let dumped = css_numeric_type_dump(&{variable})")
                try out.line("                let previous_dumped = css_numeric_type_dump(&previous_type)")
                try put_report(out, "                ", name, try formatted_description(try cat(["Argument '", parameter_name, "' type ({}) doesn't match type of previous arguments ({})."]),
                                                                                        "css_arg_string(&dumped), css_arg_string(&previous_dumped)"))
                try out.line("                return none")
            else:
                try out.line(f"            if let consistent_type = css_numeric_type_consistent_type(&previous_type, {variable}):")
                try out.line("                determined_argument_type = consistent_type")
                try out.line("            else:")
                try out.line(f"                let dumped = css_numeric_type_dump(&{variable})")
                try out.line("                let previous_dumped = css_numeric_type_dump(&previous_type)")
                try put_report(out, "                ", name, try formatted_description(try cat(["Argument '", parameter_name, "' type ({}) is not consistent with type of previous arguments ({})."]),
                                                                                        "css_arg_string(&dumped), css_arg_string(&previous_dumped)"))
                try out.line("                return none")
            try out.line("        else:")
            try out.line(f"            determined_argument_type = {variable}")

    try out.blank()
    try out.line("    if argument_index < ak.vector_size(arguments):")
    try out.line("        return none")

    # Generate the call to the constructor
    var call: collections.Buffer
    try call.put_text(create)
    try call.put_text("(")
    for parameter_index in 0..<parameters.count:
        let parameter = parameters.at(parameter_index)
        let parameter_type_string = (parameter.get("type") else trap("a parameter without a type")).string()
        let parameter_required = (parameter.get("required") else trap("a parameter without required")).text == "true"
        if parameter_index > 0:
            try call.put_text(", ")
        try call.put_text(try cat(["parameter_", try decimal(parameter_index)]))
        if parameter_type_string != "<rounding-strategy>" and (parameter_required or parameter.has("default")):
            try call.put_text(" else trap(\"VERIFY: release_nonnull\")")
    try call.put_text(").css_calculation_node()")
    try out.line(f"    return {call.text()}")

## `value` in decimal.
func decimal(value: usize) -> str!:
    var builder: collections.Buffer
    _ = try builder.write(f"{value}")
    return builder.text()