[nlohmann]

Part of the stack for the zero-copy view (#5295). This change speeds up json::parse on its own: it adds a float converter and faster string kernels, which the view uses later in the stack.

Summary

• Own float converter for binary32/binary64. float, double, and long double where it is IEEE 754 binary64 (MSVC, Apple arm64) are now converted by the library itself: correctly rounded (to nearest, ties to even), independent of the locale, and without calling the C or C++ library.
  1. Split the token into sign, significand w (at most 19 digits), and decimal exponent q. The scanners already record the positions of the decimal point and the exponent, so no character is classified again; digits are read eight at a time.
  2. Clinger's fast path where w and 10^|q| are exact (skipped where FLT_EVAL_METHOD != 0).
  3. Eisel-Lemire otherwise, templated for binary32 and binary64.
  4. For tokens with more than 19 significant digits whose w and w + 1 round differently: an exact big-integer comparison with the midpoint between the two candidates (fast_float's digit comparison, simplified because Eisel-Lemire already yields both candidates).
  • Parsed values are bit-identical wherever the previous chain (Eisel-Lemire in front of std::from_chars/strtod) was correctly rounded. Out-of-range values still throw out_of_range.406, and underflow still gives a zero with the sign of the token.
  • eisel_lemire() and decimal_to_float() are always inlined, so callers' hot loops keep the whole conversion inline.
  • The strtold fallback left for long double formats other than binary64 (x87, binary128) now copies a decimal point longer than one byte into a copy of the token instead of substituting its first byte. This fixes Floats are truncated at the decimal point under locales with a multi-byte decimal point (fa_IR.UTF-8) #5660 completely for a locale such as fa_IR.UTF-8.
• Faster string scanning. The SWAR kernels in string_scan.hpp find the first stop byte with the trailing-zero count of the comparison mask instead of a byte loop once a word contains a hit (the lowest flagged byte is always a real hit, since borrows can only flag bytes above one). scalar_string_bulk_run() validates a run of multi-byte UTF-8 sequences one after another instead of re-searching for the next special byte after each sequence, which helps text in non-Latin scripts. These kernels serve the lexer's contiguous fast path, the serializer, and the binary formats.
• Word loads and bit operations. Words are read in little-endian order on every platform: with one memcpy load on little-endian targets, assembled from bytes otherwise. bit_ops.hpp gains count_trailing_zeros(), and MSVC gets _BitScanForward64/_BitScanReverse64 for it and for count_leading_zeros().
• Faster \u escape decoding. get_codepoint() decoded four hex digits with four calls to get(), each going through a chain of range comparisons. For contiguous input it now uses one table lookup per byte (after yyjson's read_hex_u16); an invalid digit shows in the OR of the four values, and the lexer then falls back to the per-character loop, so error messages and positions are unchanged. The streaming path is untouched.
• Docs. number_handling.md, template_parameters.md, and number_float_t.md no longer say that parsing uses strtod/strtof/strtold. strtold and a NUL-terminated data() only matter for a long double that is not binary64. number_handling.md also documents that tokens too small for double become zero with the token's sign.
• Credit. The fast_float entry in README.md/license.md now also names the digit comparison.

Performance

Measured on Apple M1 Max (Apple clang, -O2) and an x86-64 KVM Haswell VPS pinned to one core (GCC 13 / Clang 18, -O2; the VPS is noisy, about ±5-10%). µs, best of 3 interleaved rounds of 15 runs; files from nativejson-benchmark. json::parse and json::dump, develop → this PR:

	Apple M1	x86-64 GCC	x86-64 Clang
parse canada	8958 → 7529 (−16%)	16494 → 15553 (−6%)	15709 → 14950 (−5%)
parse twitter	1528 → 1402 (−8%)	4445 → 4034 (−9%)	4386 → 3990 (−9%)
parse citm_catalog	2994 → 2974 (−1%)	7898 → 7843 (−1%)	6511 → 6546 (+1%)
dump twitter	490 → 411 (−16%)	1058 → 1007 (−5%)	1075 → 875 (−19%)

The dump speedup comes from the string-scan kernels, which the serializer also uses. Parsing citm_catalog is unchanged within the noise.

Tests

• 508 generated hard float-parsing cases with expected binary32 and binary64 bits (exact midpoints and their neighbours, boundary values, huge exponents, long tokens), checked through the converter and through json::parse with both scanners.
• Exact-bit tests for double and float (ties to even, subnormal/overflow boundaries), a 200,000-value round trip, and a 100,000-value float round trip.
• The string-scan kernels are compared against byte-by-byte reference scans on generated buffers at three alignments; the \u table is checked for valid escapes, surrogate pairs, truncation at every distance from the end, an invalid digit at each of the four positions, contiguous against streaming input, and seeded random escapes.
• unit-locale-cpp.cpp checks a multi-byte decimal point for double exactly and for long double against the "C" locale.

Generator of float_hard_cases.hpp

The 508 embedded cases are produced by compact_hard_cases.py 5 (importing hard_cases.py, the fuller generator used for the 240,187-case offline checks), then formatted as one C++ initializer per output line. For every format boundary and a set of random values, it computes the exact midpoint to the next representable value and emits that midpoint, one unit above/below it, the midpoint with digits appended just past the rounding boundary, and the midpoint truncated at several digit counts around 17-30, in all three JSON number notations, with 30% negative. Both scripts round with exact rational arithmetic and cross-check against Python's float().

Public API

No breaking changes. Everything added or removed is in nlohmann::detail. Parsed values are unchanged wherever the previous conversion was correctly rounded; they change only where it was not (a locale with a multi-byte decimal point, or a C library whose strtod is not correctly rounded). No change to dump() or any other output.

Fixes #5660.

---

Written by Claude Code.

🤖 Generated with Claude Code

[gregmarr]

A couple minor questions about alternate methods/functions, and a minor comment question, nothing required.
I did not do a deep review of the float conversion algorithms, will leave that to the tests.