RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 11:58:12 +00:00
Code Issues Activity Actions

LibWeb: Use generated math-function-parsing code

Browse source
This commit is contained in:
Sam Atkins 2023-07-13 15:18:28 +01:00 • committed by Andreas Kling
parent 618c0402a7
commit 8fc545992d
2 changed files with 2 additions and 753 deletions
Download patch file Download diff file Expand all files Collapse all files

735
Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp
View file

@ -3383,680 +3383,6 @@ ErrorOr<RefPtr<CalculatedStyleValue>> Parser::parse_calculated_value(Vector<Comp
return CalculatedStyleValue::create(calculation_tree.release_nonnull(), calc_type.release_value());
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_min_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() == 0) {
dbgln_if(CSS_PARSER_DEBUG, "min() must have at least 1 parameter"sv);
return nullptr;
}
Vector<NonnullOwnPtr<CalculationNode>> calculated_parameters;
calculated_parameters.ensure_capacity(parameters.size());
CalculatedStyleValue::ResolvedType type;
bool first = true;
for (auto& parameter : parameters) {
auto calculation_node = TRY(parse_a_calculation(parameter));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "min() parameters must be valid calculations"sv);
return nullptr;
}
auto parameter_type = calculation_node->resolved_type();
if (!parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for min() parameter #{}"sv, calculated_parameters.size() + 1);
return nullptr;
}
if (first) {
type = parameter_type.value();
first = false;
}
if (parameter_type != type) {
dbgln_if(CSS_PARSER_DEBUG, "min() parameters must all be of the same type"sv);
return nullptr;
}
calculated_parameters.append(calculation_node.release_nonnull());
}
return TRY(MinCalculationNode::create(move(calculated_parameters)));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_max_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() == 0) {
dbgln_if(CSS_PARSER_DEBUG, "max() must have at least 1 parameter"sv);
return nullptr;
}
Vector<NonnullOwnPtr<CalculationNode>> calculated_parameters;
calculated_parameters.ensure_capacity(parameters.size());
CalculatedStyleValue::ResolvedType type;
bool first = true;
for (auto& parameter : parameters) {
auto calculation_node = TRY(parse_a_calculation(parameter));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "max() parameters must be valid calculations"sv);
return nullptr;
}
auto parameter_type = calculation_node->resolved_type();
if (!parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for max() parameter #{}"sv, calculated_parameters.size() + 1);
return nullptr;
}
if (first) {
type = parameter_type.value();
first = false;
}
if (parameter_type != type) {
dbgln_if(CSS_PARSER_DEBUG, "max() parameters must all be of the same type"sv);
return nullptr;
}
calculated_parameters.append(calculation_node.release_nonnull());
}
return TRY(MaxCalculationNode::create(move(calculated_parameters)));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_clamp_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() != 3) {
dbgln_if(CSS_PARSER_DEBUG, "clamp() must have exactly three parameters"sv);
return nullptr;
}
Vector<NonnullOwnPtr<CalculationNode>> calculated_parameters;
calculated_parameters.ensure_capacity(parameters.size());
CalculatedStyleValue::ResolvedType type;
bool first = true;
for (auto& parameter : parameters) {
auto calculation_node = TRY(parse_a_calculation(parameter));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "clamp() parameters must be valid calculations"sv);
return nullptr;
}
auto parameter_type = calculation_node->resolved_type();
if (!parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for clamp() parameter #{}"sv, calculated_parameters.size() + 1);
return nullptr;
}
if (first) {
type = parameter_type.value();
first = false;
}
if (parameter_type != type) {
dbgln_if(CSS_PARSER_DEBUG, "clamp() parameters must all be of same type"sv);
return nullptr;
}
calculated_parameters.append(calculation_node.release_nonnull());
}
return TRY(ClampCalculationNode::create(move(calculated_parameters[0]), move(calculated_parameters[1]), move(calculated_parameters[2])));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_abs_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "abs() parameter must be a valid calculation"sv);
return nullptr;
}
return TRY(AbsCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_sign_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "sign() parameter must be a valid calculation"sv);
return nullptr;
}
return TRY(SignCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_sin_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "sin() parameter must be a valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = calculation_node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for sin() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number && resolved_type != CalculatedStyleValue::ResolvedType::Angle) {
dbgln_if(CSS_PARSER_DEBUG, "sin() parameter must be a number or angle"sv);
return nullptr;
}
return TRY(SinCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_cos_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "cos() parameter must be a valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = calculation_node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for cos() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number && resolved_type != CalculatedStyleValue::ResolvedType::Angle) {
dbgln_if(CSS_PARSER_DEBUG, "cos() parameter must be a number or angle"sv);
return nullptr;
}
return TRY(CosCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_tan_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "tan() parameter must be a valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = calculation_node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for tan() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number && resolved_type != CalculatedStyleValue::ResolvedType::Angle) {
dbgln_if(CSS_PARSER_DEBUG, "tan() parameter must be a number or angle"sv);
return nullptr;
}
return TRY(TanCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_asin_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "asin() parameter must be a valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = calculation_node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for asin() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number) {
dbgln_if(CSS_PARSER_DEBUG, "asin() parameter must be a number"sv);
return nullptr;
}
return TRY(AsinCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_acos_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "acos() parameter must be a valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = calculation_node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for acos() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number) {
dbgln_if(CSS_PARSER_DEBUG, "acos() parameter must be a number"sv);
return nullptr;
}
return TRY(AcosCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_atan_function(Function const& function)
{
auto calculation_node = TRY(parse_a_calculation(function.values()));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "atan() parameter must be a valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = calculation_node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for atan() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number) {
dbgln_if(CSS_PARSER_DEBUG, "atan() parameter must be a number"sv);
return nullptr;
}
return TRY(AtanCalculationNode::create(calculation_node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_atan2_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() != 2) {
dbgln_if(CSS_PARSER_DEBUG, "atan2() must have exactly two parameter"sv);
return nullptr;
}
auto node_a = TRY(parse_a_calculation(parameters[0]));
auto node_b = TRY(parse_a_calculation(parameters[1]));
if (!node_a || !node_b) {
dbgln_if(CSS_PARSER_DEBUG, "atan2() parameters must be valid calculations"sv);
return nullptr;
}
auto node_a_maybe_parameter_type = node_a->resolved_type();
if (!node_a_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for atan2() parameter 1"sv);
return nullptr;
}
auto node_b_maybe_parameter_type = node_b->resolved_type();
if (!node_b_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for atan2() parameter 2"sv);
return nullptr;
}
auto node_a_resolved_type = node_a_maybe_parameter_type.value();
auto node_b_resolved_type = node_b_maybe_parameter_type.value();
if (node_a_resolved_type != node_b_resolved_type) {
dbgln_if(CSS_PARSER_DEBUG, "atan2() parameters must be of the same type"sv);
return nullptr;
}
return TRY(Atan2CalculationNode::create(node_a.release_nonnull(), node_b.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_pow_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() != 2) {
dbgln_if(CSS_PARSER_DEBUG, "pow() must have exactly two parameters"sv);
return nullptr;
}
auto node_a = TRY(parse_a_calculation(parameters[0]));
auto node_b = TRY(parse_a_calculation(parameters[1]));
if (!node_a || !node_b) {
dbgln_if(CSS_PARSER_DEBUG, "pow() parameters must be valid calculations"sv);
return nullptr;
}
auto node_a_maybe_parameter_type = node_a->resolved_type();
if (!node_a_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for pow() parameter 1"sv);
return nullptr;
}
auto node_b_maybe_parameter_type = node_b->resolved_type();
if (!node_b_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for pow() parameter 2"sv);
return nullptr;
}
auto node_a_resolved_type = node_a_maybe_parameter_type.value();
auto node_b_resolved_type = node_b_maybe_parameter_type.value();
if (node_a_resolved_type != node_b_resolved_type) {
dbgln_if(CSS_PARSER_DEBUG, "pow() parameters must be of the same type"sv);
return nullptr;
}
if (node_a_resolved_type != CalculatedStyleValue::ResolvedType::Number) {
dbgln_if(CSS_PARSER_DEBUG, "pow() parameters must be numbers"sv);
return nullptr;
}
return TRY(PowCalculationNode::create(node_a.release_nonnull(), node_b.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_sqrt_function(Function const& function)
{
auto node = TRY(parse_a_calculation(function.values()));
if (!node) {
dbgln_if(CSS_PARSER_DEBUG, "sqrt() parameter must be valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for sqrt() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number)
return Error::from_string_view("sqrt() parameter must be number"sv);
return TRY(SqrtCalculationNode::create(node.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_hypot_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() == 0) {
dbgln_if(CSS_PARSER_DEBUG, "hypot() must have at least 1 parameter"sv);
return nullptr;
}
Vector<NonnullOwnPtr<CalculationNode>> calculated_parameters;
calculated_parameters.ensure_capacity(parameters.size());
CalculatedStyleValue::ResolvedType type;
bool first = true;
for (auto& parameter : parameters) {
auto calculation_node = TRY(parse_a_calculation(parameter));
if (!calculation_node) {
dbgln_if(CSS_PARSER_DEBUG, "hypot() parameters must be valid calculations"sv);
return nullptr;
}
auto maybe_parameter_type = calculation_node->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for hypot() parameter #{}"sv, calculated_parameters.size() + 1);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (first) {
type = resolved_type;
first = false;
}
if (resolved_type != type) {
dbgln_if(CSS_PARSER_DEBUG, "hypot() parameters must all be of the same type"sv);
return nullptr;
}
calculated_parameters.append(calculation_node.release_nonnull());
}
return TRY(HypotCalculationNode::create(move(calculated_parameters)));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_log_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
OwnPtr<CalculationNode> node_b;
if (parameters.size() == 1) {
node_b = TRY(ConstantCalculationNode::create(CalculationNode::ConstantType::E));
} else if (parameters.size() == 2) {
node_b = TRY(parse_a_calculation(parameters[1]));
} else {
dbgln_if(CSS_PARSER_DEBUG, "log() must have exactly one or two parameters"sv);
return nullptr;
}
auto node_a = TRY(parse_a_calculation(parameters[0]));
if (!node_a || !node_b) {
dbgln_if(CSS_PARSER_DEBUG, "log() parameters must be valid calculations"sv);
return nullptr;
}
auto node_a_maybe_parameter_type = node_a->resolved_type();
if (!node_a_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for log() parameter 1"sv);
return nullptr;
}
auto node_b_maybe_parameter_type = node_b->resolved_type();
if (!node_b_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for log() parameter 2"sv);
return nullptr;
}
auto node_a_resolved_type = node_a_maybe_parameter_type.value();
auto node_b_resolved_type = node_b_maybe_parameter_type.value();
if (node_a_resolved_type != node_b_resolved_type) {
dbgln_if(CSS_PARSER_DEBUG, "log() parameters must be of the same type"sv);
return nullptr;
}
if (node_a_resolved_type != CalculatedStyleValue::ResolvedType::Number) {
dbgln_if(CSS_PARSER_DEBUG, "log() parameters must be numbers"sv);
return nullptr;
}
return TRY(LogCalculationNode::create(node_a.release_nonnull(), node_b.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_exp_function(Function const& function)
{
auto node_a = TRY(parse_a_calculation(function.values()));
if (!node_a) {
dbgln_if(CSS_PARSER_DEBUG, "exp() parameter must be valid calculation"sv);
return nullptr;
}
auto maybe_parameter_type = node_a->resolved_type();
if (!maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for exp() parameter"sv);
return nullptr;
}
auto resolved_type = maybe_parameter_type.value();
if (resolved_type != CalculatedStyleValue::ResolvedType::Number) {
dbgln_if(CSS_PARSER_DEBUG, "exp() parameter must be number"sv);
return nullptr;
}
return TRY(ExpCalculationNode::create(node_a.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_round_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() != 2 && parameters.size() != 3) {
dbgln_if(CSS_PARSER_DEBUG, "round() must have exactly two or three parameters"sv);
return nullptr;
}
OwnPtr<CalculationNode> node_a = nullptr;
OwnPtr<CalculationNode> node_b = nullptr;
auto strategy = RoundingStrategy::Nearest;
if (parameters.size() == 3) {
auto rounding_strategy_component = parameters[0][0];
if (!rounding_strategy_component.is(Token::Type::Ident)) {
dbgln_if(CSS_PARSER_DEBUG, "round() strategy must be an ident"sv);
return nullptr;
}
auto maybe_value_id = value_id_from_string(rounding_strategy_component.token().ident());
if (!maybe_value_id.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "round() strategy must be one of 'nearest', 'up', 'down', or 'to-zero'"sv);
return nullptr;
}
if (auto maybe_strategy = value_id_to_rounding_strategy(maybe_value_id.value()); maybe_strategy.has_value()) {
strategy = maybe_strategy.value();
} else {
dbgln_if(CSS_PARSER_DEBUG, "round() strategy must be one of 'nearest', 'up', 'down', or 'to-zero'"sv);
return nullptr;
}
node_a = TRY(parse_a_calculation(parameters[1]));
node_b = TRY(parse_a_calculation(parameters[2]));
} else {
node_a = TRY(parse_a_calculation(parameters[0]));
node_b = TRY(parse_a_calculation(parameters[1]));
}
if (!node_a || !node_b) {
dbgln_if(CSS_PARSER_DEBUG, "round() parameters must be valid calculations"sv);
return nullptr;
}
auto node_a_maybe_parameter_type = node_a->resolved_type();
if (!node_a_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for round() parameter 1"sv);
return nullptr;
}
auto node_b_maybe_parameter_type = node_b->resolved_type();
if (!node_b_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for round() parameter 2"sv);
return nullptr;
}
auto node_a_resolved_type = node_a_maybe_parameter_type.value();
auto node_b_resolved_type = node_b_maybe_parameter_type.value();
if (node_a_resolved_type != node_b_resolved_type) {
dbgln_if(CSS_PARSER_DEBUG, "round() parameters must all be of the same type"sv);
return nullptr;
}
return TRY(RoundCalculationNode::create(strategy, node_a.release_nonnull(), node_b.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_mod_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() != 2) {
dbgln_if(CSS_PARSER_DEBUG, "mod() must have exactly two parameters"sv);
return nullptr;
}
auto node_a = TRY(parse_a_calculation(parameters[0]));
auto node_b = TRY(parse_a_calculation(parameters[1]));
if (!node_a || !node_b) {
dbgln_if(CSS_PARSER_DEBUG, "mod() parameters must be valid calculations"sv);
return nullptr;
}
auto node_a_maybe_parameter_type = node_a->resolved_type();
if (!node_a_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for mod() parameter 1"sv);
return nullptr;
}
auto node_b_maybe_parameter_type = node_b->resolved_type();
if (!node_b_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for mod() parameter 2"sv);
return nullptr;
}
auto node_a_resolved_type = node_a_maybe_parameter_type.value();
auto node_b_resolved_type = node_b_maybe_parameter_type.value();
if (node_a_resolved_type != node_b_resolved_type) {
dbgln_if(CSS_PARSER_DEBUG, "mod() parameters must all be of the same type"sv);
return nullptr;
}
return TRY(ModCalculationNode::create(node_a.release_nonnull(), node_b.release_nonnull()));
}
ErrorOr<OwnPtr<CalculationNode>> Parser::parse_rem_function(Function const& function)
{
TokenStream stream { function.values() };
auto parameters = parse_a_comma_separated_list_of_component_values(stream);
if (parameters.size() != 2) {
dbgln_if(CSS_PARSER_DEBUG, "rem() must have exactly two parameters"sv);
return nullptr;
}
auto node_a = TRY(parse_a_calculation(parameters[0]));
auto node_b = TRY(parse_a_calculation(parameters[1]));
if (!node_a || !node_b) {
dbgln_if(CSS_PARSER_DEBUG, "rem() parameters must be valid calculations"sv);
return nullptr;
}
auto node_a_maybe_parameter_type = node_a->resolved_type();
if (!node_a_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for rem() parameter 1"sv);
return nullptr;
}
auto node_b_maybe_parameter_type = node_b->resolved_type();
if (!node_b_maybe_parameter_type.has_value()) {
dbgln_if(CSS_PARSER_DEBUG, "Failed to resolve type for rem() parameter 2"sv);
return nullptr;
}
auto node_a_resolved_type = node_a_maybe_parameter_type.value();
auto node_b_resolved_type = node_b_maybe_parameter_type.value();
if (node_a_resolved_type != node_b_resolved_type) {
dbgln_if(CSS_PARSER_DEBUG, "rem() parameters must all be of the same type"sv);
return nullptr;
}
return TRY(RemCalculationNode::create(node_a.release_nonnull(), node_b.release_nonnull()));
}
ErrorOr<RefPtr<StyleValue>> Parser::parse_dynamic_value(ComponentValue const& component_value)
{
if (component_value.is_function()) {
@ -4086,65 +3412,8 @@ ErrorOr<OwnPtr<CalculationNode>> Parser::parse_a_calc_function_node(Function con
if (function.name().equals_ignoring_ascii_case("calc"sv))
return TRY(parse_a_calculation(function.values()));
if (function.name().equals_ignoring_ascii_case("min"sv))
return TRY(parse_min_function(function));
if (function.name().equals_ignoring_ascii_case("max"sv))
return TRY(parse_max_function(function));
if (function.name().equals_ignoring_ascii_case("clamp"sv))
return TRY(parse_clamp_function(function));
if (function.name().equals_ignoring_ascii_case("abs"sv))
return TRY(parse_abs_function(function));
if (function.name().equals_ignoring_ascii_case("sign"sv))
return TRY(parse_sign_function(function));
if (function.name().equals_ignoring_ascii_case("sin"sv))
return TRY(parse_sin_function(function));
if (function.name().equals_ignoring_ascii_case("cos"sv))
return TRY(parse_cos_function(function));
if (function.name().equals_ignoring_ascii_case("tan"sv))
return TRY(parse_tan_function(function));
if (function.name().equals_ignoring_ascii_case("asin"sv))
return TRY(parse_asin_function(function));
if (function.name().equals_ignoring_ascii_case("acos"sv))
return TRY(parse_acos_function(function));
if (function.name().equals_ignoring_ascii_case("atan"sv))
return TRY(parse_atan_function(function));
if (function.name().equals_ignoring_ascii_case("atan2"sv))
return TRY(parse_atan2_function(function));
if (function.name().equals_ignoring_ascii_case("pow"sv))
return TRY(parse_pow_function(function));
if (function.name().equals_ignoring_ascii_case("sqrt"sv))
return TRY(parse_sqrt_function(function));
if (function.name().equals_ignoring_ascii_case("hypot"sv))
return TRY(parse_hypot_function(function));
if (function.name().equals_ignoring_ascii_case("log"sv))
return TRY(parse_log_function(function));
if (function.name().equals_ignoring_ascii_case("exp"sv))
return TRY(parse_exp_function(function));
if (function.name().equals_ignoring_ascii_case("round"sv))
return TRY(parse_round_function(function));
if (function.name().equals_ignoring_ascii_case("mod"sv))
return TRY(parse_mod_function(function));
if (function.name().equals_ignoring_ascii_case("rem"sv))
return TRY(parse_rem_function(function));
if (auto maybe_function = TRY(parse_math_function(m_context.current_property_id(), function)); maybe_function)
return maybe_function;
return nullptr;
}