Guard <charconv> include with __has_include for GCC 7

GCC 7 sets __cplusplus to the C++17 value under -std=gnu++1z, so
JSON_HAS_CPP_17 is defined, but its libstdc++ ships no <charconv> header
(added in GCC 8; floating-point from_chars in GCC 11). The unconditional
"#if defined(JSON_HAS_CPP_17) #include <charconv>" therefore failed to
compile there: "fatal error: charconv: No such file or directory" in the
ci_test_compilers_gcc (7) job.

Wrap the include in __has_include(<charconv>), mirroring the library's
existing handling of <version> and <filesystem> in macro_scope.hpp. When
the header is absent, __cpp_lib_to_chars stays undefined and
parse_float_from_chars() takes its scalar fallback, so the from_chars use
site (already gated on __cpp_lib_to_chars) is never reached. GCC 8-10,
which have <charconv> but no floating-point from_chars, are unaffected:
they include the header but still take the fallback. GCC 11+ is unchanged.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AXcDtEma2PjxgmPS9cQGzA
Signed-off-by: Niels Lohmann <mail@nlohmann.me>

include/nlohmann/detail/input/input_adapters.hpp

@@ -658,7 +658,7 @@ typename container_input_adapter_factory_impl::container_input_adapter_factory<C
 // iterators it replaces did.
 template < typename ContainerType,
            enable_if_t < is_contiguous_byte_container<ContainerType>::value, int > = 0 >
-auto input_adapter(ContainerType && container)
+auto input_adapter(const ContainerType& container)
 -> decltype(input_adapter(container.data(), container.data() + container.size()))
 {
     return input_adapter(container.data(), container.data() + container.size());

include/nlohmann/detail/input/lexer.hpp

@@ -1382,8 +1382,14 @@ scan_number_done:
         }
 
         // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. Try the exact fast path (double
-        // only) before falling back to the locale-independent strtof/strtod.
+        // 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.
+        if (parse_float_from_chars(num_begin, num_end, value_float))
+        {
+            return token_type::value_float;
+        }
         if (parse_float_fast(num_begin, num_end, decimal_point_char, value_float))
         {
             return token_type::value_float;

include/nlohmann/detail/input/number_parse.hpp

@@ -9,12 +9,24 @@
 #pragma once
 
 #include <array> // array
+#include <cfloat> // FLT_EVAL_METHOD
 #include <cstddef> // size_t
 #include <cstdint> // int64_t, uint64_t
 #include <limits> // numeric_limits
 
 #include <nlohmann/detail/macro_scope.hpp>
 
+// std::from_chars lives in <charconv>, but being in C++17 mode does not
+// guarantee the header exists: GCC 7 sets __cplusplus to C++17 yet ships no
+// <charconv> (added in GCC 8; floating-point support in GCC 11). Guard the
+// include with __has_include so such toolchains fall back to the scalar path.
+#if defined(JSON_HAS_CPP_17) && defined(__has_include)
+    #if __has_include(<charconv>)
+        #include <charconv> // from_chars (only used when __cpp_lib_to_chars is defined)
+        #include <system_error> // errc
+    #endif
+#endif
+
 // This file contains the value-conversion helpers used by the lexer to turn an
 // already-validated number token into a value, without the locale/errno
 // overhead of std::strtoull/std::strtod. They are free functions so the lexer
@@ -54,7 +66,7 @@ bool parse_integer_unsigned(const char* first, const char* last, NumberUnsignedT
         {
             return false;
         }
-        x = x * 10u + digit;
+        x = (x * 10u) + digit;
     }
     value = static_cast<NumberUnsignedType>(x);
     // reject values that do not round-trip into a narrower NumberUnsignedType
@@ -84,7 +96,7 @@ bool parse_integer_signed(const char* first, const char* last, NumberIntegerType
         {
             return false;
         }
-        magnitude = magnitude * 10u + digit;
+        magnitude = (magnitude * 10u) + digit;
     }
     const std::int64_t x = (magnitude == limit)
                            ? (std::numeric_limits<std::int64_t>::min)()
@@ -115,6 +127,19 @@ below).
 template<typename DecimalPointType>
 bool parse_float_fast(const char* first, const char* last, DecimalPointType decimal_point, double& out) noexcept
 {
+#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
+    // Clinger's fast path is only exact when double operations are evaluated in
+    // true double precision. On platforms that keep intermediates in extended
+    // precision (e.g. the x87 FPU on 32-bit x86, where FLT_EVAL_METHOD == 2) the
+    // single significand * 10^scale step is double-rounded and can be 1 ULP off,
+    // so decline and let the caller fall back to the correctly-rounded
+    // std::from_chars / std::strtod path.
+    static_cast<void>(first);
+    static_cast<void>(last);
+    static_cast<void>(decimal_point);
+    static_cast<void>(out);
+    return false;
+#else
     static const std::array<double, 23> powers_of_ten =
     {
         {
@@ -146,7 +171,7 @@ bool parse_float_fast(const char* first, const char* last, DecimalPointType deci
             {
                 return false; // significand may not fit into uint64_t
             }
-            significand = significand * 10u + static_cast<std::uint64_t>(c - '0');
+            significand = (significand * 10u) + static_cast<std::uint64_t>(c - '0');
             ++num_digits;
             fractional_digits += static_cast<int>(seen_dot);
         }
@@ -189,7 +214,7 @@ bool parse_float_fast(const char* first, const char* last, DecimalPointType deci
             {
                 return false;
             }
-            exponent = exponent * 10 + (*p - '0');
+            exponent = (exponent * 10) + (*p - '0');
             any_exp_digit = true;
             if (JSON_HEDLEY_UNLIKELY(exponent > 9999))
             {
@@ -231,6 +256,7 @@ bool parse_float_fast(const char* first, const char* last, DecimalPointType deci
     }
     out = negative ? -result : result;
     return true;
+#endif
 }
 
 /// fast float path is only exact for `double`; decline for float/long double
@@ -240,5 +266,37 @@ bool parse_float_fast(const char* /*first*/, const char* /*last*/, DecimalPointT
     return false;
 }
 
+/*!
+@brief parse a float with std::from_chars (Eisel-Lemire) when available
+
+std::from_chars is locale-independent, correctly rounded, and - via the
+Eisel-Lemire algorithm in modern standard libraries - much faster than strtod
+over the whole value range (not just the Clinger subset). It is used only when
+__cpp_lib_to_chars indicates full floating-point support and only when it
+consumes the entire token ([first, last)); a partial parse means the buffer
+uses a non-'.' locale decimal point, in which case the caller falls back to the
+locale-aware path. An under-/overflow (result_out_of_range) also declines, so
+the caller's strtod fallback supplies the well-defined ±inf/0 result the parser
+expects (side-stepping the P4168 divergence between implementations).
+
+@return true if the value was parsed exactly and fully; false to fall back
+*/
+template<typename FloatType>
+bool parse_float_from_chars(const char* first, const char* last, FloatType& out) noexcept
+{
+    // JSON_HAS_CPP_17 must gate the use as well as the <charconv> include above:
+    // some standard libraries (e.g. libstdc++ 15) define __cpp_lib_to_chars even
+    // in C++14 mode, where <charconv> is not included.
+#if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars)
+    const auto result = std::from_chars(first, last, out);
+    return result.ec == std::errc() && result.ptr == last;
+#else
+    static_cast<void>(first);
+    static_cast<void>(last);
+    static_cast<void>(out);
+    return false;
+#endif
+}
+
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

single_include/nlohmann/json.hpp

@@ -7645,7 +7645,7 @@ typename container_input_adapter_factory_impl::container_input_adapter_factory<C
 // iterators it replaces did.
 template < typename ContainerType,
            enable_if_t < is_contiguous_byte_container<ContainerType>::value, int > = 0 >
-auto input_adapter(ContainerType && container)
+auto input_adapter(const ContainerType& container)
 -> decltype(input_adapter(container.data(), container.data() + container.size()))
 {
     return input_adapter(container.data(), container.data() + container.size());
@@ -7791,6 +7791,7 @@ NLOHMANN_JSON_NAMESPACE_END
 
 
 #include <array> // array
+#include <cfloat> // FLT_EVAL_METHOD
 #include <cstddef> // size_t
 #include <cstdint> // int64_t, uint64_t
 #include <limits> // numeric_limits
@@ -7798,6 +7799,17 @@ NLOHMANN_JSON_NAMESPACE_END
 // #include <nlohmann/detail/macro_scope.hpp>
 
 
+// std::from_chars lives in <charconv>, but being in C++17 mode does not
+// guarantee the header exists: GCC 7 sets __cplusplus to C++17 yet ships no
+// <charconv> (added in GCC 8; floating-point support in GCC 11). Guard the
+// include with __has_include so such toolchains fall back to the scalar path.
+#if defined(JSON_HAS_CPP_17) && defined(__has_include)
+    #if __has_include(<charconv>)
+        #include <charconv> // from_chars (only used when __cpp_lib_to_chars is defined)
+        #include <system_error> // errc
+    #endif
+#endif
+
 // This file contains the value-conversion helpers used by the lexer to turn an
 // already-validated number token into a value, without the locale/errno
 // overhead of std::strtoull/std::strtod. They are free functions so the lexer
@@ -7837,7 +7849,7 @@ bool parse_integer_unsigned(const char* first, const char* last, NumberUnsignedT
         {
             return false;
         }
-        x = x * 10u + digit;
+        x = (x * 10u) + digit;
     }
     value = static_cast<NumberUnsignedType>(x);
     // reject values that do not round-trip into a narrower NumberUnsignedType
@@ -7867,7 +7879,7 @@ bool parse_integer_signed(const char* first, const char* last, NumberIntegerType
         {
             return false;
         }
-        magnitude = magnitude * 10u + digit;
+        magnitude = (magnitude * 10u) + digit;
     }
     const std::int64_t x = (magnitude == limit)
                            ? (std::numeric_limits<std::int64_t>::min)()
@@ -7898,6 +7910,19 @@ below).
 template<typename DecimalPointType>
 bool parse_float_fast(const char* first, const char* last, DecimalPointType decimal_point, double& out) noexcept
 {
+#if defined(FLT_EVAL_METHOD) && FLT_EVAL_METHOD != 0
+    // Clinger's fast path is only exact when double operations are evaluated in
+    // true double precision. On platforms that keep intermediates in extended
+    // precision (e.g. the x87 FPU on 32-bit x86, where FLT_EVAL_METHOD == 2) the
+    // single significand * 10^scale step is double-rounded and can be 1 ULP off,
+    // so decline and let the caller fall back to the correctly-rounded
+    // std::from_chars / std::strtod path.
+    static_cast<void>(first);
+    static_cast<void>(last);
+    static_cast<void>(decimal_point);
+    static_cast<void>(out);
+    return false;
+#else
     static const std::array<double, 23> powers_of_ten =
     {
         {
@@ -7929,7 +7954,7 @@ bool parse_float_fast(const char* first, const char* last, DecimalPointType deci
             {
                 return false; // significand may not fit into uint64_t
             }
-            significand = significand * 10u + static_cast<std::uint64_t>(c - '0');
+            significand = (significand * 10u) + static_cast<std::uint64_t>(c - '0');
             ++num_digits;
             fractional_digits += static_cast<int>(seen_dot);
         }
@@ -7972,7 +7997,7 @@ bool parse_float_fast(const char* first, const char* last, DecimalPointType deci
             {
                 return false;
             }
-            exponent = exponent * 10 + (*p - '0');
+            exponent = (exponent * 10) + (*p - '0');
             any_exp_digit = true;
             if (JSON_HEDLEY_UNLIKELY(exponent > 9999))
             {
@@ -8014,6 +8039,7 @@ bool parse_float_fast(const char* first, const char* last, DecimalPointType deci
     }
     out = negative ? -result : result;
     return true;
+#endif
 }
 
 /// fast float path is only exact for `double`; decline for float/long double
@@ -8023,6 +8049,38 @@ bool parse_float_fast(const char* /*first*/, const char* /*last*/, DecimalPointT
     return false;
 }
 
+/*!
+@brief parse a float with std::from_chars (Eisel-Lemire) when available
+
+std::from_chars is locale-independent, correctly rounded, and - via the
+Eisel-Lemire algorithm in modern standard libraries - much faster than strtod
+over the whole value range (not just the Clinger subset). It is used only when
+__cpp_lib_to_chars indicates full floating-point support and only when it
+consumes the entire token ([first, last)); a partial parse means the buffer
+uses a non-'.' locale decimal point, in which case the caller falls back to the
+locale-aware path. An under-/overflow (result_out_of_range) also declines, so
+the caller's strtod fallback supplies the well-defined ±inf/0 result the parser
+expects (side-stepping the P4168 divergence between implementations).
+
+@return true if the value was parsed exactly and fully; false to fall back
+*/
+template<typename FloatType>
+bool parse_float_from_chars(const char* first, const char* last, FloatType& out) noexcept
+{
+    // JSON_HAS_CPP_17 must gate the use as well as the <charconv> include above:
+    // some standard libraries (e.g. libstdc++ 15) define __cpp_lib_to_chars even
+    // in C++14 mode, where <charconv> is not included.
+#if defined(JSON_HAS_CPP_17) && defined(__cpp_lib_to_chars)
+    const auto result = std::from_chars(first, last, out);
+    return result.ec == std::errc() && result.ptr == last;
+#else
+    static_cast<void>(first);
+    static_cast<void>(last);
+    static_cast<void>(out);
+    return false;
+#endif
+}
+
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
@@ -9630,8 +9688,14 @@ scan_number_done:
         }
 
         // this code is reached if we parse a floating-point number or if an
-        // integer conversion above overflowed. Try the exact fast path (double
-        // only) before falling back to the locale-independent strtof/strtod.
+        // 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.
+        if (parse_float_from_chars(num_begin, num_end, value_float))
+        {
+            return token_type::value_float;
+        }
         if (parse_float_fast(num_begin, num_end, decimal_point_char, value_float))
         {
             return token_type::value_float;

tests/src/unit-class_lexer.cpp

@@ -249,7 +249,11 @@ TEST_CASE("lexer number fast path")
             "-9223372036854775808",            // INT64_MIN -> integer
             "-9223372036854775809",            // INT64_MIN - 1 -> float
             "123456789012345678901234567890",  // huge -> float
-            "0.30000000000000004", "2.2250738585072014e-308", "1e308"
+            "0.30000000000000004", "2.2250738585072014e-308", "1e308",
+            // high-precision / wide-exponent values that exercise the
+            // std::from_chars (Eisel-Lemire) path beyond the Clinger subset
+            "1.7976931348623157e308", "1.2345678901234567e-250",
+            "9007199254740993", "5e-324", "1e-320"
         };
 
         for (const auto& n : numbers)