diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 3c428e6..03e02b4 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -5,3 +5,4 @@ Neal Richardson Tim Paine Fabio Pellacini Lénárd Szolnoki +Jan Pharago \ No newline at end of file diff --git a/README.md b/README.md index 1327f5a..fe1c1ca 100644 --- a/README.md +++ b/README.md @@ -97,6 +97,24 @@ constexpr double constexptest() { } ``` +## Non-ASCII Inputs + +We also support UTF-16 and UTF-32 inputs, as well as ASCII/UTF-8, as in the following example: + +``` C++ +#include "fast_float/fast_float.h" +#include + +int main() { + const std::u16string input = u"3.1416 xyz "; + double result; + auto answer = fast_float::from_chars(input.data(), input.data()+input.size(), result); + if(answer.ec != std::errc()) { std::cerr << "parsing failure\n"; return EXIT_FAILURE; } + std::cout << "parsed the number " << result << std::endl; + return EXIT_SUCCESS; +} +``` + ## Using commas as decimal separator diff --git a/include/fast_float/ascii_number.h b/include/fast_float/ascii_number.h index f583c2b..82a06b1 100644 --- a/include/fast_float/ascii_number.h +++ b/include/fast_float/ascii_number.h @@ -18,9 +18,9 @@ namespace fast_float { // Next function can be micro-optimized, but compilers are entirely // able to optimize it well. -template -fastfloat_really_inline constexpr bool is_integer(CharT c) noexcept { - return c >= CharT('0') && c <= CharT('9'); +template +fastfloat_really_inline constexpr bool is_integer(UC c) noexcept { + return !(c > UC('9') || c < UC('0')); } fastfloat_really_inline constexpr uint64_t byteswap(uint64_t val) { @@ -70,11 +70,11 @@ uint64_t simd_read8_to_u64(const char16_t* chars) { } #endif -// Read 8 CharT into a u64. Truncates CharT if != char. -template +// Read 8 UC into a u64. Truncates UC if not char. +template fastfloat_really_inline FASTFLOAT_CONSTEXPR20 -uint64_t read8_to_u64(const CharT *chars) { - if (cpp20_and_in_constexpr() || !std::is_same::value) { +uint64_t read8_to_u64(const UC *chars) { + if (cpp20_and_in_constexpr() || !std::is_same::value) { uint64_t val = 0; for(int i = 0; i < 8; ++i) { val |= uint64_t(char(*chars)) << (i*8); @@ -135,7 +135,7 @@ uint32_t parse_eight_digits_unrolled(const char16_t* chars) noexcept { #ifdef FASTFLOAT_HAS_SIMD return parse_eight_digits_unrolled(simd_read8_to_u64(chars)); #else - // never reaches here, remove warning + // never reaches here, removes warning return 0; #endif } @@ -150,7 +150,7 @@ uint32_t parse_eight_digits_unrolled(const char32_t* chars) noexcept { // credit @aqrit fastfloat_really_inline constexpr bool is_made_of_eight_digits_fast(uint64_t val) noexcept { return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) & - 0x8080808080808080)); + 0x8080808080808080)); } fastfloat_really_inline FASTFLOAT_CONSTEXPR20 @@ -199,50 +199,47 @@ bool parse_if_eight_digits_unrolled(const char32_t*, uint64_t&) noexcept { return false; } - - -typedef span byte_span; - -template -struct parsed_number_string { +template +struct parsed_number_string_t { int64_t exponent{0}; uint64_t mantissa{0}; int64_t exp_number{0}; - const CharT *lastmatch{nullptr}; + UC const * lastmatch{nullptr}; bool negative{false}; bool valid{false}; bool too_many_digits{false}; // contains the range of the significant digits - span integer{}; // non-nullable - span fraction{}; // nullable + span integer{}; // non-nullable + span fraction{}; // nullable }; - +using byte_span = span; +using parsed_number_string = parsed_number_string_t; // Assuming that you use no more than 19 digits, this will // parse an ASCII string. -template +template fastfloat_really_inline FASTFLOAT_CONSTEXPR20 -parsed_number_string parse_number_string(const CharT *p, const CharT *pend, parse_options options) noexcept { - const chars_format fmt = options.format; - const CharT decimal_point = options.decimal_point; +parsed_number_string_t parse_number_string(UC const *p, UC const * pend, parse_options_t options) noexcept { + chars_format const fmt = options.format; + UC const decimal_point = options.decimal_point; - parsed_number_string answer; + parsed_number_string_t answer; answer.valid = false; answer.too_many_digits = false; - answer.negative = (*p == CharT('-')); + answer.negative = (*p == UC('-')); #ifdef FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default - if ((*p == CharT('-')) || (*p == CharT('+'))) { + if ((*p == UC('-')) || (*p == UC('+'))) { #else - if (*p == CharT('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here + if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here #endif ++p; if (p == pend) { return answer; } - // a sign must be followed by an integer or the dot - if (!is_integer(*p) && *p != decimal_point) - return answer; + if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot + return answer; + } } - const CharT *const start_digits = p; + UC const * const start_digits = p; uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad) @@ -250,43 +247,42 @@ parsed_number_string parse_number_string(const CharT *p, const CharT *pen // a multiplication by 10 is cheaper than an arbitrary integer // multiplication i = 10 * i + - uint64_t(*p - CharT('0')); // might overflow, we will handle the overflow later + uint64_t(*p - UC('0')); // might overflow, we will handle the overflow later ++p; } - const CharT *const end_of_integer_part = p; + UC const * const end_of_integer_part = p; int64_t digit_count = int64_t(end_of_integer_part - start_digits); - answer.integer = span(start_digits, size_t(digit_count)); + answer.integer = span(start_digits, size_t(digit_count)); int64_t exponent = 0; - const bool has_decimal_point = (p != pend) && (*p == decimal_point); - if (has_decimal_point) { + if ((p != pend) && (*p == decimal_point)) { ++p; - const CharT* before = p; + UC const * before = p; // can occur at most twice without overflowing, but let it occur more, since // for integers with many digits, digit parsing is the primary bottleneck. while ((std::distance(p, pend) >= 8) && parse_if_eight_digits_unrolled(p, i)) { // in rare cases, this will overflow, but that's ok p += 8; } while ((p != pend) && is_integer(*p)) { - i = i * 10 + uint64_t(*p - CharT('0')); // in rare cases, this will overflow, but that's ok + uint8_t digit = uint8_t(*p - UC('0')); ++p; } exponent = before - p; - answer.fraction = span(before, size_t(p - before)); + answer.fraction = span(before, size_t(p - before)); digit_count -= exponent; } - // we must have encountered at least one integer + // we must have encountered at least one integer! if (digit_count == 0) { return answer; } int64_t exp_number = 0; // explicit exponential part - if ((fmt & chars_format::scientific) && (p != pend) && ((CharT('e') == *p) || (CharT('E') == *p))) { - const CharT * location_of_e = p; + if ((fmt & chars_format::scientific) && (p != pend) && ((UC('e') == *p) || (UC('E') == *p))) { + UC const * location_of_e = p; ++p; bool neg_exp = false; - if ((p != pend) && (CharT('-') == *p)) { + if ((p != pend) && (UC('-') == *p)) { neg_exp = true; ++p; - } else if ((p != pend) && (CharT('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) + } else if ((p != pend) && (UC('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) ++p; } if ((p == pend) || !is_integer(*p)) { @@ -298,7 +294,7 @@ parsed_number_string parse_number_string(const CharT *p, const CharT *pen p = location_of_e; } else { while ((p != pend) && is_integer(*p)) { - uint8_t digit = uint8_t(*p - CharT('0')); + uint8_t digit = uint8_t(*p - UC('0')); if (exp_number < 0x10000000) { exp_number = 10 * exp_number + digit; } @@ -325,13 +321,13 @@ parsed_number_string parse_number_string(const CharT *p, const CharT *pen // We have to handle the case where we have 0.0000somenumber. // We need to be mindful of the case where we only have zeroes... // E.g., 0.000000000...000. - const CharT *start = start_digits; - while ((start != pend) && (*start == CharT('0') || *start == decimal_point)) { - if(*start == CharT('0')) { digit_count --; } + UC const * start = start_digits; + while ((start != pend) && (*start == UC('0') || *start == decimal_point)) { + if(*start == UC('0')) { digit_count --; } start++; } - // exponent/mantissa must be truncated later + // exponent/mantissa must be truncated later! // this is unlikely, so don't inline truncation code with the rest of parse_number_string() answer.too_many_digits = digit_count > 19; } diff --git a/include/fast_float/digit_comparison.h b/include/fast_float/digit_comparison.h index b9601c3..512a27f 100644 --- a/include/fast_float/digit_comparison.h +++ b/include/fast_float/digit_comparison.h @@ -23,9 +23,9 @@ constexpr static uint64_t powers_of_ten_uint64[] = { // this algorithm is not even close to optimized, but it has no practical // effect on performance: in order to have a faster algorithm, we'd need // to slow down performance for faster algorithms, and this is still fast. -template +template fastfloat_really_inline FASTFLOAT_CONSTEXPR14 -int32_t scientific_exponent(parsed_number_string& num) noexcept { +int32_t scientific_exponent(parsed_number_string_t & num) noexcept { uint64_t mantissa = num.mantissa; int32_t exponent = int32_t(num.exponent); while (mantissa >= 10000) { @@ -154,22 +154,19 @@ void round_down(adjusted_mantissa& am, int32_t shift) noexcept { } am.power2 += shift; } - -template +template fastfloat_really_inline FASTFLOAT_CONSTEXPR20 -void skip_zeros(const CharT*& first, const CharT* last) noexcept { - if (std::is_same::value) { - uint64_t val; - while (!cpp20_and_in_constexpr() && std::distance(first, last) >= 8) { - ::memcpy(&val, first, sizeof(uint64_t)); - if (val != 0x3030303030303030) { - break; - } - first += 8; +void skip_zeros(UC const * & first, UC const * last) noexcept { + uint64_t val; + while (!cpp20_and_in_constexpr() && std::distance(first, last) >= int_cmp_len()) { + ::memcpy(&val, first, sizeof(uint64_t)); + if (val != int_cmp_zeros()) { + break; } + first += int_cmp_len(); } while (first != last) { - if (*first != CharT('0')) { + if (*first != UC('0')) { break; } first++; @@ -178,48 +175,46 @@ void skip_zeros(const CharT*& first, const CharT* last) noexcept { // determine if any non-zero digits were truncated. // all characters must be valid digits. -template +template fastfloat_really_inline FASTFLOAT_CONSTEXPR20 -bool is_truncated(const CharT* first, const CharT* last) noexcept { - if (std::is_same::value) { - // do 8-bit optimizations, can just compare to 8 literal 0s. - uint64_t val; - while (!cpp20_and_in_constexpr() && std::distance(first, last) >= 8) { - ::memcpy(&val, first, sizeof(uint64_t)); - if (val != 0x3030303030303030) { - return true; - } - first += 8; - } - } - while (first != last) { - if (*first != CharT('0')) { +bool is_truncated(UC const * first, UC const * last) noexcept { + // do 8-bit optimizations, can just compare to 8 literal 0s. + uint64_t val; + while (!cpp20_and_in_constexpr() && std::distance(first, last) >= int_cmp_len()) { + ::memcpy(&val, first, sizeof(uint64_t)); + if (val != int_cmp_zeros()) { return true; } - first++; + first += int_cmp_len(); + } + while (first != last) { + if (*first != UC('0')) { + return true; + } + ++first; } return false; } - -template +template fastfloat_really_inline FASTFLOAT_CONSTEXPR20 -bool is_truncated(span s) noexcept { +bool is_truncated(span s) noexcept { return is_truncated(s.ptr, s.ptr + s.len()); } -template + +template fastfloat_really_inline FASTFLOAT_CONSTEXPR20 -void parse_eight_digits(const CharT*& p, limb& value, size_t& counter, size_t& count) noexcept { +void parse_eight_digits(const UC*& p, limb& value, size_t& counter, size_t& count) noexcept { value = value * 100000000 + parse_eight_digits_unrolled(p); p += 8; counter += 8; count += 8; } -template +template fastfloat_really_inline FASTFLOAT_CONSTEXPR14 -void parse_one_digit(const CharT*& p, limb& value, size_t& counter, size_t& count) noexcept { - value = value * 10 + limb(*p - CharT('0')); +void parse_one_digit(UC const *& p, limb& value, size_t& counter, size_t& count) noexcept { + value = value * 10 + limb(*p - UC('0')); p++; counter++; count++; @@ -240,9 +235,9 @@ void round_up_bigint(bigint& big, size_t& count) noexcept { } // parse the significant digits into a big integer -template +template inline FASTFLOAT_CONSTEXPR20 -void parse_mantissa(bigint& result, parsed_number_string& num, size_t max_digits, size_t& digits) noexcept { +void parse_mantissa(bigint& result, parsed_number_string_t& num, size_t max_digits, size_t& digits) noexcept { // try to minimize the number of big integer and scalar multiplication. // therefore, try to parse 8 digits at a time, and multiply by the largest // scalar value (9 or 19 digits) for each step. @@ -256,8 +251,8 @@ void parse_mantissa(bigint& result, parsed_number_string& num, size_t max #endif // process all integer digits. - const CharT* p = num.integer.ptr; - const CharT* pend = p + num.integer.len(); + UC const * p = num.integer.ptr; + UC const * pend = p + num.integer.len(); skip_zeros(p, pend); // process all digits, in increments of step per loop while (p != pend) { @@ -406,9 +401,9 @@ adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int // `b` as a big-integer type, scaled to the same binary exponent as // the actual digits. we then compare the big integer representations // of both, and use that to direct rounding. -template +template inline FASTFLOAT_CONSTEXPR20 -adjusted_mantissa digit_comp(parsed_number_string& num, adjusted_mantissa am) noexcept { +adjusted_mantissa digit_comp(parsed_number_string_t& num, adjusted_mantissa am) noexcept { // remove the invalid exponent bias am.power2 -= invalid_am_bias; diff --git a/include/fast_float/fast_float.h b/include/fast_float/fast_float.h index 57d39b3..1cc25f4 100644 --- a/include/fast_float/fast_float.h +++ b/include/fast_float/fast_float.h @@ -13,22 +13,25 @@ enum chars_format { general = fixed | scientific }; -template -struct from_chars_result { - const CharT *ptr; +template +struct from_chars_result_t { + UC const * ptr; std::errc ec; }; +using from_chars_result = from_chars_result_t; -struct parse_options { - constexpr explicit parse_options( - chars_format fmt = chars_format::general, char dot = '.') +template +struct parse_options_t { + constexpr explicit parse_options_t(chars_format fmt = chars_format::general, + UC dot = UC('.')) : format(fmt), decimal_point(dot) {} /** Which number formats are accepted */ chars_format format; /** The character used as decimal point */ - char decimal_point; + UC decimal_point; }; +using parse_options = parse_options_t; /** * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting @@ -49,21 +52,19 @@ struct parse_options { * to determine whether we allow the fixed point and scientific notation respectively. * The default is `fast_float::chars_format::general` which allows both `fixed` and `scientific`. */ -template +template FASTFLOAT_CONSTEXPR20 -from_chars_result from_chars(const CharT *first, const CharT *last, +from_chars_result_t from_chars(UC const * first, UC const * last, T &value, chars_format fmt = chars_format::general) noexcept; /** * Like from_chars, but accepts an `options` argument to govern number parsing. */ -template +template FASTFLOAT_CONSTEXPR20 -from_chars_result from_chars_advanced(const CharT *first, const CharT *last, - T &value, parse_options options) noexcept; +from_chars_result_t from_chars_advanced(UC const * first, UC const * last, + T &value, parse_options_t options) noexcept; -} - -// namespace fast_float +} // namespace fast_float #include "parse_number.h" #endif // FASTFLOAT_FAST_FLOAT_H diff --git a/include/fast_float/float_common.h b/include/fast_float/float_common.h index 236dcae..f63a090 100644 --- a/include/fast_float/float_common.h +++ b/include/fast_float/float_common.h @@ -136,13 +136,12 @@ fastfloat_really_inline constexpr bool has_simd() { } // Compares two ASCII strings in a case insensitive manner. -// maya: for now, keep input2 ASCII only -template +template inline FASTFLOAT_CONSTEXPR14 bool -fastfloat_strncasecmp(const CharT *input1, const char *input2, size_t length) { +fastfloat_strncasecmp(UC const * input1, UC const * input2, size_t length) { char running_diff{0}; - for (size_t i = 0; i < length; i++) { - running_diff |= (char(input1[i]) ^ input2[i]); + for (size_t i = 0; i < length; ++i) { + running_diff |= (char(input1[i]) ^ char(input2[i])); } return (running_diff == 0) || (running_diff == 32); } @@ -535,6 +534,68 @@ constexpr bool space_lut::value[]; inline constexpr bool is_space(uint8_t c) { return space_lut<>::value[c]; } #endif + +template +static constexpr uint64_t int_cmp_zeros() +{ + static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4), "Unsupported character size"); + return (sizeof(UC) == 1) ? 0x3030303030303030 : (sizeof(UC) == 2) ? (uint64_t(UC('0')) << 48 | uint64_t(UC('0')) << 32 | uint64_t(UC('0')) << 16 | UC('0')) : (uint64_t(UC('0')) << 32 | UC('0')); +} +template +static constexpr int int_cmp_len() +{ + return sizeof(uint64_t) / sizeof(UC); +} +template +static constexpr UC const * str_const_nan() +{ + return nullptr; +} +template<> +constexpr char const * str_const_nan() +{ + return "nan"; +} +template<> +constexpr wchar_t const * str_const_nan() +{ + return L"nan"; +} +template<> +constexpr char16_t const * str_const_nan() +{ + return u"nan"; +} +template<> +constexpr char32_t const * str_const_nan() +{ + return U"nan"; +} +template +static constexpr UC const * str_const_inf() +{ + return nullptr; +} +template<> +constexpr char const * str_const_inf() +{ + return "infinity"; +} +template<> +constexpr wchar_t const * str_const_inf() +{ + return L"infinity"; +} +template<> +constexpr char16_t const * str_const_inf() +{ + return u"infinity"; +} +template<> +constexpr char32_t const * str_const_inf() +{ + return U"infinity"; +} } // namespace fast_float #endif diff --git a/include/fast_float/parse_number.h b/include/fast_float/parse_number.h index 99ccd49..6daf800 100644 --- a/include/fast_float/parse_number.h +++ b/include/fast_float/parse_number.h @@ -19,43 +19,41 @@ namespace detail { * The case comparisons could be made much faster given that we know that the * strings a null-free and fixed. **/ -template -from_chars_result FASTFLOAT_CONSTEXPR14 -parse_infnan(const CharT *first, const CharT *last, T &value) noexcept { - from_chars_result answer{}; +template +from_chars_result_t FASTFLOAT_CONSTEXPR14 +parse_infnan(UC const * first, UC const * last, T &value) noexcept { + from_chars_result_t answer{}; answer.ptr = first; answer.ec = std::errc(); // be optimistic bool minusSign = false; - if (*first == CharT('-')) { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here + if (*first == UC('-')) { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here minusSign = true; ++first; } #ifdef FASTFLOAT_ALLOWS_LEADING_PLUS // disabled by default - if (*first == CharT('+')) { + if (*first == UC('+')) { ++first; } #endif if (last - first >= 3) { - if (fastfloat_strncasecmp(first, "nan", 3)) { + if (fastfloat_strncasecmp(first, str_const_nan(), 3)) { answer.ptr = (first += 3); value = minusSign ? -std::numeric_limits::quiet_NaN() : std::numeric_limits::quiet_NaN(); // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7, C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan). - if(first != last && *first == CharT('(')) { - for(const CharT* ptr = first + 1; ptr != last; ++ptr) { - if (*ptr == CharT(')')) { + if(first != last && *first == UC('(')) { + for(UC const * ptr = first + 1; ptr != last; ++ptr) { + if (*ptr == UC(')')) { answer.ptr = ptr + 1; // valid nan(n-char-seq-opt) break; } - else if(!((CharT('a') <= *ptr && *ptr <= CharT('z')) || - (CharT('A') <= *ptr && *ptr <= CharT('Z')) || - (CharT('0') <= *ptr && *ptr <= CharT('9')) || *ptr == CharT('_'))) + else if(!((UC('a') <= *ptr && *ptr <= UC('z')) || (UC('A') <= *ptr && *ptr <= UC('Z')) || (UC('0') <= *ptr && *ptr <= UC('9')) || *ptr == UC('_'))) break; // forbidden char, not nan(n-char-seq-opt) } } return answer; } - if (fastfloat_strncasecmp(first, "inf", 3)) { - if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, "inity", 5)) { + if (fastfloat_strncasecmp(first, str_const_inf(), 3)) { + if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, str_const_inf() + 3, 5)) { answer.ptr = first + 8; } else { answer.ptr = first + 3; @@ -134,22 +132,25 @@ fastfloat_really_inline bool rounds_to_nearest() noexcept { } // namespace detail -template +template FASTFLOAT_CONSTEXPR20 -from_chars_result from_chars(const CharT *first, const CharT *last, +from_chars_result_t from_chars(UC const * first, UC const * last, T &value, chars_format fmt /*= chars_format::general*/) noexcept { - return from_chars_advanced(first, last, value, parse_options{fmt}); + return from_chars_advanced(first, last, value, parse_options_t{fmt}); } -template +template FASTFLOAT_CONSTEXPR20 -from_chars_result from_chars_advanced(const CharT *first, const CharT *last, - T &value, parse_options options) noexcept { -{ +from_chars_result_t from_chars_advanced(UC const * first, UC const * last, + T &value, parse_options_t options) noexcept { + static_assert (std::is_same::value || std::is_same::value, "only float and double are supported"); + static_assert (std::is_same::value || + std::is_same::value || + std::is_same::value || + std::is_same::value , "only char, wchar_t, char16_t and char32_t are supported"); - - from_chars_result answer; + from_chars_result_t answer; #ifdef FASTFLOAT_SKIP_WHITE_SPACE // disabled by default while ((first != last) && fast_float::is_space(uint8_t(*first))) { first++; @@ -160,7 +161,7 @@ from_chars_result from_chars_advanced(const CharT *first, const CharT *la answer.ptr = first; return answer; } - parsed_number_string pns = parse_number_string(first, last, options); + parsed_number_string_t pns = parse_number_string(first, last, options); if (!pns.valid) { return detail::parse_infnan(first, last, value); } diff --git a/tests/basictest.cpp b/tests/basictest.cpp index 1f8d5d1..3d7f753 100644 --- a/tests/basictest.cpp +++ b/tests/basictest.cpp @@ -644,9 +644,9 @@ enum class Diag { runtime, comptime }; } // anonymous namespace -template -constexpr void check_basic_test_result(std::string_view str, - fast_float::from_chars_result result, +template +constexpr void check_basic_test_result(stringtype str, + result_type result, T actual, T expected, std::errc expected_ec) { if constexpr (diag == Diag::runtime) { INFO( @@ -702,11 +702,33 @@ constexpr void check_basic_test_result(std::string_view str, #undef FASTFLOAT_CHECK_EQ } + template constexpr void basic_test(std::string_view str, T expected, std::errc expected_ec = std::errc()) { T actual; auto result = fast_float::from_chars(str.data(), str.data() + str.size(), actual); check_basic_test_result(str, result, actual, expected, expected_ec); + constexpr size_t global_string_capacity = 2048; + + if(str.size() > global_string_capacity) { + return; + } + // We give plenty of memory: 2048 characters. + char16_t u16[global_string_capacity]{}; + + for (size_t i = 0; i < str.size(); i++) { + u16[i] = char16_t(str[i]); + } + auto result16 = fast_float::from_chars(u16, u16 + str.size(), actual); + check_basic_test_result(std::u16string_view(u16, str.size()), result16, actual, expected, expected_ec); + + char32_t u32[global_string_capacity]{}; + + for (size_t i = 0; i < str.size(); i++) { + u32[i] = char32_t(str[i]); + } + auto result32 = fast_float::from_chars(u32, u32 + str.size(), actual); + check_basic_test_result(std::u32string_view(u32, str.size()), result32, actual, expected, expected_ec); } template