diff --git a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp index 4807d92f8f..2aa09f40ef 100644 --- a/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp +++ b/Userland/Libraries/LibWeb/CSS/Parser/Parser.cpp @@ -3383,680 +3383,6 @@ ErrorOr> Parser::parse_calculated_value(Vector> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> Parser::parse_log_function(Function const& function) -{ - TokenStream stream { function.values() }; - auto parameters = parse_a_comma_separated_list_of_component_values(stream); - - OwnPtr 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> 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> 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 node_a = nullptr; - OwnPtr 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> 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> 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> Parser::parse_dynamic_value(ComponentValue const& component_value) { if (component_value.is_function()) { @@ -4086,65 +3412,8 @@ ErrorOr> 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; } diff --git a/Userland/Libraries/LibWeb/CSS/Parser/Parser.h b/Userland/Libraries/LibWeb/CSS/Parser/Parser.h index 9fee2e552e..ee015dc657 100644 --- a/Userland/Libraries/LibWeb/CSS/Parser/Parser.h +++ b/Userland/Libraries/LibWeb/CSS/Parser/Parser.h @@ -293,26 +293,6 @@ private: // NOTE: Implemented in generated code. (GenerateCSSMathFunctions.cpp) ErrorOr> parse_math_function(PropertyID, Function const&); ErrorOr> parse_a_calc_function_node(Function const&); - ErrorOr> parse_min_function(Function const&); - ErrorOr> parse_max_function(Function const&); - ErrorOr> parse_clamp_function(Function const&); - ErrorOr> parse_abs_function(Function const&); - ErrorOr> parse_sign_function(Function const&); - ErrorOr> parse_sin_function(Function const&); - ErrorOr> parse_cos_function(Function const&); - ErrorOr> parse_tan_function(Function const&); - ErrorOr> parse_asin_function(Function const&); - ErrorOr> parse_acos_function(Function const&); - ErrorOr> parse_atan_function(Function const&); - ErrorOr> parse_atan2_function(Function const&); - ErrorOr> parse_pow_function(Function const&); - ErrorOr> parse_sqrt_function(Function const&); - ErrorOr> parse_hypot_function(Function const&); - ErrorOr> parse_log_function(Function const&); - ErrorOr> parse_exp_function(Function const&); - ErrorOr> parse_round_function(Function const&); - ErrorOr> parse_mod_function(Function const&); - ErrorOr> parse_rem_function(Function const&); ErrorOr> parse_dimension_value(ComponentValue const&); ErrorOr> parse_integer_value(TokenStream&); ErrorOr> parse_number_value(TokenStream&);