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