AK+Everywhere: Replace custom number parsers with fast_float

Our floating point number parser was based on the fast_float library: https://github.com/fastfloat/fast_float However, our implementation only supports 8-bit characters. To support UTF-16, we will need to be able to convert char16_t-based strings to numbers as well. This works out-of-the-box with fast_float. We can also use fast_float for integer parsing.
Author: https://github.com/trflynn89 Commit: https://github.com/LadybirdBrowser/ladybird/commit/62d9a84b8d7 Pull-request: https://github.com/LadybirdBrowser/ladybird/pull/5228 Reviewed-by: https://github.com/ADKaster ✅ Reviewed-by: https://github.com/shannonbooth
2026-04-26 01:35:08 +02:00 · 2025-06-26 19:06:46 -04:00 · 2025-07-03 13:53:10 +00:00
parent 9fc3e72db2
commit 62d9a84b8d
30 changed files with 413 additions and 3034 deletions
--- a/AK/StringConversions.cpp
+++ b/AK/StringConversions.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2022, David Tuin <davidot@serenityos.org>
+ * Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <AK/StringConversions.h>
+#include <AK/StringView.h>
+
+#include <fast_float/fast_float.h>
+
+namespace AK {
+
+#define ENUMERATE_INTEGRAL_TYPES    \
+    __ENUMERATE_TYPE(i8)            \
+    __ENUMERATE_TYPE(i16)           \
+    __ENUMERATE_TYPE(i32)           \
+    __ENUMERATE_TYPE(long)          \
+    __ENUMERATE_TYPE(long long)     \
+    __ENUMERATE_TYPE(u8)            \
+    __ENUMERATE_TYPE(u16)           \
+    __ENUMERATE_TYPE(u32)           \
+    __ENUMERATE_TYPE(unsigned long) \
+    __ENUMERATE_TYPE(unsigned long long)
+
+#define ENUMERATE_ARITHMETIC_TYPES \
+    ENUMERATE_INTEGRAL_TYPES       \
+    __ENUMERATE_TYPE(float)        \
+    __ENUMERATE_TYPE(double)
+
+template<Arithmetic T>
+Optional<ParseFirstNumberResult<T>> parse_first_number(StringView string, TrimWhitespace trim_whitespace, int base)
+{
+    if (trim_whitespace == TrimWhitespace::Yes)
+        string = StringUtils::trim_whitespace(string, TrimMode::Both);
+
+    auto const* begin = string.characters_without_null_termination();
+    auto const* end = begin + string.length();
+    T value { 0 };
+
+    fast_float::parse_options_t<char> options;
+    options.base = base;
+    options.format |= fast_float::chars_format::no_infnan;
+
+    if constexpr (IsSigned<T> || IsFloatingPoint<T>) {
+        options.format |= fast_float::chars_format::allow_leading_plus;
+    }
+
+    auto result = fast_float::from_chars_advanced(begin, end, value, options);
+
+    if constexpr (IsFloatingPoint<T>) {
+        if (result.ec == std::errc::result_out_of_range && (__builtin_isinf(value) || value == 0))
+            result.ec = {};
+    }
+
+    if (result.ec != std::errc {})
+        return {};
+
+    return ParseFirstNumberResult { value, static_cast<size_t>(result.ptr - begin) };
+}
+
+#define __ENUMERATE_TYPE(type) \
+    template Optional<ParseFirstNumberResult<type>> parse_first_number(StringView, TrimWhitespace, int);
+ENUMERATE_ARITHMETIC_TYPES
+#undef __ENUMERATE_TYPE
+
+template<Arithmetic T>
+Optional<T> parse_number(StringView string, TrimWhitespace trim_whitespace, int base)
+{
+    if (trim_whitespace == TrimWhitespace::Yes)
+        string = StringUtils::trim_whitespace(string, TrimMode::Both);
+
+    auto result = parse_first_number<T>(string, TrimWhitespace::No, base);
+    if (!result.has_value())
+        return {};
+
+    if (result->characters_parsed != string.length())
+        return {};
+
+    return result->value;
+}
+
+#define __ENUMERATE_TYPE(type) \
+    template Optional<type> parse_number(StringView, TrimWhitespace, int);
+ENUMERATE_ARITHMETIC_TYPES
+#undef __ENUMERATE_TYPE
+
+template<Integral T>
+Optional<T> parse_hexadecimal_number(StringView string, TrimWhitespace trim_whitespace)
+{
+    return parse_number<T>(string, trim_whitespace, 16);
+}
+
+#define __ENUMERATE_TYPE(type) \
+    template Optional<type> parse_hexadecimal_number(StringView, TrimWhitespace);
+ENUMERATE_INTEGRAL_TYPES
+#undef __ENUMERATE_TYPE
+
+}