Regenerate the amalgamated headers

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

README.md

@@ -1387,7 +1387,7 @@ THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR I
 - The class contains a slightly modified version of the Grisu2 algorithm from Florian Loitsch which is licensed under the [MIT License](https://opensource.org/licenses/MIT) (see above). Copyright © 2009 [Florian Loitsch](https://florian.loitsch.com/)
 - The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 - The class contains parts of [Google Abseil](https://github.com/abseil/abseil-cpp) which is licensed under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).
-- The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors
+- The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors
 
 <img align="right" src="https://git.fsfe.org/reuse/reuse-ci/raw/branch/master/reuse-horizontal.png" alt="REUSE Software">
 

docs/mkdocs/docs/api/basic_json/number_float_t.md

@@ -23,9 +23,10 @@ type to use.
 ## Template parameters
 
 `NumberFloatType`
-:   the type to store floating-point numbers. Parsing and serialization are implemented in terms of
-    `#!cpp std::strtof`/`#!cpp std::strtod`/`#!cpp std::strtold` and `#!cpp std::snprintf`, so the type must be
-    `#!cpp float`, `#!cpp double`, or `#!cpp long double`. The
+:   the type to store floating-point numbers. The type must be `#!cpp float`, `#!cpp double`, or
+    `#!cpp long double`. The parser converts `#!cpp float`, `#!cpp double`, and a `#!cpp long double` that is IEEE 754
+    binary64 itself. It converts other `#!cpp long double` formats with `#!cpp std::from_chars` where available, or
+    with `#!cpp std::strtold` otherwise. Serialization falls back to `#!cpp std::snprintf`. The
     [binary formats](../../features/binary_formats/index.md) additionally require `#!cpp float` or `#!cpp double`,
     because they have no encoding for `#!cpp long double`. See
     [Template Parameter Requirements](../../features/types/template_parameters.md#numberfloattype).

docs/mkdocs/docs/api/basic_json/to_bjdata.md

@@ -123,6 +123,4 @@ Linear in the size of the JSON value `j`.
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid BJData.
-- Writes unsigned integers wider than 64 bits as high-precision numbers since version 3.13.0; previously, they were
-  silently truncated to 64 bits.
+  array or object was silently skipped, producing invalid BJData.

docs/mkdocs/docs/api/basic_json/to_bon8.md

@@ -37,9 +37,8 @@ With (2), the bytes written before the exception remain in the output adapter.
 
 ## Exceptions
 
-- Throws [out_of_range.407](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an integer outside
-  the range of int64 (an unsigned integer above 9223372036854775807, or, with a number type wider than 64 bits, any
-  integer beyond int64), which BON8 cannot represent
+- Throws [out_of_range.407](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an unsigned integer
+  above 9223372036854775807, which BON8 cannot represent
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if `j` contains a string that is not
   valid UTF-8
 - Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is

docs/mkdocs/docs/api/basic_json/to_bson.md

@@ -47,10 +47,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 
 - Throws [`type_error.317`](../../home/exceptions.md#jsonexceptiontype_error317) if the top-level type of the JSON value
   is not an object; example: `"to serialize to BSON, top-level type must be object, but is string"`
-- Throws [`out_of_range.407`](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains a signed integer
-  outside the range of int64 or an unsigned integer outside the range of uint64, which is only possible with a number
-  type wider than 64 bits; example:
-  `"integer number 9223372036854775808 cannot be represented by BSON as it does not fit int64"`
 - Throws [`out_of_range.409`](../../home/exceptions.md#jsonexceptionout_of_range409) if a key in the JSON object contains
   a null byte (code point U+0000); example: `"BSON key cannot contain code point U+0000 (at byte 2)"`
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a document, array,
@@ -123,5 +119,3 @@ pass before anything is written.
   that is not valid UTF-8 unchanged, as before; `strict` (the default if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316` before anything
   is written.
-- Throws `out_of_range.407` for integers that do not fit 64 bits since version 3.13.0; previously, integers of a
-  number type wider than 64 bits were silently truncated.

docs/mkdocs/docs/api/basic_json/to_cbor.md

@@ -46,9 +46,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 
 ## Exceptions
 
-- Throws [`out_of_range.407`](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an integer
-  outside [-2^64, 2^64-1], which is only possible with a number type wider than 64 bits; example:
-  `"integer number 18446744073709551616 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
   not valid UTF-8 and `error_handler` is `strict` (the default only if
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
@@ -93,5 +90,3 @@ Linear in the size of the JSON value `j`.
   [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
   array or object was silently skipped, producing invalid CBOR.
-- Throws `out_of_range.407` for integers that do not fit 64 bits since version 3.13.0; previously, integers of a
-  number type wider than 64 bits were silently truncated.

docs/mkdocs/docs/api/basic_json/to_msgpack.md

@@ -46,9 +46,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 
 ## Exceptions
 
-- Throws [`out_of_range.407`](../../home/exceptions.md#jsonexceptionout_of_range407) if `j` contains an integer
-  outside [-2^63, 2^64-1], which is only possible with a number type wider than 64 bits; example:
-  `"integer number 18446744073709551616 cannot be represented by MessagePack as it does not fit [-2^63, 2^64-1]"`
 - Throws [`out_of_range.412`](../../home/exceptions.md#jsonexceptionout_of_range412) if the length of a string, binary
   value, array, or object exceeds 4294967295, the maximum MessagePack can store; example:
   `"MessagePack length 4294967296 exceeds maximum of 4294967295"`
@@ -115,5 +112,3 @@ Linear in the size of the JSON value `j`.
   `number_unsigned_t`.
 - Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
   array or object was silently skipped, producing invalid MessagePack.
-- Throws `out_of_range.407` for integers that do not fit 64 bits since version 3.13.0; previously, integers of a
-  number type wider than 64 bits were silently truncated.

docs/mkdocs/docs/features/types/number_handling.md

@@ -82,12 +82,13 @@ flowchart TD
 
     - Numbers with a decimal digit or scientific notation are always stored as `#!c double`.
     - The number types can be changed, see [Template number types](#template-number-types). 
-    - Integers are converted by the library's own digit parser. Floating-point numbers are converted with
-      [`std::from_chars`](https://en.cppreference.com/w/cpp/utility/from_chars) if the library is compiled with C++17
-      and the standard library supports it, then with an exact fast path for `#!c double` values with few significant
-      digits, and otherwise with the locale-aware
-      [`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) (`std::strtof`/`std::strtold` for the
-      other floating-point types). Before version 3.13.0, the conversion was realized by
+    - The library converts integers and floating-point numbers itself, independent of the locale. Floating-point
+      numbers are correctly rounded (to nearest, ties to even). Only a `#!c long double` that is not IEEE 754 binary64
+      (e.g., the 80-bit x87 format) is converted with `#!cpp std::from_chars` where available, or else with
+      [`std::strtold`](https://en.cppreference.com/w/cpp/string/byte/strtof). For that call, the library temporarily
+      replaces the `.` with the decimal point of the current locale (which may be longer than one byte, e.g., in
+      `fa_IR.UTF-8`), so the result does not depend on the locale either. Changing the locale in another thread during
+      parsing is undefined behavior of the C library, though. Before version 3.13.0, the conversion was realized by
       [`std::strtoull`](https://en.cppreference.com/w/cpp/string/byte/strtoul),
       [`std::strtoll`](https://en.cppreference.com/w/cpp/string/byte/strtol), and `std::strtod`, respectively.
 
@@ -100,10 +101,10 @@ flowchart TD
 ### Number limits
 
 - Any 64-bit signed or unsigned integer can be stored without loss of precision.
-- Numbers exceeding the limits of `#!c double` (i.e., numbers that after conversion via
-[`std::strtod`](https://en.cppreference.com/w/cpp/string/byte/strtof) are not satisfying
+- Numbers exceeding the limits of `#!c double` (i.e., numbers whose rounded value is not satisfying
 [`std::isfinite`](https://en.cppreference.com/w/cpp/numeric/math/isfinite) such as `#!c 1E400`) will throw exception
-[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing.
+[`json.exception.out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) during parsing. Numbers too
+small for `#!c double` (such as `#!c 1E-400`) become zero, with the sign of the number.
 - Floating-point numbers are rounded to the next number representable as `double`. For instance
 `#!c 3.141592653589793238462643383279` is stored as [`0x400921fb54442d18`](https://float.exposed/0x400921fb54442d18).
 This is the same behavior as the code `#!c double x = 3.141592653589793238462643383279;`.

docs/mkdocs/docs/features/types/template_parameters.md

@@ -30,9 +30,9 @@ Requirements are split into two groups:
     diagnosed with dedicated error messages, and violating most of them results in a compiler error somewhere inside
     the library. Four violations are not caught at compile time at all:
 
-    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and can silently misparse
-      floating-point numbers, because the lexer may hand the buffer to `#!cpp std::strtod`, which reads up to the
-      terminating null character.
+    - A [`StringType`](#stringtype) whose `data()` is not null-terminated compiles and silently misparses numbers
+      stored as a `#!cpp long double` that is not IEEE 754 binary64 (e.g., the 80-bit x87 format), because the lexer
+      hands the buffer to `#!cpp std::strtold`.
     - A stateful [`AllocatorType`](#allocatortype) compiles and silently ignores its state: allocation, deallocation,
       and [`get_allocator()`](../../api/basic_json/get_allocator.md) each use a different default-constructed instance.
     - The two [cross-specialization conversions](#cross-specialization-conversions) below. These abort on an assertion
@@ -353,16 +353,21 @@ using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
 ### Always required
 
 - A member type `value_type` that is one byte wide and `char`-compatible. The library stores and processes UTF-8
-  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtod`.
+  encoded `char` data and passes `data()` to functions that take a `#!cpp const char*`, such as `#!cpp std::strtold`
+  (only used to parse a `#!cpp long double` that is not IEEE 754 binary64, see
+  [`NumberFloatType`](#numberfloattype)).
   `#!cpp std::wstring`, `#!cpp std::u16string`, and `#!cpp std::u32string` are **not** valid choices; see the FAQ on
   [wide string handling](../../home/faq.md#wide-string-handling).
 - Constructors: default, copy, move, from `#!cpp const char*` (which must not be `#!cpp explicit`), from
   `#!cpp (const char*, size_type)`, and from `#!cpp (size_type, char)`; and copy or move assignment.
 - Member functions `size()`, `clear()`, `resize(n, c)`, `data()`, `push_back(char)`, and `operator[]`
   (const and non-const, returning references). `c_str()` and `back()` are **not** required.
-- `data()` must return a pointer to a contiguous, **null-terminated** buffer -- the parser may hand it to
-  `#!cpp std::strtod`, which reads up to the null character. A type whose `data()` is not null-terminated does not
-  fail to compile; it can silently misparse floating-point numbers.
+- `data()` must return a pointer to a contiguous, **null-terminated** buffer. `#!cpp float`, `#!cpp double`, and a
+  `#!cpp long double` that is IEEE 754 binary64 are converted by the library itself and do not depend on this. For any
+  other `NumberFloatType` (a `#!cpp long double` of another format), the parser falls back to `#!cpp std::strtold` when
+  `#!cpp std::from_chars` is not available or declines the token, and `std::strtold` reads up to the null character. A type whose `data()`
+  is not null-terminated does not fail to compile; with such a `NumberFloatType` it can silently misparse
+  floating-point numbers.
 - `append(const char*, size_type)`, used by [`dump`](../../api/basic_json/dump.md), and `append(const StringType&)`,
   used by the CBOR reader for indefinite-length strings. The library's internal string concatenation additionally has
   to append a `#!cpp char` and a `#!cpp const char*`; for each it selects between `append(arg)`, `#!cpp operator+=`,
@@ -541,9 +546,10 @@ therefore silently changes parse results rather than raising an error. See
 
 `NumberFloatType` must be one of `#!cpp float`, `#!cpp double`, or `#!cpp long double`:
 
-- The [parser](../parsing/index.md) converts number literals with `#!cpp std::from_chars` or, as a fallback, with
-  `#!cpp std::strtof`, `#!cpp std::strtod`, or `#!cpp std::strtold`; the library provides overloads for exactly these
-  three types.
+- The [parser](../parsing/index.md) converts number literals to `#!cpp float`, `#!cpp double`, and a
+  `#!cpp long double` that is IEEE 754 binary64 itself; other `#!cpp long double` formats are converted with
+  `#!cpp std::from_chars` where available, or with `#!cpp std::strtold`. The library provides overloads for exactly
+  these three types.
 - [`dump`](../../api/basic_json/dump.md) falls back to `#!cpp std::snprintf` with the `%g` and `%Lg` conversion
   specifiers, for which the library likewise provides only `#!cpp double` and `#!cpp long double` overloads
   (`#!cpp float` is promoted to `#!cpp double`).

docs/mkdocs/docs/home/exceptions.md

@@ -914,34 +914,14 @@ double-precision number when `number_float_t` is `#!cpp float`.
 
 ### json.exception.out_of_range.407
 
-An integer number cannot be represented by the binary format it is serialized to:
+This exception previously indicated that the UBJSON and BSON binary formats did not support integer numbers greater than
+9223372036854775807 due to limitations in the implemented mapping. However, these limitations have since been resolved,
+and this exception no longer occurs.
 
-- [BON8](../features/binary_formats/bon8.md) only stores integers that fit into int64.
-- [CBOR](../features/binary_formats/cbor.md), [MessagePack](../features/binary_formats/messagepack.md), and
-  [BSON](../features/binary_formats/bson.md) store integers in at most 64 bits. With the default number types, every
-  integer fits, but a [`number_integer_t`](../api/basic_json/number_integer_t.md) or
-  [`number_unsigned_t`](../api/basic_json/number_unsigned_t.md) wider than 64 bits (e.g., `__int128`) can hold values
-  outside the range of the format: [-2^64, 2^64-1] for CBOR, [-2^63, 2^64-1] for MessagePack, and the range of int64
-  (signed integers) or uint64 (unsigned integers) for BSON.
+!!! success "Exception cannot occur any more"
 
-[UBJSON](../features/binary_formats/ubjson.md) and [BJData](../features/binary_formats/bjdata.md) never throw this
-exception, because they serialize integers beyond 64 bits as high-precision numbers.
-
-!!! failure "Example messages"
-
-    ```
-    integer number 9223372036854775808 cannot be represented by BON8 as it does not fit int64
-    ```
-    ```
-    integer number 1267650600228229401496703205376 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]
-    ```
-
-!!! note
-
-    Before version 3.13.0, CBOR, MessagePack, and BSON silently truncated integers wider than 64 bits, and BJData
-    truncated unsigned integers wider than 64 bits. This exception was previously thrown by UBJSON and BSON for
-    integers greater than 9223372036854775807; since version 3.9.0, such integers are serialized as high-precision
-    UBJSON numbers, and since version 3.12.0 as uint64 BSON numbers.
+    - Since version 3.9.0, integer numbers beyond int64 are serialized as high-precision UBJSON numbers.
+    - Since version 3.12.0, integer numbers beyond int64 are serialized as uint64 BSON numbers.
 
 ### json.exception.out_of_range.408
 

docs/mkdocs/docs/home/license.md

@@ -20,4 +20,4 @@ The class contains a slightly modified version of the Grisu2 algorithm from Flor
 
 The class contains a copy of [Hedley](https://nemequ.github.io/hedley/) from Evan Nemerson which is licensed as [CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/).
 
-The class contains an adapted version of the Eisel-Lemire algorithm and its table of powers of five from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors
+The class contains an adapted version of the Eisel-Lemire algorithm, its table of powers of five, and its digit comparison for long numbers from [fast_float](https://github.com/fastfloat/fast_float) by Daniel Lemire and contributors, which is available under the [MIT License](https://opensource.org/licenses/MIT) (used here), the Apache 2.0 License, and the Boost Software License. Copyright © 2021 The fast_float authors

include/nlohmann/detail/bit_ops.hpp

@@ -9,8 +9,9 @@
 #pragma once
 
 #include <cstdint> // uint64_t
-#if !defined(__SIZEOF_INT128__) && defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
-    #include <intrin0.h> // __umulh, _umul128
+#include <cstring> // memcpy
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64)) && (!defined(__SIZEOF_INT128__) || (!defined(__GNUC__) && !defined(__clang__)))
+    #include <intrin0.h> // __umulh, _umul128, _BitScanForward64, _BitScanReverse64
 #endif
 
 #include <nlohmann/detail/abi_macros.hpp>
@@ -28,6 +29,10 @@ inline int count_leading_zeros(std::uint64_t x) noexcept
 {
 #if defined(__GNUC__) || defined(__clang__)
     return __builtin_clzll(x);
+#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
+    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
+    _BitScanReverse64(&index, x);
+    return 63 - static_cast<int>(index);
 #else
     int n = 0;
     for (int shift = 32; shift != 0; shift >>= 1)
@@ -42,6 +47,29 @@ inline int count_leading_zeros(std::uint64_t x) noexcept
 #endif
 }
 
+/// number of trailing zero bits of x (x != 0)
+inline int count_trailing_zeros(std::uint64_t x) noexcept
+{
+#if defined(__GNUC__) || defined(__clang__)
+    return __builtin_ctzll(x);
+#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
+    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
+    _BitScanForward64(&index, x);
+    return static_cast<int>(index);
+#else
+    int n = 0;
+    for (int shift = 32; shift != 0; shift >>= 1)
+    {
+        if ((x << (64 - shift)) == 0)
+        {
+            n += shift;
+            x >>= shift;
+        }
+    }
+    return n;
+#endif
+}
+
 /// the 128-bit product of two 64-bit numbers
 struct uint128_parts
 {
@@ -75,15 +103,26 @@ inline uint128_parts full_multiplication(std::uint64_t a, std::uint64_t b) noexc
 #endif
 }
 
-/// eight bytes as a little-endian word (compilers fold this into one load on
-/// little-endian targets)
-inline std::uint64_t read_eight_bytes(const char* p) noexcept
+/// eight bytes as a little-endian word (a single load on little-endian targets)
+inline std::uint64_t read_eight_bytes(const unsigned char* b) noexcept
 {
-    const auto* b = reinterpret_cast<const unsigned char*>(p); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+#if defined(_MSC_VER) || defined(__x86_64__) || defined(__i386__) || (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+    // the byte order already matches (all MSVC targets are little-endian)
+    std::uint64_t result = 0;
+    std::memcpy(&result, b, sizeof(result));
+    return result;
+#else
     return static_cast<std::uint64_t>(b[0]) | (static_cast<std::uint64_t>(b[1]) << 8u)
            | (static_cast<std::uint64_t>(b[2]) << 16u) | (static_cast<std::uint64_t>(b[3]) << 24u)
            | (static_cast<std::uint64_t>(b[4]) << 32u) | (static_cast<std::uint64_t>(b[5]) << 40u)
            | (static_cast<std::uint64_t>(b[6]) << 48u) | (static_cast<std::uint64_t>(b[7]) << 56u);
+#endif
+}
+
+/// eight bytes as a little-endian word
+inline std::uint64_t read_eight_bytes(const char* p) noexcept
+{
+    return read_eight_bytes(reinterpret_cast<const unsigned char*>(p)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
 }
 
 }  // namespace detail

include/nlohmann/detail/input/lexer.hpp

@@ -221,6 +221,44 @@ class lexer : public lexer_base<BasicJsonType>
     // scan functions
     /////////////////////
 
+    /// contiguous input: try to decode the 4 hex digits following `\\u`
+    /// directly from the input buffer via hex_codepoint(), instead of 4 calls
+    /// to get(). On success, advances the adapter and the position counters
+    /// exactly as those 4 get() calls would (a hex digit is never '\n', so
+    /// only the flat counters move) and leaves @a current holding the last of
+    /// the 4 digits, just as the last such get() would; the codepoint is
+    /// written to @a out. Makes no state change and returns false - for a
+    /// pending unget, fewer than 4 remaining bytes, or any of the 4 bytes not
+    /// being a hex digit - so the caller falls back unchanged to the
+    /// per-character loop, which then reports the same diagnostic (stopping
+    /// at the first invalid digit) as before this optimization.
+    bool get_codepoint_bulk(std::true_type /*bulk*/, int& out)
+    {
+        if (next_unget || ia.bulk_remaining() < 4)
+        {
+            return false;
+        }
+        const char_type* const raw = ia.bulk_data();
+        const int codepoint = hex_codepoint(reinterpret_cast<const unsigned char*>(raw));
+        if (codepoint < 0)
+        {
+            return false;
+        }
+        ia.bulk_skip(4);
+        // a hex digit is never a newline, so only the flat counters advance
+        position.chars_read_total += 4;
+        position.chars_read_current_line += 4;
+        current = char_traits<char_type>::to_int_type(raw[3]);
+        out = codepoint;
+        return true;
+    }
+
+    /// streaming input: no bulk fast path
+    bool get_codepoint_bulk(std::false_type /*bulk*/, int& /*out*/) const noexcept
+    {
+        return false;
+    }
+
     /*!
     @brief get codepoint from 4 hex characters following `\\u`
 
@@ -240,6 +278,14 @@ class lexer : public lexer_base<BasicJsonType>
     {
         // this function only makes sense after reading `\u`
         JSON_ASSERT(current == 'u');
+
+        // contiguous input: decode all 4 hex digits directly from the buffer
+        int fast_codepoint = 0;
+        if (get_codepoint_bulk(std::integral_constant<bool, bulk_scan> {}, fast_codepoint))
+        {
+            return fast_codepoint;
+        }
+
         int codepoint = 0;
 
         const auto factors = { 12u, 8u, 4u, 0u };
@@ -1044,9 +1090,11 @@ class lexer : public lexer_base<BasicJsonType>
             token_type::parse_error otherwise
 
     @note The scanner is independent of the current locale: token_buffer
-          always holds `.`. Only the std::strtod fallback of convert_number()
-          depends on the locale, and it looks up the decimal point right
-          before converting (see detail::convert_float_locale_aware()).
+          always holds `.`. The conversion of float and double does not use
+          the locale either. Only the std::strtold fallback of
+          convert_number() for long double formats other than binary64
+          depends on it, and it looks up the decimal point right before
+          converting (see detail::convert_float_locale_aware()).
     */
     token_type scan_number()  // lgtm [cpp/use-of-goto] `goto` is used in this function to implement the number-parsing state machine described above. By design, any finite input will eventually reach the "done" state or return token_type::parse_error. In each intermediate state, 1 byte of the input is appended to the token_buffer vector, and only the already initialized variables token_buffer, number_type, and error_message are manipulated.
     {
@@ -1059,7 +1107,7 @@ class lexer : public lexer_base<BasicJsonType>
 
         // offset just past the last mantissa byte in token_buffer (i.e. the
         // index of 'e'/'E', or the whole token when there is no exponent).
-        // convert_number() uses it to count significant digits; npos means
+        // convert_number() uses it to split the token; npos means
         // "not seen an exponent yet" and is resolved at scan_number_done
         std::size_t mantissa_end = std::string::npos;
 
@@ -1389,8 +1437,8 @@ scan_number_done:
     @param[in] mantissa_end  offset just past the last mantissa byte in
                              token_buffer (the index of 'e'/'E', or
                              token_buffer.size() when there is no exponent);
-                             used to skip Clinger's fast path when it cannot
-                             possibly succeed - see detail::mantissa_fits_clinger()
+                             with decimal_point_position, it locates the parts
+                             of a float token without scanning it again
     */
     token_type convert_number(token_type number_type, std::size_t mantissa_end)
     {
@@ -1444,10 +1492,11 @@ scan_number_done:
         }
 
         // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. Prefer std::from_chars
-        // (Eisel-Lemire, locale-independent, correctly rounded) when available;
-        // otherwise the exact Clinger fast path (double only); otherwise the
-        // locale-aware strtof/strtod/strtold.
+        // integer conversion above overflowed. float and double (and long
+        // double where it is binary64) are converted by the library itself,
+        // correctly rounded and independent of the locale; other long double
+        // formats use std::from_chars when available, otherwise the
+        // locale-aware strtold.
         if (convert_float_fast(num_begin, num_end, decimal_point_position, mantissa_end, value_float))
         {
             return token_type::value_float;

include/nlohmann/detail/input/pow5_table.hpp

@@ -22,6 +22,10 @@ namespace detail
 constexpr std::int64_t pow5_128_smallest_power = -342;
 constexpr std::int64_t pow5_128_largest_power = 308;
 
+// every entry of pow5_128() holds two 64-bit halves of 5^q, one per covered power of 5
+static_assert((pow5_128_largest_power - pow5_128_smallest_power + 1) * 2 == 1302,
+              "pow5_128_smallest_power/pow5_128_largest_power must match the size of the pow5_128() table");
+
 /*!
 @brief 128-bit approximations of 5^q for q in [-342, 308]
 

include/nlohmann/detail/input/string_scan.hpp

@@ -8,10 +8,12 @@
 
 #pragma once
 
+#include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint64_t
+#include <cstdint> // uint64_t, uint8_t
 #include <cstring> // memcpy
 
+#include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 
 // Optional SIMD backend for bulk UTF-8 validation. This is an opt-in external
@@ -69,18 +71,12 @@ inline std::size_t find_string_special(const unsigned char* data, std::size_t n)
     std::size_t i = 0;
     for (; i + 8 <= n; i += 8)
     {
-        std::uint64_t word = 0;
-        std::memcpy(&word, data + i, sizeof(word));
-        if (swar_string_special(word) != 0)
+        const std::uint64_t special = swar_string_special(read_eight_bytes(data + i));
+        if (special != 0)
         {
-            // a special byte is in this word; locate it (endian-agnostic)
-            for (std::size_t j = 0; j < 8; ++j)
-            {
-                if (is_string_special(data[i + j]))
-                {
-                    return i + j;
-                }
-            }
+            // the lowest flagged byte is the first special one: the borrows of
+            // the subtractions can only flag bytes above a true hit
+            return i + (static_cast<std::size_t>(count_trailing_zeros(special)) / 8);
         }
     }
     for (; i < n; ++i)
@@ -114,8 +110,7 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
     std::size_t i = 0;
     for (; i + 8 <= n; i += 8)
     {
-        std::uint64_t v = 0;
-        std::memcpy(&v, data + i, sizeof(v));
+        const std::uint64_t v = read_eight_bytes(data + i);
         const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'  (0x22)
         const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\' (0x5C)
         const std::uint64_t d = v ^ 0x7F7F7F7F7F7F7F7Full; // DEL  (0x7F)
@@ -126,7 +121,9 @@ inline std::size_t find_ascii_copyable_run(const unsigned char* data, std::size_
                                    | (v & high);               // >= 0x80
         if (stop != 0)
         {
-            break;
+            // the lowest flagged byte is the first one to stop at (see
+            // find_string_special())
+            return i + (static_cast<std::size_t>(count_trailing_zeros(stop)) / 8);
         }
     }
     for (; i < n; ++i)
@@ -253,12 +250,18 @@ inline std::size_t scalar_string_bulk_run(const unsigned char* data, std::size_t
         {
             break; // end of buffer, or a quote/escape/control byte
         }
-        const std::size_t seq = validate_one_utf8(data + pos, n - pos);
-        if (seq == 0)
+        // a run of multi-byte sequences (e.g. CJK text) is validated sequence
+        // by sequence without searching for the next special byte in between
+        do
         {
-            break; // ill-formed or truncated: let the byte path diagnose it
+            const std::size_t seq = validate_one_utf8(data + pos, n - pos);
+            if (seq == 0)
+            {
+                return pos; // ill-formed or truncated: let the byte path diagnose it
+            }
+            pos += seq;
         }
-        pos += seq;
+        while (pos < n && data[pos] >= 0x80u);
     }
     return pos;
 }
@@ -273,8 +276,7 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
     std::size_t i = 0;
     for (; i + 8 <= n; i += 8)
     {
-        std::uint64_t v = 0;
-        std::memcpy(&v, data + i, sizeof(v));
+        const std::uint64_t v = read_eight_bytes(data + i);
         const std::uint64_t q = v ^ 0x2222222222222222ull;
         const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull;
         const std::uint64_t hit = ((q - ones) & ~q & high)
@@ -282,14 +284,8 @@ inline std::size_t find_string_delimiter(const unsigned char* data, std::size_t
                                   | ((v - 0x2020202020202020ull) & ~v & high);
         if (hit != 0)
         {
-            for (std::size_t j = 0; j < 8; ++j)
-            {
-                const unsigned char c = data[i + j];
-                if (c == '\"' || c == '\\' || c < 0x20u)
-                {
-                    return i + j;
-                }
-            }
+            // the lowest flagged byte is the first delimiter (see find_string_special())
+            return i + (static_cast<std::size_t>(count_trailing_zeros(hit)) / 8);
         }
     }
     for (; i < n; ++i)
@@ -320,5 +316,50 @@ inline std::size_t string_bulk_run(const unsigned char* data, std::size_t n) noe
     return scalar_string_bulk_run(data, n);
 }
 
+// Decode the 4 hex digits at [data, data+4) - the digits following a `\u`
+// escape - into a codepoint 0x0000..0xFFFF via one table lookup per byte
+// (after yyjson's read_hex_u16), or return -1 if any of the 4 bytes is not a
+// hex digit ('0'..'9', 'A'..'F', 'a'..'f'). The caller must already have
+// checked that 4 bytes are available; used by lexer::get_codepoint()'s
+// contiguous fast path. On -1 it falls back to the byte-at-a-time loop, which
+// stops at the first invalid digit, so the reported error and position are
+// unaffected by this fast path.
+inline int hex_codepoint(const unsigned char* data) noexcept
+{
+    static const std::array<std::uint8_t, 256> hex_digit_table = // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+    {
+        {
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 00..0F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 10..1F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 20..2F
+            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 30..3F ('0'..'9')
+            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 40..4F ('A'..'F')
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 50..5F
+            0xFF, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 60..6F ('a'..'f')
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 70..7F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 80..8F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 90..9F
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // A0..AF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // B0..BF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // C0..CF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // D0..DF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // E0..EF
+            0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF  // F0..FF
+        }
+    };
+
+    const std::uint8_t d0 = hex_digit_table[data[0]];
+    const std::uint8_t d1 = hex_digit_table[data[1]];
+    const std::uint8_t d2 = hex_digit_table[data[2]];
+    const std::uint8_t d3 = hex_digit_table[data[3]];
+    // every valid digit is <= 0xF; the combined OR only exceeds it if at
+    // least one of the four bytes was not a hex digit (looked up as 0xFF)
+    if ((d0 | d1 | d2 | d3) > 0x0F)
+    {
+        return -1;
+    }
+    return (d0 << 12) | (d1 << 8) | (d2 << 4) | d3;
+}
+
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/output/binary_writer.hpp

@@ -207,10 +207,6 @@ class binary_writer
             {
                 if (j.m_data.m_value.number_integer >= 0)
                 {
-                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_integer)))
-                    {
-                        throw_integer_out_of_range(j, "CBOR", "[-2^64, 2^64-1]");
-                    }
                     // CBOR does not differentiate between positive signed
                     // integers and unsigned integers
                     write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
@@ -218,10 +214,6 @@ class binary_writer
                 else
                 {
                     // a negative integer n is encoded as -1 - n
-                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(-1 - j.m_data.m_value.number_integer)))
-                    {
-                        throw_integer_out_of_range(j, "CBOR", "[-2^64, 2^64-1]");
-                    }
                     write_cbor_head(0x20, static_cast<std::uint64_t>(-1 - j.m_data.m_value.number_integer));
                 }
                 break;
@@ -229,11 +221,7 @@ class binary_writer
 
             case value_t::number_unsigned:
             {
-                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_unsigned)))
-                {
-                    throw_integer_out_of_range(j, "CBOR", "uint64");
-                }
-                write_cbor_head(0x00, static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                write_cbor_head(0x00, j.m_data.m_value.number_unsigned);
                 break;
             }
 
@@ -435,20 +423,12 @@ class binary_writer
             {
                 if (j.m_data.m_value.number_integer >= 0)
                 {
-                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_integer)))
-                    {
-                        throw_integer_out_of_range(j, "MessagePack", "[-2^63, 2^64-1]");
-                    }
                     // MessagePack does not differentiate between positive
                     // signed integers and unsigned integers.
                     write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
                 }
                 else
                 {
-                    if (JSON_HEDLEY_UNLIKELY(!integer_fits_min<std::int64_t>(j.m_data.m_value.number_integer)))
-                    {
-                        throw_integer_out_of_range(j, "MessagePack", "[-2^63, 2^64-1]");
-                    }
                     if (j.m_data.m_value.number_integer >= -32)
                     {
                         // negative fixnum
@@ -487,10 +467,6 @@ class binary_writer
 
             case value_t::number_unsigned:
             {
-                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_unsigned)))
-                {
-                    throw_integer_out_of_range(j, "MessagePack", "uint64");
-                }
                 write_msgpack_unsigned(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
                 break;
             }
@@ -848,133 +824,6 @@ class binary_writer
         JSON_THROW(type_error::create(exception_id::discarded_value_used, concat("cannot serialize discarded value to ", format_name), &j));
     }
 
-    /*!
-    @brief whether integer @a n does not exceed the maximum of @a TargetType
-
-    The binary formats store integers in at most 64 bits, but number_integer_t
-    and number_unsigned_t may be wider (e.g., __int128). The range of the
-    integer is taken from std::numeric_limits, so a number type whose range
-    fits into @a TargetType is never checked: the function is then constant
-    true, and the default int64_t/uint64_t types pay nothing.
-    */
-    template<typename TargetType, typename NumberType>
-    static constexpr bool integer_fits_max(const NumberType n) noexcept
-    {
-        return integer_fits_max<TargetType>(n, std::integral_constant < bool,
-                                            (std::numeric_limits<NumberType>::digits > std::numeric_limits<TargetType>::digits) > ());
-    }
-
-    template<typename TargetType, typename NumberType>
-    static constexpr bool integer_fits_max(const NumberType /*unused*/, std::false_type /*may_exceed*/) noexcept
-    {
-        return true;
-    }
-
-    template<typename TargetType, typename NumberType>
-    static constexpr bool integer_fits_max(const NumberType n, std::true_type /*may_exceed*/) noexcept
-    {
-        // NumberType has more digits than TargetType, so it can hold its maximum
-        return n <= static_cast<NumberType>((std::numeric_limits<TargetType>::max)());
-    }
-
-    /*!
-    @brief whether integer @a n is not below the minimum of @a TargetType;
-           constant true if NumberType cannot hold such a value
-    */
-    template<typename TargetType, typename NumberType>
-    static constexpr bool integer_fits_min(const NumberType n) noexcept
-    {
-        return integer_fits_min<TargetType>(n, std::integral_constant < bool, std::numeric_limits<NumberType>::is_signed &&
-                                            (!std::numeric_limits<TargetType>::is_signed || std::numeric_limits<NumberType>::digits > std::numeric_limits<TargetType>::digits) > ());
-    }
-
-    template<typename TargetType, typename NumberType>
-    static constexpr bool integer_fits_min(const NumberType /*unused*/, std::false_type /*may_fall_below*/) noexcept
-    {
-        return true;
-    }
-
-    template<typename TargetType, typename NumberType>
-    static constexpr bool integer_fits_min(const NumberType n, std::true_type /*may_fall_below*/) noexcept
-    {
-        // NumberType is signed and either TargetType is unsigned (minimum 0)
-        // or NumberType has more digits, so it can hold the minimum
-        return n >= static_cast<NumberType>((std::numeric_limits<TargetType>::min)());
-    }
-
-    /*!
-    @brief whether integer @a n lies in the range of @a TargetType
-    */
-    template<typename TargetType, typename NumberType>
-    static constexpr bool integer_fits(const NumberType n) noexcept
-    {
-        return integer_fits_min<TargetType>(n) && integer_fits_max<TargetType>(n);
-    }
-
-    /*!
-    @brief the decimal digits of the non-negative integer @a n
-    */
-    template<typename NumberType>
-    static std::string integer_to_string(NumberType n, std::false_type /*is_signed*/)
-    {
-        std::string result;
-        do
-        {
-            result.push_back(static_cast<char>('0' + (n % 10)));
-            n = static_cast<NumberType>(n / 10);
-        }
-        while (n != 0);
-        std::reverse(result.begin(), result.end());
-        return result;
-    }
-
-    /*!
-    @brief the decimal digits of the integer @a n, with a leading '-' if it
-           is negative
-    */
-    template<typename NumberType>
-    static std::string integer_to_string(NumberType n, std::true_type /*is_signed*/)
-    {
-        // the remainder of a negative n is not positive; each digit is
-        // negated on its own, because negating the minimum of NumberType
-        // as a whole would overflow
-        const bool negative = n < 0;
-        std::string result;
-        do
-        {
-            const auto remainder = n % 10;
-            result.push_back(static_cast<char>('0' + (remainder < 0 ? -remainder : remainder)));
-            n = static_cast<NumberType>(n / 10);
-        }
-        while (n != 0);
-        if (negative)
-        {
-            result.push_back('-');
-        }
-        std::reverse(result.begin(), result.end());
-        return result;
-    }
-
-    /*!
-    @brief throws because the integer @a j is too large for @a format_name
-    @throw out_of_range.407 always
-    */
-    JSON_HEDLEY_NO_RETURN static void throw_integer_out_of_range(const BasicJsonType& j, const char* format_name, const char* range)
-    {
-        // neither std::to_string(), which has no overload for integer types
-        // wider than 64 bits, nor dump(), which would also instantiate the
-        // serializer for objects and fail for key types it cannot write
-        using integer_limits = std::numeric_limits<typename BasicJsonType::number_integer_t>;
-        using unsigned_limits = std::numeric_limits<typename BasicJsonType::number_unsigned_t>;
-        const std::string number = j.is_number_unsigned()
-                                   ? integer_to_string(j.m_data.m_value.number_unsigned, std::integral_constant<bool, unsigned_limits::is_signed>())
-                                   : integer_to_string(j.m_data.m_value.number_integer, std::integral_constant<bool, integer_limits::is_signed>());
-        static_cast<void>(number); // unused when JSON_NOEXCEPTION is defined
-        static_cast<void>(format_name);
-        static_cast<void>(range);
-        JSON_THROW(out_of_range::create(exception_id::integer_too_large, concat("integer number ", number, " cannot be represented by ", format_name, " as it does not fit ", range), &j));
-    }
-
     void write_msgpack_array_prefix(const std::size_t N, const BasicJsonType& j)
     {
         const auto n = to_msgpack_length(N, j);
@@ -1731,8 +1580,6 @@ class binary_writer
             is neither an object nor an array
     @throw out_of_range.415 if @a j is binary with a subtype that does not fit
            into a byte, before anything is written
-    @throw out_of_range.407 if @a j is an integer that does not fit the 64 bits
-           of a BSON integer, before anything is written
     @throw type_error.316 if @a j is a string that is not valid UTF-8, before
            anything is written
     @throw type_error.321 if @a j is discarded
@@ -1751,18 +1598,10 @@ class binary_writer
                 return 8ul;
 
             case value_t::number_integer:
-                if (JSON_HEDLEY_UNLIKELY(!integer_fits<std::int64_t>(j.m_data.m_value.number_integer)))
-                {
-                    throw_integer_out_of_range(j, "BSON", "int64");
-                }
-                return calc_bson_integer_size(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                return calc_bson_integer_size(j.m_data.m_value.number_integer);
 
             case value_t::number_unsigned:
-                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::uint64_t>(j.m_data.m_value.number_unsigned)))
-                {
-                    throw_integer_out_of_range(j, "BSON", "uint64");
-                }
-                return calc_bson_unsigned_size(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                return calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
 
             case value_t::string:
                 return calc_bson_string_size(*j.m_data.m_value.string, j);
@@ -1800,12 +1639,11 @@ class binary_writer
             case value_t::number_float:
                 return write_bson_double(name, j.m_data.m_value.number_float);
 
-            // calc_bson_value_size() checked that integers fit 64 bits
             case value_t::number_integer:
-                return write_bson_integer(name, static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                return write_bson_integer(name, j.m_data.m_value.number_integer);
 
             case value_t::number_unsigned:
-                return write_bson_unsigned(name, static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                return write_bson_unsigned(name, j.m_data.m_value.number_unsigned);
 
             case value_t::string:
                 return write_bson_string(name, *j.m_data.m_value.string);
@@ -2309,7 +2147,7 @@ class binary_writer
         {
             return 'L';
         }
-        if (use_bjdata && std::is_unsigned<NumberType>::value && integer_fits_max<std::uint64_t>(n))
+        if (use_bjdata && std::is_unsigned<NumberType>::value)
         {
             return 'M';
         }
@@ -2434,16 +2272,14 @@ class binary_writer
     @brief checks whether a JSON number fits into @a TargetType
     @param[in] el a JSON number of either the signed or unsigned integer kind
     @return whether @a el's value can be represented by @a TargetType without
-            wrapping, regardless of which of the two kinds it is stored as;
-            false for a value that does not even fit the 64-bit type it is
-            read as (possible for number types wider than 64 bits)
+            wrapping, regardless of which of the two kinds it is stored as
     */
     template<typename TargetType>
     static bool bjdata_ndarray_value_in_range(const BasicJsonType& el)
     {
         return el.is_number_unsigned()
-               ? integer_fits_max<std::uint64_t>(el.m_data.m_value.number_unsigned) && value_in_range_of<TargetType>(el.template get<std::uint64_t>())
-               : integer_fits<std::int64_t>(el.m_data.m_value.number_integer) && value_in_range_of<TargetType>(el.template get<std::int64_t>());
+               ? value_in_range_of<TargetType>(el.template get<std::uint64_t>())
+               : value_in_range_of<TargetType>(el.template get<std::int64_t>());
     }
 
     /*!
@@ -2675,11 +2511,10 @@ class binary_writer
         for (const auto& el : dims)
         {
             // a dimension is read as an unsigned value below, so anything that
-            // is not a non-negative integer in the range of std::uint64_t is
-            // rejected: a non-integer entry would pun unrelated bytes as the
-            // dimension, and a negative or wider one would wrap into a
-            // nonsensical length
-            if (!el.is_number_integer() || !bjdata_ndarray_value_in_range<std::uint64_t>(el))
+            // is not a non-negative integer is rejected: a non-integer entry
+            // would pun unrelated bytes as the dimension, and a negative one
+            // would wrap into a nonsensical length
+            if (!el.is_number_integer() || (!el.is_number_unsigned() && el.template get<std::int64_t>() < 0))
             {
                 return true;
             }
@@ -2811,9 +2646,9 @@ class binary_writer
 
             case value_t::number_unsigned:
             {
-                if (JSON_HEDLEY_UNLIKELY(!integer_fits_max<std::int64_t>(j.m_data.m_value.number_unsigned)))
+                if (j.m_data.m_value.number_unsigned > static_cast<typename BasicJsonType::number_unsigned_t>((std::numeric_limits<std::int64_t>::max)()))
                 {
-                    throw_integer_out_of_range(j, "BON8", "int64");
+                    JSON_THROW(out_of_range::create(exception_id::integer_too_large, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BON8 as it does not fit int64"), &j));
                 }
                 write_bon8_integer(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned));
                 string_open = false;
@@ -2822,10 +2657,6 @@ class binary_writer
 
             case value_t::number_integer:
             {
-                if (JSON_HEDLEY_UNLIKELY(!integer_fits<std::int64_t>(j.m_data.m_value.number_integer)))
-                {
-                    throw_integer_out_of_range(j, "BON8", "int64");
-                }
                 write_bon8_integer(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
                 string_open = false;
                 break;

include/nlohmann/detail/value_t.hpp

@@ -14,6 +14,7 @@
 #include <cstdint> // uint8_t
 #include <limits> // numeric_limits
 #include <string> // string
+#include <type_traits> // is_signed
 
 #include <nlohmann/detail/macro_scope.hpp>
 #if JSON_HAS_THREE_WAY_COMPARISON
@@ -146,16 +147,13 @@ FloatType compare_integer_with_float(const IntegerType i, const FloatType f) noe
 
     // values of IntegerType lie in [-bound, bound) when signed and in
     // [0, bound) when unsigned; digits excludes the sign bit, so bound is a
-    // power of two that the float represents exactly; the signedness comes
-    // from numeric_limits as well, because std::is_signed is false for class
-    // types such as 128-bit or multiprecision integers
-    using limits = std::numeric_limits<IntegerType>;
-    const FloatType bound = std::ldexp(static_cast<FloatType>(1), limits::digits);
+    // power of two that the float represents exactly
+    const FloatType bound = std::ldexp(static_cast<FloatType>(1), std::numeric_limits<IntegerType>::digits);
     if (f >= bound)
     {
         return ordered(-1);
     }
-    if (limits::is_signed ? (f < -bound) : (f < static_cast<FloatType>(0)))
+    if (std::is_signed<IntegerType>::value ? (f < -bound) : (f < static_cast<FloatType>(0)))
     {
         return ordered(1);
     }

tests/src/float_hard_cases.hpp

@@ -0,0 +1,599 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstdint> // uint32_t, uint64_t
+
+// Number tokens that are hard to round correctly, with the IEEE-754 binary64
+// and binary32 bits of their correctly rounded values (ties to even; infinity
+// for an overflow, a signed zero for an underflow).
+//
+// For doubles and floats around 0, the smallest normal number, 1, 2^24, 2^53,
+// 0.1, and the largest finite number, and for random ones, the exact midpoint
+// m to the next number gives: m, m with one unit more and less in the last
+// digit, m with "01" and "0...01" appended, m with trailing zeros, and m cut
+// after 17 to 30 digits (rounded down and up, so that the rounding is decided
+// after the 19th digit), in fixed and exponent notation, 30% of them negative.
+// Tokens longer than 80 characters are left out, except for four of 700 digits
+// and more. Zeros, underflow, overflow, huge exponents, and integers beyond 64
+// bits complete the set. Of the 508 tokens, 134 (as double) and 150 (as
+// float) need the exact comparison with the midpoint (detail::digit_comparison()).
+//
+// The expected bits were computed with exact rational arithmetic in Python
+// (fractions.Fraction) and cross-checked with Python's float(); strtod_l and
+// strtof_l of Apple's libc and of glibc agree. Generated by
+// compact_hard_cases.py 5 (with hard_cases.py), see the pull request that
+// added this file.
+
+namespace float_hard_cases
+{
+
+struct hard_case
+{
+    const char* token;
+    std::uint64_t bits64;
+    std::uint32_t bits32;
+};
+
+inline const std::array<hard_case, 508>& cases()
+{
+    static const std::array<hard_case, 508> table =
+    {
+        {
+            {"-2.4703282292062327e-324", 0x8000000000000000u, 0x80000000u},
+            {"24703282292062328e-340", 0x0000000000000001u, 0x00000000u},
+            {"247032822920623272e-341", 0x0000000000000000u, 0x00000000u},
+            {"-0.2470328229206232721e-323", 0x8000000000000001u, 0x80000000u},
+            {"-0.24703282292062327208e-323", 0x8000000000000000u, 0x80000000u},
+            {"-2.4703282292062327209e-324", 0x8000000000000001u, 0x80000000u},
+            {"2.47032822920623272088e-324", 0x0000000000000000u, 0x00000000u},
+            {"247032822920623272089e-344", 0x0000000000000001u, 0x00000000u},
+            {"-247032822920623272088284396434e-353", 0x8000000000000000u, 0x80000000u},
+            {"0.247032822920623272088284396435e-323", 0x0000000000000001u, 0x00000000u},
+            {"-74109846876186981e-340", 0x8000000000000001u, 0x80000000u},
+            {"0.74109846876186982e-323", 0x0000000000000002u, 0x00000000u},
+            {"-0.7410984687618698162e-323", 0x8000000000000001u, 0x80000000u},
+            {"-7.410984687618698163e-324", 0x8000000000000002u, 0x80000000u},
+            {"7.4109846876186981626e-324", 0x0000000000000001u, 0x00000000u},
+            {"-74109846876186981627e-343", 0x8000000000000002u, 0x80000000u},
+            {"-741098468761869816264e-344", 0x8000000000000001u, 0x80000000u},
+            {"0.741098468761869816265e-323", 0x0000000000000002u, 0x00000000u},
+            {"0.741098468761869816264853189302e-323", 0x0000000000000001u, 0x00000000u},
+            {"-7.41098468761869816264853189303e-324", 0x8000000000000002u, 0x80000000u},
+            {"0.22250738585072006e-307", 0x000FFFFFFFFFFFFEu, 0x00000000u},
+            {"2.2250738585072007e-308", 0x000FFFFFFFFFFFFFu, 0x00000000u},
+            {"2.225073858507200641e-308", 0x000FFFFFFFFFFFFEu, 0x00000000u},
+            {"-2225073858507200642e-326", 0x800FFFFFFFFFFFFFu, 0x80000000u},
+            {"22250738585072006419e-327", 0x000FFFFFFFFFFFFEu, 0x00000000u},
+            {"0.2225073858507200642e-307", 0x000FFFFFFFFFFFFFu, 0x00000000u},
+            {"0.222507385850720064199e-307", 0x000FFFFFFFFFFFFEu, 0x00000000u},
+            {"2.225073858507200642e-308", 0x000FFFFFFFFFFFFFu, 0x00000000u},
+            {"-2.22507385850720064199176395546e-308", 0x800FFFFFFFFFFFFEu, 0x80000000u},
+            {"222507385850720064199176395547e-337", 0x000FFFFFFFFFFFFFu, 0x00000000u},
+            {"-2.2250738585072011e-308", 0x800FFFFFFFFFFFFFu, 0x80000000u},
+            {"-22250738585072012e-324", 0x8010000000000000u, 0x80000000u},
+            {"-2225073858507201136e-326", 0x800FFFFFFFFFFFFFu, 0x80000000u},
+            {"0.2225073858507201137e-307", 0x0010000000000000u, 0x00000000u},
+            {"0.2225073858507201136e-307", 0x000FFFFFFFFFFFFFu, 0x00000000u},
+            {"-2.2250738585072011361e-308", 0x8010000000000000u, 0x80000000u},
+            {"2.22507385850720113605e-308", 0x000FFFFFFFFFFFFFu, 0x00000000u},
+            {"222507385850720113606e-328", 0x0010000000000000u, 0x00000000u},
+            {"22250738585072011360574097967e-336", 0x000FFFFFFFFFFFFFu, 0x00000000u},
+            {"0.222507385850720113605740979671e-307", 0x0010000000000000u, 0x00000000u},
+            {"22250738585072016e-324", 0x0010000000000000u, 0x00000000u},
+            {"0.22250738585072017e-307", 0x0010000000000001u, 0x00000000u},
+            {"0.222507385850720163e-307", 0x0010000000000000u, 0x00000000u},
+            {"2.225073858507201631e-308", 0x0010000000000001u, 0x00000000u},
+            {"-2.2250738585072016301e-308", 0x8010000000000000u, 0x80000000u},
+            {"22250738585072016302e-327", 0x0010000000000001u, 0x00000000u},
+            {"-222507385850720163012e-328", 0x8010000000000000u, 0x80000000u},
+            {"0.222507385850720163013e-307", 0x0010000000000001u, 0x00000000u},
+            {"0.222507385850720163012305563795e-307", 0x0010000000000000u, 0x00000000u},
+            {"-2.22507385850720163012305563796e-308", 0x8010000000000001u, 0x80000000u},
+            {"0.17976931348623156E+309", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
+            {"1.7976931348623157e308", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
+            {"1.797693134862315608e308", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
+            {"-1797693134862315609e290", 0xFFEFFFFFFFFFFFFFu, 0xFF800000u},
+            {"-17976931348623156083e289", 0xFFEFFFFFFFFFFFFEu, 0xFF800000u},
+            {"-0.17976931348623156084E+309", 0xFFEFFFFFFFFFFFFFu, 0xFF800000u},
+            {"0.179769313486231560835E+309", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
+            {"-1.79769313486231560836e308", 0xFFEFFFFFFFFFFFFFu, 0xFF800000u},
+            {"1.79769313486231560835325876058e308", 0x7FEFFFFFFFFFFFFEu, 0x7F800000u},
+            {"179769313486231560835325876059e279", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
+            {"1.7976931348623158e308", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
+            {"17976931348623159e292", 0x7FF0000000000000u, 0x7F800000u},
+            {"1797693134862315807e290", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
+            {"0.1797693134862315808E+309", 0x7FF0000000000000u, 0x7F800000u},
+            {"0.17976931348623158079E+309", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
+            {"-1.797693134862315808e308", 0xFFF0000000000000u, 0xFF800000u},
+            {"1.79769313486231580793e308", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
+            {"179769313486231580794e288", 0x7FF0000000000000u, 0x7F800000u},
+            {"179769313486231580793728971405e279", 0x7FEFFFFFFFFFFFFFu, 0x7F800000u},
+            {"-0.179769313486231580793728971406E+309", 0xFFF0000000000000u, 0xFF800000u},
+            {"100000000000000011102230246251565404236316680908203125e-53", 0x3FF0000000000000u, 0x3F800000u},
+            {"-1.00000000000000011102230246251565404236316680908203126", 0xBFF0000000000001u, 0xBF800000u},
+            {"1.00000000000000011102230246251565404236316680908203124e0", 0x3FF0000000000000u, 0x3F800000u},
+            {"10000000000000001110223024625156540423631668090820312501e-55", 0x3FF0000000000001u, 0x3F800000u},
+            {"1.00000000000000011102230246251565404236316680908203125000000000000000000001", 0x3FF0000000000001u, 0x3F800000u},
+            {"10000000000000001e-16", 0x3FF0000000000000u, 0x3F800000u},
+            {"1.0000000000000002", 0x3FF0000000000001u, 0x3F800000u},
+            {"1.000000000000000111", 0x3FF0000000000000u, 0x3F800000u},
+            {"1.000000000000000112e0", 0x3FF0000000000001u, 0x3F800000u},
+            {"1.000000000000000111e0", 0x3FF0000000000000u, 0x3F800000u},
+            {"-10000000000000001111e-19", 0xBFF0000000000001u, 0xBF800000u},
+            {"-100000000000000011102e-20", 0xBFF0000000000000u, 0xBF800000u},
+            {"-1.00000000000000011103", 0xBFF0000000000001u, 0xBF800000u},
+            {"1.00000000000000011102230246251", 0x3FF0000000000000u, 0x3F800000u},
+            {"1.00000000000000011102230246252e0", 0x3FF0000000000001u, 0x3F800000u},
+            {"-0.999999999999999944488848768742172978818416595458984375", 0xBFF0000000000000u, 0xBF800000u},
+            {"-9.99999999999999944488848768742172978818416595458984376e-1", 0xBFF0000000000000u, 0xBF800000u},
+            {"999999999999999944488848768742172978818416595458984374e-54", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
+            {"0.99999999999999994448884876874217297881841659545898437501", 0x3FF0000000000000u, 0x3F800000u},
+            {"9.99999999999999944488848768742172978818416595458984375000000000000000000001e-1", 0x3FF0000000000000u, 0x3F800000u},
+            {"-0.99999999999999994", 0xBFEFFFFFFFFFFFFFu, 0xBF800000u},
+            {"9.9999999999999995e-1", 0x3FF0000000000000u, 0x3F800000u},
+            {"9.999999999999999444e-1", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
+            {"9999999999999999445e-19", 0x3FF0000000000000u, 0x3F800000u},
+            {"99999999999999994448e-20", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
+            {"-0.99999999999999994449", 0xBFF0000000000000u, 0xBF800000u},
+            {"0.999999999999999944488", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
+            {"-9.99999999999999944489e-1", 0xBFF0000000000000u, 0xBF800000u},
+            {"9.99999999999999944488848768742e-1", 0x3FEFFFFFFFFFFFFFu, 0x3F800000u},
+            {"999999999999999944488848768743e-30", 0x3FF0000000000000u, 0x3F800000u},
+            {"-9.007199254740993e15", 0xC340000000000000u, 0xDA000000u},
+            {"9007199254740994e0", 0x4340000000000001u, 0x5A000000u},
+            {"9007199254740992", 0x4340000000000000u, 0x5A000000u},
+            {"9.00719925474099301e15", 0x4340000000000001u, 0x5A000000u},
+            {"9007199254740993000000000000000000001e-21", 0x4340000000000001u, 0x5A000000u},
+            {"-9007199254740993.000000000000000000000000000000", 0xC340000000000000u, 0xDA000000u},
+            {"90071992547409915e-1", 0x4340000000000000u, 0x5A000000u},
+            {"-9007199254740991.6", 0xC340000000000000u, 0xDA000000u},
+            {"9.0071992547409914e15", 0x433FFFFFFFFFFFFFu, 0x5A000000u},
+            {"-9007199254740991501e-3", 0xC340000000000000u, 0xDA000000u},
+            {"9007199254740991.5000000000000000000001", 0x4340000000000000u, 0x5A000000u},
+            {"9.0071992547409915000000000000000000000000000000e15", 0x4340000000000000u, 0x5A000000u},
+            {"0.100000000000000012490009027033011079765856266021728515625", 0x3FB999999999999Au, 0x3DCCCCCDu},
+            {"1.00000000000000012490009027033011079765856266021728515626e-1", 0x3FB999999999999Bu, 0x3DCCCCCDu},
+            {"100000000000000012490009027033011079765856266021728515624e-57", 0x3FB999999999999Au, 0x3DCCCCCDu},
+            {"0.10000000000000001249000902703301107976585626602172851562501", 0x3FB999999999999Bu, 0x3DCCCCCDu},
+            {"0.10000000000000001", 0x3FB999999999999Au, 0x3DCCCCCDu},
+            {"1.0000000000000002e-1", 0x3FB999999999999Bu, 0x3DCCCCCDu},
+            {"-1.000000000000000124e-1", 0xBFB999999999999Au, 0xBDCCCCCDu},
+            {"1000000000000000125e-19", 0x3FB999999999999Bu, 0x3DCCCCCDu},
+            {"-10000000000000001249e-20", 0xBFB999999999999Au, 0xBDCCCCCDu},
+            {"0.1000000000000000125", 0x3FB999999999999Bu, 0x3DCCCCCDu},
+            {"0.10000000000000001249", 0x3FB999999999999Au, 0x3DCCCCCDu},
+            {"1.00000000000000012491e-1", 0x3FB999999999999Bu, 0x3DCCCCCDu},
+            {"1.00000000000000012490009027033e-1", 0x3FB999999999999Au, 0x3DCCCCCDu},
+            {"100000000000000012490009027034e-30", 0x3FB999999999999Bu, 0x3DCCCCCDu},
+            {"2.45134755833537796875e14", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
+            {"-245134755833537796876e-6", 0xC2EBDE5C4164D83Au, 0xD75EF2E2u},
+            {"-245134755833537.796874", 0xC2EBDE5C4164D839u, 0xD75EF2E2u},
+            {"2.4513475583353779687501e14", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
+            {"245134755833537796875000000000000000000001e-27", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
+            {"245134755833537.796875000000000000000000000000000000", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
+            {"2.4513475583353779e14", 0x42EBDE5C4164D839u, 0x575EF2E2u},
+            {"2451347558335378e-1", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
+            {"2451347558335377968e-4", 0x42EBDE5C4164D839u, 0x575EF2E2u},
+            {"245134755833537.7969", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
+            {"245134755833537.79687", 0x42EBDE5C4164D839u, 0x575EF2E2u},
+            {"2.4513475583353779688e14", 0x42EBDE5C4164D83Au, 0x575EF2E2u},
+            {"181510327827821147441864013671875e-23", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
+            {"-1815103278.27821147441864013671876", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
+            {"1.81510327827821147441864013671874e9", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
+            {"18151032782782114744186401367187501e-25", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
+            {"1815103278.27821147441864013671875000000000000000000001", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
+            {"-1.81510327827821147441864013671875000000000000000000000000000000e9", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
+            {"18151032782782114e-7", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
+            {"1815103278.2782115", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
+            {"1815103278.278211474", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
+            {"-1.815103278278211475e9", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
+            {"1.8151032782782114744e9", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
+            {"-18151032782782114745e-10", 0xC1DB0C11CB91CE38u, 0xCED8608Eu},
+            {"181510327827821147441e-11", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
+            {"1815103278.27821147442", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
+            {"1815103278.27821147441864013671", 0x41DB0C11CB91CE37u, 0x4ED8608Eu},
+            {"1.81510327827821147441864013672e9", 0x41DB0C11CB91CE38u, 0x4ED8608Eu},
+            {"3809325632181785344", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
+            {"3.809325632181785345e18", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
+            {"3809325632181785343e0", 0x43CA6EB8BD69FE29u, 0x5E5375C6u},
+            {"3809325632181785344.01", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
+            {"3.809325632181785344000000000000000000001e18", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
+            {"3809325632181785344000000000000000000000000000000e-30", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
+            {"3809325632181785300", 0x43CA6EB8BD69FE29u, 0x5E5375C6u},
+            {"3.8093256321817854e18", 0x43CA6EB8BD69FE2Au, 0x5E5375C6u},
+            {"4.046966549916366943359375e12", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"4046966549916366943359376e-12", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"4046966549916.366943359374", 0x428D7210076CE2EFu, 0x546B9080u},
+            {"4.04696654991636694335937501e12", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"4046966549916366943359375000000000000000000001e-33", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"-4046966549916.366943359375000000000000000000000000000000", 0xC28D7210076CE2F0u, 0xD46B9080u},
+            {"4.0469665499163669e12", 0x428D7210076CE2EFu, 0x546B9080u},
+            {"4046966549916367e-3", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"4046966549916366943e-6", 0x428D7210076CE2EFu, 0x546B9080u},
+            {"4046966549916.366944", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"4046966549916.3669433", 0x428D7210076CE2EFu, 0x546B9080u},
+            {"4.0469665499163669434e12", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"-4.04696654991636694335e12", 0xC28D7210076CE2EFu, 0xD46B9080u},
+            {"404696654991636694336e-8", 0x428D7210076CE2F0u, 0x546B9080u},
+            {"28093802557000874e154", 0x63529C3B77330BDBu, 0x7F800000u},
+            {"0.28093802557000875E+171", 0x63529C3B77330BDCu, 0x7F800000u},
+            {"0.2809380255700087447E+171", 0x63529C3B77330BDBu, 0x7F800000u},
+            {"2.809380255700087448e170", 0x63529C3B77330BDCu, 0x7F800000u},
+            {"2.8093802557000874472e170", 0x63529C3B77330BDBu, 0x7F800000u},
+            {"28093802557000874473e151", 0x63529C3B77330BDCu, 0x7F800000u},
+            {"280938025570008744728e150", 0x63529C3B77330BDBu, 0x7F800000u},
+            {"-0.280938025570008744729E+171", 0xE3529C3B77330BDCu, 0xFF800000u},
+            {"-0.280938025570008744728403667979E+171", 0xE3529C3B77330BDBu, 0xFF800000u},
+            {"2.8093802557000874472840366798e170", 0x63529C3B77330BDCu, 0x7F800000u},
+            {"0.39523280297734525e-154", 0x1FE0F51BF17FD374u, 0x00000000u},
+            {"-3.9523280297734526e-155", 0x9FE0F51BF17FD375u, 0x80000000u},
+            {"3.952328029773452547e-155", 0x1FE0F51BF17FD374u, 0x00000000u},
+            {"3952328029773452548e-173", 0x1FE0F51BF17FD375u, 0x00000000u},
+            {"-39523280297734525478e-174", 0x9FE0F51BF17FD374u, 0x80000000u},
+            {"0.39523280297734525479e-154", 0x1FE0F51BF17FD375u, 0x00000000u},
+            {"-0.395232802977345254787e-154", 0x9FE0F51BF17FD374u, 0x80000000u},
+            {"-3.95232802977345254788e-155", 0x9FE0F51BF17FD375u, 0x80000000u},
+            {"-3.95232802977345254787245825501e-155", 0x9FE0F51BF17FD374u, 0x80000000u},
+            {"395232802977345254787245825502e-184", 0x1FE0F51BF17FD375u, 0x00000000u},
+            {"-1.0790205420931879e-276", 0x86A3209CA6233255u, 0x80000000u},
+            {"-1079020542093188e-291", 0x86A3209CA6233256u, 0x80000000u},
+            {"-1079020542093187947e-294", 0x86A3209CA6233255u, 0x80000000u},
+            {"0.1079020542093187948e-275", 0x06A3209CA6233256u, 0x00000000u},
+            {"0.1079020542093187947e-275", 0x06A3209CA6233255u, 0x00000000u},
+            {"1.0790205420931879471e-276", 0x06A3209CA6233256u, 0x00000000u},
+            {"1.07902054209318794701e-276", 0x06A3209CA6233255u, 0x00000000u},
+            {"-107902054209318794702e-296", 0x86A3209CA6233256u, 0x80000000u},
+            {"107902054209318794701153285302e-305", 0x06A3209CA6233255u, 0x00000000u},
+            {"-0.107902054209318794701153285303e-275", 0x86A3209CA6233256u, 0x80000000u},
+            {"58530471071351308e-228", 0x1413B446E6A16A3Bu, 0x00000000u},
+            {"-0.58530471071351309e-211", 0x9413B446E6A16A3Cu, 0x80000000u},
+            {"0.5853047107135130893e-211", 0x1413B446E6A16A3Bu, 0x00000000u},
+            {"-5.853047107135130894e-212", 0x9413B446E6A16A3Cu, 0x80000000u},
+            {"5.853047107135130893e-212", 0x1413B446E6A16A3Bu, 0x00000000u},
+            {"58530471071351308931e-231", 0x1413B446E6A16A3Cu, 0x00000000u},
+            {"-585304710713513089304e-232", 0x9413B446E6A16A3Bu, 0x80000000u},
+            {"0.585304710713513089305e-211", 0x1413B446E6A16A3Cu, 0x00000000u},
+            {"-0.585304710713513089304248824438e-211", 0x9413B446E6A16A3Bu, 0x80000000u},
+            {"5.85304710713513089304248824439e-212", 0x1413B446E6A16A3Cu, 0x00000000u},
+            {"0.19334214893983531e-78", 0x2F96ECBF1CFB10F6u, 0x00000000u},
+            {"1.9334214893983532e-79", 0x2F96ECBF1CFB10F7u, 0x00000000u},
+            {"1.933421489398353102e-79", 0x2F96ECBF1CFB10F6u, 0x00000000u},
+            {"1933421489398353103e-97", 0x2F96ECBF1CFB10F7u, 0x00000000u},
+            {"19334214893983531023e-98", 0x2F96ECBF1CFB10F6u, 0x00000000u},
+            {"0.19334214893983531024e-78", 0x2F96ECBF1CFB10F7u, 0x00000000u},
+            {"0.193342148939835310231e-78", 0x2F96ECBF1CFB10F6u, 0x00000000u},
+            {"1.93342148939835310232e-79", 0x2F96ECBF1CFB10F7u, 0x00000000u},
+            {"-1.93342148939835310231359014704e-79", 0xAF96ECBF1CFB10F6u, 0x80000000u},
+            {"193342148939835310231359014705e-108", 0x2F96ECBF1CFB10F7u, 0x00000000u},
+            {"2.9873358928024455e227", 0x6F2938807814E8A2u, 0x7F800000u},
+            {"29873358928024456e211", 0x6F2938807814E8A3u, 0x7F800000u},
+            {"298733589280244551e210", 0x6F2938807814E8A2u, 0x7F800000u},
+            {"0.2987335892802445511E+228", 0x6F2938807814E8A3u, 0x7F800000u},
+            {"0.29873358928024455109E+228", 0x6F2938807814E8A2u, 0x7F800000u},
+            {"2.987335892802445511e227", 0x6F2938807814E8A3u, 0x7F800000u},
+            {"-2.98733589280244551098e227", 0xEF2938807814E8A2u, 0xFF800000u},
+            {"-298733589280244551099e207", 0xEF2938807814E8A3u, 0xFF800000u},
+            {"298733589280244551098081559931e198", 0x6F2938807814E8A2u, 0x7F800000u},
+            {"0.298733589280244551098081559932E+228", 0x6F2938807814E8A3u, 0x7F800000u},
+            {"7.0064923216240853e-46", 0x3690000000000000u, 0x00000000u},
+            {"70064923216240854e-62", 0x3690000000000000u, 0x00000001u},
+            {"7006492321624085354e-64", 0x3690000000000000u, 0x00000000u},
+            {"-0.7006492321624085355e-45", 0xB690000000000000u, 0x80000001u},
+            {"0.70064923216240853546e-45", 0x3690000000000000u, 0x00000000u},
+            {"7.0064923216240853547e-46", 0x3690000000000000u, 0x00000001u},
+            {"7.00649232162408535461e-46", 0x3690000000000000u, 0x00000000u},
+            {"-700649232162408535462e-66", 0xB690000000000000u, 0x80000001u},
+            {"-700649232162408535461864791644e-75", 0xB690000000000000u, 0x80000000u},
+            {"0.700649232162408535461864791645e-45", 0x3690000000000000u, 0x00000001u},
+            {"21019476964872256e-61", 0x36A8000000000000u, 0x00000001u},
+            {"0.21019476964872257e-44", 0x36A8000000000000u, 0x00000002u},
+            {"-0.2101947696487225606e-44", 0xB6A8000000000000u, 0x80000001u},
+            {"-2.101947696487225607e-45", 0xB6A8000000000000u, 0x80000002u},
+            {"2.1019476964872256063e-45", 0x36A8000000000000u, 0x00000001u},
+            {"21019476964872256064e-64", 0x36A8000000000000u, 0x00000002u},
+            {"-210194769648722560638e-65", 0xB6A8000000000000u, 0x80000001u},
+            {"-0.210194769648722560639e-44", 0xB6A8000000000000u, 0x80000002u},
+            {"-0.210194769648722560638559437493e-44", 0xB6A8000000000000u, 0x80000001u},
+            {"2.10194769648722560638559437494e-45", 0x36A8000000000000u, 0x00000002u},
+            {"0.11754941406275178e-37", 0x380FFFFFA0000000u, 0x007FFFFEu},
+            {"1.1754941406275179e-38", 0x380FFFFFA0000000u, 0x007FFFFFu},
+            {"-1.175494140627517859e-38", 0xB80FFFFFA0000000u, 0x807FFFFEu},
+            {"117549414062751786e-55", 0x380FFFFFA0000000u, 0x007FFFFFu},
+            {"-11754941406275178592e-57", 0xB80FFFFFA0000000u, 0x807FFFFEu},
+            {"0.11754941406275178593e-37", 0x380FFFFFA0000000u, 0x007FFFFFu},
+            {"0.117549414062751785924e-37", 0x380FFFFFA0000000u, 0x007FFFFEu},
+            {"1.17549414062751785925e-38", 0x380FFFFFA0000000u, 0x007FFFFFu},
+            {"-1.17549414062751785924617589866e-38", 0xB80FFFFFA0000000u, 0x807FFFFEu},
+            {"117549414062751785924617589867e-67", 0x380FFFFFA0000000u, 0x007FFFFFu},
+            {"1.1754942807573642e-38", 0x380FFFFFDFFFFFFFu, 0x007FFFFFu},
+            {"11754942807573643e-54", 0x380FFFFFE0000000u, 0x00800000u},
+            {"1175494280757364291e-56", 0x380FFFFFE0000000u, 0x007FFFFFu},
+            {"0.1175494280757364292e-37", 0x380FFFFFE0000000u, 0x00800000u},
+            {"0.11754942807573642917e-37", 0x380FFFFFE0000000u, 0x007FFFFFu},
+            {"-1.1754942807573642918e-38", 0xB80FFFFFE0000000u, 0x80800000u},
+            {"-1.17549428075736429172e-38", 0xB80FFFFFE0000000u, 0x807FFFFFu},
+            {"-117549428075736429173e-58", 0xB80FFFFFE0000000u, 0x80800000u},
+            {"117549428075736429172788299103e-67", 0x380FFFFFE0000000u, 0x007FFFFFu},
+            {"0.117549428075736429172788299104e-37", 0x380FFFFFE0000000u, 0x00800000u},
+            {"11754944208872107e-54", 0x3810000010000000u, 0x00800000u},
+            {"-0.11754944208872108e-37", 0xB810000010000000u, 0x80800001u},
+            {"0.1175494420887210724e-37", 0x3810000010000000u, 0x00800000u},
+            {"1.175494420887210725e-38", 0x3810000010000000u, 0x00800001u},
+            {"1.1754944208872107242e-38", 0x3810000010000000u, 0x00800000u},
+            {"-11754944208872107243e-57", 0xB810000010000000u, 0x80800001u},
+            {"-11754944208872107242e-57", 0xB810000010000000u, 0x80800000u},
+            {"0.117549442088721072421e-37", 0x3810000010000000u, 0x00800001u},
+            {"0.11754944208872107242095900834e-37", 0x3810000010000000u, 0x00800000u},
+            {"-1.17549442088721072420959008341e-38", 0xB810000010000000u, 0x80800001u},
+            {"340282336497324057985868971510891282432", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"-3.40282336497324057985868971510891282433e38", 0xC7EFFFFFD0000000u, 0xFF7FFFFFu},
+            {"340282336497324057985868971510891282431e0", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"340282336497324057985868971510891282432.01", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
+            {"3.40282336497324057985868971510891282432000000000000000000001e38", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
+            {"340282336497324057985868971510891282432000000000000000000000000000000e-30", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"340282336497324050000000000000000000000", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"3.4028233649732406e38", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
+            {"3.402823364973240579e38", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"340282336497324058e21", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
+            {"34028233649732405798e19", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"340282336497324057990000000000000000000", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
+            {"340282336497324057985000000000000000000", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"3.40282336497324057986e38", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
+            {"3.4028233649732405798586897151e38", 0x47EFFFFFD0000000u, 0x7F7FFFFEu},
+            {"340282336497324057985868971511e9", 0x47EFFFFFD0000000u, 0x7F7FFFFFu},
+            {"3.40282356779733661637539395458142568448e38", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"-340282356779733661637539395458142568449e0", 0xC7EFFFFFF0000000u, 0xFF800000u},
+            {"340282356779733661637539395458142568447", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
+            {"3.4028235677973366163753939545814256844801e38", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"340282356779733661637539395458142568448000000000000000000001e-21", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"340282356779733661637539395458142568448.000000000000000000000000000000", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"3.4028235677973366e38", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
+            {"-34028235677973367e22", 0xC7EFFFFFF0000000u, 0xFF800000u},
+            {"3402823567797336616e20", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
+            {"340282356779733661700000000000000000000", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"340282356779733661630000000000000000000", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
+            {"3.4028235677973366164e38", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"3.40282356779733661637e38", 0x47EFFFFFF0000000u, 0x7F7FFFFFu},
+            {"340282356779733661638e18", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"-340282356779733661637539395458e9", 0xC7EFFFFFF0000000u, 0xFF7FFFFFu},
+            {"340282356779733661637539395459000000000", 0x47EFFFFFF0000000u, 0x7F800000u},
+            {"-1000000059604644775390625e-24", 0xBFF0000010000000u, 0xBF800000u},
+            {"-1.000000059604644775390626", 0xBFF0000010000000u, 0xBF800001u},
+            {"-1.000000059604644775390624e0", 0xBFF0000010000000u, 0xBF800000u},
+            {"100000005960464477539062501e-26", 0x3FF0000010000000u, 0x3F800001u},
+            {"1.000000059604644775390625000000000000000000001", 0x3FF0000010000000u, 0x3F800001u},
+            {"1.000000059604644775390625000000000000000000000000000000e0", 0x3FF0000010000000u, 0x3F800000u},
+            {"-10000000596046447e-16", 0xBFF0000010000000u, 0xBF800000u},
+            {"1.0000000596046448", 0x3FF0000010000000u, 0x3F800001u},
+            {"1.000000059604644775", 0x3FF0000010000000u, 0x3F800000u},
+            {"-1.000000059604644776e0", 0xBFF0000010000000u, 0xBF800001u},
+            {"-1.0000000596046447753e0", 0xBFF0000010000000u, 0xBF800000u},
+            {"10000000596046447754e-19", 0x3FF0000010000000u, 0x3F800001u},
+            {"100000005960464477539e-20", 0x3FF0000010000000u, 0x3F800000u},
+            {"-1.0000000596046447754", 0xBFF0000010000000u, 0xBF800001u},
+            {"0.9999999701976776123046875", 0x3FEFFFFFF0000000u, 0x3F800000u},
+            {"9.999999701976776123046876e-1", 0x3FEFFFFFF0000000u, 0x3F800000u},
+            {"9999999701976776123046874e-25", 0x3FEFFFFFF0000000u, 0x3F7FFFFFu},
+            {"0.999999970197677612304687501", 0x3FEFFFFFF0000000u, 0x3F800000u},
+            {"-9.999999701976776123046875000000000000000000001e-1", 0xBFEFFFFFF0000000u, 0xBF800000u},
+            {"-9999999701976776123046875000000000000000000000000000000e-55", 0xBFEFFFFFF0000000u, 0xBF800000u},
+            {"0.99999997019767761", 0x3FEFFFFFF0000000u, 0x3F7FFFFFu},
+            {"-9.9999997019767762e-1", 0xBFEFFFFFF0000000u, 0xBF800000u},
+            {"-9.999999701976776123e-1", 0xBFEFFFFFF0000000u, 0xBF7FFFFFu},
+            {"9999999701976776124e-19", 0x3FEFFFFFF0000000u, 0x3F800000u},
+            {"9999999701976776123e-19", 0x3FEFFFFFF0000000u, 0x3F7FFFFFu},
+            {"0.99999997019767761231", 0x3FEFFFFFF0000000u, 0x3F800000u},
+            {"-0.999999970197677612304", 0xBFEFFFFFF0000000u, 0xBF7FFFFFu},
+            {"9.99999970197677612305e-1", 0x3FEFFFFFF0000000u, 0x3F800000u},
+            {"-1.6777217e7", 0xC170000010000000u, 0xCB800000u},
+            {"16777218e0", 0x4170000020000000u, 0x4B800001u},
+            {"16777216", 0x4170000000000000u, 0x4B800000u},
+            {"-1.677721701e7", 0xC17000001028F5C3u, 0xCB800001u},
+            {"-16777217000000000000000000001e-21", 0xC170000010000000u, 0xCB800001u},
+            {"16777217.000000000000000000000000000000", 0x4170000010000000u, 0x4B800000u},
+            {"167772155e-1", 0x416FFFFFF0000000u, 0x4B800000u},
+            {"16777215.6", 0x416FFFFFF3333333u, 0x4B800000u},
+            {"1.67772154e7", 0x416FFFFFECCCCCCDu, 0x4B7FFFFFu},
+            {"16777215501e-3", 0x416FFFFFF0083127u, 0x4B800000u},
+            {"-16777215.5000000000000000000001", 0xC16FFFFFF0000000u, 0xCB800000u},
+            {"-1.67772155000000000000000000000000000000e7", 0xC16FFFFFF0000000u, 0xCB800000u},
+            {"0.1000000052154064178466796875", 0x3FB99999B0000000u, 0x3DCCCCCEu},
+            {"1.000000052154064178466796876e-1", 0x3FB99999B0000000u, 0x3DCCCCCEu},
+            {"-1000000052154064178466796874e-28", 0xBFB99999B0000000u, 0xBDCCCCCDu},
+            {"0.100000005215406417846679687501", 0x3FB99999B0000000u, 0x3DCCCCCEu},
+            {"1.000000052154064178466796875000000000000000000001e-1", 0x3FB99999B0000000u, 0x3DCCCCCEu},
+            {"-1000000052154064178466796875000000000000000000000000000000e-58", 0xBFB99999B0000000u, 0xBDCCCCCEu},
+            {"-0.10000000521540641", 0xBFB99999AFFFFFFFu, 0xBDCCCCCDu},
+            {"-1.0000000521540642e-1", 0xBFB99999B0000000u, 0xBDCCCCCEu},
+            {"1.000000052154064178e-1", 0x3FB99999B0000000u, 0x3DCCCCCDu},
+            {"-1000000052154064179e-19", 0xBFB99999B0000000u, 0xBDCCCCCEu},
+            {"10000000521540641784e-20", 0x3FB99999B0000000u, 0x3DCCCCCDu},
+            {"0.10000000521540641785", 0x3FB99999B0000000u, 0x3DCCCCCEu},
+            {"0.100000005215406417846", 0x3FB99999B0000000u, 0x3DCCCCCDu},
+            {"1.00000005215406417847e-1", 0x3FB99999B0000000u, 0x3DCCCCCEu},
+            {"5.429001220703125e3", 0x40B5350050000000u, 0x45A9A802u},
+            {"-5429001220703126e-12", 0xC0B5350050000001u, 0xC5A9A803u},
+            {"-5429.001220703124", 0xC0B535004FFFFFFFu, 0xC5A9A802u},
+            {"5.42900122070312501e3", 0x40B5350050000000u, 0x45A9A803u},
+            {"5429001220703125000000000000000000001e-33", 0x40B5350050000000u, 0x45A9A803u},
+            {"-5429.001220703125000000000000000000000000000000", 0xC0B5350050000000u, 0xC5A9A802u},
+            {"503719056e0", 0x41BE062490000000u, 0x4DF03124u},
+            {"503719057", 0x41BE062491000000u, 0x4DF03125u},
+            {"5.03719055e8", 0x41BE06248F000000u, 0x4DF03124u},
+            {"50371905601e-2", 0x41BE062490028F5Cu, 0x4DF03125u},
+            {"503719056.000000000000000000001", 0x41BE062490000000u, 0x4DF03125u},
+            {"5.03719056000000000000000000000000000000e8", 0x41BE062490000000u, 0x4DF03124u},
+            {"-92331620", 0xC196037990000000u, 0xCCB01BCCu},
+            {"9.233163e7", 0x41960379B8000000u, 0x4CB01BCEu},
+            {"9233161e1", 0x4196037968000000u, 0x4CB01BCBu},
+            {"92331620.1", 0x4196037990666666u, 0x4CB01BCDu},
+            {"9.233162000000000000000000001e7", 0x4196037990000000u, 0x4CB01BCDu},
+            {"9233162000000000000000000000000000000e-29", 0x4196037990000000u, 0x4CB01BCCu},
+            {"3.002458625e6", 0x4146E82D50000000u, 0x4A37416Au},
+            {"3002458626e-3", 0x4146E82D5020C49Cu, 0x4A37416Bu},
+            {"3002458.624", 0x4146E82D4FDF3B64u, 0x4A37416Au},
+            {"-3.00245862501e6", 0xC146E82D500053E3u, 0xCA37416Bu},
+            {"3002458625000000000000000000001e-24", 0x4146E82D50000000u, 0x4A37416Bu},
+            {"3002458.625000000000000000000000000000000", 0x4146E82D50000000u, 0x4A37416Au},
+            {"-1095485584696182596504479582065262592e1", 0xC7A07BA830000000u, 0xFD03DD42u},
+            {"10954855846961825965044795820652625930", 0x47A07BA830000000u, 0x7D03DD42u},
+            {"1.095485584696182596504479582065262591e37", 0x47A07BA830000000u, 0x7D03DD41u},
+            {"109548558469618259650447958206526259201e-1", 0x47A07BA830000000u, 0x7D03DD42u},
+            {"-10954855846961825965044795820652625920.00000000000000000001", 0xC7A07BA830000000u, 0xFD03DD42u},
+            {"1.095485584696182596504479582065262592000000000000000000000000000000e37", 0x47A07BA830000000u, 0x7D03DD42u},
+            {"10954855846961825e21", 0x47A07BA830000000u, 0x7D03DD41u},
+            {"10954855846961826000000000000000000000", 0x47A07BA830000000u, 0x7D03DD42u},
+            {"10954855846961825960000000000000000000", 0x47A07BA830000000u, 0x7D03DD41u},
+            {"1.095485584696182597e37", 0x47A07BA830000000u, 0x7D03DD42u},
+            {"1.0954855846961825965e37", 0x47A07BA830000000u, 0x7D03DD41u},
+            {"-10954855846961825966e18", 0xC7A07BA830000000u, 0xFD03DD42u},
+            {"10954855846961825965e18", 0x47A07BA830000000u, 0x7D03DD41u},
+            {"10954855846961825965100000000000000000", 0x47A07BA830000000u, 0x7D03DD42u},
+            {"10954855846961825965044795820600000000", 0x47A07BA830000000u, 0x7D03DD41u},
+            {"-1.09548558469618259650447958207e37", 0xC7A07BA830000000u, 0xFD03DD42u},
+            {"1.6449216019182103706535606608388384863861375606575165875256061553955078126e-21", 0x3B9F125A50000000u, 0x1CF892D3u},
+            {"-16449216019182103706535606608388384863861375606575165875256061553955078124e-94", 0xBB9F125A50000000u, 0x9CF892D2u},
+            {"-0.0000000000000000000016449216019182103", 0xBB9F125A50000000u, 0x9CF892D2u},
+            {"-1.6449216019182104e-21", 0xBB9F125A50000000u, 0x9CF892D3u},
+            {"-1.64492160191821037e-21", 0xBB9F125A50000000u, 0x9CF892D2u},
+            {"-1644921601918210371e-39", 0xBB9F125A50000000u, 0x9CF892D3u},
+            {"-16449216019182103706e-40", 0xBB9F125A50000000u, 0x9CF892D2u},
+            {"0.0000000000000000000016449216019182103707", 0x3B9F125A50000000u, 0x1CF892D3u},
+            {"0.00000000000000000000164492160191821037065", 0x3B9F125A50000000u, 0x1CF892D2u},
+            {"1.64492160191821037066e-21", 0x3B9F125A50000000u, 0x1CF892D3u},
+            {"1.64492160191821037065356066083e-21", 0x3B9F125A50000000u, 0x1CF892D2u},
+            {"164492160191821037065356066084e-50", 0x3B9F125A50000000u, 0x1CF892D3u},
+            {"6.565061509609222412109375e-1", 0x3FE5021930000000u, 0x3F2810CAu},
+            {"6565061509609222412109376e-25", 0x3FE5021930000000u, 0x3F2810CAu},
+            {"0.6565061509609222412109374", 0x3FE5021930000000u, 0x3F2810C9u},
+            {"6.56506150960922241210937501e-1", 0x3FE5021930000000u, 0x3F2810CAu},
+            {"6565061509609222412109375000000000000000000001e-46", 0x3FE5021930000000u, 0x3F2810CAu},
+            {"-0.6565061509609222412109375000000000000000000000000000000", 0xBFE5021930000000u, 0xBF2810CAu},
+            {"6.5650615096092224e-1", 0x3FE5021930000000u, 0x3F2810C9u},
+            {"-65650615096092225e-17", 0xBFE5021930000000u, 0xBF2810CAu},
+            {"6565061509609222412e-19", 0x3FE5021930000000u, 0x3F2810C9u},
+            {"0.6565061509609222413", 0x3FE5021930000000u, 0x3F2810CAu},
+            {"0.65650615096092224121", 0x3FE5021930000000u, 0x3F2810C9u},
+            {"6.5650615096092224122e-1", 0x3FE5021930000000u, 0x3F2810CAu},
+            {"-6.5650615096092224121e-1", 0xBFE5021930000000u, 0xBF2810C9u},
+            {"656506150960922241211e-21", 0x3FE5021930000000u, 0x3F2810CAu},
+            {"18014627239033005156980393746124491372029297053813934326171875e-77", 0x3CA9F63970000000u, 0x254FB1CCu},
+            {"0.00000000000000018014627239033005156980393746124491372029297053813934326171876", 0x3CA9F63970000000u, 0x254FB1CCu},
+            {"-1.8014627239033005156980393746124491372029297053813934326171874e-16", 0xBCA9F63970000000u, 0xA54FB1CBu},
+            {"1801462723903300515698039374612449137202929705381393432617187501e-79", 0x3CA9F63970000000u, 0x254FB1CCu},
+            {"18014627239033005e-32", 0x3CA9F63970000000u, 0x254FB1CBu},
+            {"0.00000000000000018014627239033006", 0x3CA9F63970000000u, 0x254FB1CCu},
+            {"0.0000000000000001801462723903300515", 0x3CA9F63970000000u, 0x254FB1CBu},
+            {"-1.801462723903300516e-16", 0xBCA9F63970000000u, 0xA54FB1CCu},
+            {"-1.8014627239033005156e-16", 0xBCA9F63970000000u, 0xA54FB1CBu},
+            {"18014627239033005157e-35", 0x3CA9F63970000000u, 0x254FB1CCu},
+            {"180146272390330051569e-36", 0x3CA9F63970000000u, 0x254FB1CBu},
+            {"-0.00000000000000018014627239033005157", 0xBCA9F63970000000u, 0xA54FB1CCu},
+            {"0.000000000000000180146272390330051569803937461", 0x3CA9F63970000000u, 0x254FB1CBu},
+            {"1.80146272390330051569803937462e-16", 0x3CA9F63970000000u, 0x254FB1CCu},
+            {"0.05534819327294826507568359375", 0x3FAC569930000000u, 0x3D62B4CAu},
+            {"-5.534819327294826507568359376e-2", 0xBFAC569930000000u, 0xBD62B4CAu},
+            {"5534819327294826507568359374e-29", 0x3FAC569930000000u, 0x3D62B4C9u},
+            {"-0.0553481932729482650756835937501", 0xBFAC569930000000u, 0xBD62B4CAu},
+            {"5.534819327294826507568359375000000000000000000001e-2", 0x3FAC569930000000u, 0x3D62B4CAu},
+            {"5534819327294826507568359375000000000000000000000000000000e-59", 0x3FAC569930000000u, 0x3D62B4CAu},
+            {"0.055348193272948265", 0x3FAC569930000000u, 0x3D62B4C9u},
+            {"5.5348193272948266e-2", 0x3FAC569930000000u, 0x3D62B4CAu},
+            {"5.534819327294826507e-2", 0x3FAC569930000000u, 0x3D62B4C9u},
+            {"5534819327294826508e-20", 0x3FAC569930000000u, 0x3D62B4CAu},
+            {"55348193272948265075e-21", 0x3FAC569930000000u, 0x3D62B4C9u},
+            {"-0.055348193272948265076", 0xBFAC569930000000u, 0xBD62B4CAu},
+            {"0.0553481932729482650756", 0x3FAC569930000000u, 0x3D62B4C9u},
+            {"-5.53481932729482650757e-2", 0xBFAC569930000000u, 0xBD62B4CAu},
+            {"5.179692133247783258005389047985340416e36", 0x478F2C9450000000u, 0x7C7964A2u},
+            {"5179692133247783258005389047985340417e0", 0x478F2C9450000000u, 0x7C7964A3u},
+            {"5179692133247783258005389047985340415", 0x478F2C9450000000u, 0x7C7964A2u},
+            {"-5.17969213324778325800538904798534041601e36", 0xC78F2C9450000000u, 0xFC7964A3u},
+            {"-5179692133247783258005389047985340416000000000000000000001e-21", 0xC78F2C9450000000u, 0xFC7964A3u},
+            {"-5179692133247783258005389047985340416.000000000000000000000000000000", 0xC78F2C9450000000u, 0xFC7964A2u},
+            {"5.1796921332477832e36", 0x478F2C9450000000u, 0x7C7964A2u},
+            {"51796921332477833e20", 0x478F2C9450000000u, 0x7C7964A3u},
+            {"-5179692133247783258e18", 0xC78F2C9450000000u, 0xFC7964A2u},
+            {"5179692133247783259000000000000000000", 0x478F2C9450000000u, 0x7C7964A3u},
+            {"5179692133247783258000000000000000000", 0x478F2C9450000000u, 0x7C7964A2u},
+            {"5.1796921332477832581e36", 0x478F2C9450000000u, 0x7C7964A3u},
+            {"-5.179692133247783258e36", 0xC78F2C9450000000u, 0xFC7964A2u},
+            {"-517969213324778325801e16", 0xC78F2C9450000000u, 0xFC7964A3u},
+            {"517969213324778325800538904798e7", 0x478F2C9450000000u, 0x7C7964A2u},
+            {"5179692133247783258005389047990000000", 0x478F2C9450000000u, 0x7C7964A3u},
+            {
+                "0.22250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350"
+                "8791414915891303962110687008643869459464552765720740782062174337998814106326732925355228688137214901"
+                "2981122451451889849057222307285255133155755015914397476397983411801999323962548289017107081850690630"
+                "6666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050"
+                "5108060994073026293712895895000358379996720725430436028407889577179615094551674824347103070260914462"
+                "1572289880258182545180325707018860872113128079512233426288368622321503775666622503982534335974568884"
+                "4239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704"
+                "2756718644338377048603786162277173854562306587467901408672332763671875e-307", 0x0010000000000000u, 0x00000000u
+            },
+            {
+                "2.22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508"
+                "7914149158913039621106870086438694594645527657207407820621743379988141063267329253552286881372149012"
+                "9811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306"
+                "6665599493827577257201576306269066333264756530000924588831643303777979186961204949739037782970490505"
+                "1080609940730262937128958950003583799967207254304360284078895771796150945516748243471030702609144621"
+                "5722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844"
+                "2390026549819838548794829220689472168983109969836584681402285424333066033985088644580400103493397042"
+                "756718644338377048603786162277173854562306587467901408672332763671875000000000000000000001e-308", 0x0010000000000000u, 0x00000000u
+            },
+            {
+                "0.11754942807573642917278829910357665133228589927589904276829631184250030649651730385585324256680905"
+                "8189392089843750000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "00000000000000000000000000000000000000000000000000000000000000000e-37", 0x380FFFFFE0000000u, 0x00800000u
+            },
+            {
+                "1175494280757364291727882991035766513322858992758990427682963118425003064965173038558532425668090581"
+                "8939208984375000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                "00000000000001e-751", 0x380FFFFFE0000000u, 0x00800000u
+            },
+            {"0", 0x0000000000000000u, 0x00000000u},
+            {"-0", 0x8000000000000000u, 0x80000000u},
+            {"0.0", 0x0000000000000000u, 0x00000000u},
+            {"-0.0", 0x8000000000000000u, 0x80000000u},
+            {"0e999999999999999999999", 0x0000000000000000u, 0x00000000u},
+            {"-0.000e-99999", 0x8000000000000000u, 0x80000000u},
+            {"1e-400", 0x0000000000000000u, 0x00000000u},
+            {"-1e-400", 0x8000000000000000u, 0x80000000u},
+            {"1e400", 0x7FF0000000000000u, 0x7F800000u},
+            {"-1e400", 0xFFF0000000000000u, 0xFF800000u},
+            {"1e-50", 0x358DEE7A4AD4B81Fu, 0x00000000u},
+            {"-1e-50", 0xB58DEE7A4AD4B81Fu, 0x80000000u},
+            {"1e39", 0x48078287F49C4A1Du, 0x7F800000u},
+            {"-1e39", 0xC8078287F49C4A1Du, 0xFF800000u},
+            {"1e99999999999999999999999999", 0x7FF0000000000000u, 0x7F800000u},
+            {"1e-99999999999999999999999999", 0x0000000000000000u, 0x00000000u},
+            {"1e0000000000000000000000000000000000000000308", 0x7FE1CCF385EBC8A0u, 0x7F800000u},
+            {"123456789012345678901234567890e-30", 0x3FBF9ADD3746F65Fu, 0x3DFCD6EAu},
+            {"18446744073709551615", 0x43F0000000000000u, 0x5F800000u},
+            {"18446744073709551616", 0x43F0000000000000u, 0x5F800000u},
+            {"-9223372036854775808", 0xC3E0000000000000u, 0xDF000000u},
+            {"-9223372036854775809", 0xC3E0000000000000u, 0xDF000000u},
+        }
+    };
+    return table;
+}
+
+} // namespace float_hard_cases

tests/src/unit-class_lexer.cpp

@@ -13,16 +13,20 @@
 using nlohmann::json;
 
 #include <array> // array
-#include <cfloat> // FLT_EVAL_METHOD
 #include <cstdint> // uint32_t, uint64_t
+#include <cstdio> // snprintf
 #include <cstdlib> // strtod
 #include <cstring> // memcpy
 #include <limits> // numeric_limits
+#include <map> // map
+#include <random> // mt19937
 #include <sstream> // stringstream
 #include <string> // string
 #include <utility> // pair
 #include <vector> // vector
 
+#include "float_hard_cases.hpp"
+
 namespace
 {
 // shortcut to scan a string literal
@@ -258,7 +262,7 @@ TEST_CASE("lexer number fast path")
             "123456789012345678901234567890",  // huge -> float
             "0.30000000000000004", "2.2250738585072014e-308", "1e308",
             // high-precision / wide-exponent values that exercise the
-            // std::from_chars (Eisel-Lemire) path beyond the Clinger subset
+            // Eisel-Lemire path beyond the Clinger subset
             "1.7976931348623157e308", "1.2345678901234567e-250",
             "9007199254740993", "5e-324", "1e-320"
         };
@@ -280,20 +284,18 @@ TEST_CASE("lexer number fast path")
         }
     }
 
-    SECTION("significant-digit gate for the Clinger fast path")
+    SECTION("significant digits around Clinger's fast path")
     {
-        // Clinger's fast path needs a significand below 2^53, so it cannot
-        // succeed once the mantissa has 17 or more significant digits (the
-        // significand would be at least 10^16). The lexer skips the attempt
-        // there. That is only allowed to save work: every value must still come
-        // out bit-exactly, and both scanners must agree. In particular the gate
-        // must not fire for tokens whose leading zeros merely look like extra
-        // digits - "0.1234567890123456" has 16 significant digits, not 17.
+        // Clinger's fast path needs a significand of at most 2^53, which
+        // tokens with 17 or more significant digits exceed. The conversion
+        // splits the token at the positions the scanners recorded, so leading
+        // zeros must not count as digits - "0.1234567890123456" has 16
+        // significant digits, not 17 - and both scanners must agree.
         const std::vector<std::string> numbers =
         {
             "1234567890123456",                  // 16 significant digits
-            "12345678901234567",                 // 17 -> attempt skipped
-            "123456789012345678",                // 18 -> attempt skipped
+            "12345678901234567",                 // 17
+            "123456789012345678",                // 18
             "0.1234567890123456",                // 16: the leading "0" is not significant
             "0.12345678901234567",               // 17
             "0.00000000000000001",               // 1, in a long token
@@ -664,46 +666,323 @@ TEST_CASE("lexer string fast path")
     }
 }
 
-TEST_CASE("parse_float_fast declines what it cannot convert exactly")
+TEST_CASE("lexer escape fast path")
 {
-    // The lexer only hands well-formed numbers to parse_float_fast, so the
-    // malformed ones below can only be passed to it directly. Declining is
-    // always safe: the caller then falls back to a slower, exact conversion.
-    const auto fast = [](const std::string & s, double & out)
+    // json::accept() never throws, so this section stays covered without
+    // exceptions; it pins which of the cases below are valid/invalid and
+    // checks the contiguous and streaming paths agree on that classification.
+    SECTION("accept() parity")
     {
-        return nlohmann::detail::parse_float_fast(s.data(), s.data() + s.size(), out);
+        const std::vector<std::pair<std::string, bool>> cases =
+        {
+            {"\\u0041", true}, {"\\u00e4", true}, {"\\u00E4", true},
+            {"\\uD83D\\uDE00", true},
+            {"\\u12", false}, {"\\u12G4", false}, {"\\uXYZW", false},
+            {"\\uD800", false}, {"\\uD800A", false}, {"\\uD800\\u0041", false},
+            {"\\uDC00", false}, {"\\u", false}
+        };
+
+        for (const auto& c : cases)
+        {
+            for (const std::size_t offset :
+                    {
+                        std::size_t{0}, std::size_t{9}
+                    })
+            {
+                const std::string doc = "[\"" + std::string(offset, 'a') + c.first + "\"]";
+                CAPTURE(doc)
+                CHECK(json::accept(doc) == c.second);
+                std::stringstream ss(doc);
+                CHECK(json::accept(ss) == c.second);
+            }
+        }
+    }
+
+#if !defined(JSON_NOEXCEPTION)
+    // the full outcome of parsing @a doc: the parsed value, or the exact
+    // error message, so a mismatch in either is caught
+    const auto outcome = [](const std::string & doc, bool streaming) -> std::string
+    {
+        try
+        {
+            if (streaming)
+            {
+                std::stringstream ss(doc);
+                const json j = json::parse(ss);
+                return j.dump();
+            }
+            const json j = json::parse(doc);
+            return j.dump();
+        }
+        catch (const json::exception& e)
+        {
+            return {e.what()};
+        }
     };
-    double out = 0;
 
-#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
-    // without true double precision, the fast path declines everything
-    CHECK_FALSE(fast("1.5", out));
-#else
-    CHECK(fast("1.5", out));
-    CHECK(out == 1.5);
-    CHECK(fast("+2.5e1", out));
-    CHECK(out == 25.0);
-    CHECK(fast("-25E-1", out));
-    CHECK(out == -2.5);
-    CHECK(fast("1e", out));
-    CHECK(out == 1.0);
+    SECTION("contiguous vs streaming parity")
+    {
+        const std::vector<std::string> escapes =
+        {
+            "\\u0041",             // "A"
+            "\\u00e4",             // "ä" (lowercase hex)
+            "\\u00E4",             // "ä" (uppercase hex)
+            "\\uD83D\\uDE00",      // valid surrogate pair (an emoji)
+            "\\u12",               // truncated: only 2 hex digits before the closing quote
+            "\\u12G4",             // invalid hex digit at the 3rd position
+            "\\uXYZW",             // all 4 bytes invalid
+            "\\uD800",             // lone high surrogate, string ends right after
+            "\\uD800A",            // high surrogate not followed by another \u escape
+            "\\uD800\\u0041",      // high surrogate followed by \u, but not a low surrogate
+            "\\uDC00",             // lone low surrogate
+            "\\u",                 // '\u' with nothing after (closing quote right away)
+        };
+
+        // once at the start of the string and once past the first 8-byte SWAR
+        // word of the outer string_bulk_run, so the escape is reached both
+        // right after the opening quote and mid-run
+        for (const auto& escape : escapes)
+        {
+            for (const std::size_t offset :
+                    {
+                        std::size_t{0}, std::size_t{9}
+                    })
+            {
+                const std::string doc = "[\"" + std::string(offset, 'a') + escape + "\"]";
+                CAPTURE(doc)
+                CHECK(outcome(doc, false) == outcome(doc, true));
+            }
+
+            // the escape is the last thing before end of input: no closing
+            // quote at all
+            const std::string truncated_doc = "[\"" + escape;
+            CAPTURE(truncated_doc)
+            CHECK(outcome(truncated_doc, false) == outcome(truncated_doc, true));
+        }
+    }
+
+    SECTION("truncated \\u escape at every distance from the end of input")
+    {
+        // ia.bulk_remaining() must correctly report fewer than 4 bytes for
+        // every possible count of trailing hex-looking bytes (0, 1, 2, or 3)
+        // before end of input, so the fast path declines and the byte path
+        // alone reports the "must be followed by 4 hex digits" error, at the
+        // same position, in every case
+        for (const std::string& tail :
+                {
+                    std::string{}, std::string("1"), std::string("12"), std::string("123")
+                })
+        {
+            const std::string doc = "[\"\\u" + tail;
+            CAPTURE(doc)
+            CHECK(outcome(doc, false) == outcome(doc, true));
+            CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
+        }
+    }
+
+    SECTION("invalid hex digit at every position of the 4")
+    {
+        // the fast path must decline for *any* invalid byte among the 4, not
+        // just the first, and the byte path must then stop at exactly that
+        // position - same as it always has
+        for (std::size_t bad_pos = 0; bad_pos < 4; ++bad_pos)
+        {
+            std::string digits = "1234";
+            digits[bad_pos] = 'g'; // not a hex digit
+            const std::string doc = "[\"\\u" + digits + "\"]";
+            CAPTURE(doc)
+            CHECK(outcome(doc, false) == outcome(doc, true));
+            CHECK(outcome(doc, false).find("must be followed by 4 hex digits") != std::string::npos);
+        }
+    }
+
+    SECTION("random escapes")
+    {
+        // A seeded PRNG builds the 4 bytes following `\u` from a mix of hex
+        // digits and non-hex bytes, at varying distances from the start of
+        // the string, to compare the two scanners on many more shapes than
+        // are practical to enumerate by hand.
+        std::mt19937 gen(7654321); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
+        const std::string hex_alphabet = "0123456789AaBbCcDdEeFf";
+        std::uniform_int_distribution<std::size_t> pick_hex(0, hex_alphabet.size() - 1);
+        std::uniform_int_distribution<int> pick_byte(1, 255); // never NUL
+        std::uniform_int_distribution<int> pick_is_hex(0, 4); // 4-in-5 chance of a hex digit
+        std::uniform_int_distribution<std::size_t> pick_offset(0, 12);
+
+        std::vector<std::string> mismatches;
+        for (int iter = 0; iter < 3000; ++iter)
+        {
+            std::string digits;
+            for (int i = 0; i < 4; ++i)
+            {
+                if (pick_is_hex(gen) != 0)
+                {
+                    digits += hex_alphabet[pick_hex(gen)];
+                }
+                else
+                {
+                    char c = static_cast<char>(pick_byte(gen));
+                    if (c == '"' || c == '\\')
+                    {
+                        // keep the string well-formed apart from the escape
+                        // itself, so any mismatch is attributable to the \u
+                        // handling and not to an unrelated quote/escape
+                        c = 'z';
+                    }
+                    digits += c;
+                }
+            }
+            const std::string doc = "[\"" + std::string(pick_offset(gen), 'a') + "\\u" + digits + "\"]";
+            if (outcome(doc, false) != outcome(doc, true))
+            {
+                mismatches.push_back(doc);
+            }
+        }
+        CAPTURE(mismatches)
+        CHECK(mismatches.empty());
+    }
 #endif
+}
 
-    // not a number
-    CHECK_FALSE(fast("", out));
-    CHECK_FALSE(fast("-", out));
-    CHECK_FALSE(fast(".", out));
-    CHECK_FALSE(fast("1.2.3", out));
-    CHECK_FALSE(fast("1x", out));
-    CHECK_FALSE(fast("1e+", out));
-    CHECK_FALSE(fast("1e1x", out));
+namespace
+{
+// the index of the decimal point (or npos) and of the end of the mantissa of a
+// number token, which the lexer records while scanning it
+std::pair<std::size_t, std::size_t> float_token_layout(const std::string& s)
+{
+    std::size_t dot = std::string::npos;
+    std::size_t mantissa_end = s.size();
+    for (std::size_t i = 0; i < s.size(); ++i)
+    {
+        if (s[i] == '.')
+        {
+            dot = i;
+        }
+        else if (s[i] == 'e' || s[i] == 'E')
+        {
+            mantissa_end = i;
+            break;
+        }
+    }
+    return {dot, mantissa_end};
+}
 
-    // numbers that are not represented exactly on the fast path
-    CHECK_FALSE(fast("12345678901234567890", out));
-    CHECK_FALSE(fast("1e10000", out));
-    CHECK_FALSE(fast("9007199254740993", out));
-    CHECK_FALSE(fast("1e23", out));
-    CHECK_FALSE(fast("1e-23", out));
+template<typename FloatType>
+FloatType parse_native(const std::string& s)
+{
+    const auto layout = float_token_layout(s);
+    return nlohmann::detail::parse_float_native<FloatType>(s.data(), s.data() + s.size(), layout.first, layout.second);
+}
+
+std::uint64_t bits_of(double d)
+{
+    std::uint64_t b = 0;
+    std::memcpy(&b, &d, sizeof(b));
+    return b;
+}
+
+std::uint32_t bits_of(float f)
+{
+    std::uint32_t b = 0;
+    std::memcpy(&b, &f, sizeof(b));
+    return b;
+}
+
+std::uint64_t native_bits64(const std::string& s)
+{
+    return bits_of(parse_native<double>(s));
+}
+
+std::uint32_t native_bits32(const std::string& s)
+{
+    return bits_of(parse_native<float>(s));
+}
+} // namespace
+
+TEST_CASE("parse_float_native rounds correctly")
+{
+    SECTION("double")
+    {
+        CHECK(native_bits64("1.5") == 0x3FF8000000000000u);
+        CHECK(native_bits64("0.1") == 0x3FB999999999999Au);
+        CHECK(native_bits64("-0.0") == 0x8000000000000000u);
+        CHECK(native_bits64("0e999999999999999999999") == 0u);
+        // 2^53 + 1 is exactly between two doubles: ties to even, unless more digits follow
+        CHECK(native_bits64("9007199254740993") == 0x4340000000000000u);
+        CHECK(native_bits64("9007199254740993.0000000000000000001") == 0x4340000000000001u);
+        CHECK(native_bits64("9007199254740992.9999999999999999999") == 0x4340000000000000u);
+        // 1 + 2^-53 exactly (a tie), and one unit in the 55th digit around it
+        CHECK(native_bits64("1.00000000000000011102230246251565404236316680908203125") == 0x3FF0000000000000u);
+        CHECK(native_bits64("1.00000000000000011102230246251565404236316680908203126") == 0x3FF0000000000001u);
+        CHECK(native_bits64("1.00000000000000011102230246251565404236316680908203124") == 0x3FF0000000000000u);
+        // subnormal and overflow boundaries
+        CHECK(native_bits64("2.4703282292062327e-324") == 0u);
+        CHECK(native_bits64("2.4703282292062328e-324") == 1u);
+        CHECK(native_bits64("2.2250738585072011e-308") == 0x000FFFFFFFFFFFFFu);
+        CHECK(native_bits64("2.2250738585072012e-308") == 0x0010000000000000u);
+        CHECK(native_bits64("1.7976931348623157e308") == 0x7FEFFFFFFFFFFFFFu);
+        CHECK(native_bits64("1.7976931348623159e308") == 0x7FF0000000000000u);
+        CHECK(native_bits64("-1e400") == 0xFFF0000000000000u);
+        CHECK(native_bits64("-1e-400") == 0x8000000000000000u);
+        // exponents and zeros far beyond the range cancel out
+        CHECK(native_bits64("0." + std::string(1000, '0') + "1e1001") == 0x3FF0000000000000u);
+        CHECK(native_bits64("1" + std::string(1000, '0') + "e-1000") == 0x3FF0000000000000u);
+        CHECK(native_bits64("1e-99999999999999999999999") == 0u);
+        CHECK(native_bits64("1E+99999999999999999999999") == 0x7FF0000000000000u);
+        // more digits than any midpoint has (769): only whether a nonzero digit follows matters
+        const std::string tie = "1.00000000000000011102230246251565404236316680908203125";
+        CHECK(native_bits64(tie + std::string(800, '0')) == 0x3FF0000000000000u);
+        CHECK(native_bits64(tie + std::string(800, '0') + "1") == 0x3FF0000000000001u);
+    }
+
+    SECTION("float")
+    {
+        CHECK(native_bits32("1.5") == 0x3FC00000u);
+        CHECK(native_bits32("0.1") == 0x3DCCCCCDu);
+        CHECK(native_bits32("-0.0") == 0x80000000u);
+        // 2^24 + 1 is exactly between two floats
+        CHECK(native_bits32("16777217") == 0x4B800000u);
+        CHECK(native_bits32("16777217.000000000000000000001") == 0x4B800001u);
+        CHECK(native_bits32("16777218.999999999999999999999") == 0x4B800001u);
+        CHECK(native_bits32("16777219") == 0x4B800002u);
+        // subnormal and overflow boundaries
+        CHECK(native_bits32("3.4028235677973366e38") == 0x7F7FFFFFu);
+        CHECK(native_bits32("3.4028235677973367e38") == 0x7F800000u);
+        CHECK(native_bits32("7.006492321624085e-46") == 0u);
+        CHECK(native_bits32("7.006492321624086e-46") == 1u);
+        CHECK(native_bits32("1.1754942e-38") == 0x007FFFFFu);
+        CHECK(native_bits32("-1.17549435e-38") == 0x80800000u);
+        CHECK(native_bits32("1e39") == 0x7F800000u);
+        CHECK(native_bits32("-1e-50") == 0x80000000u);
+        // not rounded through double: its double would round to another float
+        CHECK(native_bits32("1.00000005960464477539062500000000001") == 0x3F800001u);
+        CHECK(native_bits32("9007199254740993") == 0x5A000000u);
+    }
+
+    SECTION("the conversion shared with other parsers")
+    {
+        // convert_float() gives the lexer's results, for every type
+        const std::vector<std::string> tokens =
+        {
+            "0", "-0.0", "1.5", "0.1", "1e-400", "-2.5E+3", "123456789012345678901234567890",
+            "9007199254740993.0000000000000000001", "4.9406564584124654e-324"
+        };
+        using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
+        using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
+        for (const auto& t : tokens)
+        {
+            CAPTURE(t)
+            const auto layout = float_token_layout(t);
+            const char* const first = t.data();
+            const char* const last = first + t.size();
+            const auto d = nlohmann::detail::convert_float<double>(first, last, layout.first, layout.second);
+            const auto f = nlohmann::detail::convert_float<float>(first, last, layout.first, layout.second);
+            const auto ld = nlohmann::detail::convert_float<long double>(first, last, layout.first, layout.second);
+            CHECK(bits_of(d) == bits_of(json::parse(t).get<double>()));
+            CHECK(bits_of(f) == bits_of(float_json::parse(t).get<float>()));
+            CHECK(ld == long_double_json::parse(t).get<long double>());
+        }
+    }
 }
 
 namespace
@@ -807,40 +1086,6 @@ std::size_t big_bit_length(const big_uint& a)
     }
     return n;
 }
-
-std::uint64_t bits_of(double d)
-{
-    std::uint64_t b = 0;
-    std::memcpy(&b, &d, sizeof(b));
-    return b;
-}
-
-bool eisel_lemire(const std::string& s, double& out)
-{
-    return nlohmann::detail::parse_float_eisel_lemire(s.data(), s.data() + s.size(), out);
-}
-
-// significant digits of a token, without trailing zeros
-std::size_t significant_digits(const std::string& s)
-{
-    std::string digits;
-    for (const char c : s)
-    {
-        if (c == 'e' || c == 'E')
-        {
-            break;
-        }
-        if (c >= '0' && c <= '9' && !(digits.empty() && c == '0'))
-        {
-            digits += c;
-        }
-    }
-    while (!digits.empty() && digits.back() == '0')
-    {
-        digits.pop_back();
-    }
-    return digits.size();
-}
 } // namespace
 
 TEST_CASE("Eisel-Lemire float conversion")
@@ -1268,26 +1513,33 @@ TEST_CASE("Eisel-Lemire float conversion")
         for (const auto& c : known)
         {
             CAPTURE(c.first)
-            double out = 0;
-            if (eisel_lemire(c.first, out))
-            {
-                CHECK(bits_of(out) == c.second);
-            }
-            else
-            {
-                // only tokens with more than 19 significant digits are left to
-                // strtod: those whose value lies too close to a tie
-                CHECK(significant_digits(c.first) > 19);
-            }
+            CHECK(native_bits64(c.first) == c.second);
         }
     }
 
+    SECTION("binary32")
+    {
+        using binary32 = nlohmann::detail::ieee_binary_format<24>;
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(0, 1) == 0x3F800000u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(-1, 1) == 0x3DCCCCCDu);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(-1, 15) == 0x3FC00000u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(0, 16777217) == 0x4B800000u); // tie, to even
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(0, 16777219) == 0x4B800002u); // tie, to even
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(-45, 1) == 0x00000001u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(-46, 7) == 0x00000000u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(-46, 8) == 0x00000001u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(-65, 9999999999999999999u) == 0x00000000u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(20, 3402823466385288598u) == 0x7F7FFFFFu);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(20, 3402823669209384635u) == 0x7F800000u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(39, 1) == 0x7F800000u);
+        CHECK(nlohmann::detail::eisel_lemire<binary32>(-5, 0) == 0x00000000u);
+    }
+
     SECTION("round trip")
     {
-        // every double written by to_chars and read back, also with trailing
-        // digits that make the token longer than 19 digits
+        // every double written by to_chars and read back, and its 17-digit
+        // form with trailing digits that make the token longer than 19 digits
         std::uint64_t state = 5295;
-        std::size_t declined = 0;
         for (int i = 0; i < 200000; ++i)
         {
             state ^= state << 13u;
@@ -1309,30 +1561,51 @@ TEST_CASE("Eisel-Lemire float conversion")
             const char* end = nlohmann::detail::to_chars(buffer.data(), buffer.data() + buffer.size(), d);
             const std::string token(buffer.data(), static_cast<std::size_t>(end - buffer.data()));
             CAPTURE(token)
-            double out = 0;
-            REQUIRE(eisel_lemire(token, out));
-            CHECK(bits_of(out) == b);
+            CHECK(native_bits64(token) == b);
 
-            // insert digits before the exponent: the value moves by far less
-            // than the distance to the rounding boundary, so it must not change
-            std::string longer = token;
+            // insert digits before the exponent of the 17-digit form: that
+            // form lies strictly inside the rounding interval of the double
+            // (the shortest one may lie on its boundary), and the digits move
+            // it by far less than the distance to the boundary, so the value
+            // must not change
+            std::array<char, 64> digits17{};
+            static_cast<void>(std::snprintf(digits17.data(), digits17.size(), "%.17g", d)); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+            std::string longer = digits17.data();
             const std::size_t e = longer.find('e');
             const std::size_t dot = longer.find('.');
             const std::string extra = dot == std::string::npos ? ".000000000000000000001" : "000000000000000000001";
             longer.insert(e == std::string::npos ? longer.size() : e, extra);
             CAPTURE(longer)
-            if (eisel_lemire(longer, out))
+            CHECK(native_bits64(longer) == b);
+        }
+    }
+
+    SECTION("round trip, binary32")
+    {
+        std::uint32_t state = 5295;
+        for (int i = 0; i < 100000; ++i)
+        {
+            state ^= state << 13u;
+            state ^= state >> 17u;
+            state ^= state << 5u;
+            std::uint32_t b = state;
+            if ((b & 0x7F800000u) == 0x7F800000u)
             {
-                CHECK(bits_of(out) == b);
+                continue; // infinity or NaN
             }
-            else
+            if (i % 4 == 0)
             {
-                // w and w + 1 round differently: only when the value is very
-                // close to a rounding boundary
-                ++declined;
+                b &= 0x807FFFFFu; // subnormals
             }
+            float f = 0;
+            std::memcpy(&f, &b, sizeof(f));
+
+            std::array<char, 64> buffer{};
+            const char* end = nlohmann::detail::to_chars(buffer.data(), buffer.data() + buffer.size(), f);
+            const std::string token(buffer.data(), static_cast<std::size_t>(end - buffer.data()));
+            CAPTURE(token)
+            CHECK(native_bits32(token) == b);
         }
-        CHECK(declined < 1000); // 107 of the 200,000
     }
 
     SECTION("used by the lexer")
@@ -1346,3 +1619,184 @@ TEST_CASE("Eisel-Lemire float conversion")
                              "[json.exception.out_of_range.406] number overflow parsing '1.7976931348623159e308'", json::out_of_range&);
     }
 }
+
+namespace
+{
+using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
+
+// the bits of the float that parse() gives for a token, via both scanners;
+// the value must be the same for both
+template<typename Json, typename Bits>
+void check_parse(const std::string& token, Bits expected, Bits infinity)
+{
+    std::stringstream stream(token);
+    if ((expected & ~(Bits{1} << ((8 * sizeof(Bits)) - 1))) == infinity)
+    {
+        Json _;
+        CHECK_THROWS_WITH_AS(_ = Json::parse(token), ("[json.exception.out_of_range.406] number overflow parsing '" + token + "'").c_str(), typename Json::out_of_range&);
+        CHECK_THROWS_WITH_AS(_ = Json::parse(stream), ("[json.exception.out_of_range.406] number overflow parsing '" + token + "'").c_str(), typename Json::out_of_range&);
+        return;
+    }
+    const Json contiguous = Json::parse(token);
+    const Json streamed = Json::parse(stream);
+    if (contiguous.is_number_float()) // not an integer that fits
+    {
+        CHECK(bits_of(contiguous.template get<typename Json::number_float_t>()) == expected);
+        CHECK(bits_of(streamed.template get<typename Json::number_float_t>()) == expected);
+    }
+    else
+    {
+        CHECK(streamed.is_number_integer());
+    }
+}
+} // namespace
+
+TEST_CASE("float conversion of hard cases")
+{
+    // see float_hard_cases.hpp
+    for (const auto& c : float_hard_cases::cases())
+    {
+        const std::string token = c.token;
+        CAPTURE(token)
+        CHECK(native_bits64(token) == c.bits64);
+        CHECK(native_bits32(token) == c.bits32);
+        check_parse<json>(token, c.bits64, std::uint64_t{0x7FF0000000000000u});
+        check_parse<float_json>(token, c.bits32, std::uint32_t{0x7F800000u});
+    }
+}
+
+TEST_CASE("float overflow and underflow in the parser")
+{
+    SECTION("double")
+    {
+        check_parse<json>("1.7976931348623157e308", std::uint64_t{0x7FEFFFFFFFFFFFFFu}, std::uint64_t{0x7FF0000000000000u});
+        check_parse<json>("1.7976931348623159e308", std::uint64_t{0x7FF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
+        check_parse<json>("-1e309", std::uint64_t{0xFFF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
+        check_parse<json>("1" + std::string(400, '0'), std::uint64_t{0x7FF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
+        check_parse<json>("1e99999999999999999999", std::uint64_t{0x7FF0000000000000u}, std::uint64_t{0x7FF0000000000000u});
+        // an underflow gives a zero with the sign of the token
+        check_parse<json>("1e-400", std::uint64_t{0}, std::uint64_t{0x7FF0000000000000u});
+        check_parse<json>("-1e-400", std::uint64_t{0x8000000000000000u}, std::uint64_t{0x7FF0000000000000u});
+        check_parse<json>("-2.4703282292062327e-324", std::uint64_t{0x8000000000000000u}, std::uint64_t{0x7FF0000000000000u});
+        check_parse<json>("0." + std::string(400, '0') + "1", std::uint64_t{0}, std::uint64_t{0x7FF0000000000000u});
+    }
+
+    SECTION("float")
+    {
+        check_parse<float_json>("3.4028234e38", std::uint32_t{0x7F7FFFFFu}, std::uint32_t{0x7F800000u});
+        check_parse<float_json>("3.4028236e38", std::uint32_t{0x7F800000u}, std::uint32_t{0x7F800000u});
+        check_parse<float_json>("-1e39", std::uint32_t{0xFF800000u}, std::uint32_t{0x7F800000u});
+        check_parse<float_json>("1e-46", std::uint32_t{0}, std::uint32_t{0x7F800000u});
+        check_parse<float_json>("-1e-46", std::uint32_t{0x80000000u}, std::uint32_t{0x7F800000u});
+        check_parse<float_json>("-7.006492321624085e-46", std::uint32_t{0x80000000u}, std::uint32_t{0x7F800000u});
+        check_parse<float_json>("-7.006492321624086e-46", std::uint32_t{0x80000001u}, std::uint32_t{0x7F800000u});
+    }
+}
+
+TEST_CASE("string scanning kernels")
+{
+    // the word-at-a-time kernels must stop exactly where a byte-by-byte scan
+    // stops, for any content, length, and alignment
+    const auto reference_special = [](const unsigned char* data, std::size_t n)
+    {
+        std::size_t i = 0;
+        while (i < n && !nlohmann::detail::is_string_special(data[i]))
+        {
+            ++i;
+        }
+        return i;
+    };
+    const auto reference_copyable = [](const unsigned char* data, std::size_t n)
+    {
+        std::size_t i = 0;
+        while (i < n && nlohmann::detail::is_ascii_copyable(data[i]))
+        {
+            ++i;
+        }
+        return i;
+    };
+    const auto reference_bulk_run = [](const unsigned char* data, std::size_t n)
+    {
+        std::size_t i = 0;
+        while (i < n)
+        {
+            if (data[i] < 0x80u)
+            {
+                if (nlohmann::detail::is_string_special(data[i]))
+                {
+                    break;
+                }
+                ++i;
+                continue;
+            }
+            const std::size_t seq = nlohmann::detail::validate_one_utf8(data + i, n - i);
+            if (seq == 0)
+            {
+                break;
+            }
+            i += seq;
+        }
+        return i;
+    };
+
+    // pieces: ordinary ASCII, stops, DEL, well-formed sequences of every
+    // length, and ill-formed or truncated ones
+    const std::vector<std::string> pieces =
+    {
+        "a", "Z", " ", "~", "0123456789", "\"", "\\", std::string(1, '\0'), "\n", "\x1F", "\x7F",
+        "\xC3\xA4", "\xE2\x82\xAC", "\xE6\x97\xA5\xE6\x9C\xAC", "\xF0\x9F\x98\x80", "\xED\x9F\xBF",
+        "\x80", "\xC0\x80", "\xC3", "\xE2\x82", "\xED\xA0\x80", "\xF4\x90\x80\x80", "\xFF",
+    };
+    std::uint64_t state = 5295;
+    const auto next = [&state]()
+    {
+        state ^= state << 13u;
+        state ^= state >> 7u;
+        state ^= state << 17u;
+        return state;
+    };
+    // the upper half as a 32-bit value: converts to std::size_t implicitly on
+    // every platform (a cast of std::uint64_t is useless where both are the
+    // same type, and required where std::size_t is 32 bits wide)
+    const auto next_small = [&next]()
+    {
+        return static_cast<std::uint32_t>(next() >> 32u);
+    };
+    for (int round = 0; round < 100000; ++round)
+    {
+        // mostly ordinary text, so that runs span several words
+        std::string text(next_small() % 8u, '.');
+        const std::size_t count = next_small() % 12u;
+        for (std::size_t k = 0; k < count; ++k)
+        {
+            const std::size_t p = (next() % 4 == 0) ? next_small() % pieces.size() : 0;
+            text += pieces[p];
+            text += std::string(next_small() % 10u, 'x');
+        }
+        const auto* data = reinterpret_cast<const unsigned char*>(text.data()); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+        for (std::size_t offset = 0; offset < 3 && offset <= text.size(); ++offset)
+        {
+            const std::size_t n = text.size() - offset;
+            CAPTURE(text)
+            CAPTURE(offset)
+            CHECK(nlohmann::detail::find_string_special(data + offset, n) == reference_special(data + offset, n));
+            CHECK(nlohmann::detail::find_ascii_copyable_run(data + offset, n) == reference_copyable(data + offset, n));
+            CHECK(nlohmann::detail::scalar_string_bulk_run(data + offset, n) == reference_bulk_run(data + offset, n));
+        }
+    }
+
+    // the trailing-zero count, whichever implementation the compiler gets
+    for (int k = 0; k < 64; ++k)
+    {
+        const std::uint64_t bit = std::uint64_t{1} << k;
+        CHECK(nlohmann::detail::count_trailing_zeros(bit) == k);
+        CHECK(nlohmann::detail::count_trailing_zeros(bit | (bit << 1u) | 0x8000000000000000u) == k);
+    }
+
+    // eight bytes as a little-endian word, at any alignment
+    const std::array<unsigned char, 16> bytes = {{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0xFF}};
+    CHECK(nlohmann::detail::read_eight_bytes(bytes.data()) == 0x0807060504030201u);
+    CHECK(nlohmann::detail::read_eight_bytes(bytes.data() + 1) == 0x0908070605040302u);
+    CHECK(nlohmann::detail::read_eight_bytes(bytes.data() + 8) == 0xFF0F0E0D0C0B0A09u);
+    CHECK(nlohmann::detail::read_eight_bytes(reinterpret_cast<const char*>(bytes.data()) + 3) == 0x0B0A090807060504u);
+}

tests/src/unit-custom-array-type.cpp

@@ -9,9 +9,7 @@
 #include "doctest_compatibility.h"
 
 #include <nlohmann/json.hpp>
-using nlohmann::json;
 
-#include <cstdint>
 #include <deque>
 #include <map>
 #include <memory>
@@ -166,47 +164,3 @@ TEST_CASE("array type without at()")
     CHECK(j.at(no_at_json::json_pointer("/1")) == 2);
     CHECK_THROWS_AS(j.at(no_at_json::json_pointer("/3")), no_at_json::out_of_range);
 }
-
-TEST_CASE("regression test #5476 - array type without reserve()")
-{
-    // the capacity reserved for definite-length arrays must not require the
-    // array type to have a reserve() member function
-    SECTION("std::deque")
-    {
-        const auto j = deque_json::parse(R"({"a":[1,[2,3]],"b":[]})");
-        CHECK(j.dump() == R"({"a":[1,[2,3]],"b":[]})");
-
-        // the binary formats pass a definite length to start_array()
-        CHECK(deque_json::from_cbor(deque_json::to_cbor(j)) == j);
-        CHECK(deque_json::from_msgpack(deque_json::to_msgpack(j)) == j);
-        CHECK(deque_json::from_bon8(deque_json::to_bon8(j)) == j);
-
-        // parse() instantiates the callback parser as well, which reserves too
-        const auto with_callback = deque_json::parse(R"([1,2,3])", [](int /*depth*/, deque_json::parse_event_t /*event*/, deque_json& /*parsed*/) noexcept
-        {
-            return true;
-        });
-        CHECK(with_callback == deque_json({1, 2, 3}));
-    }
-
-    SECTION("std::vector still reserves")
-    {
-        json array = json::array();
-        for (int i = 0; i < 100; ++i)
-        {
-            array.push_back(i);
-        }
-
-        const auto j = json::from_cbor(json::to_cbor(array));
-        CHECK(j == array);
-        CHECK(j.get_ref<const json::array_t&>().capacity() >= 100);
-    }
-
-    SECTION("the reservation stays capped")
-    {
-        // CBOR array announcing 2^32-1 elements, but truncated right after the
-        // header: the input must be rejected without reserving that capacity
-        const std::vector<std::uint8_t> truncated = {0x9A, 0xFF, 0xFF, 0xFF, 0xFF};
-        CHECK(json::from_cbor(truncated, true, false).is_discarded());
-    }
-}

tests/src/unit-custom-number-types.cpp

@@ -1,367 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#include <cstdint>
-#include <limits>
-#include <map>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-    #include <compare>
-#endif
-
-namespace custom_number_types
-{
-
-// a signed integer of class type: std::is_signed is only true for arithmetic
-// types, so the library has to take the signedness from std::numeric_limits,
-// as it does for 128-bit and multiprecision integer classes such as
-// absl::int128 or boost::multiprecision::cpp_int
-class class_int
-{
-  public:
-    // trivial, like the 128-bit integer classes: the value is stored in a union
-    class_int() = default;
-
-    // implicit from built-in integers and explicit from floats, like absl::int128;
-    // non-template overloads (as absl::int128 has) because clang 3.4 and 3.5
-    // reject basic_json's defaulted data() for a number type with template
-    // constructors
-    class_int(int v) : value(v) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
-    class_int(unsigned v) : value(v) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
-    class_int(long v) : value(v) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
-    class_int(unsigned long v) : value(static_cast<std::int64_t>(v)) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
-    class_int(long long v) : value(v) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
-    class_int(unsigned long long v) : value(static_cast<std::int64_t>(v)) {} // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
-    explicit class_int(double v) : value(static_cast<std::int64_t>(v)) {}
-
-    template<typename T, typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0>
-    explicit operator T() const
-    {
-        return static_cast<T>(value);
-    }
-
-    friend bool operator==(class_int lhs, class_int rhs)
-    {
-        return lhs.value == rhs.value;
-    }
-    friend bool operator!=(class_int lhs, class_int rhs)
-    {
-        return lhs.value != rhs.value;
-    }
-    friend bool operator<(class_int lhs, class_int rhs)
-    {
-        return lhs.value < rhs.value;
-    }
-#if JSON_HAS_THREE_WAY_COMPARISON
-    friend std::strong_ordering operator<=>(class_int lhs, class_int rhs) // *NOPAD*
-    {
-        return lhs.value <=> rhs.value; // *NOPAD*
-    }
-#endif
-
-  private:
-    std::int64_t value;
-};
-
-} // namespace custom_number_types
-
-using custom_number_types::class_int;
-
-namespace std
-{
-// only the members the library uses
-template<>
-class numeric_limits<class_int>
-{
-  public:
-    static constexpr bool is_signed = true;
-    static constexpr int digits = std::numeric_limits<std::int64_t>::digits;
-};
-} // namespace std
-
-namespace
-{
-
-using class_int_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, class_int, std::uint64_t, double>;
-
-class_int_json make_class_int(std::int64_t v)
-{
-    class_int_json j(class_int_json::value_t::number_integer);
-    j.get_ref<class_int&>() = class_int(v);
-    return j;
-}
-
-} // namespace
-
-// the serializer cannot print an integer of class type, so doctest must not
-// try when an assertion fails
-namespace doctest
-{
-template<>
-struct StringMaker<class_int_json>
-{
-    static String convert(const class_int_json& j)
-    {
-        return j.type_name();
-    }
-};
-} // namespace doctest
-
-// __int128 as number type needs the std::numeric_limits (for the range checks)
-// and std::is_integral (for the serializer) specializations, which libc++
-// always provides and libstdc++ only outside strict ISO modes; the MSVC
-// standard library has none
-#if defined(__SIZEOF_INT128__) && (defined(_LIBCPP_VERSION) || defined(__GLIBCXX_TYPE_INT_N_0))
-    #define JSON_TEST_INT128_NUMBER_TYPES 1
-#else
-    #define JSON_TEST_INT128_NUMBER_TYPES 0
-#endif
-
-#if JSON_TEST_INT128_NUMBER_TYPES
-namespace
-{
-
-// __extension__ keeps -Wpedantic from flagging the non-standard type
-__extension__ typedef __int128 int128; // NOLINT(modernize-use-using)
-__extension__ typedef unsigned __int128 uint128; // NOLINT(modernize-use-using)
-
-static_assert(std::numeric_limits<int128>::digits == 127 && std::numeric_limits<uint128>::digits == 128 &&
-              std::is_integral<int128>::value && std::is_integral<uint128>::value, // NOLINT(misc-redundant-expression)
-              "__int128 is not fully supported by the standard library");
-
-using wide_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, int128, uint128, double>;
-
-wide_json make_int(int128 v)
-{
-    wide_json j(wide_json::value_t::number_integer);
-    j.get_ref<int128&>() = v;
-    return j;
-}
-
-wide_json make_uint(uint128 v)
-{
-    wide_json j(wide_json::value_t::number_unsigned);
-    j.get_ref<uint128&>() = v;
-    return j;
-}
-
-wide_json wrap(const wide_json& value)
-{
-    wide_json o(wide_json::value_t::object);
-    o["v"] = value;
-    return o;
-}
-
-} // namespace
-
-TEST_CASE("custom number types: integers beyond 64 bits")
-{
-    using out_of_range = wide_json::out_of_range;
-
-    const int128 two_64 = static_cast<int128>(1) << 64;
-    const int128 two_100 = static_cast<int128>(1) << 100;
-    const int128 max_int64 = (std::numeric_limits<std::int64_t>::max)();
-    const int128 min_int64 = (std::numeric_limits<std::int64_t>::min)();
-    const uint128 max_uint64 = (std::numeric_limits<std::uint64_t>::max)();
-
-    // before the range checks, these values were silently truncated, e.g.,
-    // 2^100 was written as 0
-    const wide_json int_big = make_int(two_100);
-    const wide_json int_big_negative = make_int(-two_100);
-    const wide_json uint_big = make_uint(static_cast<uint128>(two_100));
-    std::vector<std::uint8_t> _;
-
-    SECTION("CBOR")
-    {
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_cbor(int_big), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_cbor(int_big_negative), "[json.exception.out_of_range.407] integer number -1267650600228229401496703205376 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_cbor(uint_big), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by CBOR as it does not fit uint64", out_of_range&);
-        // the extremes of the 128-bit types, whose digits are produced without
-        // negating the minimum as a whole
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_cbor(make_int((std::numeric_limits<int128>::min)())), "[json.exception.out_of_range.407] integer number -170141183460469231731687303715884105728 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_cbor(make_int((std::numeric_limits<int128>::max)())), "[json.exception.out_of_range.407] integer number 170141183460469231731687303715884105727 cannot be represented by CBOR as it does not fit [-2^64, 2^64-1]", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_cbor(make_uint((std::numeric_limits<uint128>::max)())), "[json.exception.out_of_range.407] integer number 340282366920938463463374607431768211455 cannot be represented by CBOR as it does not fit uint64", out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_cbor(make_int(two_64)), out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_cbor(make_int(-two_64 - 1)), out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_cbor(make_uint(static_cast<uint128>(max_uint64) + 1)), out_of_range&);
-
-        // CBOR's integers cover [-2^64, 2^64-1]
-        CHECK(wide_json::to_cbor(make_int(two_64 - 1)) == std::vector<std::uint8_t>({0x1B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}));
-        CHECK(wide_json::to_cbor(make_int(-two_64)) == std::vector<std::uint8_t>({0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}));
-        CHECK(wide_json::to_cbor(make_uint(max_uint64)) == std::vector<std::uint8_t>({0x1B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}));
-    }
-
-    SECTION("MessagePack")
-    {
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_msgpack(int_big), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by MessagePack as it does not fit [-2^63, 2^64-1]", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_msgpack(int_big_negative), "[json.exception.out_of_range.407] integer number -1267650600228229401496703205376 cannot be represented by MessagePack as it does not fit [-2^63, 2^64-1]", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_msgpack(uint_big), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by MessagePack as it does not fit uint64", out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_msgpack(make_int(two_64)), out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_msgpack(make_int(min_int64 - 1)), out_of_range&);
-
-        // MessagePack's integers cover [-2^63, 2^64-1]
-        CHECK(wide_json::to_msgpack(make_int(two_64 - 1)) == std::vector<std::uint8_t>({0xCF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}));
-        CHECK(wide_json::to_msgpack(make_int(min_int64)) == std::vector<std::uint8_t>({0xD3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}));
-        CHECK(wide_json::to_msgpack(make_uint(max_uint64)) == std::vector<std::uint8_t>({0xCF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}));
-    }
-
-    SECTION("BSON")
-    {
-        // wrap() stores the value at /v, which JSON_DIAGNOSTICS adds to the message
-#if JSON_DIAGNOSTICS
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bson(wrap(int_big)), "[json.exception.out_of_range.407] (/v) integer number 1267650600228229401496703205376 cannot be represented by BSON as it does not fit int64", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bson(wrap(int_big_negative)), "[json.exception.out_of_range.407] (/v) integer number -1267650600228229401496703205376 cannot be represented by BSON as it does not fit int64", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bson(wrap(uint_big)), "[json.exception.out_of_range.407] (/v) integer number 1267650600228229401496703205376 cannot be represented by BSON as it does not fit uint64", out_of_range&);
-#else
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bson(wrap(int_big)), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by BSON as it does not fit int64", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bson(wrap(int_big_negative)), "[json.exception.out_of_range.407] integer number -1267650600228229401496703205376 cannot be represented by BSON as it does not fit int64", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bson(wrap(uint_big)), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by BSON as it does not fit uint64", out_of_range&);
-#endif
-        CHECK_THROWS_AS(_ = wide_json::to_bson(wrap(make_int(max_int64 + 1))), out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_bson(wrap(make_int(min_int64 - 1))), out_of_range&);
-
-        // nested values are checked as well, before anything is written
-        wide_json nested(wide_json::value_t::object);
-        nested["a"] = wide_json::array({wrap(int_big)});
-        std::vector<std::uint8_t> out;
-        CHECK_THROWS_AS(wide_json::to_bson(nested, out), out_of_range&);
-        CHECK(out.empty());
-
-        CHECK(wide_json::from_bson(wide_json::to_bson(wrap(make_int(max_int64)))) == wrap(make_int(max_int64)));
-        CHECK(wide_json::from_bson(wide_json::to_bson(wrap(make_int(min_int64)))) == wrap(make_int(min_int64)));
-        CHECK_NOTHROW(wide_json::to_bson(wrap(make_uint(max_uint64))));
-    }
-
-    SECTION("BON8")
-    {
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bon8(int_big), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by BON8 as it does not fit int64", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bon8(int_big_negative), "[json.exception.out_of_range.407] integer number -1267650600228229401496703205376 cannot be represented by BON8 as it does not fit int64", out_of_range&);
-        CHECK_THROWS_WITH_AS(_ = wide_json::to_bon8(uint_big), "[json.exception.out_of_range.407] integer number 1267650600228229401496703205376 cannot be represented by BON8 as it does not fit int64", out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_bon8(make_int(max_int64 + 1)), out_of_range&);
-        CHECK_THROWS_AS(_ = wide_json::to_bon8(make_int(min_int64 - 1)), out_of_range&);
-
-        CHECK(wide_json::from_bon8(wide_json::to_bon8(make_int(max_int64))) == make_int(max_int64));
-        CHECK(wide_json::from_bon8(wide_json::to_bon8(make_int(min_int64))) == make_int(min_int64));
-    }
-
-    SECTION("UBJSON and BJData")
-    {
-        // integers beyond 64 bits are written exactly as high-precision numbers
-        const std::string digits = "1267650600228229401496703205376";
-        std::vector<std::uint8_t> expected = {'H', 'i', static_cast<std::uint8_t>(digits.size())};
-        expected.insert(expected.end(), digits.begin(), digits.end());
-        CHECK(wide_json::to_ubjson(int_big) == expected);
-        CHECK(wide_json::to_ubjson(uint_big) == expected);
-        CHECK(wide_json::to_bjdata(int_big) == expected);
-        // BJData's uint64 marker 'M' was used for any unsigned value beyond
-        // int64, which truncated the ones beyond 64 bits
-        CHECK(wide_json::to_bjdata(uint_big) == expected);
-
-        // the uint64 marker is still used where the value fits
-        CHECK(wide_json::to_bjdata(make_uint(max_uint64)) == std::vector<std::uint8_t>({'M', 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}));
-
-        // the elements of an optimized container are written the same way;
-        // BJData does not allow 'H' as the type of an optimized container
-        std::vector<std::uint8_t> expected_ubjson_array = {'[', '$', 'H', '#', 'i', 2};
-        std::vector<std::uint8_t> expected_bjdata_array = {'[', '#', 'i', 2};
-        for (int i = 0; i < 2; ++i)
-        {
-            expected_ubjson_array.insert(expected_ubjson_array.end(), expected.begin() + 1, expected.end());
-            expected_bjdata_array.insert(expected_bjdata_array.end(), expected.begin(), expected.end());
-        }
-        CHECK(wide_json::to_ubjson(wide_json::array({uint_big, uint_big}), true, true) == expected_ubjson_array);
-        CHECK(wide_json::to_bjdata(wide_json::array({uint_big, uint_big}), true, true) == expected_bjdata_array);
-    }
-
-    SECTION("BJData ND-array")
-    {
-        // an ND-array element beyond 64 bits does not fit any dtype, so the
-        // annotated object is written as a plain object instead of truncating
-        // the element into range
-        wide_json element(wide_json::value_t::object);
-        element["_ArrayType_"] = "uint8";
-        element["_ArraySize_"] = wide_json::array({make_uint(2), make_uint(1)});
-        element["_ArrayData_"] = wide_json::array({make_uint(1), make_uint(static_cast<uint128>(two_64) + 1)});
-        const auto element_bytes = wide_json::to_bjdata(element, true, true);
-        REQUIRE(!element_bytes.empty());
-        CHECK(element_bytes[0] == '{');
-
-        wide_json signed_element = element;
-        signed_element["_ArrayType_"] = "int8";
-        signed_element["_ArrayData_"] = wide_json::array({make_int(1), make_int(-two_64 + 1)});
-        const auto signed_element_bytes = wide_json::to_bjdata(signed_element, true, true);
-        REQUIRE(!signed_element_bytes.empty());
-        CHECK(signed_element_bytes[0] == '{');
-
-        // the same for a dimension beyond 64 bits, which wrapped into a
-        // dimension matching the size of _ArrayData_ (here: 1)
-        wide_json dimension = element;
-        dimension["_ArraySize_"] = wide_json::array({make_uint(2), make_uint(static_cast<uint128>(two_64) + 1)});
-        dimension["_ArrayData_"] = wide_json::array({make_uint(1), make_uint(2)});
-        const auto dimension_bytes = wide_json::to_bjdata(dimension, true, true);
-        REQUIRE(!dimension_bytes.empty());
-        CHECK(dimension_bytes[0] == '{');
-
-        // in range, the ND-array is still written
-        wide_json fits = element;
-        fits["_ArrayData_"] = wide_json::array({make_uint(1), make_uint(2)});
-        const auto fits_bytes = wide_json::to_bjdata(fits, true, true);
-        REQUIRE(!fits_bytes.empty());
-        CHECK(fits_bytes[0] == '[');
-    }
-}
-
-#endif
-
-TEST_CASE("custom number types")
-{
-    SECTION("signed integer of class type compared with a float")
-    {
-        // std::is_signed is false for a class type, which made the comparison
-        // treat any float below zero as less than every integer
-        const class_int_json minus_five = make_class_int(-5);
-        const class_int_json minus_two = make_class_int(-2);
-        const class_int_json five = make_class_int(5);
-        const class_int_json minus_two_and_a_half = -2.5;
-        const class_int_json two_and_a_half = 2.5;
-        const class_int_json huge_negative = -1e30;
-        const class_int_json huge_positive = 1e30;
-
-        CHECK(minus_five < minus_two_and_a_half);
-        CHECK_FALSE(minus_two_and_a_half < minus_five);
-        CHECK(minus_two_and_a_half > minus_five);
-        CHECK(minus_five <= minus_two_and_a_half);
-        CHECK(minus_two_and_a_half >= minus_five);
-        CHECK(minus_five != minus_two_and_a_half);
-
-        CHECK(minus_two_and_a_half < minus_two);
-        CHECK_FALSE(minus_two < minus_two_and_a_half);
-
-        CHECK(two_and_a_half < five);
-        CHECK(minus_five < two_and_a_half);
-
-        // floats beyond the integer's range
-        CHECK(huge_negative < minus_five);
-        CHECK_FALSE(minus_five < huge_negative);
-        CHECK(five < huge_positive);
-        CHECK_FALSE(huge_positive < five);
-
-        // equality
-        const class_int_json minus_two_float = -2.0;
-        CHECK(minus_two == minus_two_float);
-        CHECK(minus_two_float == minus_two);
-    }
-
-}

tests/src/unit-locale-cpp.cpp

@@ -260,10 +260,11 @@ struct LocaleSwitchingSax final: public nlohmann::json_sax<json>
 
 TEST_CASE("locale changes between lexer construction and number conversion (#5198)")
 {
-    // The numbers are chosen so that the conversion also takes the strtod
-    // fallback, which honors the locale that is current at conversion time:
-    // too many significant digits for Clinger's fast path, an underflow that
-    // std::from_chars rejects, and a plain value.
+    // float and double are converted without the locale. A long double that
+    // is not binary64 can take the strtold fallback, which honors the locale
+    // that is current at conversion time. The numbers are chosen so that it
+    // does: too many significant digits for Clinger's fast path, an underflow
+    // that std::from_chars rejects, and a plain value.
     const std::vector<std::string> numbers = {"3.14159265358979323846", "1.5e-400", "12.34", "-0.000123456789012345678"};
     std::string text = "[";
     for (const auto& n : numbers)
@@ -327,7 +328,8 @@ TEST_CASE("locale changes between lexer construction and number conversion (#519
             }
         }
 
-        // a long double goes through std::strtold unless std::from_chars supports it
+        // a long double goes through std::strtold unless it is binary64 or
+        // std::from_chars supports it
         {
             bool switched = false;
             const auto cb = [&](int /*depth*/, long_double_json::parse_event_t event, long_double_json& /*parsed*/) noexcept
@@ -353,8 +355,15 @@ TEST_CASE("locale with a multi-byte decimal point")
 {
     // Some locales use a decimal point that is not a single character, e.g.
     // U+066B ARABIC DECIMAL SEPARATOR (two bytes in UTF-8). It cannot be
-    // substituted in place for '.', so the strtod fallback stops early. The
-    // conversion must still terminate rather than retry forever.
+    // substituted in place for '.', so the strtold fallback (only for long
+    // double formats other than binary64) converts a copy of the token with
+    // the whole decimal point instead (#5660). The values must be those of the
+    // "C" locale.
+    using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
+    const char* const long_double_numbers = "[3.14159265358979323846, 1.5e-400, -0.000123456789012345678]";
+    REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
+    const long_double_json expected_long_double = long_double_json::parse(long_double_numbers);
+
     const std::array<const char*, 6> names = {{"ar_EG.UTF-8", "ar_SA.UTF-8", "fa_IR.UTF-8", "ps_AF.UTF-8", "ar_EG", "fa_IR"}};
     bool tested = false;
     for (const char* name : names)
@@ -372,12 +381,20 @@ TEST_CASE("locale with a multi-byte decimal point")
         tested = true;
 
         // too many significant digits for Clinger's fast path, and an underflow
-        // that std::from_chars rejects: both reach the strtod fallback
+        // that std::from_chars rejects: double does not depend on the locale
         json j;
         CHECK_NOTHROW(j = json::parse("[3.14159265358979323846, 1.5e-400, -0.000123456789012345678]"));
         CHECK(j.is_array());
+        CHECK(j[0] == 3.14159265358979323846);
+        CHECK(j[1] == 0.0);
+        CHECK(j[2] == -0.000123456789012345678);
         CHECK(json::accept("3.14159265358979323846"));
 
+        // a long double that reaches the strtold fallback is not truncated
+        long_double_json ld;
+        CHECK_NOTHROW(ld = long_double_json::parse(long_double_numbers));
+        CHECK(ld == expected_long_double);
+
         // a value the locale-independent paths convert is not affected
         CHECK(json::parse("12.5") == 12.5);
     }

tests/src/unit-msgpack-custom-types.cpp

@@ -1,296 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// MessagePack tests with basic_json specializations other than nlohmann::json;
-// they are kept apart from unit-msgpack.cpp because every specialization adds
-// many sections to the object file, and MinGW cannot link objects with more
-// than 65535 sections (see the clang job in .github/workflows/windows.yml)
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstdint> // SIZE_MAX, UINT32_MAX
-#include <functional>
-#include <limits>
-#include <map>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-// the fake sizes below do not fit into a 32-bit std::size_t
-// with clang and libstdc++ 10, the std::filesystem::path conversion that
-// C++17 builds consider for every string type is ambiguous for a class
-// derived from std::string, so the string case is not tested there
-#if !(defined(__clang__) && defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 11)
-    #define JSON_TEST_BEYOND_UINT32_STRING 1
-#endif
-
-#if SIZE_MAX > UINT32_MAX
-template<typename T, typename A = std::allocator<T>>
-struct huge_array : std::vector<T, A>
-{
-    using base = std::vector<T, A>;
-    using base::base;
-
-    bool fake_size = false;
-
-    std::size_t size() const noexcept
-    {
-        if (fake_size)
-        {
-            return (std::numeric_limits<std::uint32_t>::max)() + 1ULL;
-        }
-
-        return base::size();
-    }
-};
-
-using huge_array_json = nlohmann::json::with_array_t<huge_array>;
-
-TEST_CASE("MessagePack Size above uint32 for array")
-{
-    huge_array_json j = huge_array_json::array();
-
-    j.push_back(1);
-    j.push_back(2);
-    j.push_back(3);
-
-    auto& array = j.get_ref<huge_array_json::array_t&>();
-    array.fake_size = true;
-
-    // write into a caller-owned vector: to_msgpack(j) reserves space based on
-    // the (faked) element count, which fails with bad_alloc on Windows
-    std::vector<std::uint8_t> result;
-    CHECK_THROWS_WITH_AS(
-        huge_array_json::to_msgpack(j, result),
-        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
-        json::out_of_range&);
-
-    array.fake_size = false;
-}
-
-template<typename K, typename V,
-         typename C = std::less<K>,
-         typename A = std::allocator<std::pair<const K, V>>>
-                                     struct huge_map : std::map<K, V, C, A>
-{
-    using base = std::map<K, V, C, A>;
-    using base::base;
-
-    bool fake_size = false;
-
-    std::size_t size() const noexcept
-    {
-        if (fake_size)
-        {
-            return static_cast<std::size_t>(UINT32_MAX) + 1ULL;
-        }
-
-        return base::size();
-    }
-};
-
-using huge_object_json = nlohmann::json::with_object_t<huge_map>;
-
-TEST_CASE("MessagePack Size above uint32 for object")
-{
-
-    huge_object_json j = huge_object_json::object();
-
-    j["one"] = 1;
-    j["two"] = 2;
-
-    auto& object = j.get_ref<huge_object_json::object_t&>();
-    object.fake_size = true;
-
-    // write into a caller-owned vector: to_msgpack(j) reserves space based on
-    // the (faked) element count, which fails with bad_alloc on Windows
-    std::vector<std::uint8_t> result;
-    CHECK_THROWS_WITH_AS(
-        huge_object_json::to_msgpack(j, result),
-        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
-        json::out_of_range&);
-
-    object.fake_size = false;
-}
-
-#ifdef JSON_TEST_BEYOND_UINT32_STRING
-struct huge_string : std::string
-{
-    using std::string::string;
-
-    std::size_t size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
-    {
-        return static_cast<std::size_t>(UINT32_MAX) + 1ULL;
-    }
-};
-
-using huge_string_json = nlohmann::json::with_string_t<huge_string>;
-
-TEST_CASE("MessagePack Size above uint32 for string")
-{
-    const huge_string_json j = "hello";
-
-    CHECK_THROWS_WITH_AS(
-        huge_string_json::to_msgpack(j),
-        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
-        json::out_of_range&);
-}
-#endif
-
-struct huge_binary : std::vector<std::uint8_t>
-{
-    using std::vector<std::uint8_t>::vector;
-
-    std::size_t size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
-    {
-        return static_cast<std::size_t>(UINT32_MAX) + 1ULL;
-    }
-};
-
-using huge_binary_json = nlohmann::json::with_binary_t<huge_binary>;
-
-TEST_CASE("MessagePack Size above uint32 for binary")
-{
-
-    huge_binary_json j = huge_binary_json::binary(huge_binary{});
-
-    j.get_binary().push_back(0x01);
-    j.get_binary().push_back(0x02);
-
-    CHECK_THROWS_WITH_AS(
-        huge_binary_json::to_msgpack(j),
-        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
-        json::out_of_range&);
-}
-#endif
-
-namespace
-{
-// types that report a size beyond UINT32_MAX without allocating that much
-// memory, so the MessagePack length limit can be tested cheaply; see the
-// similar types in unit-bson.cpp
-std::size_t beyond_uint32_size()
-{
-    return static_cast<std::size_t>((std::numeric_limits<std::uint32_t>::max)()) + 1;
-}
-
-class beyond_uint32_binary_t : public std::vector<std::uint8_t>
-{
-  public:
-    using std::vector<std::uint8_t>::vector;
-
-    size_type size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
-    {
-        return beyond_uint32_size();
-    }
-};
-
-#ifdef JSON_TEST_BEYOND_UINT32_STRING
-class beyond_uint32_string_t : public std::string
-{
-  public:
-    using std::string::string;
-
-    size_type size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
-    {
-        return beyond_uint32_size();
-    }
-};
-
-using beyond_uint32_string_json = nlohmann::json::with_string_t<beyond_uint32_string_t>;
-#endif
-
-using beyond_uint32_binary_json = nlohmann::json::with_binary_t<beyond_uint32_binary_t>;
-} // namespace
-
-TEST_CASE("MessagePack lengths beyond UINT32_MAX cannot be serialized")
-{
-    // MessagePack stores the length of a string, binary value, array, or
-    // object in at most 32 bits; a larger one used to be written without any
-    // length at all
-#if SIZE_MAX > UINT32_MAX
-    {
-        const char* const expected = "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295";
-
-        const beyond_uint32_binary_json binary = beyond_uint32_binary_json::binary(beyond_uint32_binary_t{});
-        CHECK_THROWS_WITH_AS(beyond_uint32_binary_json::to_msgpack(binary), expected, beyond_uint32_binary_json::out_of_range&);
-
-        const beyond_uint32_binary_json ext = beyond_uint32_binary_json::binary(beyond_uint32_binary_t{}, 42);
-        CHECK_THROWS_WITH_AS(beyond_uint32_binary_json::to_msgpack(ext), expected, beyond_uint32_binary_json::out_of_range&);
-
-#ifdef JSON_TEST_BEYOND_UINT32_STRING
-        // created from its type rather than from a beyond_uint32_string_t:
-        // that would consider the std::filesystem::path conversion, which
-        // libstdc++ 10 cannot decide for a class derived from std::string
-        const beyond_uint32_string_json string(beyond_uint32_string_json::value_t::string);
-        CHECK_THROWS_WITH_AS(beyond_uint32_string_json::to_msgpack(string), expected, beyond_uint32_string_json::out_of_range&);
-#endif
-    }
-#endif
-}
-
-TEST_CASE("MessagePack numbers use the active union member (see #5644)")
-{
-    // when number_integer_t is narrower than number_unsigned_t, to_msgpack()
-    // used to read the union member that was not the active one, writing
-    // wrong bytes for some values; std::int64_t/std::uint64_t (the default
-    // types, where both members have the same width) were not affected
-    using int32_json = nlohmann::json::with_integers_t<std::int32_t, std::uint64_t>;
-    using int16_json = nlohmann::json::with_integers_t<std::int16_t, std::uint64_t>;
-
-    SECTION("number_integer_t = std::int32_t")
-    {
-        SECTION("6442450944 (uint 64; the low 32 bits used to be sign-extended)")
-        {
-            const int32_json j = 6442450944ULL;
-            CHECK(j.is_number_unsigned());
-
-            std::vector<uint8_t> const expected{0xcf, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00};
-            const auto result = int32_json::to_msgpack(j);
-            CHECK(result == expected);
-            CHECK(int32_json::from_msgpack(result) == j);
-        }
-
-        SECTION("4294967496 (uint 64; the low 32 bits used to be the whole value)")
-        {
-            const int32_json j = 4294967496ULL;
-            CHECK(j.is_number_unsigned());
-
-            std::vector<uint8_t> const expected{0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc8};
-            const auto result = int32_json::to_msgpack(j);
-            CHECK(result == expected);
-            CHECK(int32_json::from_msgpack(result) == j);
-        }
-    }
-
-    SECTION("number_integer_t = std::int16_t, 98304 (uint 32)")
-    {
-        const int16_json j = 98304ULL;
-        CHECK(j.is_number_unsigned());
-
-        std::vector<uint8_t> const expected{0xce, 0x00, 0x01, 0x80, 0x00};
-        const auto result = int16_json::to_msgpack(j);
-        CHECK(result == expected);
-        CHECK(int16_json::from_msgpack(result) == j);
-    }
-
-    SECTION("default types (std::int64_t/std::uint64_t) are unaffected")
-    {
-        const json j = 4294967496ULL;
-        CHECK(j.is_number_unsigned());
-
-        std::vector<uint8_t> const expected{0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc8};
-        const auto result = json::to_msgpack(j);
-        CHECK(result == expected);
-        CHECK(json::from_msgpack(result) == j);
-    }
-}

tests/src/unit-msgpack.cpp

@@ -2173,6 +2173,276 @@ TEST_CASE("MessagePack roundtrips" * doctest::skip())
     }
 }
 
+// the fake sizes below do not fit into a 32-bit std::size_t
+// with clang and libstdc++ 10, the std::filesystem::path conversion that
+// C++17 builds consider for every string type is ambiguous for a class
+// derived from std::string, so the string case is not tested there
+#if !(defined(__clang__) && defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE < 11)
+    #define JSON_TEST_BEYOND_UINT32_STRING 1
+#endif
+
+#if SIZE_MAX > UINT32_MAX
+template<typename T, typename A = std::allocator<T>>
+struct huge_array : std::vector<T, A>
+{
+    using base = std::vector<T, A>;
+    using base::base;
+
+    bool fake_size = false;
+
+    std::size_t size() const noexcept
+    {
+        if (fake_size)
+        {
+            return (std::numeric_limits<std::uint32_t>::max)() + 1ULL;
+        }
+
+        return base::size();
+    }
+};
+
+using huge_array_json = nlohmann::json::with_array_t<huge_array>;
+
+TEST_CASE("MessagePack Size above uint32 for array")
+{
+    huge_array_json j = huge_array_json::array();
+
+    j.push_back(1);
+    j.push_back(2);
+    j.push_back(3);
+
+    auto& array = j.get_ref<huge_array_json::array_t&>();
+    array.fake_size = true;
+
+    // write into a caller-owned vector: to_msgpack(j) reserves space based on
+    // the (faked) element count, which fails with bad_alloc on Windows
+    std::vector<std::uint8_t> result;
+    CHECK_THROWS_WITH_AS(
+        huge_array_json::to_msgpack(j, result),
+        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
+        json::out_of_range&);
+
+    array.fake_size = false;
+}
+
+template<typename K, typename V,
+         typename C = std::less<K>,
+         typename A = std::allocator<std::pair<const K, V>>>
+                                     struct huge_map : std::map<K, V, C, A>
+{
+    using base = std::map<K, V, C, A>;
+    using base::base;
+
+    bool fake_size = false;
+
+    std::size_t size() const noexcept
+    {
+        if (fake_size)
+        {
+            return static_cast<std::size_t>(UINT32_MAX) + 1ULL;
+        }
+
+        return base::size();
+    }
+};
+
+using huge_object_json = nlohmann::json::with_object_t<huge_map>;
+
+TEST_CASE("MessagePack Size above uint32 for object")
+{
+
+    huge_object_json j = huge_object_json::object();
+
+    j["one"] = 1;
+    j["two"] = 2;
+
+    auto& object = j.get_ref<huge_object_json::object_t&>();
+    object.fake_size = true;
+
+    // write into a caller-owned vector: to_msgpack(j) reserves space based on
+    // the (faked) element count, which fails with bad_alloc on Windows
+    std::vector<std::uint8_t> result;
+    CHECK_THROWS_WITH_AS(
+        huge_object_json::to_msgpack(j, result),
+        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
+        json::out_of_range&);
+
+    object.fake_size = false;
+}
+
+#ifdef JSON_TEST_BEYOND_UINT32_STRING
+struct huge_string : std::string
+{
+    using std::string::string;
+
+    std::size_t size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
+    {
+        return static_cast<std::size_t>(UINT32_MAX) + 1ULL;
+    }
+};
+
+using huge_string_json = nlohmann::json::with_string_t<huge_string>;
+
+TEST_CASE("MessagePack Size above uint32 for string")
+{
+    const huge_string_json j = "hello";
+
+    CHECK_THROWS_WITH_AS(
+        huge_string_json::to_msgpack(j),
+        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
+        json::out_of_range&);
+}
+#endif
+
+struct huge_binary : std::vector<std::uint8_t>
+{
+    using std::vector<std::uint8_t>::vector;
+
+    std::size_t size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
+    {
+        return static_cast<std::size_t>(UINT32_MAX) + 1ULL;
+    }
+};
+
+using huge_binary_json = nlohmann::json::with_binary_t<huge_binary>;
+
+TEST_CASE("MessagePack Size above uint32 for binary")
+{
+
+    huge_binary_json j = huge_binary_json::binary(huge_binary{});
+
+    j.get_binary().push_back(0x01);
+    j.get_binary().push_back(0x02);
+
+    CHECK_THROWS_WITH_AS(
+        huge_binary_json::to_msgpack(j),
+        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
+        json::out_of_range&);
+}
+#endif
+
+namespace
+{
+// types that report a size beyond UINT32_MAX without allocating that much
+// memory, so the MessagePack length limit can be tested cheaply; see the
+// similar types in unit-bson.cpp
+std::size_t beyond_uint32_size()
+{
+    return static_cast<std::size_t>((std::numeric_limits<std::uint32_t>::max)()) + 1;
+}
+
+class beyond_uint32_binary_t : public std::vector<std::uint8_t>
+{
+  public:
+    using std::vector<std::uint8_t>::vector;
+
+    size_type size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
+    {
+        return beyond_uint32_size();
+    }
+};
+
+#ifdef JSON_TEST_BEYOND_UINT32_STRING
+class beyond_uint32_string_t : public std::string
+{
+  public:
+    using std::string::string;
+
+    size_type size() const noexcept // NOLINT(readability-convert-member-functions-to-static)
+    {
+        return beyond_uint32_size();
+    }
+};
+
+using beyond_uint32_string_json = nlohmann::json::with_string_t<beyond_uint32_string_t>;
+#endif
+
+using beyond_uint32_binary_json = nlohmann::json::with_binary_t<beyond_uint32_binary_t>;
+} // namespace
+
+TEST_CASE("MessagePack lengths beyond UINT32_MAX cannot be serialized")
+{
+    // MessagePack stores the length of a string, binary value, array, or
+    // object in at most 32 bits; a larger one used to be written without any
+    // length at all
+#if SIZE_MAX > UINT32_MAX
+    {
+        const char* const expected = "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295";
+
+        const beyond_uint32_binary_json binary = beyond_uint32_binary_json::binary(beyond_uint32_binary_t{});
+        CHECK_THROWS_WITH_AS(beyond_uint32_binary_json::to_msgpack(binary), expected, beyond_uint32_binary_json::out_of_range&);
+
+        const beyond_uint32_binary_json ext = beyond_uint32_binary_json::binary(beyond_uint32_binary_t{}, 42);
+        CHECK_THROWS_WITH_AS(beyond_uint32_binary_json::to_msgpack(ext), expected, beyond_uint32_binary_json::out_of_range&);
+
+#ifdef JSON_TEST_BEYOND_UINT32_STRING
+        // created from its type rather than from a beyond_uint32_string_t:
+        // that would consider the std::filesystem::path conversion, which
+        // libstdc++ 10 cannot decide for a class derived from std::string
+        const beyond_uint32_string_json string(beyond_uint32_string_json::value_t::string);
+        CHECK_THROWS_WITH_AS(beyond_uint32_string_json::to_msgpack(string), expected, beyond_uint32_string_json::out_of_range&);
+#endif
+    }
+#endif
+}
+
+TEST_CASE("MessagePack numbers use the active union member (see #5644)")
+{
+    // when number_integer_t is narrower than number_unsigned_t, to_msgpack()
+    // used to read the union member that was not the active one, writing
+    // wrong bytes for some values; std::int64_t/std::uint64_t (the default
+    // types, where both members have the same width) were not affected
+    using int32_json = nlohmann::json::with_integers_t<std::int32_t, std::uint64_t>;
+    using int16_json = nlohmann::json::with_integers_t<std::int16_t, std::uint64_t>;
+
+    SECTION("number_integer_t = std::int32_t")
+    {
+        SECTION("6442450944 (uint 64; the low 32 bits used to be sign-extended)")
+        {
+            const int32_json j = 6442450944ULL;
+            CHECK(j.is_number_unsigned());
+
+            std::vector<uint8_t> const expected{0xcf, 0x00, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00};
+            const auto result = int32_json::to_msgpack(j);
+            CHECK(result == expected);
+            CHECK(int32_json::from_msgpack(result) == j);
+        }
+
+        SECTION("4294967496 (uint 64; the low 32 bits used to be the whole value)")
+        {
+            const int32_json j = 4294967496ULL;
+            CHECK(j.is_number_unsigned());
+
+            std::vector<uint8_t> const expected{0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc8};
+            const auto result = int32_json::to_msgpack(j);
+            CHECK(result == expected);
+            CHECK(int32_json::from_msgpack(result) == j);
+        }
+    }
+
+    SECTION("number_integer_t = std::int16_t, 98304 (uint 32)")
+    {
+        const int16_json j = 98304ULL;
+        CHECK(j.is_number_unsigned());
+
+        std::vector<uint8_t> const expected{0xce, 0x00, 0x01, 0x80, 0x00};
+        const auto result = int16_json::to_msgpack(j);
+        CHECK(result == expected);
+        CHECK(int16_json::from_msgpack(result) == j);
+    }
+
+    SECTION("default types (std::int64_t/std::uint64_t) are unaffected")
+    {
+        const json j = 4294967496ULL;
+        CHECK(j.is_number_unsigned());
+
+        std::vector<uint8_t> const expected{0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc8};
+        const auto result = json::to_msgpack(j);
+        CHECK(result == expected);
+        CHECK(json::from_msgpack(result) == j);
+    }
+}
+
 TEST_CASE("MessagePack large strings and binaries (chunked reader)")
 {
     // get_msgpack_string()/get_msgpack_binary() both read through get_binary(),

tests/src/unit-regression3.cpp

@@ -43,6 +43,7 @@ using ordered_json = nlohmann::ordered_json;
 #endif
 
 #include <cstdio>
+#include <deque>
 #include <list>
 #include <type_traits>
 #include <utility>
@@ -914,6 +915,52 @@ TEST_CASE("issue #5402 - update(merge_objects=true) overwrites a primitive with
 }
 
 
+TEST_CASE("regression test #5476 - array type without reserve()")
+{
+    // the capacity reserved for definite-length arrays must not require the
+    // array type to have a reserve() member function
+    using deque_json = nlohmann::json::with_array_t<std::deque>;
+
+    SECTION("std::deque")
+    {
+        const auto j = deque_json::parse(R"({"a":[1,[2,3]],"b":[]})");
+        CHECK(j.dump() == R"({"a":[1,[2,3]],"b":[]})");
+
+        // the binary formats pass a definite length to start_array()
+        CHECK(deque_json::from_cbor(deque_json::to_cbor(j)) == j);
+        CHECK(deque_json::from_msgpack(deque_json::to_msgpack(j)) == j);
+        CHECK(deque_json::from_bon8(deque_json::to_bon8(j)) == j);
+
+        // parse() instantiates the callback parser as well, which reserves too
+        const auto with_callback = deque_json::parse(R"([1,2,3])", [](int /*depth*/, deque_json::parse_event_t /*event*/, deque_json& /*parsed*/) noexcept
+        {
+            return true;
+        });
+        CHECK(with_callback == deque_json({1, 2, 3}));
+    }
+
+    SECTION("std::vector still reserves")
+    {
+        json array = json::array();
+        for (int i = 0; i < 100; ++i)
+        {
+            array.push_back(i);
+        }
+
+        const auto j = json::from_cbor(json::to_cbor(array));
+        CHECK(j == array);
+        CHECK(j.get_ref<const json::array_t&>().capacity() >= 100);
+    }
+
+    SECTION("the reservation stays capped")
+    {
+        // CBOR array announcing 2^32-1 elements, but truncated right after the
+        // header: the input must be rejected without reserving that capacity
+        const std::vector<std::uint8_t> truncated = {0x9A, 0xFF, 0xFF, 0xFF, 0xFF};
+        CHECK(json::from_cbor(truncated, true, false).is_discarded());
+    }
+}
+
 TEST_CASE("issue #5317 - nested indefinite-length CBOR string chunks are rejected")
 {
     json _;