Use standard library helpers where available, with C++11 fallbacks

Add detail helpers that call the standard library function when the
library provides it (checked with the __cpp_lib_* feature-test macros, so
no new ABI-tag macros) and a C++11 implementation otherwise:

- detail::clamp (std::clamp): by value, so that static constexpr members
  need no out-of-line definition before C++17; used in json_view's dump()
  buffer sizing, where step() can now be a static constexpr member.
- detail::bit_cast (std::bit_cast): replaces dtoa_impl::reinterpret_bits
  and the memcpy bit copies in the number parser, to_chars, the json_view
  serializer, and binary_writer::to_char_type.
- detail::byteswap (std::byteswap): one implementation instead of the
  binary writer's own byte_swap() overloads and the bswap chain in
  to_chars' store_msb_first().
- count_leading_zeros/count_trailing_zeros: two 32-bit _BitScanReverse/
  _BitScanForward calls for MSVC x86/ARM32 instead of the loop, and
  std::countl_zero/countr_zero for compilers without builtins.
- conjunction, disjunction, negation, bool_constant, and uncvref_t map to
  their std counterparts in C++17/C++20.

Builtins and intrinsics stay ahead of the <bit> functions, as MSVC's
std::countl_zero checks for LZCNT at run time unless AVX2 is enabled.

The generated code is unchanged with Clang (C++11/20/23, arm64 and
x86-64) and GCC 16 for parsing, dumping, and the binary formats. The
binary reader keeps its own byte_swap() and the writer its memcpy calls:
the smaller code from detail::byteswap/std::bit_cast there made GCC 16
inline get_number()/write_number() differently, which slowed reading by
10-18 % and writing by about 1 %.

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

.github/CONTRIBUTING.md

@@ -111,8 +111,6 @@ context which existing file needs to be extended, and only very few cases requir
 When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue.
 `unit-regression2.cpp` holds the older tests; the two files exist because a single one grew large enough for the
 MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing the larger one.
-Tests that call `sax_parse` go into `unit-sax_parse.cpp` rather than into a large test file: every call instantiates
-the parser and the binary reader that recover from errors, which grows a test file considerably.
 
 #### Exceptions
 

README.md

@@ -495,7 +495,7 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const detail::exception& ex);
 ```
 
-The return value of each function determines whether parsing should proceed. For `parse_error`, returning `true` [recovers from the error](https://json.nlohmann.me/features/parsing/error_recovery/): the parser repairs the input and continues.
+The return value of each function determines whether parsing should proceed.
 
 To implement your own SAX handler, proceed as follows:
 
@@ -503,7 +503,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `bool json::sax_parse(input, &my_sax)`; where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.
 
-Note the `sax_parse` function only returns a `bool` indicating whether the input was parsed without errors and no SAX event returned `false`. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).
+Note the `sax_parse` function only returns a `bool` indicating the result of the last executed SAX event. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).
 
 ### STL-like access
 

docs/mkdocs/docs/api/basic_json/sax_parse.md

@@ -96,9 +96,7 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
 
 ## Return value
 
-`#!cpp true` if the input was parsed without errors and no SAX event returned `#!cpp false`; `#!cpp false` otherwise.
-In particular, the result is `#!cpp false` for input with errors, even if the SAX parser recovered from all of them
-(see [error recovery](../../features/parsing/error_recovery.md)).
+return value of the last processed SAX event
 
 ## Exception safety
 
@@ -155,7 +153,6 @@ use the same file with stdio functions, but it must not wait for another thread
 - Added `ignore_trailing_commas` in version 3.13.0.
 - Added `tag_handler` in version 3.13.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
-- Recovering from parse errors (see [`parse_error`](../json_sax/parse_error.md)) added in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave a `#!cpp std::istream` positioned right
   after the parsed value when `strict` is `#!cpp false`.

docs/mkdocs/docs/api/json_sax/index.md

@@ -7,8 +7,7 @@ struct json_sax;
 
 This class describes the SAX interface used by [sax_parse](../basic_json/sax_parse.md). Each function is called in
 different situations while the input is parsed. The boolean return value informs the parser whether to continue
-processing the input; for [`parse_error`](parse_error.md), it decides whether to
-[recover from the error](../../features/parsing/error_recovery.md).
+processing the input.
 
 For instance, parsing the JSON text `{"a": [1, true]}` triggers the following callbacks, in order:
 

docs/mkdocs/docs/api/json_sax/parse_error.md

@@ -21,18 +21,11 @@ A parse error occurred.
 
 ## Return value
 
-Whether to recover from the error:
-
-- `#!cpp false` stops parsing.
-- `#!cpp true` recovers from the error: the error is repaired and parsing continues. If that is not possible, which
-  happens in the binary formats when the end of the item with the error is unknown, the value read so far is completed
-  and parsing stops. See [error recovery](../../features/parsing/error_recovery.md) for how errors are repaired.
-
-Either way, [`sax_parse`](../basic_json/sax_parse.md) returns `#!cpp false`.
+Whether parsing should proceed (**must return `#!cpp false`**).
 
 ## Examples
 
-??? example "Example: (1) the SAX interface"
+??? example
 
     The example below shows how the SAX interface is used.
 
@@ -46,29 +39,12 @@ Either way, [`sax_parse`](../basic_json/sax_parse.md) returns `#!cpp false`.
     --8<-- "examples/sax_parse.output"
     ```
 
-??? example "Example: (2) recovering from errors"
-
-    The example below shows how a SAX parser recovers from errors.
-
-    ```cpp
-    --8<-- "examples/sax_parse__error_recovery.cpp"
-    ```
-    
-    Output:
-    
-    ```
-    --8<-- "examples/sax_parse__error_recovery.output"
-    ```
-
 ## See also
 
 - [sax_parse](../basic_json/sax_parse.md) - SAX parser
 - [Parsing and Exceptions](../../features/parsing/parse_exceptions.md) - the article on handling parse errors without
   exceptions
-- [Error Recovery](../../features/parsing/error_recovery.md) - the article on recovering from parse errors
 
 ## Version history
 
 - Added in version 3.2.0.
-- Returning `#!cpp true` recovers from the error since version 3.13.0; before, parsing stopped, but the result of
-  [`sax_parse`](../basic_json/sax_parse.md) could be wrong.

docs/mkdocs/docs/examples/sax_parse__error_recovery.cpp

@@ -1,43 +0,0 @@
-#include <iostream>
-#include <iomanip>
-#include <nlohmann/json.hpp>
-
-using json = nlohmann::json;
-
-// a SAX parser that creates a JSON value like json::parse does, but that
-// recovers from parse errors instead of stopping at the first one
-class recovering_parser : public nlohmann::detail::json_sax_dom_parser<json>
-{
-  public:
-    explicit recovering_parser(json& result)
-        : nlohmann::detail::json_sax_dom_parser<json>(result, false)
-    {}
-
-    bool parse_error(std::size_t position,
-                     const std::string& /*last_token*/,
-                     const json::exception& ex)
-    {
-        std::cout << "byte " << position << ": " << ex.what() << '\n';
-
-        // repair the input and continue
-        return true;
-    }
-};
-
-int main()
-{
-    // JSON text with several mistakes that ends too early
-    const std::string text = R"({
-    "name": "Hello World",
-    "tags": ["a" "b",],
-    "valid": tru,
-    "size": 1.,
-    "nested": {"x": 1)";
-
-    json result;
-    recovering_parser sax(result);
-    const bool valid = json::sax_parse(text, &sax);
-
-    std::cout << "\nvalid JSON: " << std::boolalpha << valid << '\n'
-              << std::setw(4) << result << std::endl;
-}

docs/mkdocs/docs/examples/sax_parse__error_recovery.output

@@ -1,19 +0,0 @@
-byte 49: [json.exception.parse_error.101] parse error at line 3, column 20: syntax error while parsing array - unexpected string literal; expected ']'
-byte 51: [json.exception.parse_error.101] parse error at line 3, column 22: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal
-byte 70: [json.exception.parse_error.101] parse error at line 4, column 17: syntax error while parsing value - invalid literal; last read: '"valid": tru,'
-byte 86: [json.exception.parse_error.101] parse error at line 5, column 15: syntax error while parsing value - invalid number; expected digit after '.'; last read: '1.,'
-byte 109: [json.exception.parse_error.101] parse error at line 6, column 22: syntax error while parsing object - unexpected end of input; expected '}'
-
-valid JSON: false
-{
-    "name": "Hello World",
-    "nested": {
-        "x": 1
-    },
-    "size": 1,
-    "tags": [
-        "a",
-        "b"
-    ],
-    "valid": null
-}

docs/mkdocs/docs/features/parsing/error_recovery.md

@@ -1,122 +0,0 @@
-# Error Recovery
-
-By default, parsing stops at the first error. With the [SAX interface](sax_interface.md), you can instead ask the
-parser to *recover*: to repair the error and continue, so that you get as much as possible out of malformed input, for
-instance a file that was cut off, JSON edited by hand, or the output of a language model.
-
-## Recovering from errors
-
-The SAX parser's [`parse_error`](../../api/json_sax/parse_error.md) function is called for every error. Its return value
-decides what happens next:
-
-- `#!cpp false` stops parsing. This is what the SAX parsers of the library do, so [`parse`](../../api/basic_json/parse.md)
-  and [`accept`](../../api/basic_json/accept.md) never recover.
-- `#!cpp true` repairs the error and continues parsing.
-
-When recovering, the SAX parser still receives well-formed events: every `start_object` or `start_array` is followed by
-the matching `end_object` or `end_array`, and every `key` is followed by exactly one value. A SAX parser that creates a
-JSON value, such as the one in the example below, therefore gets a complete value. Parsing always ends, and
-[`sax_parse`](../../api/basic_json/sax_parse.md) returns `#!cpp false` for input that is not valid JSON, even if every
-error was repaired. Each token is reported at most once, and the SAX parser can stop at any error by returning
-`#!cpp false`.
-
-!!! example
-
-    The example below derives a SAX parser from the library's parser for `json` values (`json_sax_dom_parser`),
-    and recovers from all errors.
-
-    ```cpp
-    --8<-- "examples/sax_parse__error_recovery.cpp"
-    ```
-    
-    Output:
-    
-    ```
-    --8<-- "examples/sax_parse__error_recovery.output"
-    ```
-
-## How errors are repaired
-
-Each error is repaired with the smallest local edit: a missing separator is inserted, a stray token is removed, what can
-be read of a broken string or number is kept, and a value that cannot be read at all becomes `#!json null`.
-
-| Mistake                   | Repair                                                                         | Example                                  | Result                     |
-|---------------------------|--------------------------------------------------------------------------------|------------------------------------------|----------------------------|
-| missing `,` or `:`        | inserted                                                                       | `#!json [1 2]`, `#!json {"a" 1}`         | `[1,2]`, `{"a":1}`         |
-| missing value             | `#!json null` for an object key or between commas in an array                  | `#!json {"a":}`, `#!json [1,,2]`         | `{"a":null}`, `[1,null,2]` |
-| trailing comma            | removed                                                                        | `#!json [1,2,]`                          | `[1,2]`                    |
-| broken string             | invalid escapes and bytes are replaced (see below); a line break ends the string | `#!json ["a\qb"]`                        | `["aqb"]`                  |
-| broken number             | the longest valid beginning is kept                                            | `#!json [1., 2e+]`                       | `[1,2]`                    |
-| unreadable value          | `#!json null`                                                                  | `#!json [1, NaN, tru]`                   | `[1,null,null]`            |
-| number too large          | passed as infinity, together with its text                                     | `#!json [1e999]`                         | infinity (see below)       |
-| stray `:`                 | removed                                                                        | `#!json ["a":1]`                         | `["a",1]`                  |
-| member without a key      | skipped up to the next `,` or `}`                                              | `#!json {1:2, "b":3}`                    | `{"b":3}`                  |
-| wrong closing bracket     | closes the innermost array or object                                           | `#!json {"a":[1,2}, "b":3}`              | `{"a":[1,2],"b":3}`        |
-| input ends too early      | all open arrays and objects are closed                                         | `#!json {"a":[1,2`                       | `{"a":[1,2]}`              |
-| text before the value     | skipped                                                                        | `#!json )]}'{"a":1}`                     | `{"a":1}`                  |
-
-In a string, an unknown escape like `\q` stands for the escaped character (`q`), as in JavaScript. An invalid `\u`
-escape, a lone surrogate, and ill-formed UTF-8 are each replaced by U+FFFD (REPLACEMENT CHARACTER), and control
-characters are kept. A string without its closing quote ends at the next line break or at the end of the input.
-
-The input after the top-level value is not repaired: as without recovery, it is reported as an error, and parsing stops.
-
-## Binary formats
-
-The binary formats ([BJData](../binary_formats/bjdata.md), [BON8](../binary_formats/bon8.md),
-[BSON](../binary_formats/bson.md), [CBOR](../binary_formats/cbor.md), [MessagePack](../binary_formats/messagepack.md),
-and [UBJSON](../binary_formats/ubjson.md)) have no delimiters to find the next value by. So what can be repaired depends
-on whether the end of the item with the error is known, a distinction that
-[RFC 8949, Section 5.3](https://www.rfc-editor.org/rfc/rfc8949.html#section-5.3) makes for CBOR, too.
-
-If the item is complete, but cannot be passed on as it is, it is replaced, and parsing continues after it:
-
-| Mistake                                                             | Formats                 | Repair                                                                  |
-|---------------------------------------------------------------------|-------------------------|-------------------------------------------------------------------------|
-| tag, if `tag_handler` is `cbor_tag_handler_t::error` (the default)  | CBOR                    | ignored                                                                 |
-| simple value other than `false`, `true`, and `null`, like undefined | CBOR                    | `#!json null`                                                           |
-| number too large for a custom `number_float_t`, like `float`        | all                     | infinity                                                                |
-| character (`C`) that is not ASCII                                   | BJData, UBJSON          | U+FFFD                                                                  |
-| invalid high-precision number (`H`)                                 | BJData, UBJSON          | the longest valid beginning is kept, as for JSON text, or `#!json null` |
-| high-precision number too large                                     | BJData, UBJSON          | passed as infinity, together with its text                              |
-| object key that is not a string                                     | BON8, CBOR, MessagePack | the member is skipped                                                   |
-| element of a type the library does not read, like ObjectId or date  | BSON                    | `#!json null`                                                           |
-| string without its terminator                                       | BSON                    | kept                                                                    |
-| document whose size does not match its content                      | BSON                    | kept                                                                    |
-
-CBOR tags and simple values are repaired as [RFC 8949, Section 6.1](https://www.rfc-editor.org/rfc/rfc8949.html#section-6.1)
-suggests for converting CBOR to JSON. By default, [`sax_parse`](../../api/basic_json/sax_parse.md) reports every tag as
-an error; when recovering, tags are then ignored like with
-[`cbor_tag_handler_t::ignore`](../../api/basic_json/cbor_tag_handler_t.md). Strings that are not valid UTF-8 are no
-error: like [`from_cbor`](../../api/basic_json/from_cbor.md) and the other functions by default, `sax_parse` passes
-them on as they are.
-
-After any other error, the end of the item is unknown: the input ended, a byte is not a valid type marker, or a size
-cannot be right. Parsing then stops, and the value read so far is completed: a key that waits for its value gets
-`#!json null`, and all open arrays and objects are closed. This keeps everything before the error of an input that was
-cut off. The exception is BSON, which stores the size of every document: an element whose end is unknown gets
-`#!json null`, the rest of its document is skipped, and parsing continues after the document.
-
-## Limitations
-
-- A repair is a guess. For example, `#!json {"a" "b": 1}` could be meant as `#!json {"a": "b"}` or as
-  `#!json {"a": null, "b": 1}`; it is repaired to the former. Treat recovered values as a best effort, and check the
-  reported errors.
-- A closing bracket always closes the innermost array or object. If a bracket is missing rather than wrong, the
-  repair differs from the intention: `#!json {"a": {"b": [1, 2}, "c": 3}` is repaired to
-  `#!json {"a": {"b": [1, 2], "c": 3}}`, although `#!json {"a": {"b": [1, 2]}, "c": 3}` may have been meant.
-- Keys without quotes, and strings in single quotes, are not supported; such members are skipped.
-- In the binary formats, a member that is skipped because its key is not a string is lost, and so are the elements of a
-  BSON document after one whose end is unknown.
-- A number that is too large for `number_float_t` is passed as positive or negative infinity. The SAX parser's
-  `number_float` also gets the number's text, but a JSON value cannot store it, and
-  [`dump`](../../api/basic_json/dump.md) serializes infinity as `#!json null`.
-- When parsing is not strict (see [`sax_parse`](../../api/basic_json/sax_parse.md)), a repair may read parts of the
-  input after the value, for instance of the next value in a stream of concatenated values.
-
-## See also
-
-- [SAX interface](sax_interface.md) - implement a custom SAX handler
-- [`parse_error`](../../api/json_sax/parse_error.md) - the SAX event for parse errors
-- [`sax_parse`](../../api/basic_json/sax_parse.md) - generate SAX events
-- [parsing and exceptions](parse_exceptions.md) - control error handling

docs/mkdocs/docs/features/parsing/index.md

@@ -99,7 +99,7 @@ You can influence a DOM parse without switching to the SAX interface by passing
 When the input is not valid JSON, the `parse` function throws an exception by default. If exceptions are undesired or
 unavailable, the parser can instead return a discarded value, or [`accept`](../../api/basic_json/accept.md) can be used
 to only check whether an input is valid JSON. See [parsing and exceptions](parse_exceptions.md) for the available
-options. To get as much as possible out of malformed input, a SAX parser can [recover from errors](error_recovery.md).
+options.
 
 ## See also
 
@@ -110,5 +110,4 @@ options. To get as much as possible out of malformed input, a SAX parser can [re
 - [parser callbacks](parser_callbacks.md) - influence the parsing by a callback function
 - [SAX interface](sax_interface.md) - implement a custom SAX handler
 - [parsing and exceptions](parse_exceptions.md) - control error handling
-- [error recovery](error_recovery.md) - get as much as possible out of malformed input
 - [parsing untrusted input](untrusted_input.md) - what to consider when parsing input from untrusted sources

docs/mkdocs/docs/features/parsing/parse_exceptions.md

@@ -64,8 +64,7 @@ bool parse_error(std::size_t position,
                  const json::exception& ex);
 ```
 
-The return value decides whether to stop parsing (`#!cpp false`) or to repair the error and continue
-(`#!cpp true`); see [error recovery](error_recovery.md) for the latter.
+The return value indicates whether the parsing should continue, so the function should usually return `#!cpp false`.
 
 ??? example "Example: report parse errors without exceptions"
 

docs/mkdocs/docs/features/parsing/sax_interface.md

@@ -60,8 +60,7 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex);
 ```
 
-The return value of each function determines whether parsing should proceed. For `parse_error`, returning
-`#!cpp true` [recovers from the error](error_recovery.md).
+The return value of each function determines whether parsing should proceed.
 
 To implement your own SAX handler, proceed as follows:
 
@@ -69,7 +68,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `#!cpp bool json::sax_parse(input, &my_sax);` where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.
 
-Note the `sax_parse` function only returns a `#!cpp bool` indicating whether the input was parsed without errors and no SAX event returned `#!cpp false`. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.
+Note the `sax_parse` function only returns a `#!cpp bool` indicating the result of the last executed SAX event. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.
 
 ## See also
 

docs/mkdocs/mkdocs.yml

@@ -88,7 +88,6 @@ nav:
       - features/performance.md
       - Parsing:
           - features/parsing/index.md
-          - features/parsing/error_recovery.md
           - features/parsing/json_lines.md
           - features/parsing/parse_exceptions.md
           - features/parsing/parser_callbacks.md

include/nlohmann/detail/bit_ops.hpp

@@ -14,11 +14,24 @@
     #include <intrin0.h> // __umulh, _umul128, _BitScanForward64, _BitScanReverse64
 #endif
 
+#ifdef _MSC_VER
+    #include <cstdlib> // _byteswap_ushort, _byteswap_ulong, _byteswap_uint64
+#endif
+#if defined(_MSC_VER) && !defined(__clang__) && (defined(_M_IX86) || defined(_M_ARM))
+    #include <intrin.h> // _BitScanForward, _BitScanReverse
+#endif
+
 #include <nlohmann/detail/macro_scope.hpp> // JSON_HEDLEY_ALWAYS_INLINE, NLOHMANN_JSON_NAMESPACE_BEGIN
 
+#if defined(__cpp_lib_bit_cast) || defined(__cpp_lib_bitops) || defined(__cpp_lib_byteswap)
+    #include <bit> // bit_cast, byteswap, countl_zero, countr_zero
+#endif
+
 // Portable bit-level helpers for the number and string scanners. They use
-// compiler builtins or platform-specific intrinsics where available and plain
-// C++ otherwise, so they work regardless of byte order.
+// compiler builtins or platform-specific intrinsics where available, the
+// C++20 <bit> functions next, and plain C++ otherwise, so they work regardless
+// of byte order. (The builtins and intrinsics come first: MSVC's
+// std::countl_zero checks for LZCNT at run time unless AVX2 is enabled.)
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -33,6 +46,16 @@ inline int count_leading_zeros(std::uint64_t x) noexcept
     unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
     _BitScanReverse64(&index, x);
     return 63 - static_cast<int>(index);
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_ARM))
+    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan* takes
+    if (_BitScanReverse(&index, static_cast<unsigned long>(x >> 32u))) // NOLINT(runtime/int)
+    {
+        return 31 - static_cast<int>(index);
+    }
+    _BitScanReverse(&index, static_cast<unsigned long>(x)); // NOLINT(runtime/int)
+    return 63 - static_cast<int>(index);
+#elif defined(__cpp_lib_bitops)
+    return std::countl_zero(x);
 #else
     int n = 0;
     for (int shift = 32; shift != 0; shift >>= 1)
@@ -56,6 +79,16 @@ inline int count_trailing_zeros(std::uint64_t x) noexcept
     unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan*64 takes
     _BitScanForward64(&index, x);
     return static_cast<int>(index);
+#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_ARM))
+    unsigned long index = 0; // NOLINT(runtime/int): the type _BitScan* takes
+    if (_BitScanForward(&index, static_cast<unsigned long>(x))) // NOLINT(runtime/int)
+    {
+        return static_cast<int>(index);
+    }
+    _BitScanForward(&index, static_cast<unsigned long>(x >> 32u)); // NOLINT(runtime/int)
+    return 32 + static_cast<int>(index);
+#elif defined(__cpp_lib_bitops)
+    return std::countr_zero(x);
 #else
     int n = 0;
     for (int shift = 32; shift != 0; shift >>= 1)
@@ -70,6 +103,67 @@ inline int count_trailing_zeros(std::uint64_t x) noexcept
 #endif
 }
 
+/// the object representation of @a from as a @a To (std::bit_cast in C++20)
+template<typename To, typename From>
+JSON_HEDLEY_ALWAYS_INLINE To bit_cast(const From& from) noexcept
+{
+    static_assert(sizeof(To) == sizeof(From), "bit_cast needs types of the same size");
+#if defined(__cpp_lib_bit_cast)
+    return std::bit_cast<To>(from);
+#else
+    To to;
+    std::memcpy(&to, &from, sizeof(To));
+    return to;
+#endif
+}
+
+/// x with its bytes in reverse order (std::byteswap in C++23); compilers lower
+/// it to a single bswap/rev/movbe
+inline std::uint16_t byteswap(std::uint16_t x) noexcept
+{
+#if defined(__GNUC__) || defined(__clang__)
+    return __builtin_bswap16(x);
+#elif defined(_MSC_VER)
+    return _byteswap_ushort(x);
+#elif defined(__cpp_lib_byteswap)
+    return std::byteswap(x);
+#else
+    return static_cast<std::uint16_t>((x >> 8u) | (x << 8u));
+#endif
+}
+
+/// x with its bytes in reverse order (std::byteswap in C++23)
+inline std::uint32_t byteswap(std::uint32_t x) noexcept
+{
+#if defined(__GNUC__) || defined(__clang__)
+    return __builtin_bswap32(x);
+#elif defined(_MSC_VER)
+    return _byteswap_ulong(x);
+#elif defined(__cpp_lib_byteswap)
+    return std::byteswap(x);
+#else
+    return ((x & 0x000000FFu) << 24u) | ((x & 0x0000FF00u) << 8u)
+           | ((x & 0x00FF0000u) >> 8u) | ((x & 0xFF000000u) >> 24u);
+#endif
+}
+
+/// x with its bytes in reverse order (std::byteswap in C++23)
+inline std::uint64_t byteswap(std::uint64_t x) noexcept
+{
+#if defined(__GNUC__) || defined(__clang__)
+    return __builtin_bswap64(x);
+#elif defined(_MSC_VER)
+    return _byteswap_uint64(x);
+#elif defined(__cpp_lib_byteswap)
+    return std::byteswap(x);
+#else
+    x = ((x & 0x00000000FFFFFFFFull) << 32u) | ((x & 0xFFFFFFFF00000000ull) >> 32u);
+    x = ((x & 0x0000FFFF0000FFFFull) << 16u) | ((x & 0xFFFF0000FFFF0000ull) >> 16u);
+    x = ((x & 0x00FF00FF00FF00FFull) << 8u) | ((x & 0xFF00FF00FF00FF00ull) >> 8u);
+    return x;
+#endif
+}
+
 /// the 128-bit product of two 64-bit numbers
 struct uint128_parts
 {

include/nlohmann/detail/conversions/to_chars.hpp

@@ -18,9 +18,6 @@
 #include <limits> // numeric_limits
 #include <type_traits> // conditional
 
-#ifdef _MSC_VER
-    #include <cstdlib> // _byteswap_uint64
-#endif
 
 // SSE2 (every x86-64 CPU) and NEON (every 64-bit Arm CPU) convert the 16
 // digits of a double at once
@@ -37,6 +34,7 @@
     #define JSON_DTOA_NEON 0
 #endif
 
+#include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/conversions/zmij.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
 
@@ -66,16 +64,6 @@ For a detailed description of the algorithm see:
 namespace dtoa_impl
 {
 
-template<typename Target, typename Source>
-Target reinterpret_bits(const Source source)
-{
-    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
-
-    Target target;
-    std::memcpy(&target, &source, sizeof(Source));
-    return target;
-}
-
 struct diyfp // f * 2^e
 {
     static constexpr int kPrecision = 64; // = q
@@ -230,7 +218,7 @@ boundaries compute_boundaries(FloatType value)
 
     using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
 
-    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
+    const auto bits = static_cast<std::uint64_t>(bit_cast<bits_type>(value));
     const std::uint64_t E = bits >> (kPrecision - 1);
     const std::uint64_t F = bits & (kHiddenBit - 1);
 
@@ -1084,14 +1072,11 @@ inline std::uint64_t eight_digit_bytes(std::uint64_t abcdefgh) noexcept
 /// the byte stores once this is inlined)
 inline void store_msb_first(char* p, std::uint64_t v) noexcept
 {
-#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-    v = __builtin_bswap64(v);
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || defined(_MSC_VER) // (MSVC: little-endian on all its targets)
+    v = byteswap(v);
     std::memcpy(p, &v, sizeof(v));
 #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     std::memcpy(p, &v, sizeof(v));
-#elif defined(_MSC_VER) // (little-endian on all its targets)
-    v = _byteswap_uint64(v);
-    std::memcpy(p, &v, sizeof(v));
 #else
     for (unsigned i = 0; i < 8; ++i)
     {
@@ -1462,8 +1447,7 @@ char* write_positive_zmij(char* first, const char* last, FloatType value)
 {
     static_assert(is_binary64<FloatType>::value,
                   "internal error: the conversion of Zmij needs IEEE 754 binary64 numbers");
-    std::uint64_t bits = 0;
-    std::memcpy(&bits, &value, sizeof(bits));
+    const auto bits = bit_cast<std::uint64_t>(value);
     const zmij::shortest_decimal d = zmij::to_shortest(bits);
     if (JSON_HEDLEY_LIKELY(last - first >= 41))
     {

include/nlohmann/detail/input/input_adapters.hpp

@@ -607,22 +607,17 @@ class iterator_input_adapter
         return get_consumed_count() + eof_reads;
     }
 
-    // number of newlines in the consumed range [first_index, last_index); if
-    // there is one, @a line_start is set to the index after the last of them,
-    // otherwise it is left unchanged; only valid when supports_seek
-    std::size_t count_consumed_lines(std::size_t first_index, std::size_t last_index, std::size_t& line_start) const
+    // number of newlines in the consumed range [0, last_index); @a line_start
+    // is set to the index after the last of them (0 if there is none); only
+    // valid when supports_seek
+    std::size_t count_consumed_lines(std::size_t last_index, std::size_t& line_start) const
     {
-        using difference_type = typename std::iterator_traits<IteratorType>::difference_type;
-        const auto from = std::next(begin, static_cast<difference_type>(first_index));
-        const auto to = std::next(from, static_cast<difference_type>(last_index - first_index));
+        const auto to = std::next(begin, static_cast<typename std::iterator_traits<IteratorType>::difference_type>(last_index));
         const auto newline = char_traits<char_type>::to_char_type('\n');
         using reverse_it = std::reverse_iterator<IteratorType>;
-        const auto last_newline = std::find(reverse_it(to), reverse_it(from), newline);
-        if (last_newline.base() != from)
-        {
-            line_start = static_cast<std::size_t>(std::distance(begin, last_newline.base()));
-        }
-        return static_cast<std::size_t>(std::count(from, last_newline.base(), newline));
+        const auto last_newline = std::find(reverse_it(to), reverse_it(begin), newline);
+        line_start = static_cast<std::size_t>(std::distance(begin, last_newline.base()));
+        return static_cast<std::size_t>(std::count(begin, last_newline.base(), newline));
     }
 
     // append the already-consumed characters in the half-open range

include/nlohmann/detail/input/json_sax.hpp

@@ -132,9 +132,7 @@ struct json_sax
     @param[in] position    the position in the input where the error occurs
     @param[in] last_token  the last read token
     @param[in] ex          an exception object describing the error
-    @return whether to recover from the error: false stops parsing; true
-            repairs the error and continues, or, if that is not possible,
-            stops after completing the value read so far
+    @return whether parsing should proceed (must return false)
     */
     virtual bool parse_error(std::size_t position,
                              const std::string& last_token,
@@ -328,12 +326,9 @@ a pointer to the respective array or object for each recursion depth.
 After successful parsing, the value that is passed by reference to the
 constructor contains the parsed value.
 
-@tparam BasicJsonType     the JSON type
-@tparam InputAdapterType  the input adapter of the lexer that can be passed to
-                          the constructor to record diagnostic positions; it
-                          does not matter if no lexer is passed
+@tparam BasicJsonType  the JSON type
 */
-template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type>
+template<typename BasicJsonType, typename InputAdapterType>
 class json_sax_dom_parser
 {
   public:
@@ -557,7 +552,7 @@ class json_sax_dom_parser
     lexer_t* m_lexer_ref = nullptr;
 };
 
-template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type>
+template<typename BasicJsonType, typename InputAdapterType>
 class json_sax_dom_callback_parser
 {
   public:

include/nlohmann/detail/input/number_parse.hpp

@@ -16,7 +16,6 @@
 #include <cstddef> // size_t
 #include <cstdint> // int64_t, uint64_t
 #include <cstdlib> // strtof, strtod, strtold
-#include <cstring> // memcpy
 #include <limits> // numeric_limits
 #include <string> // string
 #include <type_traits> // conditional, integral_constant, is_signed, true_type, false_type
@@ -758,15 +757,14 @@ std::uint64_t digit_comparison(const char* first, const char* last, std::uint64_
 inline void float_from_bits(std::uint64_t bits, double& value) noexcept
 {
     static_assert(sizeof(double) == sizeof(std::uint64_t), "double must have 64 bits");
-    std::memcpy(&value, &bits, sizeof(value));
+    value = bit_cast<double>(bits);
 }
 
 /// the float with the IEEE-754 bits @a bits (the lower 32)
 inline void float_from_bits(std::uint64_t bits, float& value) noexcept
 {
     static_assert(sizeof(float) == sizeof(std::uint32_t), "float must have 32 bits");
-    const auto bits32 = static_cast<std::uint32_t>(bits);
-    std::memcpy(&value, &bits32, sizeof(bits32));
+    value = bit_cast<float>(static_cast<std::uint32_t>(bits));
 }
 
 /// the powers of ten that are exact in binary64 (up to 10^22)

include/nlohmann/detail/input/parser.hpp

@@ -153,59 +153,24 @@ class parser
     bool accept(const bool strict = true)
     {
         json_sax_acceptor<BasicJsonType> sax_acceptor;
-        return sax_parse_impl<false>(&sax_acceptor, strict);
+        return sax_parse(&sax_acceptor, strict);
     }
 
-    /*!
-    @brief public SAX interface
-
-    If the SAX parser's parse_error() returns true, the parser recovers from
-    the error: it repairs the input and continues (see #3989).
-
-    @param[in] sax     the SAX parser
-    @param[in] strict  whether to expect the last token to be EOF
-    @return whether the input was parsed without errors and no SAX event
-            returned false
-    */
     template<typename SAX>
     JSON_HEDLEY_NON_NULL(2)
     bool sax_parse(SAX* sax, const bool strict = true)
-    {
-        return sax_parse_impl<true>(sax, strict);
-    }
-
-  private:
-    /// what sax_parse_internal() does after an object key was expected
-    enum class next_step : std::uint8_t
-    {
-        /// stop parsing
-        stop,
-        /// parse a value that begins with last_token
-        parse_value,
-        /// evaluate the state of the innermost container, which reads
-        /// last_token again
-        evaluate_state
-    };
-
-    template<bool AllowRecovery, typename SAX>
-    JSON_HEDLEY_NON_NULL(2)
-    bool sax_parse_impl(SAX* sax, const bool strict)
     {
         (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
-        const bool result = sax_parse_internal<AllowRecovery>(sax);
+        const bool result = sax_parse_internal(sax);
 
         if (result)
         {
             if (strict)
             {
-                // strict mode: next byte must be EOF; after recovering from an
-                // error, the end of the input may already have been read
-                if (last_token != token_type::end_of_input && get_token() != token_type::end_of_input)
+                // strict mode: next byte must be EOF
+                if (get_token() != token_type::end_of_input)
                 {
-                    // the value is complete, so there is nothing to recover
-                    static_cast<void>(report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr),
-                                                   std::integral_constant<bool, AllowRecovery> {}));
-                    return false;
+                    return syntax_error(*sax, exception_message(token_type::end_of_input, "value"));
                 }
             }
             else
@@ -216,9 +181,10 @@ class parser
             }
         }
 
-        return result && !error_reported;
+        return result;
     }
 
+  private:
     /// the text of the current float token for @a sax (see sax_ignores_number_text)
     template<typename SAX>
     const string_t& number_float_text(SAX* /*sax*/)
@@ -253,7 +219,7 @@ class parser
     template<typename DomSax>
     bool parse_dom(DomSax& sdp, const bool strict)
     {
-        sax_parse_internal<false>(&sdp);
+        sax_parse_internal(&sdp);
 
         if (strict)
         {
@@ -273,20 +239,10 @@ class parser
         return !sdp.is_errored();
     }
 
-    /*!
-    @brief parse a JSON value and pass it to a SAX parser
-
-    @tparam AllowRecovery  whether to recover from an error if the SAX parser's
-                           parse_error() returns true; false for the SAX parsers
-                           of parse() and accept(), which never do, so that no
-                           code for recovering is generated for them
-    */
-    template<bool AllowRecovery, typename SAX>
+    template<typename SAX>
     JSON_HEDLEY_NON_NULL(2)
     bool sax_parse_internal(SAX* sax)
     {
-        const std::integral_constant<bool, AllowRecovery> allow_recovery{};
-
         // stack to remember the hierarchy of structured values we are parsing
         // true = array; false = object
         std::vector<bool> states;
@@ -317,18 +273,10 @@ class parser
                             break;
                         }
 
-                        // remember we are now inside an object
-                        states.push_back(false);
-
-                        // parse key (the steps of parse_key(), which are
-                        // repeated here and below for speed)
+                        // parse key
                         if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                         {
-                            if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
-                            {
-                                return false;
-                            }
-                            continue;
+                            return syntax_error(*sax, exception_message(token_type::value_string, "object key"));
                         }
                         if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string_token())))
                         {
@@ -338,13 +286,12 @@ class parser
                         // parse separator (:)
                         if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                         {
-                            if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
-                            {
-                                return false;
-                            }
-                            continue;
+                            return syntax_error(*sax, exception_message(token_type::name_separator, "object separator"));
                         }
 
+                        // remember we are now inside an object
+                        states.push_back(false);
+
                         // parse values
                         get_token();
                         continue;
@@ -380,11 +327,9 @@ class parser
 
                         if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
                         {
-                            if (!overflow_error(sax, res, allow_recovery))
-                            {
-                                return false;
-                            }
-                            break;
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
                         }
 
                         if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, number_float_text(sax))))
@@ -452,63 +397,16 @@ class parser
                     case token_type::parse_error:
                     {
                         // using "uninitialized" to avoid an "expected" message
-                        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr), allow_recovery))
-                        {
-                            return false;
-                        }
-
-                        // recover: keep what can be read of the token
-                        recover_token(allow_recovery);
-                        if (last_token != token_type::uninitialized)
-                        {
-                            // a string or a number
-                            continue;
-                        }
-                        if (states.empty())
-                        {
-                            // look for the value after the garbage
-                            if (!skip_to_value(allow_recovery))
-                            {
-                                return false;
-                            }
-                            continue;
-                        }
-                        // nothing could be read
-                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
-                        {
-                            return false;
-                        }
-                        break;
+                        return syntax_error(*sax, exception_message(token_type::uninitialized, "value"));
                     }
                     case token_type::end_of_input:
                     {
                         if (JSON_HEDLEY_UNLIKELY(m_lexer.get_chars_read_total() == 1))
                         {
-                            // there is nothing to recover
-                            static_cast<void>(report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(),
-                                                           "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr), allow_recovery));
-                            return false;
+                            return syntax_error(*sax, "attempting to parse an empty input; check that your input string or stream contains the expected JSON");
                         }
 
-                        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
-                        {
-                            return false;
-                        }
-
-                        // recover: the input ends where a value is missing
-                        if (states.empty())
-                        {
-                            // there is no value
-                            return false;
-                        }
-                        if (!recover_missing_value(sax, states, allow_recovery))
-                        {
-                            return false;
-                        }
-                        // the state evaluation reads the token again
-                        unget_token(allow_recovery);
-                        skip_to_state_evaluation = true;
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::literal_or_value, "value"));
                     }
                     case token_type::uninitialized:
                     case token_type::end_array:
@@ -518,35 +416,7 @@ class parser
                     case token_type::literal_or_value:
                     default: // the last token was unexpected
                     {
-                        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
-                        {
-                            return false;
-                        }
-
-                        // recover
-                        if (states.empty())
-                        {
-                            // look for the value after the garbage
-                            if (!skip_to_value(allow_recovery))
-                            {
-                                return false;
-                            }
-                            continue;
-                        }
-                        if (last_token == token_type::name_separator)
-                        {
-                            // a stray ':'; the value may follow
-                            get_token();
-                            continue;
-                        }
-                        if (!recover_missing_value(sax, states, allow_recovery))
-                        {
-                            return false;
-                        }
-                        // the state evaluation reads the token again
-                        unget_token(allow_recovery);
-                        skip_to_state_evaluation = true;
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::literal_or_value, "value"));
                     }
                 }
             }
@@ -597,30 +467,7 @@ class parser
                     continue;
                 }
 
-                if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr), allow_recovery))
-                {
-                    return false;
-                }
-
-                // recover
-                if (last_token == token_type::end_of_input)
-                {
-                    // the input ends inside the array
-                    return close_containers(sax, states, allow_recovery);
-                }
-                if (last_token == token_type::end_object)
-                {
-                    // a wrong closing bracket closes the innermost container
-                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
-                    {
-                        return false;
-                    }
-                    states.pop_back();
-                    skip_to_state_evaluation = true;
-                }
-                // otherwise, a missing ',' (or a stray ':', which value
-                // parsing drops): the next value begins here
-                continue;
+                return syntax_error(*sax, exception_message(token_type::end_array, "array"));
             }
 
             // states.back() is false -> object
@@ -637,12 +484,9 @@ class parser
                     // parse key
                     if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                     {
-                        if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
-                        {
-                            return false;
-                        }
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::value_string, "object key"));
                     }
+
                     if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string_token())))
                     {
                         return false;
@@ -651,11 +495,7 @@ class parser
                     // parse separator (:)
                     if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                     {
-                        if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
-                        {
-                            return false;
-                        }
-                        continue;
+                        return syntax_error(*sax, exception_message(token_type::name_separator, "object separator"));
                     }
 
                     // parse values
@@ -683,546 +523,10 @@ class parser
                 continue;
             }
 
-            if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr), allow_recovery))
-            {
-                return false;
-            }
-
-            // recover
-            if (last_token == token_type::end_of_input)
-            {
-                // the input ends inside the object
-                return close_containers(sax, states, allow_recovery);
-            }
-            if (last_token == token_type::end_array)
-            {
-                // a wrong closing bracket closes the innermost container
-                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
-                {
-                    return false;
-                }
-                states.pop_back();
-                skip_to_state_evaluation = true;
-                continue;
-            }
-            if (!continue_after(recover_member(sax, allow_recovery), skip_to_state_evaluation))
-            {
-                return false;
-            }
+            return syntax_error(*sax, exception_message(token_type::end_object, "object"));
         }
     }
 
-    /*!
-    @brief continue sax_parse_internal() after a recovery
-    @return whether to continue parsing
-    */
-    bool continue_after(const next_step step, bool& skip_to_state_evaluation)
-    {
-        if (step == next_step::evaluate_state)
-        {
-            // the state evaluation reads the token again
-            m_lexer.unget_token();
-            skip_to_state_evaluation = true;
-        }
-        return step != next_step::stop;
-    }
-
-    /// the parser for parse() and accept() never recovers: stop parsing
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type continue_after(std::false_type /*step*/, bool& /*skip_to_state_evaluation*/) noexcept
-    {
-        return {};
-    }
-
-    /*!
-    @brief parse an object key and the name separator (:) after it
-
-    last_token is the token where the key is expected. sax_parse_internal()
-    repeats these steps rather than calling this function, which is used
-    when recovering from an error.
-
-    @return next_step::parse_value if the value follows, with last_token its
-            first token; next_step::evaluate_state if the object's state is
-            to be evaluated after recovering from an error; next_step::stop
-            to stop parsing
-    */
-    template<typename SAX>
-    next_step parse_key(SAX* sax)
-    {
-        const std::true_type allow_recovery{};
-
-        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
-        {
-            return key_error(sax, allow_recovery, false);
-        }
-
-        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string_token())))
-        {
-            return next_step::stop;
-        }
-
-        // parse separator (:)
-        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
-        {
-            return key_error(sax, allow_recovery, true);
-        }
-
-        // the value begins with the next token
-        get_token();
-        return next_step::parse_value;
-    }
-
-    /*!
-    @brief report a number that is too large for number_float_t, and recover
-           from the error by passing the value on; the SAX parser gets the
-           number's text as well
-
-    This is a separate function, as reading other numbers is measurably
-    slower if the error is handled where they are read.
-
-    @param[in] sax    the SAX parser
-    @param[in] value  the value that is not finite
-    @return whether to continue parsing
-    */
-    template<typename SAX>
-    bool overflow_error(SAX* sax, const number_float_t value, std::true_type allow_recovery)
-    {
-        if (!report_error(sax, out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr), allow_recovery))
-        {
-            return false;
-        }
-        return sax->number_float(value, number_float_text(sax));
-    }
-
-    /// @copydoc overflow_error
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type overflow_error(SAX* sax, const number_float_t /*value*/, std::false_type allow_recovery)
-    {
-        return report_error(sax, out_of_range::create(exception_id::number_overflow, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr), allow_recovery);
-    }
-
-    /*!
-    @brief report a missing key, or a missing name separator (:) after the
-           key; the parser for parse() and accept() never recovers
-
-    @param[in] key_read  whether the key was read, so that the name separator
-                         is missing
-    @return std::false_type, see report_error()
-    */
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type key_error(SAX* sax, std::false_type allow_recovery, const bool key_read)
-    {
-        return report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), key_read
-                            ? exception_message(token_type::name_separator, "object separator")
-                            : exception_message(token_type::value_string, "object key"), nullptr), allow_recovery);
-    }
-
-    /*!
-    @brief report a missing key, or a missing name separator (:) after the
-           key, and recover from it
-
-    @param[in] key_read  whether the key was read, so that the name separator
-                         is missing
-    */
-    template<typename SAX>
-    next_step key_error(SAX* sax, std::true_type allow_recovery, const bool key_read)
-    {
-        if (!key_read)
-        {
-            if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr), allow_recovery))
-            {
-                return next_step::stop;
-            }
-            return recover_key(sax);
-        }
-
-        if (!report_error(sax, parse_error::create(exception_id::syntax_error, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr), allow_recovery))
-        {
-            return next_step::stop;
-        }
-        return recover_name_separator(sax);
-    }
-
-    /////////////////////
-    // error recovery
-    /////////////////////
-
-    /*
-    The functions below repair an error after the SAX parser's parse_error()
-    returned true (see #3989). Each mistake is repaired by the smallest local
-    edit: a missing ',' or ':' is inserted, a stray token is removed, what can
-    be read of an invalid string or number is kept (see
-    lexer::recover_token()), a missing value becomes null, a wrong closing
-    bracket closes the innermost container, and the end of the input closes
-    all of them. The events stay balanced, and every key() is followed by
-    exactly one value.
-
-    A repair hands a token to the state evaluation, by returning it to the
-    lexer (lexer::unget_token()) so that the state evaluation reads it again,
-    only if it is ',', ']', '}', or the end of the input. The state evaluation
-    hands a token to value or key parsing only if it is none of them, so a
-    token is never handed back and forth. Every other step reads a token or
-    closes a container, so parsing always ends.
-    */
-
-    /*!
-    @brief report an error to the SAX parser; the parser for parse() and
-           accept() never recovers
-
-    @return std::false_type rather than false: its value is known where the
-            function is called even if the call is not inlined, so the code
-            for recovering is not generated
-    */
-    template<typename SAX, typename Exception>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type report_error(SAX* sax, const Exception& ex, std::false_type /*allow_recovery*/)
-    {
-        static_cast<void>(sax); // MSVC 2015 does not count calling a static parse_error() as using it
-        error_reported = true;
-        static_cast<void>(sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex));
-        return {};
-    }
-
-    /*!
-    @brief report an error to the SAX parser
-    @return whether to recover from the error
-    */
-    template<typename SAX, typename Exception>
-    bool report_error(SAX* sax, const Exception& ex, std::true_type /*allow_recovery*/)
-    {
-        static_cast<void>(sax); // MSVC 2015 does not count calling a static parse_error() as using it
-        const std::size_t position = m_lexer.get_position().chars_read_total;
-        if (error_reported && position == last_error_position && last_token == last_error_token)
-        {
-            // a repair handed on the token of the error it repaired; the
-            // token was reported already, and the SAX parser asked to recover
-            return true;
-        }
-
-        error_reported = true;
-        last_error_position = position;
-        last_error_token = last_token;
-
-        if (!sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex))
-        {
-            return false;
-        }
-
-        // the token string of the next error begins here
-        m_lexer.restart_token_string();
-        return true;
-    }
-
-    /*!
-    @brief keep what can be read of the token that the lexer rejected
-
-    The error was reported for the rejected token, so it is not reported again
-    for the token it is repaired to (see lexer::recover_token()).
-    */
-    token_type recover_token()
-    {
-        last_token = m_lexer.recover_token();
-        last_error_position = m_lexer.get_position().chars_read_total;
-        last_error_token = last_token;
-        return last_token;
-    }
-
-    // The functions below are called from sax_parse_internal() after an error
-    // was reported. The parser for parse() and accept() stopped there, so for
-    // it they are stubs: the code for recovering is then not even referenced,
-    // and unoptimized builds do not emit it either.
-
-    /// @copydoc recover_token()
-    JSON_INTERNAL_ALWAYS_INLINE
-    token_type recover_token(std::true_type /*allow_recovery*/)
-    {
-        return recover_token();
-    }
-
-    /// @copydoc recover_token()
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type recover_token(std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /// return the token that was read last to the lexer (see lexer::unget_token())
-    JSON_INTERNAL_ALWAYS_INLINE
-    void unget_token(std::true_type /*allow_recovery*/)
-    {
-        m_lexer.unget_token();
-    }
-
-    /// @copydoc unget_token(std::true_type)
-    JSON_INTERNAL_ALWAYS_INLINE
-    static void unget_token(std::false_type /*allow_recovery*/) noexcept {}
-
-    /// @copydoc skip_to_value
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type skip_to_value(std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /// @copydoc recover_missing_value
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type recover_missing_value(SAX* /*sax*/, const std::vector<bool>& /*states*/, std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /// pass the end events of all open containers
-    template<typename SAX>
-    bool close_containers(SAX* sax, std::vector<bool>& states, std::true_type /*allow_recovery*/)
-    {
-        while (!states.empty())
-        {
-            const bool is_array = states.back();
-            states.pop_back();
-            if (JSON_HEDLEY_UNLIKELY(is_array ? !sax->end_array() : !sax->end_object()))
-            {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /// @copydoc close_containers
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    static std::false_type close_containers(SAX* /*sax*/, std::vector<bool>& /*states*/, std::false_type /*allow_recovery*/) noexcept
-    {
-        return {};
-    }
-
-    /*!
-    @brief read tokens until one begins a value, skipping everything before
-           the top-level value
-    @return whether a value begins with last_token
-    */
-    bool skip_to_value(std::true_type /*allow_recovery*/)
-    {
-        while (true)
-        {
-            switch (get_token())
-            {
-                case token_type::begin_array:
-                case token_type::begin_object:
-                case token_type::literal_false:
-                case token_type::literal_null:
-                case token_type::literal_true:
-                case token_type::value_float:
-                case token_type::value_integer:
-                case token_type::value_string:
-                case token_type::value_unsigned:
-                    return true;
-
-                case token_type::end_of_input:
-                    return false;
-
-                case token_type::parse_error:
-                    recover_token();
-                    if (last_token != token_type::uninitialized)
-                    {
-                        return true;
-                    }
-                    break;
-
-                case token_type::uninitialized:
-                case token_type::end_array:
-                case token_type::end_object:
-                case token_type::name_separator:
-                case token_type::value_separator:
-                case token_type::literal_or_value:
-                default:
-                    break;
-            }
-        }
-    }
-
-    /*!
-    @brief skip the rest of an object member that cannot be read
-
-    Reads tokens, beginning with last_token, until a ',', '}', or ']' that is
-    not inside a container that begins in the skipped tokens, or the end of
-    the input.
-    */
-    void skip_member()
-    {
-        std::size_t depth = 0;
-        while (true)
-        {
-            switch (last_token)
-            {
-                case token_type::begin_array:
-                case token_type::begin_object:
-                    ++depth;
-                    break;
-
-                case token_type::end_array:
-                case token_type::end_object:
-                    if (depth == 0)
-                    {
-                        return;
-                    }
-                    --depth;
-                    break;
-
-                case token_type::value_separator:
-                    if (depth == 0)
-                    {
-                        return;
-                    }
-                    break;
-
-                case token_type::end_of_input:
-                    return;
-
-                case token_type::parse_error:
-                    recover_token();
-                    break;
-
-                case token_type::uninitialized:
-                case token_type::literal_true:
-                case token_type::literal_false:
-                case token_type::literal_null:
-                case token_type::value_string:
-                case token_type::value_unsigned:
-                case token_type::value_integer:
-                case token_type::value_float:
-                case token_type::name_separator:
-                case token_type::literal_or_value:
-                default:
-                    break;
-            }
-            get_token();
-        }
-    }
-
-    /*!
-    @brief pass a value where it is missing
-
-    last_token is ',', ']', '}', or the end of the input, where a value was
-    expected. In an object, the key gets null; in an array, a ',' where a
-    value is missing stands for null (as in JavaScript), while an array that
-    ends there just ends.
-    */
-    template<typename SAX>
-    bool recover_missing_value(SAX* sax, const std::vector<bool>& states, std::true_type /*allow_recovery*/)
-    {
-        JSON_ASSERT(!states.empty());
-        if (!states.back() || last_token == token_type::value_separator)
-        {
-            return sax->null();
-        }
-        return true;
-    }
-
-    /// recover from a missing key; last_token is where it was expected
-    template<typename SAX>
-    next_step recover_key(SAX* sax)
-    {
-        switch (last_token)
-        {
-            case token_type::value_separator:
-            case token_type::end_object:
-            case token_type::end_array:
-            case token_type::end_of_input:
-                // no member: the object's state handles the token
-                return next_step::evaluate_state;
-
-            case token_type::parse_error:
-                recover_token();
-                if (last_token == token_type::value_string)
-                {
-                    // a key that could be repaired
-                    return parse_key(sax);
-                }
-                skip_member();
-                return next_step::evaluate_state;
-
-            case token_type::uninitialized:
-            case token_type::literal_true:
-            case token_type::literal_false:
-            case token_type::literal_null:
-            case token_type::value_string:
-            case token_type::value_unsigned:
-            case token_type::value_integer:
-            case token_type::value_float:
-            case token_type::begin_array:
-            case token_type::begin_object:
-            case token_type::name_separator:
-            case token_type::literal_or_value:
-            default:
-                // a member without a key
-                skip_member();
-                return next_step::evaluate_state;
-        }
-    }
-
-    /// recover from a missing name separator (:) after the key; last_token
-    /// is where it was expected
-    template<typename SAX>
-    next_step recover_name_separator(SAX* sax)
-    {
-        switch (last_token)
-        {
-            case token_type::value_separator:
-            case token_type::end_object:
-            case token_type::end_array:
-            case token_type::end_of_input:
-                // the value is missing as well
-                return sax->null() ? next_step::evaluate_state : next_step::stop;
-
-            case token_type::uninitialized:
-            case token_type::literal_true:
-            case token_type::literal_false:
-            case token_type::literal_null:
-            case token_type::value_string:
-            case token_type::value_unsigned:
-            case token_type::value_integer:
-            case token_type::value_float:
-            case token_type::begin_array:
-            case token_type::begin_object:
-            case token_type::name_separator:
-            case token_type::parse_error:
-            case token_type::literal_or_value:
-            default:
-                // a missing ':'; the value begins here
-                return next_step::parse_value;
-        }
-    }
-
-    /// recover from a token after an object member that is neither ',' nor
-    /// '}' (nor ']' or the end of the input, which the caller handles)
-    template<typename SAX>
-    next_step recover_member(SAX* sax, std::true_type /*allow_recovery*/)
-    {
-        if (last_token == token_type::parse_error)
-        {
-            recover_token();
-        }
-        if (last_token == token_type::value_string)
-        {
-            // a missing ','; the next key begins here
-            return parse_key(sax);
-        }
-        skip_member();
-        return next_step::evaluate_state;
-    }
-
-    /// the parser for parse() and accept() never recovers (and does not come
-    /// here, as report_error() returned false)
-    template<typename SAX>
-    JSON_INTERNAL_ALWAYS_INLINE
-    std::false_type recover_member(SAX* /*sax*/, std::false_type /*allow_recovery*/) const noexcept
-    {
-        return {};
-    }
-
     /// get next token from lexer
     token_type get_token()
     {
@@ -1293,12 +597,6 @@ class parser
     const bool allow_exceptions = true;
     /// whether trailing commas in objects and arrays should be ignored (true) or signaled as errors (false)
     const bool ignore_trailing_commas = false;
-    /// whether an error was reported to the SAX parser
-    bool error_reported = false;
-    /// the position of the last reported error
-    std::size_t last_error_position = 0;
-    /// the token of the last reported error
-    token_type last_error_token = token_type::uninitialized;
 };
 
 }  // namespace detail

include/nlohmann/detail/macro_scope.hpp

@@ -199,17 +199,6 @@
     #define JSON_NO_UNIQUE_ADDRESS
 #endif
 
-// Inlines small functions even in unoptimized builds, so that they are not
-// emitted. The parsers for parse(), accept(), and from_*() use it for the
-// functions that stand in for the code recovering from errors (see #3989).
-// MSVC is left to decide, as it warns (C4714) where it does not inline a
-// __forceinline function.
-#if defined(_MSC_VER) && !defined(__clang__)
-    #define JSON_INTERNAL_ALWAYS_INLINE
-#else
-    #define JSON_INTERNAL_ALWAYS_INLINE JSON_HEDLEY_ALWAYS_INLINE
-#endif
-
 // Clang targeting MinGW does not survive the thread_local storage the copy
 // constructor uses to bound its descent: every test that copies a value
 // segfaults with clang 11.0.1 and clang 18.1.8, while the same tests pass with

include/nlohmann/detail/macro_unscope.hpp

@@ -19,7 +19,6 @@
 #undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
 #undef JSON_INLINE_VARIABLE
 #undef JSON_NO_UNIQUE_ADDRESS
-#undef JSON_INTERNAL_ALWAYS_INLINE
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
 #undef JSON_UNLOCKED_FILE_IO

include/nlohmann/detail/meta/cpp_future.hpp

@@ -10,17 +10,26 @@
 #pragma once
 
 #include <cstddef> // size_t
-#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_arithmetic, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
 #include <utility> // index_sequence, make_index_sequence, index_sequence_for
 
 #include <nlohmann/detail/macro_scope.hpp>
 
+#ifdef JSON_HAS_CPP_17
+    #include <algorithm> // clamp
+#endif
+
 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
 {
 
-template<typename T>
-using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+#ifdef __cpp_lib_remove_cvref
+    template<typename T>
+    using uncvref_t = std::remove_cvref_t<T>;
+#else
+    template<typename T>
+    using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+#endif
 
 #ifdef JSON_HAS_CPP_14
 
@@ -160,5 +169,18 @@ struct static_const
     constexpr T static_const<T>::value;
 #endif
 
+/// @a v bounded to [@a lo, @a hi] (requires !(hi < lo)); like std::clamp,
+/// but by value, so that static constexpr members can be passed without an
+/// out-of-line definition before C++17
+template<typename T, enable_if_t<std::is_arithmetic<T>::value, int> = 0>
+constexpr T clamp(T v, T lo, T hi) noexcept
+{
+#ifdef __cpp_lib_clamp
+    return std::clamp(v, lo, hi);
+#else
+    return v < lo ? lo : (hi < v ? hi : v);
+#endif
+}
+
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/meta/type_traits.hpp

@@ -313,6 +313,14 @@ struct char_traits<std::byte> : std::char_traits<char>
 // is_ functions //
 ///////////////////
 
+#ifdef __cpp_lib_logical_traits
+
+using std::conjunction;
+using std::disjunction;
+using std::negation;
+
+#else
+
 // https://en.cppreference.com/w/cpp/types/conjunction
 template<class...> struct conjunction : std::true_type { };
 template<class B> struct conjunction<B> : B { };
@@ -330,6 +338,8 @@ struct disjunction<B, Bn...>
 // https://en.cppreference.com/w/cpp/types/negation
 template<class B> struct negation : std::integral_constant < bool, !B::value > { };
 
+#endif
+
 // Reimplementation of is_constructible and is_default_constructible, due to them being broken for
 // std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
 // This causes compile errors in e.g., Clang 3.5 or GCC 4.9.
@@ -1060,8 +1070,12 @@ constexpr bool value_in_range_of(T val)
     return value_in_range_of_impl1<OfType, T>::test(val);
 }
 
-template<bool Value>
-using bool_constant = std::integral_constant<bool, Value>;
+#ifdef __cpp_lib_bool_constant
+    using std::bool_constant;
+#else
+    template<bool Value>
+    using bool_constant = std::integral_constant<bool, Value>;
+#endif
 
 // Stands in for number_unsigned_t in overload sets if it is the same type as
 // number_integer_t, so that the unsigned overloads do not collide with the

include/nlohmann/detail/output/binary_writer.hpp

@@ -19,10 +19,6 @@
 #include <utility> // move
 #include <vector> // vector
 
-#ifdef _MSC_VER
-    #include <cstdlib> // _byteswap_ushort, _byteswap_ulong, _byteswap_uint64
-#endif
-
 #include <nlohmann/detail/bit_ops.hpp>
 #include <nlohmann/detail/input/binary_reader.hpp>
 #include <nlohmann/detail/input/string_scan.hpp>
@@ -2073,7 +2069,7 @@ class binary_writer
     {
         out[0] = to_char_type(first_byte);
         const unsigned unused_bits = 64u - ((8u << size_class) >> 1u);
-        const std::uint64_t tail = is_little_endian ? byte_swap(value) >> unused_bits : value << unused_bits;
+        const std::uint64_t tail = is_little_endian ? byteswap(value) >> unused_bits : value << unused_bits;
         std::memcpy(out + 1, &tail, sizeof(tail));
         return ((std::size_t{1} << size_class) >> 1u) + 1;
     }
@@ -3517,53 +3513,14 @@ class binary_writer
     // Utility functions //
     ///////////////////////
 
-    // single-instruction byte swaps (compilers lower these to bswap/rev/movbe);
-    // used to emit big-endian numbers without a per-byte std::reverse loop
-    static std::uint16_t byte_swap(std::uint16_t x) noexcept
-    {
-#if defined(__GNUC__) || defined(__clang__)
-        return __builtin_bswap16(x);
-#elif defined(_MSC_VER)
-        return _byteswap_ushort(x);
-#else
-        return static_cast<std::uint16_t>((x >> 8) | (x << 8));
-#endif
-    }
-
-    static std::uint32_t byte_swap(std::uint32_t x) noexcept
-    {
-#if defined(__GNUC__) || defined(__clang__)
-        return __builtin_bswap32(x);
-#elif defined(_MSC_VER)
-        return _byteswap_ulong(x);
-#else
-        return ((x & 0x000000FFu) << 24) | ((x & 0x0000FF00u) << 8)
-               | ((x & 0x00FF0000u) >> 8) | ((x & 0xFF000000u) >> 24);
-#endif
-    }
-
-    static std::uint64_t byte_swap(std::uint64_t x) noexcept
-    {
-#if defined(__GNUC__) || defined(__clang__)
-        return __builtin_bswap64(x);
-#elif defined(_MSC_VER)
-        return _byteswap_uint64(x);
-#else
-        x = ((x & 0x00000000FFFFFFFFull) << 32) | ((x & 0xFFFFFFFF00000000ull) >> 32);
-        x = ((x & 0x0000FFFF0000FFFFull) << 16) | ((x & 0xFFFF0000FFFF0000ull) >> 16);
-        x = ((x & 0x00FF00FF00FF00FFull) << 8) | ((x & 0xFF00FF00FF00FF00ull) >> 8);
-        return x;
-#endif
-    }
-
     /*!
     @brief reverse the bytes of a buffer by byte-swapping it as UIntType
 
     Loading the buffer into an unsigned integer of the same width and swapping
     that is what lets the compiler emit a single bswap/rev/movbe; reversing the
     buffer element by element does not reliably get there (clang keeps a scalar
-    shuffle). The two memcpy calls are the only portable way to reinterpret the
-    bytes and are folded away by every optimizer.
+    shuffle). (The two memcpy calls, rather than bit_cast, keep GCC from
+    inlining differently in C++20, which made writing slower.)
     */
     template<typename UIntType, std::size_t N>
     static void byte_swap_buffer(std::array<CharType, N>& a) noexcept
@@ -3571,11 +3528,11 @@ class binary_writer
         static_assert(sizeof(UIntType) == N, "swap width must match the buffer size");
         UIntType v{};
         std::memcpy(&v, a.data(), sizeof(v));
-        v = byte_swap(v);
+        v = byteswap(v);
         std::memcpy(a.data(), &v, sizeof(v));
     }
 
-    // reverse the bytes of a fixed-size buffer; a single byte_swap() for the
+    // reverse the bytes of a fixed-size buffer; a single byteswap() for the
     // common 2/4/8-byte number payloads, std::reverse for any other size
     static void reverse_bytes(std::array<CharType, 2>& a) noexcept
     {
@@ -3700,9 +3657,7 @@ class binary_writer
 #endif
 
         static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
-        CharType result;
-        std::memcpy(&result, &x, sizeof(x));
-        return result;
+        return bit_cast<CharType>(x);
     }
 
     template<typename C = CharType,

include/nlohmann/detail/string_utils.hpp

@@ -13,7 +13,6 @@
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <string> // string, to_string
-#include <utility> // move
 
 #include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/macro_scope.hpp>

include/nlohmann/detail/view/serializer.hpp

@@ -105,17 +105,13 @@ class output_buffer
     }
 
   private:
-    /// the size of a growth step (a function: std::min() takes a reference,
-    /// which a static constexpr member does not have before C++17)
-    static constexpr std::size_t step() noexcept
-    {
-        return 0x10000;
-    }
+    /// the size of a growth step
+    static constexpr std::size_t step = 0x10000;
 
     static StringType& sized(StringType& out, std::size_t estimate)
     {
         out.reserve(estimate);
-        out.resize((std::min)((std::max)(estimate, static_cast<std::size_t>(64)), step()));
+        out.resize(detail::clamp(estimate, std::size_t{64}, step));
         return out;
     }
 
@@ -124,7 +120,7 @@ class output_buffer
         const auto used = static_cast<std::size_t>(m_pos - m_out.data());
         // (a step does not go beyond the reserved estimate, so that a good
         // estimate is never copied to a larger allocation)
-        const std::size_t size = (std::max)((std::min)(m_out.size() + step(), m_out.capacity()), used + n + 256);
+        const std::size_t size = (std::max)((std::min)(m_out.size() + step, m_out.capacity()), used + n + 256);
         if (size > m_out.capacity())
         {
             m_out.reserve((std::max)(m_out.capacity() * 2, size));
@@ -794,8 +790,7 @@ class view_serializer
     static char* write_double_value_at(char* w, double x)
     {
         // (from the bits: without the checks of to_chars())
-        std::uint64_t bits = 0;
-        std::memcpy(&bits, &x, sizeof(bits));
+        auto bits = bit_cast<std::uint64_t>(x);
         if (NLOHMANN_VIEW_UNLIKELY((bits & 0x7FF0000000000000u) == 0x7FF0000000000000u))
         {
             return write_text_at(w, "null", 4);

include/nlohmann/json.hpp

@@ -156,7 +156,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     friend class ::nlohmann::detail::iter_impl;
     template<typename BasicJsonType, typename CharType, typename OutputSinkType>
     friend class ::nlohmann::detail::binary_writer;
-    template<typename BasicJsonType, typename InputType, typename SAX, bool AllowRecovery>
+    template<typename BasicJsonType, typename InputType, typename SAX>
     friend class ::nlohmann::detail::binary_reader;
     template<typename BasicJsonType, typename InputAdapterType>
     friend class ::nlohmann::detail::json_sax_dom_parser;
@@ -6115,7 +6115,7 @@ public:
         auto ia = detail::input_adapter(std::forward<InputType>(i));
         return format == input_format_t::json
                ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
     }
 
     /// @brief generate SAX events (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -6133,7 +6133,7 @@ public:
         auto ia = detail::input_adapter(std::move(first), std::move(last));
         return format == input_format_t::json
                ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
     }
 
     /// @brief generate SAX events
@@ -6172,7 +6172,7 @@ public:
                // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
                ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
                // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
     }
 #endif
 #if defined(__clang__)

single_include/nlohmann/json_view.hpp

@@ -6166,17 +6166,13 @@ class output_buffer
     }
 
   private:
-    /// the size of a growth step (a function: std::min() takes a reference,
-    /// which a static constexpr member does not have before C++17)
-    static constexpr std::size_t step() noexcept
-    {
-        return 0x10000;
-    }
+    /// the size of a growth step
+    static constexpr std::size_t step = 0x10000;
 
     static StringType& sized(StringType& out, std::size_t estimate)
     {
         out.reserve(estimate);
-        out.resize((std::min)((std::max)(estimate, static_cast<std::size_t>(64)), step()));
+        out.resize(detail::clamp(estimate, std::size_t{64}, step));
         return out;
     }
 
@@ -6185,7 +6181,7 @@ class output_buffer
         const auto used = static_cast<std::size_t>(m_pos - m_out.data());
         // (a step does not go beyond the reserved estimate, so that a good
         // estimate is never copied to a larger allocation)
-        const std::size_t size = (std::max)((std::min)(m_out.size() + step(), m_out.capacity()), used + n + 256);
+        const std::size_t size = (std::max)((std::min)(m_out.size() + step, m_out.capacity()), used + n + 256);
         if (size > m_out.capacity())
         {
             m_out.reserve((std::max)(m_out.capacity() * 2, size));
@@ -6855,8 +6851,7 @@ class view_serializer
     static char* write_double_value_at(char* w, double x)
     {
         // (from the bits: without the checks of to_chars())
-        std::uint64_t bits = 0;
-        std::memcpy(&bits, &x, sizeof(bits));
+        auto bits = bit_cast<std::uint64_t>(x);
         if (NLOHMANN_VIEW_UNLIKELY((bits & 0x7FF0000000000000u) == 0x7FF0000000000000u))
         {
             return write_text_at(w, "null", 4);

src/modules/json.cppm

@@ -60,7 +60,6 @@ inline namespace json_literals
 namespace detail
 {
     using NLOHMANN_JSON_NAMESPACE::detail::json_sax_dom_callback_parser;
-    using NLOHMANN_JSON_NAMESPACE::detail::json_sax_dom_parser;
     using NLOHMANN_JSON_NAMESPACE::detail::unknown_size;
 } // namespace detail
 

tests/src/fuzzer-parse_bjdata.cpp

@@ -47,10 +47,6 @@ dumps is stable under exactly the same values that break operator==.
 The unit tests run the same checks on a fixed corpus (see the "BJData round-trip
 invariants" test case), so keep both in sync.
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bjdata() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -61,7 +57,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -86,9 +81,6 @@ static bool is_value_stable(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bjdata).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -107,9 +99,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2.1: round trip without adding size annotations to container types
@@ -143,7 +132,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -154,7 +142,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_bon8.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_bon8(vec)
 - assert(to_bon8(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bon8() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_bon8
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bon8).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_bson.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_bson(vec)
 - assert(to_bson(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_bson() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_bson
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bson).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors can occur during parsing, too
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_cbor.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_cbor(vec)
 - assert(to_cbor(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_cbor() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_cbor
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::cbor).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors can occur during parsing, too
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_json.cpp

@@ -24,16 +24,11 @@ array data, it performs the following steps:
 The pointer range takes the bulk fast paths, the other input adapters read byte
 by byte; see check_input_adapters().
 
-Furthermore, it parses data with a SAX parser that recovers from every error
-and checks that the events are balanced, that parsing ends, and that valid
-input is parsed without errors (see #3989).
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -64,13 +59,6 @@ struct accept_json
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    {
-        const auto checker = check_recovering_parse(data, size, json::input_format_t::json);
-        assert(checker.events <= (4 * size) + 4);
-        assert((checker.errors == 0) == json::accept(data, data + size));
-    }
-
     // step 0: parse input without exceptions
     bool noexcept_threw = false;
     json const j_noexcept = parse_without_exceptions([&] { return json::parse(data, data + size, nullptr, false); }, noexcept_threw);

tests/src/fuzzer-parse_msgpack.cpp

@@ -17,10 +17,6 @@ array data, it performs the following steps:
 - j2 = from_msgpack(vec)
 - assert(to_msgpack(j2) == vec)
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_msgpack() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -31,7 +27,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -49,9 +44,6 @@ struct read_msgpack
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::msgpack).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -70,9 +62,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2: round trip
@@ -94,7 +83,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -105,7 +93,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-parse_ubjson.cpp

@@ -26,10 +26,6 @@ array data, it performs the following steps:
 The unit tests run the same checks on a fixed corpus (see the "UBJSON round-trip
 invariants" test case), so keep both in sync.
 
-Furthermore, it reads data with a SAX parser that recovers from every error
-and checks that the events are balanced, that reading ends, and that it
-reports an error exactly when from_ubjson() fails (see #3989).
-
 Finally, it reads the data from a stream, a non-contiguous iterator range, and
 a FILE*, which read byte by byte, and checks that each gives the same value or
 error (id, message, byte position) as the pointer range, which takes the bulk
@@ -40,7 +36,6 @@ drivers.
 */
 
 #include "fuzzer_common.hpp"
-#include "fuzzer-recovering_checker.hpp"
 
 namespace
 {
@@ -58,9 +53,6 @@ struct read_ubjson
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // recover from all errors, reading from memory and from a stream
-    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::ubjson).errors == 0;
-
     std::vector<uint8_t> const vec1(data, data + size);
 
     // step 0: parse input without exceptions
@@ -79,9 +71,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
         // without exceptions, the same input must give the same value
         assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));
 
-        // the recovering parser must not have reported an error either
-        assert(recovered_without_errors);
-
         try
         {
             // step 2.1: round trip without adding size annotations to container types
@@ -113,7 +102,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // parse errors are ok, because input may be random bytes
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
     catch (const json::type_error&)
     {
@@ -124,7 +112,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
     {
         // out of range errors may happen if provided sizes are excessive
         assert(parsed || noexcept_threw || j_noexcept.is_discarded());
-        assert(parsed || !recovered_without_errors);
     }
 
     // step 3: the other input adapters must read the data alike

tests/src/fuzzer-recovering_checker.hpp

@@ -1,154 +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
-
-#pragma once
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <sstream>
-#include <string>
-#include <vector>
-#include <nlohmann/json.hpp>
-
-namespace
-{
-// a SAX parser that recovers from every error and checks that the events are
-// balanced and that every key is followed by exactly one value
-class recovering_checker : public nlohmann::json_sax<nlohmann::json>
-{
-  public:
-    bool null() override
-    {
-        return value();
-    }
-
-    bool boolean(bool /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_integer(number_integer_t /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_unsigned(number_unsigned_t /*val*/) override
-    {
-        return value();
-    }
-
-    bool number_float(number_float_t /*val*/, const string_t& /*s*/) override
-    {
-        return value();
-    }
-
-    bool string(string_t& /*val*/) override
-    {
-        return value();
-    }
-
-    bool binary(binary_t& /*val*/) override
-    {
-        return value();
-    }
-
-    bool start_object(std::size_t /*elements*/) override
-    {
-        value();
-        stack.push_back('o');
-        return true;
-    }
-
-    bool key(string_t& /*val*/) override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'o');
-        stack.back() = 'v';
-        return true;
-    }
-
-    bool end_object() override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'o');
-        stack.pop_back();
-        return true;
-    }
-
-    bool start_array(std::size_t /*elements*/) override
-    {
-        value();
-        stack.push_back('a');
-        return true;
-    }
-
-    bool end_array() override
-    {
-        ++events;
-        assert(!stack.empty() && stack.back() == 'a');
-        stack.pop_back();
-        return true;
-    }
-
-    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const nlohmann::detail::exception& /*ex*/) override
-    {
-        ++errors;
-        return true;
-    }
-
-    bool complete() const
-    {
-        return stack.empty();
-    }
-
-    std::size_t events = 0;
-    std::size_t errors = 0;
-
-  private:
-    bool value()
-    {
-        ++events;
-        if (!stack.empty())
-        {
-            // an array element, or the value of a key
-            assert(stack.back() != 'o');
-            if (stack.back() == 'v')
-            {
-                stack.back() = 'o';
-            }
-        }
-        return true;
-    }
-
-    // 'a' for an array, 'o' for an object that expects a key, 'v' for an
-    // object that expects the value of a key
-    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
-};
-
-/// parses @a data with a recovering_checker from memory and from a stream,
-/// checks that both see the same, that the events are balanced, and that the
-/// number of errors is bounded, and returns the checker (see #3989)
-inline recovering_checker check_recovering_parse(const std::uint8_t* data, const std::size_t size, const nlohmann::json::input_format_t format)
-{
-    recovering_checker checker;
-    const bool ok = nlohmann::json::sax_parse(data, data + size, &checker, format);
-    assert(checker.complete());
-    assert(checker.errors <= size + 1);
-    assert(ok == (checker.errors == 0));
-
-    std::istringstream stream(std::string(reinterpret_cast<const char*>(data), size));
-    recovering_checker stream_checker;
-    assert(nlohmann::json::sax_parse(stream, &stream_checker, format) == ok);
-    assert(stream_checker.complete());
-    assert(stream_checker.events == checker.events);
-    assert(stream_checker.errors == checker.errors);
-
-    return checker;
-}
-} // namespace

tests/src/sax_event_loggers.hpp

@@ -131,13 +131,11 @@ struct SaxEventLogger : public nlohmann::json_sax<nlohmann::json>
     {
         errored = true;
         events.push_back("parse_error(" + std::to_string(position) + ")");
-        return recover;
+        return false;
     }
 
     std::vector<std::string> events {}; // NOLINT(readability-redundant-member-init)
     bool errored = false;
-    /// whether parse_error() asks the parser to recover from the error (see #3989)
-    bool recover = false;
 };
 
 struct SaxEventLoggerExitAfterStartObject : public SaxEventLogger

tests/src/unit-alt-string.cpp

@@ -415,46 +415,6 @@ TEST_CASE("alternative string type")
         CHECK(j2.dump() == R"({"/foo/0":"bar","/foo/1":"baz"})");
     }
 
-    SECTION("error recovery")
-    {
-        // a SAX parser that recovers from every error (see #3989)
-        struct recovering_parser : nlohmann::detail::json_sax_dom_parser<alt_json>
-        {
-            explicit recovering_parser(alt_json& j)
-                : nlohmann::detail::json_sax_dom_parser<alt_json>(j, false)
-            {}
-
-            // sax_parse() calls the SAX parser's own parse_error(), so hiding
-            // the one of the base class is what recovering takes
-            // NOLINTNEXTLINE(bugprone-derived-method-shadowing-base-method)
-            bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const nlohmann::detail::exception& /*unused*/)
-            {
-                ++errors;
-                return true;
-            }
-
-            std::size_t errors = 0;
-        };
-
-        alt_json j;
-        recovering_parser sax(j);
-        // not inside CHECK(): MSVC reads the escape in a stringized raw string
-        const std::string input = R"([1., "a\qb", tru, {"k" 2}])";
-        CHECK(!alt_json::sax_parse(input, &sax));
-        CHECK(sax.errors == 4);
-        CHECK(j.dump() == R"([1,"aqb",null,{"k":2}])");
-
-        // a UBJSON high-precision number, a CBOR key that is not a string
-        alt_json u;
-        recovering_parser ubjson_sax(u);
-        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {'[', 'H', 'i', 2, '1', '.', ']'}, &ubjson_sax, alt_json::input_format_t::ubjson));
-        CHECK(u.dump() == "[1]");
-        alt_json c;
-        recovering_parser cbor_sax(c);
-        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {0xA2, 0x01, 0x02, 0x61, 'a', 0x03}, &cbor_sax, alt_json::input_format_t::cbor));
-        CHECK(c.dump() == R"({"a":3})");
-    }
-
     SECTION("conversion between basic_json specializations (#2649)")
     {
         // explicit conversions are always possible

tests/src/unit-class_parser.cpp

@@ -2922,648 +2922,3 @@ TEST_CASE("diagnostic positions: value lifetime, input adapters, and SAX")
     }
 }
 #endif
-
-namespace
-{
-/// builds a value like json::parse(), but asks the parser to recover from
-/// errors (see #3989), and checks that the events it receives are balanced
-class RecoveringDomParser
-{
-  public:
-    explicit RecoveringDomParser(json& j, std::size_t max_errors_ = static_cast<std::size_t>(-1))
-        : dom(j, false)
-        , max_errors(max_errors_)
-    {}
-
-    bool null()
-    {
-        value();
-        return dom.null();
-    }
-
-    bool boolean(bool val)
-    {
-        value();
-        return dom.boolean(val);
-    }
-
-    bool number_integer(json::number_integer_t val)
-    {
-        value();
-        return dom.number_integer(val);
-    }
-
-    bool number_unsigned(json::number_unsigned_t val)
-    {
-        value();
-        return dom.number_unsigned(val);
-    }
-
-    bool number_float(json::number_float_t val, const std::string& s)
-    {
-        value();
-        return dom.number_float(val, s);
-    }
-
-    bool string(std::string& val)
-    {
-        value();
-        return dom.string(val);
-    }
-
-    bool binary(json::binary_t& val)
-    {
-        value();
-        return dom.binary(val);
-    }
-
-    bool start_object(std::size_t elements)
-    {
-        value();
-        stack.push_back('o');
-        return dom.start_object(elements);
-    }
-
-    bool key(std::string& val)
-    {
-        ++events;
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.back() = 'v';
-        return dom.key(val);
-    }
-
-    bool end_object()
-    {
-        ++events;
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_object();
-    }
-
-    bool start_array(std::size_t elements)
-    {
-        value();
-        stack.push_back('a');
-        return dom.start_array(elements);
-    }
-
-    bool end_array()
-    {
-        ++events;
-        if (stack.empty() || stack.back() != 'a')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_array();
-    }
-
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const json::exception& ex)
-    {
-        errors.emplace_back(ex.what());
-        return errors.size() < max_errors;
-    }
-
-    /// whether the events were balanced and every key was followed by a value
-    bool balanced() const
-    {
-        return well_formed && stack.empty();
-    }
-
-    /// builds the value
-    nlohmann::detail::json_sax_dom_parser<json> dom;
-    std::vector<std::string> errors {}; // NOLINT(readability-redundant-member-init)
-    std::size_t events = 0;
-    /// the open containers: 'a' for an array, 'o' for an object that expects
-    /// a key, 'v' for an object that expects the value of a key
-    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
-    bool well_formed = true;
-    std::size_t max_errors;
-
-  private:
-    /// a value is passed: it is an array element, or the value of a key
-    void value()
-    {
-        ++events;
-        if (!stack.empty())
-        {
-            if (stack.back() == 'v')
-            {
-                stack.back() = 'o';
-            }
-            else if (stack.back() == 'o')
-            {
-                // a value without a key
-                well_formed = false;
-            }
-        }
-    }
-
-};
-
-struct RecoveryResult
-{
-    json value;
-    std::vector<std::string> errors;
-    std::size_t events;
-    bool ok;
-    bool balanced;
-};
-
-template<typename InputType>
-RecoveryResult parse_recovering(InputType&& input, const bool strict = true,
-                                const bool ignore_comments = false, const bool ignore_trailing_commas = false)
-{
-    json j;
-    RecoveringDomParser sax(j);
-    const bool ok = json::sax_parse(std::forward<InputType>(input), &sax, json::input_format_t::json,
-                                    strict, ignore_comments, ignore_trailing_commas);
-    return {j, sax.errors, sax.events, ok, sax.balanced()};
-}
-
-/// stops after a number of events, but recovers from errors
-class RecoveringCountdown
-{
-  public:
-    explicit RecoveringCountdown(const int count)
-        : countdown(count)
-    {}
-
-    bool null()
-    {
-        return countdown.null();
-    }
-
-    bool boolean(bool val)
-    {
-        return countdown.boolean(val);
-    }
-
-    bool number_integer(json::number_integer_t val)
-    {
-        return countdown.number_integer(val);
-    }
-
-    bool number_unsigned(json::number_unsigned_t val)
-    {
-        return countdown.number_unsigned(val);
-    }
-
-    bool number_float(json::number_float_t val, const std::string& s)
-    {
-        return countdown.number_float(val, s);
-    }
-
-    bool string(std::string& val)
-    {
-        return countdown.string(val);
-    }
-
-    bool binary(json::binary_t& val)
-    {
-        return countdown.binary(val);
-    }
-
-    bool start_object(std::size_t elements)
-    {
-        return countdown.start_object(elements);
-    }
-
-    bool key(std::string& val)
-    {
-        return countdown.key(val);
-    }
-
-    bool end_object()
-    {
-        return countdown.end_object();
-    }
-
-    bool start_array(std::size_t elements)
-    {
-        return countdown.start_array(elements);
-    }
-
-    bool end_array()
-    {
-        return countdown.end_array();
-    }
-
-    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const json::exception& /*ex*/) // NOLINT(readability-convert-member-functions-to-static)
-    {
-        return true;
-    }
-
-  private:
-    SaxCountdown countdown;
-};
-
-/// a repaired input: the value it is repaired to, and the number of errors
-struct Repair
-{
-    const char* input;
-    const char* expected;
-    std::size_t errors;
-};
-} // namespace
-
-TEST_CASE("parser error recovery (#3989)")
-{
-    SECTION("repairs")
-    {
-        const std::vector<Repair> repairs =
-        {
-            // a missing separator is inserted
-            {"[1 2]", "[1,2]", 1},
-            {R"({"a":1 "b":2})", R"({"a":1,"b":2})", 1},
-            {R"({"a" 1})", R"({"a":1})", 1},
-            {"[1 tru 2]", "[1,null,2]", 2},
-            {R"({"a" "b": 1})", R"({"a":"b"})", 2},
-
-            // a missing value is null in an object; in an array, a ',' stands
-            // for null, while an array that ends there just ends
-            {R"({"a":})", R"({"a":null})", 1},
-            {R"({"a"})", R"({"a":null})", 1},
-            {R"({"a","b":1})", R"({"a":null,"b":1})", 1},
-            {"[1,,2]", "[1,null,2]", 1},
-            {"[,1]", "[null,1]", 1},
-            {"[1,]", "[1]", 1},
-            {"[1,2,3,]", "[1,2,3]", 1},
-            {R"({"a":1,})", R"({"a":1})", 1},
-
-            // a broken string keeps what can be read
-            {R"(["a\qb"])", R"(["aqb"])", 1},
-            {R"({"na\me":1})", R"({"name":1})", 1},
-            {"[\"\xFF\"]", R"(["\uFFFD"])", 1},
-            {"[\"a\xC3(\"]", R"(["a\uFFFD("])", 1},
-            {"[\"\xE2\x82\"]", R"(["\uFFFD"])", 1},
-            {"[\"\xC3\\\\\", 1]", R"(["\uFFFD\\",1])", 1},
-            {R"(["\u12"])", R"(["\uFFFD"])", 1},
-            {R"(["\u12G4"])", R"(["\uFFFDG4"])", 1},
-            {R"(["\uDC00x"])", R"(["\uFFFDx"])", 1},
-            {R"(["\uD800x"])", R"(["\uFFFDx"])", 1},
-            {R"(["\uD800\u0041"])", R"(["\uFFFDA"])", 1},
-            {R"(["\uD800\uD800\uDC00"])", R"(["\uFFFD\uD800\uDC00"])", 1},
-            {R"(["\uD800\uD800\uD800x"])", R"(["\uFFFD\uFFFD\uFFFDx"])", 1},
-            {
-                R"(["\uD800\"x", 1])", R"(["\uFFFD\"x",1])", 1
-            },
-            {R"(["\uD800\q"])", R"(["\uFFFDq"])", 1},
-            {"[\"a\tb\"]", R"(["a\tb"])", 1},
-            {R"(["a\qb\u0041\x"])", R"(["aqbAx"])", 1},
-
-            // a broken number keeps its longest valid prefix
-            {"[1.]", "[1]", 1},
-            {"[-2.]", "[-2]", 1},
-            {"[1.5e]", "[1.5]", 1},
-            {"[1e+]", "[1]", 1},
-            {"[1.x2, 3]", "[1,3]", 1},
-
-            // what cannot be read at all is null
-            {"[1,NaN,3]", "[1,null,3]", 1},
-            {"[tru]", "[null]", 1},
-            {"[-]", "[null]", 1},
-            {R"({"a":Infinity})", R"({"a":null})", 1},
-
-            // a stray token is dropped
-            {"[:1]", "[1]", 1},
-            {R"(["a":1])", R"(["a",1])", 1},
-            {R"({"a"::1})", R"({"a":1})", 1},
-
-            // a member that cannot be read is skipped
-            {R"({1:2,"b":3})", R"({"b":3})", 1},
-            {R"({"a":1 2})", R"({"a":1})", 1},
-            {R"({,"a":1})", R"({"a":1})", 1},
-            {R"({"a":1,,"b":2})", R"({"a":1,"b":2})", 1},
-            {"{a:1}", "{}", 1},
-            {R"({"a":1 [1,{"b":2}], "c":3})", R"({"a":1,"c":3})", 1},
-            {R"([{1}, "a"])", R"([{},"a"])", 1},
-
-            // a wrong closing bracket closes the innermost container
-            {R"({"a":[1,2}, "b":3})", R"({"a":[1,2],"b":3})", 1},
-            {R"([{"a":1], 2])", R"([{"a":1},2])", 1},
-            {"{]", "{}", 1},
-            {"[}", "[]", 1},
-
-            // the end of the input closes all containers
-            {R"({"a":[1,2)", R"({"a":[1,2]})", 1},
-            {"[", "[]", 1},
-            {"{", "{}", 1},
-            {R"({"a")", R"({"a":null})", 1},
-            {R"({"a":)", R"({"a":null})", 1},
-            {"[1,", "[1]", 1},
-            {"[[[1", "[[[1]]]", 1},
-            {
-                R"(["abc)", R"(["abc"])", 2
-            },
-            {"[1,tr", "[1,null]", 2},
-            {"\"abc", "\"abc\"", 1},
-            {"[\"ab\ncd\"]", R"(["ab",null,"]"])", 4},
-
-            // what comes before the top-level value is skipped
-            {")]}'\n{\"a\":1}", R"({"a":1})", 1},
-            {R"(data: {"a":1})", R"({"a":1})", 1},
-            {"\xEF\xBB[1]", "[1]", 1},
-
-            // what comes after it is an error that ends parsing
-            {R"({"a":1}})", R"({"a":1})", 1},
-            {"[1}]", "[1]", 2},
-            {"[1] [2]", "[1]", 1},
-        };
-
-        for (const auto& repair : repairs)
-        {
-            CAPTURE(repair.input)
-            const auto result = parse_recovering(std::string(repair.input));
-            CHECK(!result.ok);
-            CHECK(result.balanced);
-            CHECK(result.value == json::parse(repair.expected));
-            CHECK(result.errors.size() == repair.errors);
-        }
-    }
-
-    SECTION("number overflow")
-    {
-        const auto result = parse_recovering(std::string("[1e999,-1e999]"));
-        CHECK(!result.ok);
-        CHECK(result.balanced);
-        CHECK(result.errors.size() == 2);
-        CHECK(result.errors[0] == "[json.exception.out_of_range.406] number overflow parsing '1e999'");
-        REQUIRE(result.value.size() == 2);
-        CHECK(result.value[0].is_number_float());
-        CHECK(result.value[0].get<double>() == std::numeric_limits<double>::infinity());
-        CHECK(result.value[1].get<double>() == -std::numeric_limits<double>::infinity());
-
-        // the SAX parser gets the number's text
-        SaxEventLogger logger;
-        logger.recover = true;
-        CHECK(!json::sax_parse("1e999", &logger));
-        CHECK(logger.events == std::vector<std::string>({"parse_error(5)", "number_float(1e999)"}));
-    }
-
-    SECTION("nothing to recover")
-    {
-        for (const std::string s :
-                {
-                    "", "   ", "]", "tru", "NaN", ",:", "/* comment"
-                })
-        {
-            CAPTURE(s)
-            const auto result = parse_recovering(s, true, true);
-            CHECK(!result.ok);
-            CHECK(result.balanced);
-            CHECK(result.events == 0);
-            CHECK(result.value == nullptr);
-            CHECK(result.errors.size() == 1);
-        }
-    }
-
-    SECTION("error messages")
-    {
-        // the first error is reported as without recovery
-        for (const std::string s :
-                {
-                    "[1 2]", R"({"a":1 "b":2})", R"({"a" 1})", R"({"a":})", "[1,]", "[1.]",
-                    R"(["a\qb"])", "[1e999]", "{1:2}", R"({"a":[1,2}})", "[1,", "[1] [2]", "{a:1}"
-                })
-        {
-            CAPTURE(s)
-            const auto result = parse_recovering(s);
-            REQUIRE(!result.errors.empty());
-            json _;
-            CHECK_THROWS_WITH_STD_STR(_ = json::parse(s), result.errors.front());
-        }
-
-        // the token of an error begins where the previous error was
-        const auto result = parse_recovering(std::string("[tru, fals, nul]"));
-        CHECK(result.errors == std::vector<std::string>(
-        {
-            "[json.exception.parse_error.101] parse error at line 1, column 5: syntax error while parsing value - invalid literal; last read: '[tru,'",
-            "[json.exception.parse_error.101] parse error at line 1, column 11: syntax error while parsing value - invalid literal; last read: ', fals,'",
-            "[json.exception.parse_error.101] parse error at line 1, column 16: syntax error while parsing value - invalid literal; last read: ', nul]'"
-        }));
-        CHECK(result.value == json::parse("[null,null,null]"));
-    }
-
-    SECTION("events")
-    {
-        // see #4522
-        SaxEventLogger logger;
-        logger.recover = true;
-        CHECK(!json::sax_parse(R"([{1}, "a"])", &logger));
-        CHECK(logger.events == std::vector<std::string>(
-        {
-            "start_array()", "start_object()", "parse_error(3)", "end_object()", "string(a)", "end_array()"
-        }));
-    }
-
-    SECTION("options")
-    {
-        SECTION("strict")
-        {
-            const auto result = parse_recovering(std::string("[1 2] [3]"), false);
-            CHECK(!result.ok);
-            CHECK(result.value == json::parse("[1,2]"));
-            CHECK(result.errors.size() == 1);
-        }
-
-        SECTION("ignore_trailing_commas")
-        {
-            for (const std::string s :
-                    {
-                        "[1,]", R"({"a":1,})", "[[1,],]"
-                    })
-            {
-                CAPTURE(s)
-                const auto result = parse_recovering(s, true, false, true);
-                CHECK(result.ok);
-                CHECK(result.errors.empty());
-            }
-
-            auto result = parse_recovering(std::string("[1,,]"), true, false, true);
-            CHECK(result.value == json::parse("[1,null]"));
-            CHECK(result.errors.size() == 1);
-
-            result = parse_recovering(std::string(R"({"a":1,,})"), true, false, true);
-            CHECK(result.value == json::parse(R"({"a":1})"));
-            CHECK(result.errors.size() == 1);
-        }
-
-        SECTION("ignore_comments")
-        {
-            auto result = parse_recovering(std::string("[1 /* one */ 2]"), true, true);
-            CHECK(result.value == json::parse("[1,2]"));
-            CHECK(result.errors.size() == 1);
-
-            // a comment that is not closed runs to the end of the input, which
-            // is not reported again
-            result = parse_recovering(std::string("[1, 2 /* unterminated"), true, true);
-            CHECK(result.balanced);
-            CHECK(result.value == json::parse("[1,2]"));
-            CHECK(result.errors.size() == 1);
-
-            // a '/' that does not begin a comment is garbage
-            result = parse_recovering(std::string("[1, /x, 2]"), true, true);
-            CHECK(result.balanced);
-            CHECK(result.value == json::parse("[1,null,2]"));
-            CHECK(result.errors.size() == 1);
-        }
-    }
-
-    SECTION("null bytes")
-    {
-        // a null byte ends the input, unless JSON_STRICT_NUL_HANDLING is set
-        const auto result = parse_recovering(std::string("[1,\0x", 5));
-        CHECK(result.balanced);
-        CHECK(!result.ok);
-#ifdef JSON_TEST_STRICT_NUL_HANDLING_ENABLED
-        CHECK(result.value == json::parse("[1,null]"));
-#else
-        CHECK(result.value == json::parse("[1]"));
-        CHECK(result.errors.size() == 1);
-#endif
-
-        const auto in_string = parse_recovering(std::string("[\"a\0b\"]", 7));
-        CHECK(in_string.balanced);
-#ifdef JSON_TEST_STRICT_NUL_HANDLING_ENABLED
-        CHECK(in_string.value == json::array({std::string("a\0b", 3)}));
-#else
-        CHECK(in_string.value == json::parse(R"(["a"])"));
-#endif
-    }
-
-    SECTION("the SAX parser stops recovering")
-    {
-        json j;
-        RecoveringDomParser sax(j, 2);
-        CHECK(!json::sax_parse("[1 2 3 4 5]", &sax));
-        CHECK(sax.errors.size() == 2);
-
-        // an error at a delimiter that an invalid token consumed is reported
-        // to the SAX parser, too
-        json j2;
-        RecoveringDomParser sax2(j2, 2);
-        CHECK(!json::sax_parse("[tru}, 1]", &sax2));
-        CHECK(sax2.errors.size() == 2);
-    }
-
-    SECTION("an event stops parsing during a repair")
-    {
-        // start_object() and key() are passed, then null() for the missing
-        // value returns false
-        RecoveringCountdown countdown(2);
-        CHECK(!json::sax_parse(R"({"a":})", &countdown));
-
-        // the end of the input: end_array() for the second array returns false
-        RecoveringCountdown countdown2(4);
-        CHECK(!json::sax_parse("[[1", &countdown2));
-    }
-
-    SECTION("input adapters")
-    {
-        // the lexer reads contiguous and streaming input differently, and it
-        // puts back a character that ended an invalid token
-        for (const std::string s :
-                {
-                    "[1 2]", "[tru}, 1]", R"({"a" "b\q", "c":[1.x, 2}})", "[\"\xFF\xC3(\", -, 1e+]", "{a:1,\"b\":2", ")]}' [1]"
-                })
-        {
-            CAPTURE(s)
-            const auto reference = parse_recovering(s);
-            CHECK(reference.balanced);
-
-            const auto from_c_string = parse_recovering(s.c_str());
-            CHECK(from_c_string.value == reference.value);
-            CHECK(from_c_string.errors == reference.errors);
-
-            const std::list<char> l(s.begin(), s.end());
-            json j;
-            RecoveringDomParser sax(j);
-            CHECK(!json::sax_parse(l.begin(), l.end(), &sax));
-            CHECK(j == reference.value);
-            CHECK(sax.errors == reference.errors);
-
-            std::istringstream ss(s);
-            const auto from_stream = parse_recovering(ss);
-            CHECK(from_stream.value == reference.value);
-            CHECK(from_stream.errors == reference.errors);
-        }
-    }
-
-    SECTION("long runs of errors")
-    {
-        // no error may copy all the input read before it
-        const auto closing = parse_recovering("[" + std::string(100000, '}'));
-        CHECK(closing.balanced);
-        CHECK(closing.value == json::array());
-
-        const auto garbage = parse_recovering("[" + std::string(100000, 'x') + "]");
-        CHECK(garbage.balanced);
-        CHECK(garbage.errors.size() == 1);
-
-        const auto commas = parse_recovering("{" + std::string(100000, ',') + "}");
-        CHECK(commas.balanced);
-        CHECK(commas.value == json::object());
-    }
-
-    SECTION("mutations of valid input")
-    {
-        // whatever the input, the events are balanced, every error is reported
-        // at most once, and valid input is parsed as usual
-        const std::vector<std::string> documents =
-        {
-            R"({"name": "value", "list": [1, -2.5, true, null, {"x": [[]]}], "e": "\u00e9"})",
-            R"([{"a": [1, 2, {"b": "c"}]}, [], {}, "\ud83d\ude00", 1e10])",
-            "{\"\xC3\xA9\": \"\xF0\x9F\x98\x80\"}",
-            R"(  {"k" : [ "v" , 0 ] }  )",
-        };
-        // each character that can be inserted, including a null byte
-        const std::string insertions("[]{},:\"x\\\0\xFF", 11);
-
-        std::vector<std::string> inputs;
-        for (const auto& doc : documents)
-        {
-            for (std::size_t i = 0; i <= doc.size(); ++i)
-            {
-                inputs.push_back(doc.substr(0, i));
-                if (i < doc.size())
-                {
-                    inputs.push_back(doc.substr(0, i) + doc.substr(i + 1));
-                }
-                for (const char c : insertions)
-                {
-                    inputs.push_back(doc.substr(0, i) + c + doc.substr(i));
-                }
-            }
-        }
-
-        for (const auto& s : inputs)
-        {
-            CAPTURE(s)
-            const auto result = parse_recovering(s);
-            CHECK(result.balanced);
-            CHECK(result.errors.size() <= s.size() + 1);
-            CHECK(result.events <= (4 * s.size()) + 4);
-            if (json::accept(s))
-            {
-                CHECK(result.ok);
-                CHECK(result.errors.empty());
-                CHECK(result.value == json::parse(s));
-            }
-            else
-            {
-                CHECK(!result.ok);
-                CHECK(!result.errors.empty());
-            }
-        }
-    }
-}

tests/src/unit-msgpack.cpp

@@ -31,6 +31,8 @@ using nlohmann::json;
 #include "make_test_data_available.hpp"
 #include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
+#include "sax_countdown.hpp"
+using utils::SaxCountdown;
 
 
 TEST_CASE("MessagePack")
@@ -1643,6 +1645,30 @@ TEST_CASE("MessagePack")
             }
         }
     }
+
+    SECTION("SAX aborts")
+    {
+        SECTION("start_array(len)")
+        {
+            std::vector<uint8_t> const v = {0x93, 0x01, 0x02, 0x03};
+            SaxCountdown scp(0);
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
+        }
+
+        SECTION("start_object(len)")
+        {
+            std::vector<uint8_t> const v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
+            SaxCountdown scp(0);
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
+        }
+
+        SECTION("key()")
+        {
+            std::vector<uint8_t> const v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
+            SaxCountdown scp(1);
+            CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
+        }
+    }
 }
 
 TEST_CASE("issue #5405 - array reserve for definite-length MessagePack arrays")
@@ -1713,6 +1739,21 @@ TEST_CASE("issue #5405 - array reserve for definite-length MessagePack arrays")
             CHECK(json::from_msgpack(packed) == j);
         }
     }
+
+    SECTION("a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
+    {
+        // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
+        // a custom SAX consumer that does not touch a DOM array sees identical events
+        json j = json::array();
+        for (int i = 0; i < 100; ++i)
+        {
+            j.push_back(i);
+        }
+        const auto packed = json::to_msgpack(j);
+
+        SaxCountdown scp(1000000); // large enough to never trigger an abort
+        CHECK(json::sax_parse(packed, &scp, json::input_format_t::msgpack));
+    }
 }
 
 TEST_CASE("regression test - MessagePack ext type rejects a subtype that doesn't fit a single byte")
@@ -1751,6 +1792,15 @@ TEST_CASE("MessagePack nesting does not consume the call stack")
         CHECK(json::from_msgpack(input, true, false).is_discarded());
     }
 
+    SECTION("a well-formed deep value is read through the SAX interface")
+    {
+        std::vector<uint8_t> input(300000, 0x91);
+        input.push_back(0x01); // innermost value
+
+        SaxCountdown accept_all(600001);
+        CHECK(json::sax_parse(input, &accept_all, json::input_format_t::msgpack));
+    }
+
     SECTION("a well-formed deep value is read into a value")
     {
         const std::size_t depth = 10000;
@@ -1798,6 +1848,31 @@ TEST_CASE("MessagePack input that cannot be read is discarded by every overload"
 #endif
 }
 
+TEST_CASE("MessagePack SAX parsing stops at every event")
+{
+    // Containers are opened and closed by the loop that reads them; a SAX
+    // handler that rejects any event - including the end of a nested
+    // container - must stop the parse right there.
+    const auto count_events = [](const std::vector<std::uint8_t>& input)
+    {
+        int events = 0;
+        while (true)
+        {
+            SaxCountdown scp(events);
+            if (json::sax_parse(input, &scp, json::input_format_t::msgpack))
+            {
+                return events;
+            }
+            ++events;
+            REQUIRE(events < 1000);
+        }
+    };
+
+    // 20 events: every container kind closes inside another one
+    const json j = json::parse(R"({"a": [1, {"b": []}], "c": {"d": [[2]]}})");
+    CHECK(count_events(json::to_msgpack(j)) == 20);
+}
+
 TEST_CASE("single MessagePack roundtrip")
 {
     SECTION("sample.json")

tests/src/unit-regression3.cpp

@@ -22,6 +22,14 @@
 // scoped enum, so get<std::byte>() (needed below to get<std::vector<std::byte>>()
 // from a plain JSON array, not just from an already-binary value) relies on
 // enum serialization being enabled
+// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
+// line *before* including json.hpp, since the library #undefs it once the header
+// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
+// tests of deprecated functions are skipped if these functions are deleted
+#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
+    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
+#endif
+
 #if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
     #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
 #endif
@@ -802,6 +810,50 @@ TEST_CASE("issue #5338 - truncated CBOR tagged binary subtype is rejected")
     }
 }
 
+TEST_CASE("issue #5676 - SAX parsing of CBOR tags")
+{
+    const json expected = json::binary({1, 2, 3}, 42);
+    const auto cbor = json::to_cbor(expected);
+
+    nlohmann::detail::json_sax_acceptor<json> acceptor;
+    CHECK_FALSE(json::sax_parse(cbor, &acceptor, json::input_format_t::cbor));
+    CHECK_FALSE(json::sax_parse(cbor, &acceptor, json::input_format_t::cbor,
+                                true, false, false, json::cbor_tag_handler_t::error));
+
+    CHECK(json::sax_parse(cbor, &acceptor, json::input_format_t::cbor,
+                          true, false, false, json::cbor_tag_handler_t::ignore));
+
+    json parsed;
+    nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> sax(parsed);
+    CHECK(json::sax_parse(cbor, &sax, json::input_format_t::cbor,
+                          true, false, false, json::cbor_tag_handler_t::store));
+    CHECK(parsed == expected);
+
+    json iterator_parsed;
+    nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> iterator_sax(iterator_parsed);
+    CHECK(json::sax_parse(cbor.begin(), cbor.end(), &iterator_sax, json::input_format_t::cbor,
+                          true, false, false, json::cbor_tag_handler_t::store));
+    CHECK(iterator_parsed == expected);
+
+#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
+    json span_parsed;
+    nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> span_sax(span_parsed);
+    CHECK(json::sax_parse(nlohmann::detail::span_input_adapter(cbor.data(), cbor.size()), &span_sax,
+                          json::input_format_t::cbor, true, false, false, json::cbor_tag_handler_t::store));
+    CHECK(span_parsed == expected);
+#endif
+
+    const std::string text = "null";
+    CHECK(json::sax_parse(text, &acceptor, json::input_format_t::json,
+                          true, false, false, json::cbor_tag_handler_t::store));
+    CHECK(json::sax_parse(text.begin(), text.end(), &acceptor, json::input_format_t::json,
+                          true, false, false, json::cbor_tag_handler_t::store));
+#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
+    CHECK(json::sax_parse(nlohmann::detail::span_input_adapter(text.data(), text.size()), &acceptor,
+                          json::input_format_t::json, true, false, false, json::cbor_tag_handler_t::store));
+#endif
+}
+
 TEST_CASE("issue #5402 - update(merge_objects=true) overwrites a primitive with an object")
 {
     json t = {{"k", 1}};

tests/src/unit-sax_parse.cpp

@@ -1,768 +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
-
-/////////////////////////////////////////////////////////////////////
-// Tests that call basic_json::sax_parse have a file of their own: every
-// sax_parse call instantiates the parser and binary reader that recover from
-// errors (see #3989), and in unit-regression2.cpp, unit-regression3.cpp, and
-// unit-msgpack.cpp this made the objects too large for the MinGW linker to
-// relocate (see #5511).
-/////////////////////////////////////////////////////////////////////
-
-#include "doctest_compatibility.h"
-
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
-#include <nlohmann/json.hpp>
-using json = nlohmann::json;
-
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <initializer_list>
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "sax_countdown.hpp"
-using utils::SaxCountdown;
-
-// a narrow number_float_t, so that a double read from binary input can
-// overflow it
-using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
-
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
-
-namespace
-{
-/// builds a value from SAX events, asks the parser to recover from its first
-/// 100 errors, and checks that the events are balanced (see #3989)
-template<typename BasicJsonType>
-class BasicRecoveringParser
-{
-  public:
-    explicit BasicRecoveringParser(BasicJsonType& j)
-        : dom(j, false)
-    {}
-
-    bool null()
-    {
-        value();
-        return dom.null();
-    }
-
-    bool boolean(bool val)
-    {
-        value();
-        return dom.boolean(val);
-    }
-
-    bool number_integer(typename BasicJsonType::number_integer_t val)
-    {
-        value();
-        return dom.number_integer(val);
-    }
-
-    bool number_unsigned(typename BasicJsonType::number_unsigned_t val)
-    {
-        value();
-        return dom.number_unsigned(val);
-    }
-
-    bool number_float(typename BasicJsonType::number_float_t val, const std::string& s)
-    {
-        value();
-        return dom.number_float(val, s);
-    }
-
-    bool string(std::string& val)
-    {
-        value();
-        return dom.string(val);
-    }
-
-    bool binary(typename BasicJsonType::binary_t& val)
-    {
-        value();
-        return dom.binary(val);
-    }
-
-    bool start_object(std::size_t elements)
-    {
-        value();
-        stack.push_back('o');
-        return dom.start_object(elements);
-    }
-
-    bool key(std::string& val)
-    {
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.back() = 'v';
-        return dom.key(val);
-    }
-
-    bool end_object()
-    {
-        if (stack.empty() || stack.back() != 'o')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_object();
-    }
-
-    bool start_array(std::size_t elements)
-    {
-        value();
-        stack.push_back('a');
-        return dom.start_array(elements);
-    }
-
-    bool end_array()
-    {
-        if (stack.empty() || stack.back() != 'a')
-        {
-            well_formed = false;
-            return false;
-        }
-        stack.pop_back();
-        return dom.end_array();
-    }
-
-    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const json::exception& ex)
-    {
-        messages.emplace_back(ex.what());
-        // a limit, so that a reader that does not stop fails the test
-        // instead of making it hang
-        return ++errors < 100;
-    }
-
-    /// whether the events were balanced and every key was followed by a value
-    bool balanced() const
-    {
-        return well_formed && stack.empty();
-    }
-
-    /// builds the value
-    nlohmann::detail::json_sax_dom_parser<BasicJsonType> dom;
-    std::size_t errors = 0;
-    std::vector<std::string> messages {}; // NOLINT(readability-redundant-member-init)
-    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
-    bool well_formed = true;
-
-  private:
-    void value()
-    {
-        if (!stack.empty())
-        {
-            if (stack.back() == 'v')
-            {
-                stack.back() = 'o';
-            }
-            else if (stack.back() == 'o')
-            {
-                well_formed = false;
-            }
-        }
-    }
-
-};
-
-using RecoveringParser = BasicRecoveringParser<json>;
-
-struct BinaryParseResult
-{
-    json value;
-    std::size_t errors;
-    std::vector<std::string> messages;
-    bool ok;
-    bool balanced;
-};
-
-BinaryParseResult parse_binary_recovering(const std::vector<std::uint8_t>& input, const json::input_format_t format)
-{
-    json j;
-    RecoveringParser sax(j);
-    const bool ok = json::sax_parse(input, &sax, format);
-    return {j, sax.errors, sax.messages, ok, sax.balanced()};
-}
-
-#if !defined(JSON_NOEXCEPTION)
-/// the message of the exception that reading @a input into a JSON value
-/// throws, or an empty string if reading succeeds
-std::string binary_error_message(const std::vector<std::uint8_t>& input, const json::input_format_t format)
-{
-    try
-    {
-        json _;
-        switch (format)
-        {
-            case json::input_format_t::cbor:
-                _ = json::from_cbor(input);
-                break;
-            case json::input_format_t::msgpack:
-                _ = json::from_msgpack(input);
-                break;
-            case json::input_format_t::ubjson:
-                _ = json::from_ubjson(input);
-                break;
-            case json::input_format_t::bjdata:
-                _ = json::from_bjdata(input);
-                break;
-            case json::input_format_t::bson:
-                _ = json::from_bson(input);
-                break;
-            case json::input_format_t::bon8:
-                _ = json::from_bon8(input);
-                break;
-            case json::input_format_t::json:
-            default:
-                break;
-        }
-    }
-    catch (const json::exception& e)
-    {
-        return e.what();
-    }
-    return "";
-}
-#endif
-
-/// a BSON element: its type, its name, and its value
-std::vector<std::uint8_t> bson_element(const std::uint8_t type, const std::string& name, const std::vector<std::uint8_t>& value)
-{
-    std::vector<std::uint8_t> result = {type};
-    result.insert(result.end(), name.begin(), name.end());
-    result.push_back(0x00);
-    result.insert(result.end(), value.begin(), value.end());
-    return result;
-}
-
-/// a BSON document of the given elements; @a size_offset is added to the
-/// size it declares
-std::vector<std::uint8_t> bson_document(const std::vector<std::vector<std::uint8_t>>& elements, const int size_offset = 0)
-{
-    std::vector<std::uint8_t> body;
-    for (const auto& element : elements)
-    {
-        body.insert(body.end(), element.begin(), element.end());
-    }
-    const auto size = static_cast<std::uint32_t>(static_cast<int>(body.size()) + 5 + size_offset);
-    std::vector<std::uint8_t> result = {static_cast<std::uint8_t>(size & 0xFFu), static_cast<std::uint8_t>((size >> 8u) & 0xFFu),
-                                        static_cast<std::uint8_t>((size >> 16u) & 0xFFu), static_cast<std::uint8_t>((size >> 24u) & 0xFFu)
-                                       };
-    result.insert(result.end(), body.begin(), body.end());
-    result.push_back(0x00);
-    return result;
-}
-
-/// a BSON int32 value
-std::vector<std::uint8_t> bson_int32(const std::int32_t value)
-{
-    const auto u = static_cast<std::uint32_t>(value);
-    return {static_cast<std::uint8_t>(u & 0xFFu), static_cast<std::uint8_t>((u >> 8u) & 0xFFu),
-            static_cast<std::uint8_t>((u >> 16u) & 0xFFu), static_cast<std::uint8_t>((u >> 24u) & 0xFFu)};
-}
-
-/// a BSON string value, whose length is @a length_offset off
-std::vector<std::uint8_t> bson_string(const std::string& value, const std::int32_t length_offset = 0)
-{
-    auto result = bson_int32(static_cast<std::int32_t>(value.size() + 1) + length_offset);
-    result.insert(result.end(), value.begin(), value.end());
-    result.push_back(0x00);
-    return result;
-}
-
-/// @a count bytes of value 0xAB
-std::vector<std::uint8_t> bytes(const std::size_t count)
-{
-    return std::vector<std::uint8_t>(count, 0xAB);
-}
-
-/// the bytes of @a parts, one after the other
-std::vector<std::uint8_t> concatenated(std::initializer_list<std::vector<std::uint8_t>> parts)
-{
-    std::vector<std::uint8_t> result;
-    for (const auto& part : parts)
-    {
-        result.insert(result.end(), part.begin(), part.end());
-    }
-    return result;
-}
-
-/// U+FFFD REPLACEMENT CHARACTER
-std::string replacement_character()
-{
-    return "\xEF\xBF\xBD";
-}
-}  // namespace
-
-TEST_CASE("regression test - #3989 SAX parse_error() returning true")
-{
-    SECTION("binary formats complete what was read before the input ends")
-    {
-        const json j = {{"a", {1, -2, {{"b", "c"}}, json::array()}}, {"d", {{"e", nullptr}, {"f", true}}}, {"g", 1.5}, {"h", json::binary({1, 2, 3})}};
-
-        const std::vector<std::pair<json::input_format_t, std::vector<std::uint8_t>>> encodings =
-        {
-            {json::input_format_t::cbor, json::to_cbor(j)},
-            {json::input_format_t::msgpack, json::to_msgpack(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j, true, true)},
-            {json::input_format_t::bjdata, json::to_bjdata(j)},
-            {json::input_format_t::bjdata, json::to_bjdata(j, true, true)},
-            {json::input_format_t::bson, json::to_bson(j)},
-            {json::input_format_t::bon8, json::to_bon8(j)},
-        };
-
-        for (const auto& encoding : encodings)
-        {
-            const auto format = encoding.first;
-            const auto& bytes = encoding.second;
-            CAPTURE(format)
-
-            // every prefix is truncated input
-            for (std::size_t length = 0; length < bytes.size(); ++length)
-            {
-                CAPTURE(length)
-                const auto result = parse_binary_recovering(std::vector<std::uint8_t>(bytes.begin(), bytes.begin() + static_cast<std::ptrdiff_t>(length)), format);
-                CHECK(!result.ok);
-                CHECK(result.errors == 1);
-                CHECK(result.balanced);
-            }
-
-            // the complete input is read as usual (binary values do not
-            // round-trip through every format, so compare with a plain parse)
-            json expected;
-            nlohmann::detail::json_sax_dom_parser<json> dom(expected);
-            CHECK(json::sax_parse(bytes, &dom, format));
-            const auto complete = parse_binary_recovering(bytes, format);
-            CHECK(complete.ok);
-            CHECK(complete.errors == 0);
-            CHECK(complete.value == expected);
-
-            // a byte after the value
-            auto trailing_bytes = bytes;
-            trailing_bytes.push_back(0x01);
-            const auto trailing = parse_binary_recovering(trailing_bytes, format);
-            CHECK(!trailing.ok);
-            CHECK(trailing.errors == 1);
-            CHECK(trailing.value == expected);
-        }
-    }
-
-    SECTION("containers without an end")
-    {
-        // these made the readers loop, or read on, after the error
-        const auto cbor_array = parse_binary_recovering({0x9F}, json::input_format_t::cbor);
-        CHECK(cbor_array.errors == 1);
-        CHECK(cbor_array.value == json::array());
-
-        const auto cbor_map = parse_binary_recovering({0xBF, 0x61, 'a'}, json::input_format_t::cbor);
-        CHECK(cbor_map.errors == 1);
-        CHECK(cbor_map.value == json({{"a", nullptr}}));
-
-        const auto msgpack_array = parse_binary_recovering({0xDD, 0xFF, 0xFF, 0xFF, 0xFF}, json::input_format_t::msgpack);
-        CHECK(msgpack_array.errors == 1);
-        CHECK(msgpack_array.value == json::array());
-
-        const auto msgpack_map = parse_binary_recovering({0x81, 0xA1, 'a', 0x92, 0x01}, json::input_format_t::msgpack);
-        CHECK(msgpack_map.errors == 1);
-        CHECK(msgpack_map.value == json({{"a", {1}}}));
-    }
-
-    SECTION("BJData ndarray")
-    {
-        // a 2x3 int8 array with two of its six elements; the annotated array
-        // format opens an object and two arrays of its own
-        const auto result = parse_binary_recovering({'[', '$', 'i', '#', '[', '$', 'i', '#', 'i', 2, 2, 3, 1, 2}, json::input_format_t::bjdata);
-        CHECK(result.errors == 1);
-        CHECK(result.balanced);
-        CHECK(result.value == json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2}}}));
-    }
-
-    SECTION("binary formats repair items whose end is known")
-    {
-        struct Repair
-        {
-            json::input_format_t format;
-            std::vector<std::uint8_t> input;
-            json expected;
-            std::size_t errors;
-        };
-
-        const std::vector<Repair> repairs =
-        {
-            // CBOR: tags are ignored (here tag 1 and the self-describe tag 55799)
-            {json::input_format_t::cbor, {0x82, 0xC1, 0x05, 0xD9, 0xD9, 0xF7, 0x06}, {5, 6}, 2},
-            // CBOR: undefined and other simple values become null
-            {json::input_format_t::cbor, {0x84, 0xF7, 0xE0, 0xF8, 0x20, 0x01}, {nullptr, nullptr, nullptr, 1}, 3},
-            // CBOR: members whose key is not a string are skipped, whatever their key and value
-            {json::input_format_t::cbor, {0xA4, 0x01, 0x02, 0x82, 0x01, 0x02, 0xA1, 0x61, 'x', 0x9F, 0xFF, 0xC1, 0x01, 0x5F, 0x41, 0x00, 0xFF, 0x61, 'a', 0x03}, {{"a", 3}}, 3},
-            {json::input_format_t::cbor, {0xBF, 0xF5, 0xBF, 0x61, 'x', 0x7F, 0x61, 'y', 0xFF, 0xFF, 0x61, 'a', 0x03, 0xFF}, {{"a", 3}}, 1},
-            // MessagePack: members whose key is not a string are skipped
-            {json::input_format_t::msgpack, {0x84, 0x01, 0x02, 0x81, 0xA1, 'x', 0x01, 0x92, 0x01, 0x02, 0xD4, 0x01, 0x02, 0xC0, 0xA1, 'a', 0x04}, {{"a", 4}}, 3},
-            // UBJSON: a char that is not ASCII becomes U+FFFD
-            {json::input_format_t::ubjson, {'[', 'C', 0x80, 'C', 'A', ']'}, {replacement_character(), "A"}, 1},
-            // UBJSON: the longest beginning of a high-precision number is kept
-            {json::input_format_t::ubjson, {'[', 'H', 'i', 5, '1', '2', 'a', 'b', 'c', 'H', 'i', 2, '1', '.', 'H', 'i', 3, 'a', 'b', 'c', 'H', 'i', 3, '4', '.', '5', ']'}, {12, 1, nullptr, 4.5}, 3},
-            // BJData, too
-            {json::input_format_t::bjdata, {'[', 'C', 0xFF, 'H', 'i', 2, '-', '1', 'H', 'i', 2, '-', 'x', ']'}, {replacement_character(), -1, nullptr}, 2},
-            // a NUL ends a high-precision number, as it ends JSON text
-            {json::input_format_t::ubjson, {'[', 'H', 'i', 4, '1', '2', 0, '9', 'H', 'i', 2, 0, '1', 'i', 3, ']'}, {12, nullptr, 3}, 2},
-            // BON8: members whose key is not a string are skipped
-            {json::input_format_t::bon8, {0x89, 0x91, 0x92, 0xC9, 0x40, 0x82, 0x91, 0x92, 0x61, 0x93}, {{"a", 3}}, 2},
-            {json::input_format_t::bon8, {0x8B, 0x91, 0x85, 0x91, 0xFE, 0xFA, 0x8B, 'x', 0x91, 0xFE, 0x61, 0x93, 0xFE}, {{"a", 3}}, 2},
-            // BSON: elements of types the library does not read become null
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x07, "_id", bytes(12)),                         // ObjectId
-                    bson_element(0x09, "date", bytes(8)),                         // UTC datetime
-                    bson_element(0x13, "decimal", bytes(16)),                     // 128-bit decimal
-                    bson_element(0x0B, "regex", {'a', '+', 0, 'i', 0}),           // regular expression
-                    bson_element(0x0D, "code", bson_string("f()")),               // JavaScript code
-                    bson_element(0x0E, "symbol", bson_string("s")),               // symbol
-                    bson_element(0x0C, "pointer", concatenated({bson_string("c"), bytes(12)})), // DBPointer
-                    bson_element(0x0F, "scope", concatenated({bson_int32(15), bson_string("g"), bson_document({})})), // code with scope
-                    bson_element(0x06, "undefined", {}),                          // undefined
-                    bson_element(0xFF, "min", {}),                                // min key
-                    bson_element(0x7F, "max", {}),                                // max key
-                    bson_element(0x10, "z", bson_int32(7)),
-                }),
-                {{"_id", nullptr}, {"date", nullptr}, {"decimal", nullptr}, {"regex", nullptr}, {"code", nullptr}, {"symbol", nullptr}, {"pointer", nullptr}, {"scope", nullptr}, {"undefined", nullptr}, {"min", nullptr}, {"max", nullptr}, {"z", 7}},
-                11
-            },
-            // BSON: an element of an unknown type becomes null, and the rest of its document is skipped
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x03, "inner", bson_document({bson_element(0x10, "a", bson_int32(1)), bson_element(0x42, "x", bytes(3)), bson_element(0x10, "b", bson_int32(2))})),
-                    bson_element(0x04, "array", bson_document({bson_element(0x10, "0", bson_int32(1)), bson_element(0x42, "1", bytes(3))})),
-                    bson_element(0x10, "after", bson_int32(3)),
-                }),
-                {{"inner", {{"a", 1}, {"x", nullptr}}}, {"array", {1, nullptr}}, {"after", 3}},
-                2
-            },
-            // BSON: so does a string or byte array whose length cannot be right
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x03, "inner", bson_document({bson_element(0x02, "s", bson_string("abc", -10)), bson_element(0x10, "b", bson_int32(2))})),
-                    bson_element(0x03, "bin", bson_document({bson_element(0x05, "b", concatenated({bson_int32(-1), bytes(1)})), bson_element(0x10, "b", bson_int32(2))})),
-                    bson_element(0x10, "after", bson_int32(3)),
-                }),
-                {{"inner", {{"s", nullptr}}}, {"bin", {{"b", nullptr}}}, {"after", 3}},
-                2
-            },
-            // BSON: a string without its terminator, and a document whose size does not match, are kept
-            {
-                json::input_format_t::bson, bson_document(
-                {
-                    bson_element(0x02, "s", {2, 0, 0, 0, 'a', 'X'}),
-                    bson_element(0x03, "inner", bson_document({bson_element(0x10, "a", bson_int32(1))}, 1)),
-                }),
-                {{"s", "a"}, {"inner", {{"a", 1}}}},
-                2
-            },
-        };
-
-        for (const auto& repair : repairs)
-        {
-            CAPTURE(repair.format)
-            CAPTURE(repair.input)
-            const auto result = parse_binary_recovering(repair.input, repair.format);
-            CHECK(!result.ok);
-            CHECK(result.balanced);
-            CHECK(result.errors == repair.errors);
-            CHECK(result.value == repair.expected);
-            REQUIRE(!result.messages.empty());
-#if !defined(JSON_NOEXCEPTION)
-            // the first error is the one reported without recovering; under
-            // JSON_NOEXCEPTION, reading without recovering aborts instead of
-            // throwing, so there is no message to compare with
-            CHECK(result.messages.front() == binary_error_message(repair.input, repair.format));
-#endif
-        }
-    }
-
-    SECTION("binary formats repair numbers that are out of range")
-    {
-        // CBOR: a double too large for a float number_float_t
-        float_json cbor;
-        BasicRecoveringParser<float_json> sax(cbor);
-        const std::vector<std::uint8_t> cbor_input = {0x82, 0xFB, 0x7E, 0x37, 0xE4, 0x3C, 0x88, 0x00, 0x75, 0x9C, 0x01}; // [1e300, 1]
-        CHECK(!float_json::sax_parse(cbor_input, &sax, float_json::input_format_t::cbor));
-        CHECK(sax.errors == 1);
-        CHECK(sax.messages.front() == "[json.exception.out_of_range.406] syntax error while parsing CBOR value: number overflow");
-        REQUIRE(cbor.size() == 2);
-        CHECK(std::isinf(cbor[0].get<float>()));
-        CHECK(cbor[1] == 1);
-
-        // UBJSON: a high-precision number too large for number_float_t
-        const auto ubjson = parse_binary_recovering({'H', 'i', 5, '1', 'e', '9', '9', '9'}, json::input_format_t::ubjson);
-        CHECK(ubjson.errors == 1);
-        CHECK(ubjson.value.is_number_float());
-        CHECK(std::isinf(ubjson.value.get<double>()));
-    }
-
-    SECTION("binary formats stop where the end of an item is not known")
-    {
-        // a byte that begins no item
-        const auto cbor = parse_binary_recovering({0x82, 0x01, 0x1C, 0x02}, json::input_format_t::cbor);
-        CHECK(cbor.errors == 1);
-        CHECK(cbor.value == json({1}));
-
-        // a key that is no item: the unused MessagePack byte, a CBOR break
-        // in a map of known size, and the end of a BON8 container
-        const auto msgpack = parse_binary_recovering({0x82, 0xA1, 'a', 0x01, 0xC1, 0x02}, json::input_format_t::msgpack);
-        CHECK(msgpack.errors == 1);
-        CHECK(msgpack.value == json({{"a", 1}}));
-        const auto cbor_break = parse_binary_recovering({0xA2, 0x61, 'a', 0x01, 0xFF, 0x02}, json::input_format_t::cbor);
-        CHECK(cbor_break.errors == 1);
-        CHECK(cbor_break.value == json({{"a", 1}}));
-        const auto bon8 = parse_binary_recovering({0x88, 0x61, 0x91, 0xFE}, json::input_format_t::bon8);
-        CHECK(bon8.errors == 1);
-        CHECK(bon8.value == json({{"a", 1}}));
-
-        // an indefinite-length string inside an indefinite-length string
-        const auto nested = parse_binary_recovering({0x82, 0x01, 0x7F, 0x7F, 0x61, 'a', 0xFF, 0xFF}, json::input_format_t::cbor);
-        CHECK(nested.errors == 1);
-        CHECK(nested.value == json({1}));
-
-        // a BJData ndarray whose element type has no name: the object that
-        // holds the ndarray was already begun
-        const auto ndarray = parse_binary_recovering({'[', '$', 0x01, '#', '[', '$', 'i', '#', 'i', 2, 2, 3}, json::input_format_t::bjdata);
-        CHECK(ndarray.errors == 1);
-        CHECK(ndarray.balanced);
-        CHECK(ndarray.value == json::object());
-
-        // a skipped member that the input ends in
-        const auto truncated = parse_binary_recovering({0xA2, 0x01, 0x82, 0x01}, json::input_format_t::cbor);
-        CHECK(truncated.errors == 2);
-        CHECK(truncated.balanced);
-        CHECK(truncated.value == json::object());
-
-        // a BSON element of an unknown type in a document whose size cannot be right
-        const auto bson = parse_binary_recovering(bson_document({bson_element(0x10, "a", bson_int32(1)), bson_element(0x42, "x", bytes(3))}, -10), json::input_format_t::bson);
-        CHECK(bson.errors == 1);
-        CHECK(bson.value == json({{"a", 1}, {"x", nullptr}}));
-    }
-
-    SECTION("changed bytes in binary input")
-    {
-        const json j = {{"a", {1, -2, {{"b", "c"}}, json::array()}}, {"d", {{"e", nullptr}, {"f", true}}}, {"g", 1.5}, {"h", json::binary({1, 2, 3})}, {"i", "\xC3\xA4"}};
-
-        const std::vector<std::pair<json::input_format_t, std::vector<std::uint8_t>>> encodings =
-        {
-            {json::input_format_t::cbor, json::to_cbor(j)},
-            {json::input_format_t::msgpack, json::to_msgpack(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j)},
-            {json::input_format_t::ubjson, json::to_ubjson(j, true, true)},
-            {json::input_format_t::bjdata, json::to_bjdata(j)},
-            {json::input_format_t::bjdata, json::to_bjdata(j, true, true)},
-            {json::input_format_t::bson, json::to_bson(j)},
-            {json::input_format_t::bon8, json::to_bon8(j)},
-        };
-        const std::vector<std::uint8_t> replacements = {0x00, 0x01, 0x7F, 0x80, 0xC1, 0xD9, 0xE0, 0xF7, 0xFE, 0xFF};
-
-        for (const auto& encoding : encodings)
-        {
-            const auto format = encoding.first;
-            const auto& original = encoding.second;
-            CAPTURE(format)
-
-            std::vector<std::vector<std::uint8_t>> inputs;
-            for (std::size_t position = 0; position < original.size(); ++position)
-            {
-                for (const auto replacement : replacements)
-                {
-                    auto changed = original;
-                    changed[position] = replacement;
-                    inputs.push_back(changed);
-                }
-                auto removed = original;
-                removed.erase(removed.begin() + static_cast<std::ptrdiff_t>(position));
-                inputs.push_back(removed);
-            }
-
-            for (const auto& input : inputs)
-            {
-                CAPTURE(input)
-                const auto result = parse_binary_recovering(input, format);
-                CHECK(result.balanced);
-                CHECK(result.errors <= input.size() + 1);
-#if !defined(JSON_NOEXCEPTION)
-                // an error is reported exactly if reading into a JSON value
-                // fails, and the first one is the same (under JSON_NOEXCEPTION,
-                // that reading aborts instead of throwing)
-                const auto message = binary_error_message(input, format);
-                CHECK(result.ok == message.empty());
-                if (!result.ok && result.errors < 100)
-                {
-                    CHECK(result.messages.front() == message);
-                }
-#endif
-            }
-        }
-    }
-
-    SECTION("JSON text")
-    {
-        // the parser stopped, but reported success
-        json j;
-        RecoveringParser sax(j);
-        CHECK(!json::sax_parse("[1,2,3,]", &sax));
-        CHECK(sax.errors == 1);
-        CHECK(j == json({1, 2, 3}));
-    }
-
-    SECTION("the SAX parsers of the library stop")
-    {
-        json _;
-        CHECK(json::from_cbor(std::vector<std::uint8_t> {0x9F}, true, false).is_discarded());
-        CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<std::uint8_t> {0x9F}), "[json.exception.parse_error.110] parse error at byte 2: syntax error while parsing CBOR value: unexpected end of input", json::parse_error&);
-        CHECK(json::parse("[1,2,3,]", nullptr, false).is_discarded());
-        CHECK(!json::accept("[1,2,3,]"));
-    }
-}
-
-
-TEST_CASE("issue #5676 - SAX parsing of CBOR tags")
-{
-    const json expected = json::binary({1, 2, 3}, 42);
-    const auto cbor = json::to_cbor(expected);
-
-    nlohmann::detail::json_sax_acceptor<json> acceptor;
-    CHECK_FALSE(json::sax_parse(cbor, &acceptor, json::input_format_t::cbor));
-    CHECK_FALSE(json::sax_parse(cbor, &acceptor, json::input_format_t::cbor,
-                                true, false, false, json::cbor_tag_handler_t::error));
-
-    CHECK(json::sax_parse(cbor, &acceptor, json::input_format_t::cbor,
-                          true, false, false, json::cbor_tag_handler_t::ignore));
-
-    json parsed;
-    nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> sax(parsed);
-    CHECK(json::sax_parse(cbor, &sax, json::input_format_t::cbor,
-                          true, false, false, json::cbor_tag_handler_t::store));
-    CHECK(parsed == expected);
-
-    json iterator_parsed;
-    nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> iterator_sax(iterator_parsed);
-    CHECK(json::sax_parse(cbor.begin(), cbor.end(), &iterator_sax, json::input_format_t::cbor,
-                          true, false, false, json::cbor_tag_handler_t::store));
-    CHECK(iterator_parsed == expected);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    json span_parsed;
-    nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> span_sax(span_parsed);
-    CHECK(json::sax_parse(nlohmann::detail::span_input_adapter(cbor.data(), cbor.size()), &span_sax,
-                          json::input_format_t::cbor, true, false, false, json::cbor_tag_handler_t::store));
-    CHECK(span_parsed == expected);
-#endif
-
-    const std::string text = "null";
-    CHECK(json::sax_parse(text, &acceptor, json::input_format_t::json,
-                          true, false, false, json::cbor_tag_handler_t::store));
-    CHECK(json::sax_parse(text.begin(), text.end(), &acceptor, json::input_format_t::json,
-                          true, false, false, json::cbor_tag_handler_t::store));
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-    CHECK(json::sax_parse(nlohmann::detail::span_input_adapter(text.data(), text.size()), &acceptor,
-                          json::input_format_t::json, true, false, false, json::cbor_tag_handler_t::store));
-#endif
-}
-
-
-TEST_CASE("MessagePack SAX aborts")
-{
-    SECTION("start_array(len)")
-    {
-        std::vector<uint8_t> const v = {0x93, 0x01, 0x02, 0x03};
-        SaxCountdown scp(0);
-        CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
-    }
-
-    SECTION("start_object(len)")
-    {
-        std::vector<uint8_t> const v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
-        SaxCountdown scp(0);
-        CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
-    }
-
-    SECTION("key()")
-    {
-        std::vector<uint8_t> const v = {0x81, 0xa3, 0x66, 0x6F, 0x6F, 0xc2};
-        SaxCountdown scp(1);
-        CHECK(!json::sax_parse(v, &scp, json::input_format_t::msgpack));
-    }
-}
-
-TEST_CASE("issue #5405 - a user-defined SAX consumer is unaffected by the internal DOM reserve optimization")
-{
-    // the reserve() call is local to json_sax_dom_parser / json_sax_dom_callback_parser;
-    // a custom SAX consumer that does not touch a DOM array sees identical events
-    json j = json::array();
-    for (int i = 0; i < 100; ++i)
-    {
-        j.push_back(i);
-    }
-    const auto packed = json::to_msgpack(j);
-
-    SaxCountdown scp(1000000); // large enough to never trigger an abort
-    CHECK(json::sax_parse(packed, &scp, json::input_format_t::msgpack));
-}
-
-TEST_CASE("MessagePack nesting does not consume the call stack - SAX interface")
-{
-    // see the test case of the same name in unit-msgpack.cpp (#5104)
-    std::vector<uint8_t> input(300000, 0x91);
-    input.push_back(0x01); // innermost value
-
-    SaxCountdown accept_all(600001);
-    CHECK(json::sax_parse(input, &accept_all, json::input_format_t::msgpack));
-}
-
-TEST_CASE("MessagePack SAX parsing stops at every event")
-{
-    // Containers are opened and closed by the loop that reads them; a SAX
-    // handler that rejects any event - including the end of a nested
-    // container - must stop the parse right there.
-    const auto count_events = [](const std::vector<std::uint8_t>& input)
-    {
-        int events = 0;
-        while (true)
-        {
-            SaxCountdown scp(events);
-            if (json::sax_parse(input, &scp, json::input_format_t::msgpack))
-            {
-                return events;
-            }
-            ++events;
-            REQUIRE(events < 1000);
-        }
-    };
-
-    // 20 events: every container kind closes inside another one
-    const json j = json::parse(R"({"a": [1, {"b": []}], "c": {"d": [[2]]}})");
-    CHECK(count_events(json::to_msgpack(j)) == 20);
-}
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP

tests/src/unit-stl_helpers.cpp

@@ -0,0 +1,129 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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 <array>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+// The detail helpers that stand in for standard library functions of newer
+// standards: each uses the standard function where the library has it and a
+// C++11 implementation otherwise, so this file is also built with
+// JSON_HAS_CPP_17, JSON_HAS_CPP_20, and JSON_HAS_CPP_23 to test both.
+
+namespace
+{
+struct with_constexpr_member
+{
+    static constexpr std::size_t lower = 64; // no out-of-line definition
+};
+} // namespace
+
+TEST_CASE("detail::clamp")
+{
+    using nlohmann::detail::clamp;
+
+    SECTION("integers")
+    {
+        CHECK(clamp(5, 1, 10) == 5);
+        CHECK(clamp(0, 1, 10) == 1);
+        CHECK(clamp(11, 1, 10) == 10);
+        CHECK(clamp(1, 1, 10) == 1);
+        CHECK(clamp(10, 1, 10) == 10);
+        CHECK(clamp(7, 7, 7) == 7);
+        CHECK(clamp(-5, -3, 3) == -3);
+        CHECK(clamp(std::size_t{0}, std::size_t{64}, std::size_t{0x10000}) == 64);
+        CHECK(clamp(std::size_t{0x20000}, std::size_t{64}, std::size_t{0x10000}) == 0x10000);
+    }
+
+    SECTION("floating-point numbers")
+    {
+        CHECK(clamp(0.5, 0.0, 1.0) == 0.5);
+        CHECK(clamp(-0.5, 0.0, 1.0) == 0.0);
+        CHECK(clamp(1.5, 0.0, 1.0) == 1.0);
+        CHECK(clamp(-std::numeric_limits<double>::infinity(), 0.0, 1.0) == 0.0);
+    }
+
+    SECTION("by value: a static constexpr member needs no definition")
+    {
+        CHECK(clamp(std::size_t{1}, with_constexpr_member::lower, std::size_t{100}) == 64);
+    }
+
+    SECTION("constexpr and noexcept")
+    {
+        static_assert(clamp(3, 1, 2) == 2, "clamp must be constexpr");
+        static_assert(noexcept(clamp(3, 1, 2)), "clamp must be noexcept");
+    }
+}
+
+TEST_CASE("detail::bit_cast")
+{
+    using nlohmann::detail::bit_cast;
+
+    CHECK(bit_cast<std::uint64_t>(1.0) == 0x3FF0000000000000u);
+    CHECK(bit_cast<std::uint64_t>(-2.0) == 0xC000000000000000u);
+    CHECK(bit_cast<std::uint32_t>(1.0f) == 0x3F800000u);
+    CHECK(bit_cast<double>(std::uint64_t{0x4009000000000000u}) == 3.125);
+    CHECK(bit_cast<float>(std::uint32_t{0xC0490000u}) == -3.140625f);
+    CHECK(bit_cast<std::int8_t>(std::uint8_t{0xFF}) == -1);
+
+    // to and from byte arrays
+    const auto bytes = bit_cast<std::array<std::uint8_t, 4>>(std::uint32_t{0x01020304u});
+    CHECK(bit_cast<std::uint32_t>(bytes) == 0x01020304u);
+
+    static_assert(noexcept(bit_cast<std::uint64_t>(1.0)), "bit_cast must be noexcept");
+}
+
+TEST_CASE("detail::byteswap")
+{
+    using nlohmann::detail::byteswap;
+
+    CHECK(byteswap(std::uint16_t{0x0102u}) == 0x0201u);
+    CHECK(byteswap(std::uint16_t{0xFF00u}) == 0x00FFu);
+    CHECK(byteswap(std::uint32_t{0x01020304u}) == 0x04030201u);
+    CHECK(byteswap(std::uint32_t{0xFF000080u}) == 0x800000FFu);
+    CHECK(byteswap(std::uint64_t{0x0102030405060708u}) == 0x0807060504030201u);
+    CHECK(byteswap(std::uint64_t{0xFF00000000000080u}) == 0x80000000000000FFu);
+
+    // an involution
+    for (std::uint64_t x :
+            {
+                std::uint64_t{0}, std::uint64_t{1}, std::uint64_t{0x123456789ABCDEF0u}, (std::numeric_limits<std::uint64_t>::max)()
+            })
+    {
+        CHECK(byteswap(byteswap(x)) == x);
+        CHECK(byteswap(byteswap(static_cast<std::uint32_t>(x))) == static_cast<std::uint32_t>(x));
+        CHECK(byteswap(byteswap(static_cast<std::uint16_t>(x))) == static_cast<std::uint16_t>(x));
+    }
+
+    static_assert(std::is_same < decltype(byteswap(std::uint16_t{})), std::uint16_t >::value, "byteswap keeps the type");
+    static_assert(std::is_same < decltype(byteswap(std::uint32_t{})), std::uint32_t >::value, "byteswap keeps the type");
+    static_assert(std::is_same < decltype(byteswap(std::uint64_t{})), std::uint64_t >::value, "byteswap keeps the type");
+}
+
+TEST_CASE("detail::count_leading_zeros and count_trailing_zeros")
+{
+    using nlohmann::detail::count_leading_zeros;
+    using nlohmann::detail::count_trailing_zeros;
+
+    // a single bit, and that bit with all lower (resp. higher) bits set: both
+    // halves of the 32-bit fallbacks
+    for (int k = 0; k < 64; ++k)
+    {
+        const std::uint64_t bit = std::uint64_t{1} << k;
+        CAPTURE(k)
+        CHECK(count_leading_zeros(bit) == 63 - k);
+        CHECK(count_leading_zeros(bit | (bit - 1)) == 63 - k);
+        CHECK(count_trailing_zeros(bit) == k);
+        CHECK(count_trailing_zeros(bit | ~(bit | (bit - 1))) == k);
+    }
+}

tests/src/unit-to_chars.cpp

@@ -13,7 +13,7 @@
 #include "doctest_compatibility.h"
 
 #include <nlohmann/json.hpp>
-using nlohmann::detail::dtoa_impl::reinterpret_bits;
+using nlohmann::detail::bit_cast;
 
 #include <algorithm>
 #include <array>
@@ -44,7 +44,7 @@ float make_float(uint32_t sign_bit, uint32_t biased_exponent, uint32_t significa
     bits |= biased_exponent << 23;
     bits |= significand;
 
-    return reinterpret_bits<float>(bits);
+    return bit_cast<float>(bits);
 }
 
 // ldexp -- convert f * 2^e to IEEE single precision
@@ -81,7 +81,7 @@ float make_float(uint64_t f, int e)
                                      : static_cast<uint64_t>(e + kExponentBias);
 
     const uint64_t bits = (f & kSignificandMask) | (biased_exponent << kPhysicalSignificandSize);
-    return reinterpret_bits<float>(static_cast<uint32_t>(bits));
+    return bit_cast<float>(static_cast<uint32_t>(bits));
 }
 
 double make_double(uint64_t sign_bit, uint64_t biased_exponent, uint64_t significand)
@@ -96,7 +96,7 @@ double make_double(uint64_t sign_bit, uint64_t biased_exponent, uint64_t signifi
     bits |= biased_exponent << 52;
     bits |= significand;
 
-    return reinterpret_bits<double>(bits);
+    return bit_cast<double>(bits);
 }
 
 // ldexp -- convert f * 2^e to IEEE double precision
@@ -133,7 +133,7 @@ double make_double(uint64_t f, int e)
                                      : static_cast<uint64_t>(e + kExponentBias);
 
     const uint64_t bits = (f & kSignificandMask) | (biased_exponent << kPhysicalSignificandSize);
-    return reinterpret_bits<double>(bits);
+    return bit_cast<double>(bits);
 }
 } // namespace
 
@@ -652,7 +652,7 @@ bool reads_back(const std::string& digits, int e, double v)
 {
     const std::string text = digits + "e" + std::to_string(e);
     // (compared bit for bit: v is positive and finite, and -Wfloat-equal)
-    return reinterpret_bits<std::uint64_t>(parse_double(text)) == reinterpret_bits<std::uint64_t>(v);
+    return bit_cast<std::uint64_t>(parse_double(text)) == bit_cast<std::uint64_t>(v);
 }
 
 /// Check the representation of a positive finite double: it reads back as
@@ -665,7 +665,7 @@ void check_shortest(double v)
     CAPTURE(text)
     CHECK(parse_double(text) == v);
     // the layout is that of format_buffer() for the digits of Zmij
-    const auto sd = nlohmann::detail::zmij::to_shortest(reinterpret_bits<std::uint64_t>(v));
+    const auto sd = nlohmann::detail::zmij::to_shortest(bit_cast<std::uint64_t>(v));
     const std::uint64_t significand = sd.has_digit ? (sd.integral * 10) + sd.digit : sd.integral;
     int exponent = sd.has_digit ? sd.exponent : sd.exponent + 1;
     std::string significand_digits = std::to_string(significand);
@@ -779,7 +779,7 @@ TEST_CASE("shortest digits of doubles")
         for (int i = 0; i < 100000; ++i)
         {
             const std::uint64_t bits = rng() & 0x7FFFFFFFFFFFFFFFu;
-            const auto v = reinterpret_bits<double>(bits);
+            const auto v = bit_cast<double>(bits);
             if (std::isfinite(v) && bits != 0)
             {
                 check_shortest(v);