dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / generated / math_functions.lucb
#==============================================================================================
#
# math_functions - Parser::parse_math_function: parsing the CSS math functions
#
# DESCRIPTION:
# 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)
#
#==============================================================================================
# mark: parse_rounding_strategy =================================================================
## Ported from Build/Libraries/LibWeb/CSS/MathFunctions.cpp Web::CSS::Parser::parse_rounding_strategy.
func css_parse_rounding_strategy(stream: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> css_data.RoundingStrategy?:
css_syntax.token_stream_discard_whitespace(stream)
if not css_syntax.token_stream_has_next_token(stream):
return none
let ident = css_syntax.token_stream_consume_a_token(stream)
if not css_syntax.component_value_is(&ident, .ident):
return none
css_syntax.token_stream_discard_whitespace(stream)
if css_syntax.token_stream_has_next_token(stream):
return none
let name = css_component_value_ident(&ident)
let maybe_keyword = css_data.keyword_from_string(ak.fly_string_bytes_as_string_view(&name)) else return none
return css_data.keyword_to_rounding_strategy(maybe_keyword)
## `ErrorReporter::the().report(InvalidValueError { .value_type = "<name>()"_fly_string,
## .value_string = stream.dump_string(), .description })`, which every branch makes.
func css_math_function_report_invalid_value(value_type: str, stream: css_syntax.TokenStream[css_syntax.ComponentValue]*, description: ak.String):
css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_value_error(CssInvalidValueError(
value_type = ak.fly_string_from_str(value_type),
value_string = css_syntax.token_stream_dump_string(stream),
description = description,
)))
# mark: parse_math_function =====================================================================
## Ported from Build/Libraries/LibWeb/CSS/MathFunctions.cpp Web::CSS::Parser::Parser::parse_math_function.
pub func css_parser_parse_math_function(this: CssParser*, function: const css_syntax.Function*, context: const CssCalculationContext*) -> CssCalculationNode*?:
var stream = css_syntax.token_stream_create(function.value)
let arguments = css_parser_parse_a_comma_separated_list_of_component_values(this, &stream)
let percentages_resolve_as = context.percentages_resolve_as
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("abs")):
return css_parser_parse_math_function_abs(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("acos")):
return css_parser_parse_math_function_acos(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("asin")):
return css_parser_parse_math_function_asin(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("atan")):
return css_parser_parse_math_function_atan(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("atan2")):
return css_parser_parse_math_function_atan2(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("clamp")):
return css_parser_parse_math_function_clamp(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("cos")):
return css_parser_parse_math_function_cos(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("exp")):
return css_parser_parse_math_function_exp(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("hypot")):
return css_parser_parse_math_function_hypot(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("log")):
return css_parser_parse_math_function_log(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("max")):
return css_parser_parse_math_function_max(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("min")):
return css_parser_parse_math_function_min(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("mod")):
return css_parser_parse_math_function_mod(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("pow")):
return css_parser_parse_math_function_pow(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("random")):
return css_parser_parse_math_function_random(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("rem")):
return css_parser_parse_math_function_rem(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("round")):
return css_parser_parse_math_function_round(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("sign")):
return css_parser_parse_math_function_sign(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("sin")):
return css_parser_parse_math_function_sin(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("sqrt")):
return css_parser_parse_math_function_sqrt(this, &stream, &arguments, context, percentages_resolve_as)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&function.name, ak.sv("tan")):
return css_parser_parse_math_function_tan(this, &stream, &arguments, context, percentages_resolve_as)
return none
## The `abs` branch of parse_math_function.
func css_parser_parse_math_function_abs(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("abs()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("abs()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("abs()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("abs()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_0) or css_numeric_type_matches_percentage(&argument_type_0)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("abs()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("abs()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_abs_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `acos` branch of parse_math_function.
func css_parser_parse_math_function_acos(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("acos()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("acos()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("acos()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("acos()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("acos()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("acos()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_acos_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `asin` branch of parse_math_function.
func css_parser_parse_math_function_asin(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("asin()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("asin()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("asin()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("asin()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("asin()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("asin()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_asin_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `atan` branch of parse_math_function.
func css_parser_parse_math_function_atan(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("atan()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("atan()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("atan()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("atan()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("atan()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("atan()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_atan_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `atan2` branch of parse_math_function.
func css_parser_parse_math_function_atan2(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*?:
if ak.vector_size(arguments) < 2 or ak.vector_size(arguments) > 2:
css_math_function_report_invalid_value("atan2()", stream, css_string_formatted("Wrong number of arguments {}, expected between 2 and 2 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("atan2()", stream, ak.string_from_str("Missing required argument 'y'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("atan2()", stream, ak.string_from_str("Failed to parse required argument 'y'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("atan2()", stream, ak.string_from_str("Argument 'y' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_0) or css_numeric_type_matches_percentage(&argument_type_0)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("atan2()", stream, css_string_formatted("Argument 'y' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_0):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("atan2()", stream, css_string_formatted("Argument 'y' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
var parameter_1: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("atan2()", stream, ak.string_from_str("Missing required argument 'x'."))
return none
else:
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
else:
css_math_function_report_invalid_value("atan2()", stream, ak.string_from_str("Failed to parse required argument 'x'."))
return none
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("atan2()", stream, ak.string_from_str("Argument 'x' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_1) or css_numeric_type_matches_percentage(&argument_type_1)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("atan2()", stream, css_string_formatted("Argument 'x' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_1):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("atan2()", stream, css_string_formatted("Argument 'x' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
if argument_index < ak.vector_size(arguments):
return none
return css_atan2_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull"), parameter_1 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `clamp` branch of parse_math_function.
func css_parser_parse_math_function_clamp(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*?:
if ak.vector_size(arguments) < 3 or ak.vector_size(arguments) > 3:
css_math_function_report_invalid_value("clamp()", stream, css_string_formatted("Wrong number of arguments {}, expected between 3 and 3 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Missing required argument 'min'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Failed to parse required argument 'min'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Argument 'min' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_0) or css_numeric_type_matches_percentage(&argument_type_0)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("clamp()", stream, css_string_formatted("Argument 'min' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_0):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("clamp()", stream, css_string_formatted("Argument 'min' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
var parameter_1: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Missing required argument 'central'."))
return none
else:
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
else:
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Failed to parse required argument 'central'."))
return none
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Argument 'central' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_1) or css_numeric_type_matches_percentage(&argument_type_1)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("clamp()", stream, css_string_formatted("Argument 'central' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_1):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("clamp()", stream, css_string_formatted("Argument 'central' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
var parameter_2: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Missing required argument 'max'."))
return none
else:
var tokens_2 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_2 = css_parser_parse_a_calculation(this, &tokens_2, *context):
parameter_2 = parsed_argument_2
argument_index += 1
else:
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Failed to parse required argument 'max'."))
return none
if let parameter_value_2 = parameter_2:
let maybe_argument_type_2 = css_calculation_node_numeric_type(parameter_value_2)
if maybe_argument_type_2 == none:
css_math_function_report_invalid_value("clamp()", stream, ak.string_from_str("Argument 'max' couldn't determine its type."))
return none
let argument_type_2 = maybe_argument_type_2 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_2, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_2) or css_numeric_type_matches_percentage(&argument_type_2)):
let dumped = css_numeric_type_dump(&argument_type_2)
css_math_function_report_invalid_value("clamp()", stream, css_string_formatted("Argument 'max' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_2):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_2)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("clamp()", stream, css_string_formatted("Argument 'max' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_2
if argument_index < ak.vector_size(arguments):
return none
return css_clamp_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull"), parameter_1 else trap("VERIFY: release_nonnull"), parameter_2 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `cos` branch of parse_math_function.
func css_parser_parse_math_function_cos(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("cos()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("cos()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("cos()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("cos()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_angle(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("cos()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("cos()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_cos_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `exp` branch of parse_math_function.
func css_parser_parse_math_function_exp(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("exp()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("exp()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("exp()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("exp()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("exp()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("exp()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_exp_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `hypot` branch of parse_math_function.
func css_parser_parse_math_function_hypot(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 determined_argument_type: CssNumericType? = none
var parsed_arguments = ak.Vector[CssCalculationNode*]()
ak.vector_ensure_capacity(&parsed_arguments, ak.vector_size(arguments))
for argument in ak.vector_span_const(arguments):
var tokens = css_syntax.token_stream_create(argument)
let maybe_calculation_node = css_parser_parse_a_calculation(this, &tokens, *context)
if maybe_calculation_node == none:
css_math_function_report_invalid_value("hypot()", stream, css_string_formatted("Argument #{} is not a valid calculation.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments))]))
return none
let calculation_node = maybe_calculation_node else trap("VERIFY: a calculation")
let maybe_argument_type = css_calculation_node_numeric_type(calculation_node)
if maybe_argument_type == none:
css_math_function_report_invalid_value("hypot()", stream, css_string_formatted("Argument #{} couldn't determine its type.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments))]))
return none
let argument_type = maybe_argument_type else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type) or css_numeric_type_matches_percentage(&argument_type)):
let dumped = css_numeric_type_dump(&argument_type)
css_math_function_report_invalid_value("hypot()", stream, css_string_formatted("Argument #{} type ({}) is not an accepted type.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments)), css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("hypot()", stream, css_string_formatted("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)]))
return none
else:
determined_argument_type = argument_type
ak.vector_append_t(&parsed_arguments, calculation_node)
return css_hypot_calculation_node_create(parsed_arguments).css_calculation_node()
## The `log` branch of parse_math_function.
func css_parser_parse_math_function_log(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 2:
css_math_function_report_invalid_value("log()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 2 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("log()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("log()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("log()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("log()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("log()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
var parameter_1 = (CssCalculationNode*?)css_numeric_calculation_node_from_keyword(css_data.Keyword.e, *context)
if argument_index < ak.vector_size(arguments):
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("log()", stream, ak.string_from_str("Argument 'base' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("log()", stream, css_string_formatted("Argument 'base' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_1:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("log()", stream, css_string_formatted("Argument 'base' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
if argument_index < ak.vector_size(arguments):
return none
return css_log_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull"), parameter_1 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `max` branch of parse_math_function.
func css_parser_parse_math_function_max(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 determined_argument_type: CssNumericType? = none
var parsed_arguments = ak.Vector[CssCalculationNode*]()
ak.vector_ensure_capacity(&parsed_arguments, ak.vector_size(arguments))
for argument in ak.vector_span_const(arguments):
var tokens = css_syntax.token_stream_create(argument)
let maybe_calculation_node = css_parser_parse_a_calculation(this, &tokens, *context)
if maybe_calculation_node == none:
css_math_function_report_invalid_value("max()", stream, css_string_formatted("Argument #{} is not a valid calculation.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments))]))
return none
let calculation_node = maybe_calculation_node else trap("VERIFY: a calculation")
let maybe_argument_type = css_calculation_node_numeric_type(calculation_node)
if maybe_argument_type == none:
css_math_function_report_invalid_value("max()", stream, css_string_formatted("Argument #{} couldn't determine its type.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments))]))
return none
let argument_type = maybe_argument_type else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type) or css_numeric_type_matches_percentage(&argument_type)):
let dumped = css_numeric_type_dump(&argument_type)
css_math_function_report_invalid_value("max()", stream, css_string_formatted("Argument #{} type ({}) is not an accepted type.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments)), css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("max()", stream, css_string_formatted("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)]))
return none
else:
determined_argument_type = argument_type
ak.vector_append_t(&parsed_arguments, calculation_node)
return css_max_calculation_node_create(parsed_arguments).css_calculation_node()
## The `min` branch of parse_math_function.
func css_parser_parse_math_function_min(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 determined_argument_type: CssNumericType? = none
var parsed_arguments = ak.Vector[CssCalculationNode*]()
ak.vector_ensure_capacity(&parsed_arguments, ak.vector_size(arguments))
for argument in ak.vector_span_const(arguments):
var tokens = css_syntax.token_stream_create(argument)
let maybe_calculation_node = css_parser_parse_a_calculation(this, &tokens, *context)
if maybe_calculation_node == none:
css_math_function_report_invalid_value("min()", stream, css_string_formatted("Argument #{} is not a valid calculation.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments))]))
return none
let calculation_node = maybe_calculation_node else trap("VERIFY: a calculation")
let maybe_argument_type = css_calculation_node_numeric_type(calculation_node)
if maybe_argument_type == none:
css_math_function_report_invalid_value("min()", stream, css_string_formatted("Argument #{} couldn't determine its type.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments))]))
return none
let argument_type = maybe_argument_type else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type) or css_numeric_type_matches_percentage(&argument_type)):
let dumped = css_numeric_type_dump(&argument_type)
css_math_function_report_invalid_value("min()", stream, css_string_formatted("Argument #{} type ({}) is not an accepted type.", [ak.arg_u64((u64)ak.vector_size(&parsed_arguments)), css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("min()", stream, css_string_formatted("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)]))
return none
else:
determined_argument_type = argument_type
ak.vector_append_t(&parsed_arguments, calculation_node)
return css_min_calculation_node_create(parsed_arguments).css_calculation_node()
## The `mod` branch of parse_math_function.
func css_parser_parse_math_function_mod(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*?:
if ak.vector_size(arguments) < 2 or ak.vector_size(arguments) > 2:
css_math_function_report_invalid_value("mod()", stream, css_string_formatted("Wrong number of arguments {}, expected between 2 and 2 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("mod()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("mod()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("mod()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_0) or css_numeric_type_matches_percentage(&argument_type_0)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("mod()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("mod()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
var parameter_1: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("mod()", stream, ak.string_from_str("Missing required argument 'divisor'."))
return none
else:
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
else:
css_math_function_report_invalid_value("mod()", stream, ak.string_from_str("Failed to parse required argument 'divisor'."))
return none
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("mod()", stream, ak.string_from_str("Argument 'divisor' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_1) or css_numeric_type_matches_percentage(&argument_type_1)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("mod()", stream, css_string_formatted("Argument 'divisor' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_1:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("mod()", stream, css_string_formatted("Argument 'divisor' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
if argument_index < ak.vector_size(arguments):
return none
return css_mod_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull"), parameter_1 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `pow` branch of parse_math_function.
func css_parser_parse_math_function_pow(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*?:
if ak.vector_size(arguments) < 2 or ak.vector_size(arguments) > 2:
css_math_function_report_invalid_value("pow()", stream, css_string_formatted("Wrong number of arguments {}, expected between 2 and 2 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("pow()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("pow()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("pow()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("pow()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_0):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("pow()", stream, css_string_formatted("Argument 'value' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
var parameter_1: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("pow()", stream, ak.string_from_str("Missing required argument 'exponent'."))
return none
else:
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
else:
css_math_function_report_invalid_value("pow()", stream, ak.string_from_str("Failed to parse required argument 'exponent'."))
return none
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("pow()", stream, ak.string_from_str("Argument 'exponent' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("pow()", stream, css_string_formatted("Argument 'exponent' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_1):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("pow()", stream, css_string_formatted("Argument 'exponent' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
if argument_index < ak.vector_size(arguments):
return none
return css_pow_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull"), parameter_1 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `random` branch of parse_math_function.
func css_parser_parse_math_function_random(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*?:
if not css_parser_context_allows_random_functions(this):
return none
this.m_random_function_index += 1
if ak.vector_size(arguments) < 2 or ak.vector_size(arguments) > 4:
css_math_function_report_invalid_value("random()", stream, css_string_formatted("Wrong number of arguments {}, expected between 2 and 4 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssRandomValueSharingStyleValue*? = css_random_value_sharing_style_value_create_auto(css_parser_random_value_sharing_auto_name(this), false)
if argument_index < ak.vector_size(arguments):
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_random_value_sharing(this, &tokens_0):
parameter_0 = parsed_argument_0
argument_index += 1
var parameter_1: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("random()", stream, ak.string_from_str("Missing required argument 'minimum'."))
return none
else:
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
else:
css_math_function_report_invalid_value("random()", stream, ak.string_from_str("Failed to parse required argument 'minimum'."))
return none
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("random()", stream, ak.string_from_str("Argument 'minimum' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_1) or css_numeric_type_matches_percentage(&argument_type_1)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("random()", stream, css_string_formatted("Argument 'minimum' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_1):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("random()", stream, css_string_formatted("Argument 'minimum' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
var parameter_2: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("random()", stream, ak.string_from_str("Missing required argument 'maximum'."))
return none
else:
var tokens_2 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_2 = css_parser_parse_a_calculation(this, &tokens_2, *context):
parameter_2 = parsed_argument_2
argument_index += 1
else:
css_math_function_report_invalid_value("random()", stream, ak.string_from_str("Failed to parse required argument 'maximum'."))
return none
if let parameter_value_2 = parameter_2:
let maybe_argument_type_2 = css_calculation_node_numeric_type(parameter_value_2)
if maybe_argument_type_2 == none:
css_math_function_report_invalid_value("random()", stream, ak.string_from_str("Argument 'maximum' couldn't determine its type."))
return none
let argument_type_2 = maybe_argument_type_2 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_2, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_2) or css_numeric_type_matches_percentage(&argument_type_2)):
let dumped = css_numeric_type_dump(&argument_type_2)
css_math_function_report_invalid_value("random()", stream, css_string_formatted("Argument 'maximum' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_2):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_2)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("random()", stream, css_string_formatted("Argument 'maximum' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_2
var parameter_3: CssCalculationNode*? = none
if argument_index < ak.vector_size(arguments):
var tokens_3 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_3 = css_parser_parse_a_calculation(this, &tokens_3, *context):
parameter_3 = parsed_argument_3
argument_index += 1
if let parameter_value_3 = parameter_3:
let maybe_argument_type_3 = css_calculation_node_numeric_type(parameter_value_3)
if maybe_argument_type_3 == none:
css_math_function_report_invalid_value("random()", stream, ak.string_from_str("Argument 'step' couldn't determine its type."))
return none
let argument_type_3 = maybe_argument_type_3 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_3, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_3) or css_numeric_type_matches_percentage(&argument_type_3)):
let dumped = css_numeric_type_dump(&argument_type_3)
css_math_function_report_invalid_value("random()", stream, css_string_formatted("Argument 'step' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_3):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_3)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("random()", stream, css_string_formatted("Argument 'step' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_3
if argument_index < ak.vector_size(arguments):
return none
return css_random_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull"), parameter_1 else trap("VERIFY: release_nonnull"), parameter_2 else trap("VERIFY: release_nonnull"), parameter_3).css_calculation_node()
## The `rem` branch of parse_math_function.
func css_parser_parse_math_function_rem(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*?:
if ak.vector_size(arguments) < 2 or ak.vector_size(arguments) > 2:
css_math_function_report_invalid_value("rem()", stream, css_string_formatted("Wrong number of arguments {}, expected between 2 and 2 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("rem()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("rem()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("rem()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_0) or css_numeric_type_matches_percentage(&argument_type_0)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("rem()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("rem()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
var parameter_1: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("rem()", stream, ak.string_from_str("Missing required argument 'divisor'."))
return none
else:
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
else:
css_math_function_report_invalid_value("rem()", stream, ak.string_from_str("Failed to parse required argument 'divisor'."))
return none
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("rem()", stream, ak.string_from_str("Argument 'divisor' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_1) or css_numeric_type_matches_percentage(&argument_type_1)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("rem()", stream, css_string_formatted("Argument 'divisor' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_1:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("rem()", stream, css_string_formatted("Argument 'divisor' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
if argument_index < ak.vector_size(arguments):
return none
return css_rem_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull"), parameter_1 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `round` branch of parse_math_function.
func css_parser_parse_math_function_round(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*?:
if ak.vector_size(arguments) < 2 or ak.vector_size(arguments) > 3:
css_math_function_report_invalid_value("round()", stream, css_string_formatted("Wrong number of arguments {}, expected between 2 and 3 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0 = css_data.RoundingStrategy.nearest
if argument_index < ak.vector_size(arguments):
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parse_rounding_strategy(&tokens_0):
parameter_0 = parsed_argument_0
argument_index += 1
var parameter_1: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("round()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_1 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_1 = css_parser_parse_a_calculation(this, &tokens_1, *context):
parameter_1 = parsed_argument_1
argument_index += 1
else:
css_math_function_report_invalid_value("round()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_1 = parameter_1:
let maybe_argument_type_1 = css_calculation_node_numeric_type(parameter_value_1)
if maybe_argument_type_1 == none:
css_math_function_report_invalid_value("round()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_1 = maybe_argument_type_1 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_1, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_1) or css_numeric_type_matches_percentage(&argument_type_1)):
let dumped = css_numeric_type_dump(&argument_type_1)
css_math_function_report_invalid_value("round()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_1):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_1)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("round()", stream, css_string_formatted("Argument 'value' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_1
var parameter_2: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("round()", stream, ak.string_from_str("Missing required argument 'interval'."))
return none
else:
var tokens_2 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_2 = css_parser_parse_a_calculation(this, &tokens_2, *context):
parameter_2 = parsed_argument_2
argument_index += 1
else:
css_math_function_report_invalid_value("round()", stream, ak.string_from_str("Failed to parse required argument 'interval'."))
return none
if let parameter_value_2 = parameter_2:
let maybe_argument_type_2 = css_calculation_node_numeric_type(parameter_value_2)
if maybe_argument_type_2 == none:
css_math_function_report_invalid_value("round()", stream, ak.string_from_str("Argument 'interval' couldn't determine its type."))
return none
let argument_type_2 = maybe_argument_type_2 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_2, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_2) or css_numeric_type_matches_percentage(&argument_type_2)):
let dumped = css_numeric_type_dump(&argument_type_2)
css_math_function_report_invalid_value("round()", stream, css_string_formatted("Argument 'interval' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if let consistent_type = css_numeric_type_consistent_type(&previous_type, argument_type_2):
determined_argument_type = consistent_type
else:
let dumped = css_numeric_type_dump(&argument_type_2)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("round()", stream, css_string_formatted("Argument 'interval' type ({}) is not consistent with type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_2
if argument_index < ak.vector_size(arguments):
return none
return css_round_calculation_node_create(parameter_0, parameter_1 else trap("VERIFY: release_nonnull"), parameter_2 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `sign` branch of parse_math_function.
func css_parser_parse_math_function_sign(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("sign()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("sign()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("sign()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("sign()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_dimension(&argument_type_0) or css_numeric_type_matches_percentage(&argument_type_0)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("sign()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("sign()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_sign_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `sin` branch of parse_math_function.
func css_parser_parse_math_function_sin(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("sin()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("sin()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("sin()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("sin()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_angle(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("sin()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("sin()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_sin_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `sqrt` branch of parse_math_function.
func css_parser_parse_math_function_sqrt(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("sqrt()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("sqrt()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("sqrt()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("sqrt()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("sqrt()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("sqrt()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_sqrt_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()
## The `tan` branch of parse_math_function.
func css_parser_parse_math_function_tan(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*?:
if ak.vector_size(arguments) < 1 or ak.vector_size(arguments) > 1:
css_math_function_report_invalid_value("tan()", stream, css_string_formatted("Wrong number of arguments {}, expected between 1 and 1 inclusive.", [ak.arg_u64((u64)ak.vector_size(arguments))]))
return none
var argument_index: usize = 0
var determined_argument_type: CssNumericType? = none
var parameter_0: CssCalculationNode*? = none
if argument_index >= ak.vector_size(arguments):
css_math_function_report_invalid_value("tan()", stream, ak.string_from_str("Missing required argument 'value'."))
return none
else:
var tokens_0 = css_syntax.token_stream_create(*ak.vector_at_const(arguments, argument_index))
if let parsed_argument_0 = css_parser_parse_a_calculation(this, &tokens_0, *context):
parameter_0 = parsed_argument_0
argument_index += 1
else:
css_math_function_report_invalid_value("tan()", stream, ak.string_from_str("Failed to parse required argument 'value'."))
return none
if let parameter_value_0 = parameter_0:
let maybe_argument_type_0 = css_calculation_node_numeric_type(parameter_value_0)
if maybe_argument_type_0 == none:
css_math_function_report_invalid_value("tan()", stream, ak.string_from_str("Argument 'value' couldn't determine its type."))
return none
let argument_type_0 = maybe_argument_type_0 else trap("VERIFY: a type")
if not (css_numeric_type_matches_number(&argument_type_0, percentages_resolve_as) or css_numeric_type_matches_angle(&argument_type_0, percentages_resolve_as)):
let dumped = css_numeric_type_dump(&argument_type_0)
css_math_function_report_invalid_value("tan()", stream, css_string_formatted("Argument 'value' type ({}) is not an accepted type.", [css_arg_string(&dumped)]))
return none
if let previous_type = determined_argument_type:
if previous_type != argument_type_0:
let dumped = css_numeric_type_dump(&argument_type_0)
let previous_dumped = css_numeric_type_dump(&previous_type)
css_math_function_report_invalid_value("tan()", stream, css_string_formatted("Argument 'value' type ({}) doesn't match type of previous arguments ({}).", [css_arg_string(&dumped), css_arg_string(&previous_dumped)]))
return none
else:
determined_argument_type = argument_type_0
if argument_index < ak.vector_size(arguments):
return none
return css_tan_calculation_node_create(parameter_0 else trap("VERIFY: release_nonnull")).css_calculation_node()