Make JSON_STRICT_NUL_HANDLING part of the ABI tag

JSON_STRICT_NUL_HANDLING (#5534) changes the bodies of inline functions:
the lexer's handling of '\0' and input_adapter() for char arrays. So
translation units compiled with and without it define the same functions
differently, an ODR violation - the case the ABI tag exists for, as with
JSON_BRACE_INIT_COPY_SEMANTICS (_bics). It now appends _snul to the inline
namespace. The macro is new in 3.13.0, so no existing namespace changes.

Its default moves to abi_macros.hpp, and it is only #undef'd without
JSON_TEST_KEEP_MACROS, as for the other ABI macros. The ABI config tests,
the namespace docs, the macro's docs and the Natvis file cover the new tag.

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

.github/CONTRIBUTING.md

@@ -158,15 +158,6 @@ make amalgamate
 Running `make amalgamate` will also apply automatic formatting to the source files using
 [`Artistic Style`](https://astyle.sourceforge.net/). This formatting may modify your source files in-place. Be certain to review and commit any changes to avoid unintended formatting diffs in commits.
 
-If you add, rename, or remove a header in `include/nlohmann`, also regenerate the header list in
-[`BUILD.bazel`](https://github.com/nlohmann/json/blob/develop/BUILD.bazel) (requires CMake) by executing:
-
-```shell
-make BUILD.bazel
-```
-
-The amalgamation check in CI fails if any of these generated files is out of date.
-
 ## Recommended documentation
 
 - The library’s [README file](https://github.com/nlohmann/json/blob/master/README.md) is an excellent starting point to

.github/workflows/check_amalgamation.yml

@@ -57,16 +57,13 @@ jobs:
           python3 -mvenv venv
           venv/bin/pip3 install -r $MAIN_DIR/tools/astyle/requirements.txt
 
-      - name: Regenerate amalgamation, formatting, and BUILD.bazel
+      - name: Regenerate amalgamation and formatting
         run: |
           cd $MAIN_DIR
 
           python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
           python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .
 
-          # the header list of the Bazel "json" target must match the files in include/
-          cmake -P cmake/scripts/gen_bazel_build_file.cmake
-
           ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
             $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp
 
@@ -90,7 +87,7 @@ jobs:
           mkdir -p ${{ github.workspace }}/patch
           git diff --patch --no-color > ${{ github.workspace }}/patch/amalgamation.patch
           if [ -s ${{ github.workspace }}/patch/amalgamation.patch ]; then
-            echo "The source code has not been amalgamated/formatted correctly or BUILD.bazel is out of date. Diff:"
+            echo "The source code has not been amalgamated/formatted correctly. Diff:"
             cat ${{ github.workspace }}/patch/amalgamation.patch
             echo "has_diff=true" >> "$GITHUB_OUTPUT"
           else

.github/workflows/comment_check_amalgamation.yml

@@ -95,13 +95,13 @@ jobs:
               issue_number: issue_number,
               owner: context.repo.owner,
               repo: context.repo.repo,
-              body: '## 🔴 Amalgamation check failed! 🔴\nThe source code has not been amalgamated and/or formatted correctly, or `BUILD.bazel` is out of date.'
+              body: '## 🔴 Amalgamation check failed! 🔴\nThe source code has not been amalgamated and/or formatted correctly.'
                     + (hasPatch ? '\n\n📎 A ready-to-apply patch is attached to the [failed workflow run](' + runUrl + ') as the `amalgamation-patch` artifact.'
                                   + ' Download it, then apply it locally from the repository root with:'
                                   + '\n\n```shell\ngit apply amalgamation.patch\n```\n\n'
                                   + 'This does not require installing astyle yourself.'
                                 : '')
                     + (first ? '\n\n@' + author + ' Please read and follow the [Contribution Guidelines]'
-                               + '(https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#amalgamate-the-source-code).'
+                               + '(https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#files-to-change).'
                              : '')
               })

BUILD.bazel

@@ -30,10 +30,8 @@ cc_library(
         "include/nlohmann/detail/input/input_adapters.hpp",
         "include/nlohmann/detail/input/json_sax.hpp",
         "include/nlohmann/detail/input/lexer.hpp",
-        "include/nlohmann/detail/input/number_parse.hpp",
         "include/nlohmann/detail/input/parser.hpp",
         "include/nlohmann/detail/input/position_t.hpp",
-        "include/nlohmann/detail/input/string_scan.hpp",
         "include/nlohmann/detail/iterators/internal_iterator.hpp",
         "include/nlohmann/detail/iterators/iter_impl.hpp",
         "include/nlohmann/detail/iterators/iteration_proxy.hpp",
@@ -51,14 +49,12 @@ cc_library(
         "include/nlohmann/detail/meta/detected.hpp",
         "include/nlohmann/detail/meta/identity_tag.hpp",
         "include/nlohmann/detail/meta/is_sax.hpp",
-        "include/nlohmann/detail/meta/logic.hpp",
         "include/nlohmann/detail/meta/std_fs.hpp",
         "include/nlohmann/detail/meta/type_traits.hpp",
         "include/nlohmann/detail/meta/void_t.hpp",
         "include/nlohmann/detail/output/binary_writer.hpp",
         "include/nlohmann/detail/output/output_adapters.hpp",
         "include/nlohmann/detail/output/serializer.hpp",
-        "include/nlohmann/detail/recursion_depth_limit.hpp",
         "include/nlohmann/detail/string_concat.hpp",
         "include/nlohmann/detail/string_escape.hpp",
         "include/nlohmann/detail/string_utils.hpp",

FILES.md

@@ -250,16 +250,12 @@ Further documentation:
 
 ### `BUILD.bazel`
 
-The build definition for [Bazel](https://bazel.build). The file is generated by
-`cmake/scripts/gen_bazel_build_file.cmake`, which derives the header list from the files in `include`; change the
-script rather than editing the file by hand. The file can be updated by calling
+The file can be updated by calling
 
 ```shell
 make BUILD.bazel
 ```
 
-The "Check amalgamation" workflow fails if the file is out of date.
-
 ### `meson.build`
 
 The build definition for the [Meson](https://mesonbuild.com) build system.

Makefile

@@ -1,4 +1,4 @@
-.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel
+.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef
 
 ##########################################################################
 # configuration
@@ -30,9 +30,8 @@ AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 # main target
 all:
 	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd}.hpp from the include/nlohmann sources"
-	@echo "BUILD.bazel - regenerate the Bazel BUILD file from the include/nlohmann sources"
 	@echo "ChangeLog.md - generate ChangeLog file"
-	@echo "check-amalgamation - check whether sources have been amalgamated and BUILD.bazel is up to date"
+	@echo "check-amalgamation - check whether sources have been amalgamated"
 	@echo "clean - remove built files"
 	@echo "doctest - compile example files and check their output"
 	@echo "fuzz_testing - prepare fuzz testing of the JSON parser"
@@ -173,13 +172,8 @@ check-amalgamation:
 	@diff $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE) ; false)
 	@mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE)
 	@mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE)
-	@mv BUILD.bazel BUILD.bazel~
-	@$(MAKE) BUILD.bazel
-	@diff BUILD.bazel BUILD.bazel~ || (echo "===================================================================\n  BUILD.bazel is out of date! Please run 'make BUILD.bazel'.\n===================================================================" ; mv BUILD.bazel~ BUILD.bazel ; false)
-	@mv BUILD.bazel~ BUILD.bazel
 
-# generate the Bazel BUILD file; phony, because a removed header would not trigger a rebuild
-BUILD.bazel:
+BUILD.bazel: $(SRCS)
 	cmake -P cmake/scripts/gen_bazel_build_file.cmake
 
 ##########################################################################

cmake/scripts/gen_bazel_build_file.cmake

@@ -1,58 +1,24 @@
 # generate Bazel BUILD file
-#
-# usage: cmake -P cmake/scripts/gen_bazel_build_file.cmake (or: make BUILD.bazel)
-#
-# The header list of the "json" target is derived from the files in include/. Everything else is fixed text below,
-# so edit this script rather than BUILD.bazel.
 
-get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+set(PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/../..")
 set(BUILD_FILE "${PROJECT_ROOT}/BUILD.bazel")
 
-file(GLOB_RECURSE HEADERS LIST_DIRECTORIES false RELATIVE "${PROJECT_ROOT}" "${PROJECT_ROOT}/include/*.hpp")
-list(SORT HEADERS)
-
-set(CONTENT [=[
-load("@rules_cc//cc:cc_library.bzl", "cc_library")
-load("@rules_license//rules:license.bzl", "license")
-
-package(
-    default_applicable_licenses = [":license"],
-)
-
-exports_files([
-    "LICENSE.MIT",
-])
-
-license(
-    name = "license",
-    license_kinds = ["@rules_license//licenses/spdx:MIT"],
-    license_text = "LICENSE.MIT",
-)
+file(GLOB_RECURSE HEADERS LIST_DIRECTORIES false RELATIVE "${PROJECT_ROOT}" "include/*.hpp")
 
+file(WRITE "${BUILD_FILE}" [=[
 cc_library(
     name = "json",
     hdrs = [
 ]=])
 
 foreach(header ${HEADERS})
-    string(APPEND CONTENT "        \"${header}\",\n")
+    file(APPEND "${BUILD_FILE}" "        \"${header}\",\n")
 endforeach()
 
-string(APPEND CONTENT [=[
+file(APPEND "${BUILD_FILE}" [=[
     ],
     includes = ["include"],
     visibility = ["//visibility:public"],
     alwayslink = True,
 )
-
-cc_library(
-    name = "singleheader-json",
-    hdrs = [
-        "single_include/nlohmann/json.hpp",
-    ],
-    includes = ["single_include"],
-    visibility = ["//visibility:public"],
-)
 ]=])
-
-file(WRITE "${BUILD_FILE}" "${CONTENT}")

docs/mkdocs/docs/api/macros/json_strict_nul_handling.md

@@ -65,6 +65,12 @@ The default value is `0` (disabled — existing behavior is preserved).
     for CBOR or MessagePack, are never affected by this trimming; their full extent - including a genuine trailing
     `0x00` - is always preserved, in both states of this macro.
 
+!!! note "ABI compatibility"
+
+    The value of this macro is encoded in the [namespace](../../features/namespace.md) (tag `_snul`), resulting in
+    distinct symbol names. Translation units compiled with and without it can therefore be linked into the same program
+    without One Definition Rule (ODR) violations, but they cannot exchange instances of library types.
+
 !!! tip "Workaround without the macro"
 
     To reject a NUL byte without enabling this macro, trim your input yourself before calling `parse()`:

docs/mkdocs/docs/features/namespace.md

@@ -18,6 +18,7 @@ The complete default namespace name is derived as follows:
     - [`JSON_DIAGNOSTIC_POSITIONS`](../api/macros/json_diagnostic_positions.md) defined non-zero appends `_dp`.
     - [`JSON_BRACE_INIT_COPY_SEMANTICS`](../api/macros/json_brace_init_copy_semantics.md) defined non-zero appends
       `_bics`.
+    - [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md) defined non-zero appends `_snul`.
 - The inline namespace ends with the suffix `_v` followed by the 3 components of the version number separated by
   underscores. To omit the version component, see [Disabling the version component](#disabling-the-version-component)
   below.

include/nlohmann/detail/abi_macros.hpp

@@ -38,6 +38,10 @@
     #define JSON_BRACE_INIT_COPY_SEMANTICS 0
 #endif
 
+#ifndef JSON_STRICT_NUL_HANDLING
+    #define JSON_STRICT_NUL_HANDLING 0
+#endif
+
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -62,21 +66,28 @@
     #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
 #endif
 
+#if JSON_STRICT_NUL_HANDLING
+    #define NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING _snul
+#else
+    #define NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e) json_abi ## a ## b ## c ## d ## e
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
             NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
+            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
+            NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

include/nlohmann/detail/hash.hpp

@@ -11,10 +11,8 @@
 #include <cstdint> // uint8_t
 #include <cstddef> // size_t
 #include <functional> // hash
-#include <vector> // vector
 
 #include <nlohmann/detail/abi_macros.hpp>
-#include <nlohmann/detail/recursion_depth_limit.hpp>
 #include <nlohmann/detail/value_t.hpp>
 
 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -28,9 +26,6 @@ inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
     return seed;
 }
 
-template<typename BasicJsonType>
-std::size_t hash_iteratively(const BasicJsonType& j);
-
 /*!
 @brief hash a JSON value
 
@@ -38,21 +33,12 @@ The hash function tries to rely on std::hash where possible. Furthermore, the
 type of the JSON value is taken into account to have different hash values for
 null, 0, 0U, and false, etc.
 
-Hashing an array or an object hashes its elements, which used to call this
-function again once per nesting level, so a value nested deeply enough
-exhausted the call stack and terminated the process. The descent is bounded
-here: once @ref recursion_depth_limit levels have been entered, @ref
-hash_iteratively hashes what is left without the call stack. A value nested
-less deeply than that - all but a vanishing minority - is hashed exactly as
-before, without allocating.
-
 @tparam BasicJsonType basic_json specialization
 @param j JSON value to hash
-@param depth nesting level of @a j, counted from the value passed by the caller
 @return hash value of j
 */
 template<typename BasicJsonType>
-std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
+std::size_t hash(const BasicJsonType& j)
 {
     using string_t = typename BasicJsonType::string_t;
     using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -70,32 +56,22 @@ std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
 
         case BasicJsonType::value_t::object:
         {
-            if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
-            {
-                return hash_iteratively(j);
-            }
-
             auto seed = combine(type, j.size());
             for (const auto& element : j.items())
             {
                 const auto h = std::hash<string_t> {}(element.key());
                 seed = combine(seed, h);
-                seed = combine(seed, hash(element.value(), depth + 1));
+                seed = combine(seed, hash(element.value()));
             }
             return seed;
         }
 
         case BasicJsonType::value_t::array:
         {
-            if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
-            {
-                return hash_iteratively(j);
-            }
-
             auto seed = combine(type, j.size());
             for (const auto& element : j)
             {
-                seed = combine(seed, hash(element, depth + 1));
+                seed = combine(seed, hash(element));
             }
             return seed;
         }
@@ -151,77 +127,5 @@ std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
     }
 }
 
-/// an array or object whose elements @ref hash_iteratively is hashing
-template<typename BasicJsonType>
-struct hash_frame
-{
-    hash_frame(const BasicJsonType* value_, std::size_t seed_) noexcept
-        : value(value_), position(value_->cbegin()), seed(seed_)
-    {}
-
-    const BasicJsonType* value;
-    typename BasicJsonType::const_iterator position;
-    std::size_t seed;
-};
-
-/*!
-@brief hash the array or object @a j without the call stack
-
-Computes the same value as @ref hash, keeping the arrays and objects it has
-entered on an explicit stack instead of descending into them. Only reached for
-values nested deeper than @ref recursion_depth_limit.
-
-@tparam BasicJsonType basic_json specialization
-@param j array or object to hash
-@return hash value of j
-*/
-template<typename BasicJsonType>
-std::size_t hash_iteratively(const BasicJsonType& j)
-{
-    using string_t = typename BasicJsonType::string_t;
-
-    std::vector<hash_frame<BasicJsonType>> stack;
-    stack.emplace_back(&j, combine(static_cast<std::size_t>(j.type()), j.size()));
-
-    while (true)
-    {
-        // a copy, as entering an element below can reallocate the stack; the
-        // frame itself is only changed through stack.back()
-        const hash_frame<BasicJsonType> frame = stack.back();
-
-        if (frame.position == frame.value->cend())
-        {
-            // all elements are hashed: fold this value's hash into its parent's
-            // seed, exactly where the recursive version returns it
-            const std::size_t h = frame.seed;
-            stack.pop_back();
-            if (stack.empty())
-            {
-                return h;
-            }
-            stack.back().seed = combine(stack.back().seed, h);
-            continue;
-        }
-
-        if (frame.value->is_object())
-        {
-            stack.back().seed = combine(stack.back().seed, std::hash<string_t> {}(frame.position.key()));
-        }
-
-        // advance before entering the element, which pushes onto the stack
-        const BasicJsonType& element = *frame.position;
-        ++stack.back().position;
-
-        if (element.is_structured())
-        {
-            stack.emplace_back(&element, combine(static_cast<std::size_t>(element.type()), element.size()));
-        }
-        else
-        {
-            stack.back().seed = combine(stack.back().seed, hash(element));
-        }
-    }
-}
-
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/detail/macro_scope.hpp

@@ -812,7 +812,3 @@ void templated_json_throw(ExceptionType exception)
 #ifndef JSON_USE_GLOBAL_UDLS
     #define JSON_USE_GLOBAL_UDLS 1
 #endif
-
-#ifndef JSON_STRICT_NUL_HANDLING
-    #define JSON_STRICT_NUL_HANDLING 0
-#endif

include/nlohmann/detail/macro_unscope.hpp

@@ -26,7 +26,6 @@
 #undef JSON_NO_UNIQUE_ADDRESS
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_USE_GLOBAL_UDLS
-#undef JSON_STRICT_NUL_HANDLING
 
 #ifndef JSON_TEST_KEEP_MACROS
     #undef JSON_CATCH
@@ -45,6 +44,7 @@
     #undef JSON_HAS_STATIC_RTTI
     #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
     #undef JSON_BRACE_INIT_COPY_SEMANTICS
+    #undef JSON_STRICT_NUL_HANDLING
 #endif
 
 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>

include/nlohmann/detail/output/serializer.hpp

@@ -30,7 +30,6 @@
 #include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/output/binary_writer.hpp>
 #include <nlohmann/detail/output/output_adapters.hpp>
-#include <nlohmann/detail/recursion_depth_limit.hpp>
 #include <nlohmann/detail/string_concat.hpp>
 #include <nlohmann/detail/value_t.hpp>
 
@@ -134,7 +133,7 @@ class serializer
 
     Serializing a container descends into its elements, so a value nested deeply
     enough used to exhaust the call stack and terminate the process with no
-    exception to catch. The descent is bounded here: once @ref recursion_depth_limit
+    exception to catch. The descent is bounded here: once @ref dump_depth_limit
     levels have been entered, @ref dump_iteratively writes out what is left
     without the call stack. A value nested less deeply than that - all but a
     vanishing minority - is written by exactly the code that always wrote it.
@@ -149,7 +148,7 @@ class serializer
         {
             case value_t::object:
             {
-                if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
+                if (JSON_HEDLEY_UNLIKELY(depth >= dump_depth_limit()))
                 {
                     dump_iteratively(val, current_indent);
                     return;
@@ -224,7 +223,7 @@ class serializer
 
             case value_t::array:
             {
-                if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
+                if (JSON_HEDLEY_UNLIKELY(depth >= dump_depth_limit()))
                 {
                     dump_iteratively(val, current_indent);
                     return;
@@ -409,12 +408,19 @@ class serializer
     }
 
   private:
+    /// the number of levels @ref dump_internal descends into before it hands
+    /// over to @ref dump_iteratively
+    static constexpr std::size_t dump_depth_limit()
+    {
+        return 128;
+    }
+
     /*!
     @brief write out @a val and everything below it without the call stack
 
     Emits the same bytes as @ref dump_internal, keeping the containers it has
     entered on an explicit stack instead of descending into them. Only reached
-    for values nested deeper than @ref recursion_depth_limit, which is why it is not
+    for values nested deeper than @ref dump_depth_limit, which is why it is not
     written for speed: walking every value this way measured up to 20% slower on
     object-heavy documents than letting the compiler drive the descent.
     */

include/nlohmann/detail/recursion_depth_limit.hpp

@@ -1,35 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  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 <cstddef> // size_t
-
-#include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail
-{
-
-/*!
-@brief the number of nesting levels an operation recurses into
-
-Operations that walk a value (serializing, hashing, merging, ...) recurse once
-per nesting level, which is fastest, but a value nested deeply enough would
-exhaust the call stack. So they recurse only this many levels deep and finish
-whatever lies below with an explicit stack. All of them share this limit.
-
-@sa https://github.com/nlohmann/json/issues/5387
-*/
-constexpr std::size_t recursion_depth_limit() noexcept
-{
-    return 128;
-}
-
-}  // namespace detail
-NLOHMANN_JSON_NAMESPACE_END

include/nlohmann/json.hpp

@@ -68,7 +68,6 @@
 #include <nlohmann/detail/output/binary_writer.hpp>
 #include <nlohmann/detail/output/output_adapters.hpp>
 #include <nlohmann/detail/output/serializer.hpp>
-#include <nlohmann/detail/recursion_depth_limit.hpp>
 #include <nlohmann/detail/value_t.hpp>
 #include <nlohmann/json_fwd.hpp>
 #include <nlohmann/ordered_map.hpp>
@@ -3913,54 +3912,17 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
         }
 
-        update_members(first, last, merge_objects, 0);
-    }
-
-  private:
-    /// @brief an object @ref update_members_iteratively or @ref
-    /// merge_patch_iteratively is merging into, and the members still to merge
-    struct merge_frame
-    {
-        merge_frame(basic_json* target_, const_iterator position_, const_iterator last_) noexcept
-            : target(target_), position(std::move(position_)), last(std::move(last_))
-        {}
-
-        basic_json* target;
-        const_iterator position;
-        const_iterator last;
-    };
-
-    /*!
-    @brief the members loop of @ref update, for this object and range
-
-    Merging a nested object calls this function again, once per nesting
-    level, so a value nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    update_members_iteratively merges what is left without the call stack.
-
-    @param[in] depth  nesting level of this object, counted from the object
-                      @ref update was called on
-    */
-    void update_members(const const_iterator& first, const const_iterator& last, const bool merge_objects, const std::size_t depth)
-    {
-        if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-        {
-            update_members_iteratively(first, last);
-            return;
-        }
-
         for (auto it = first; it != last; ++it)
         {
             if (merge_objects && it.value().is_object())
             {
-                const auto it2 = m_data.m_value.object->find(it.key());
+                auto it2 = m_data.m_value.object->find(it.key());
                 // Only recurse when the existing value is itself an object.
                 // Otherwise overwrite, matching the documented "all other values
                 // are overwritten as usual" behavior (see #5402).
                 if (it2 != m_data.m_value.object->end() && it2->second.is_object())
                 {
-                    it2->second.update_members(it.value().cbegin(), it.value().cend(), true, depth + 1);
+                    it2->second.update(it.value(), true);
 #if JSON_DIAGNOSTICS
                     it2->second.set_parents();
 #endif
@@ -3974,64 +3936,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-    /*!
-    @brief merge @a first to @a last into this object without the call stack
-
-    Does the same as @ref update_members with `merge_objects` set, keeping the
-    objects whose merge was interrupted by a nested one on an explicit stack
-    instead of descending into them. A nested object is still merged
-    completely before the next member, in the same order as the recursive
-    version. Only reached for values nested deeper than @ref
-    detail::recursion_depth_limit.
-    */
-    void update_members_iteratively(const_iterator first, const_iterator last)
-    {
-        std::vector<merge_frame> stack;
-
-        basic_json* target = this;
-        while (true)
-        {
-            if (first == last)
-            {
-                if (stack.empty())
-                {
-                    break;
-                }
-
-                // a nested object is merged: continue with its parent
-#if JSON_DIAGNOSTICS
-                target->set_parents();
-#endif
-                target = stack.back().target;
-                first = stack.back().position;
-                last = stack.back().last;
-                stack.pop_back();
-                continue;
-            }
-
-            if (first.value().is_object())
-            {
-                const auto it2 = target->m_data.m_value.object->find(first.key());
-                if (it2 != target->m_data.m_value.object->end() && it2->second.is_object())
-                {
-                    const basic_json& source = first.value();
-                    ++first;
-                    stack.emplace_back(target, first, last);
-                    target = &it2->second;
-                    first = source.cbegin();
-                    last = source.cend();
-                    continue;
-                }
-            }
-            target->m_data.m_value.object->operator[](first.key()) = first.value();
-#if JSON_DIAGNOSTICS
-            target->m_data.m_value.object->operator[](first.key()).m_parent = target;
-#endif
-            ++first;
-        }
-    }
-
-  public:
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
     void swap(reference other) noexcept (
@@ -5926,30 +5830,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief applies a JSON Merge Patch
     /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
     void merge_patch(const basic_json& apply_patch)
-    {
-        apply_merge_patch(apply_patch, 0);
-    }
-
-  private:
-    /*!
-    @brief @ref merge_patch, for a patch at nesting level @a depth
-
-    Applying a nested object calls this function again, once per nesting
-    level, so a patch nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    merge_patch_iteratively applies what is left without the call stack.
-    */
-    void apply_merge_patch(const basic_json& apply_patch, const std::size_t depth)
     {
         if (apply_patch.is_object())
         {
-            if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-            {
-                merge_patch_iteratively(apply_patch);
-                return;
-            }
-
             if (!is_object())
             {
                 *this = object();
@@ -5962,7 +5845,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 }
                 else
                 {
-                    operator[](it.key()).apply_merge_patch(it.value(), depth + 1);
+                    operator[](it.key()).merge_patch(it.value());
                 }
             }
         }
@@ -5972,62 +5855,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-    /*!
-    @brief apply @a apply_patch to this value without the call stack
-
-    Does the same as @ref merge_patch, keeping the objects being patched on an
-    explicit stack instead of descending into them. A nested object is still
-    patched completely before the next member, in the same order as the
-    recursive version. Only reached for patches nested deeper than @ref
-    detail::recursion_depth_limit.
-    */
-    void merge_patch_iteratively(const basic_json& apply_patch)
-    {
-        std::vector<merge_frame> stack;
-
-        // patch `target` with `patch`, or start patching it member by member
-        const auto apply = [&stack](basic_json & target, const basic_json & patch)
-        {
-            if (patch.is_object())
-            {
-                if (!target.is_object())
-                {
-                    target = basic_json::object();
-                }
-                stack.emplace_back(&target, patch.cbegin(), patch.cend());
-            }
-            else
-            {
-                target = patch;
-            }
-        };
-
-        apply(*this, apply_patch);
-        while (!stack.empty())
-        {
-            // a copy, as applying a member below can reallocate the stack;
-            // the frame itself is only changed through stack.back()
-            const merge_frame frame = stack.back();
-            if (frame.position == frame.last)
-            {
-                stack.pop_back();
-                continue;
-            }
-
-            const const_iterator member = frame.position;
-            ++stack.back().position;
-            if (member.value().is_null())
-            {
-                frame.target->erase(member.key());
-            }
-            else
-            {
-                apply(frame.target->operator[](member.key()), member.value());
-            }
-        }
-    }
-
-  public:
     /// @}
 };
 

single_include/nlohmann/json.hpp

@@ -95,6 +95,10 @@
     #define JSON_BRACE_INIT_COPY_SEMANTICS 0
 #endif
 
+#ifndef JSON_STRICT_NUL_HANDLING
+    #define JSON_STRICT_NUL_HANDLING 0
+#endif
+
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -119,21 +123,28 @@
     #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
 #endif
 
+#if JSON_STRICT_NUL_HANDLING
+    #define NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING _snul
+#else
+    #define NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e) json_abi ## a ## b ## c ## d ## e
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
             NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
+            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
+            NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -3202,10 +3213,6 @@ void templated_json_throw(ExceptionType exception)
     #define JSON_USE_GLOBAL_UDLS 1
 #endif
 
-#ifndef JSON_STRICT_NUL_HANDLING
-    #define JSON_STRICT_NUL_HANDLING 0
-#endif
-
 #if JSON_HAS_THREE_WAY_COMPARISON
     #include <compare> // partial_ordering
 #endif
@@ -7028,48 +7035,9 @@ NLOHMANN_JSON_NAMESPACE_END
 #include <cstdint> // uint8_t
 #include <cstddef> // size_t
 #include <functional> // hash
-#include <vector> // vector
 
 // #include <nlohmann/detail/abi_macros.hpp>
 
-// #include <nlohmann/detail/recursion_depth_limit.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-
-
-#include <cstddef> // size_t
-
-// #include <nlohmann/detail/abi_macros.hpp>
-
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail
-{
-
-/*!
-@brief the number of nesting levels an operation recurses into
-
-Operations that walk a value (serializing, hashing, merging, ...) recurse once
-per nesting level, which is fastest, but a value nested deeply enough would
-exhaust the call stack. So they recurse only this many levels deep and finish
-whatever lies below with an explicit stack. All of them share this limit.
-
-@sa https://github.com/nlohmann/json/issues/5387
-*/
-constexpr std::size_t recursion_depth_limit() noexcept
-{
-    return 128;
-}
-
-}  // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
-
 // #include <nlohmann/detail/value_t.hpp>
 
 
@@ -7084,9 +7052,6 @@ inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
     return seed;
 }
 
-template<typename BasicJsonType>
-std::size_t hash_iteratively(const BasicJsonType& j);
-
 /*!
 @brief hash a JSON value
 
@@ -7094,21 +7059,12 @@ The hash function tries to rely on std::hash where possible. Furthermore, the
 type of the JSON value is taken into account to have different hash values for
 null, 0, 0U, and false, etc.
 
-Hashing an array or an object hashes its elements, which used to call this
-function again once per nesting level, so a value nested deeply enough
-exhausted the call stack and terminated the process. The descent is bounded
-here: once @ref recursion_depth_limit levels have been entered, @ref
-hash_iteratively hashes what is left without the call stack. A value nested
-less deeply than that - all but a vanishing minority - is hashed exactly as
-before, without allocating.
-
 @tparam BasicJsonType basic_json specialization
 @param j JSON value to hash
-@param depth nesting level of @a j, counted from the value passed by the caller
 @return hash value of j
 */
 template<typename BasicJsonType>
-std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
+std::size_t hash(const BasicJsonType& j)
 {
     using string_t = typename BasicJsonType::string_t;
     using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -7126,32 +7082,22 @@ std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
 
         case BasicJsonType::value_t::object:
         {
-            if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
-            {
-                return hash_iteratively(j);
-            }
-
             auto seed = combine(type, j.size());
             for (const auto& element : j.items())
             {
                 const auto h = std::hash<string_t> {}(element.key());
                 seed = combine(seed, h);
-                seed = combine(seed, hash(element.value(), depth + 1));
+                seed = combine(seed, hash(element.value()));
             }
             return seed;
         }
 
         case BasicJsonType::value_t::array:
         {
-            if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
-            {
-                return hash_iteratively(j);
-            }
-
             auto seed = combine(type, j.size());
             for (const auto& element : j)
             {
-                seed = combine(seed, hash(element, depth + 1));
+                seed = combine(seed, hash(element));
             }
             return seed;
         }
@@ -7207,78 +7153,6 @@ std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
     }
 }
 
-/// an array or object whose elements @ref hash_iteratively is hashing
-template<typename BasicJsonType>
-struct hash_frame
-{
-    hash_frame(const BasicJsonType* value_, std::size_t seed_) noexcept
-        : value(value_), position(value_->cbegin()), seed(seed_)
-    {}
-
-    const BasicJsonType* value;
-    typename BasicJsonType::const_iterator position;
-    std::size_t seed;
-};
-
-/*!
-@brief hash the array or object @a j without the call stack
-
-Computes the same value as @ref hash, keeping the arrays and objects it has
-entered on an explicit stack instead of descending into them. Only reached for
-values nested deeper than @ref recursion_depth_limit.
-
-@tparam BasicJsonType basic_json specialization
-@param j array or object to hash
-@return hash value of j
-*/
-template<typename BasicJsonType>
-std::size_t hash_iteratively(const BasicJsonType& j)
-{
-    using string_t = typename BasicJsonType::string_t;
-
-    std::vector<hash_frame<BasicJsonType>> stack;
-    stack.emplace_back(&j, combine(static_cast<std::size_t>(j.type()), j.size()));
-
-    while (true)
-    {
-        // a copy, as entering an element below can reallocate the stack; the
-        // frame itself is only changed through stack.back()
-        const hash_frame<BasicJsonType> frame = stack.back();
-
-        if (frame.position == frame.value->cend())
-        {
-            // all elements are hashed: fold this value's hash into its parent's
-            // seed, exactly where the recursive version returns it
-            const std::size_t h = frame.seed;
-            stack.pop_back();
-            if (stack.empty())
-            {
-                return h;
-            }
-            stack.back().seed = combine(stack.back().seed, h);
-            continue;
-        }
-
-        if (frame.value->is_object())
-        {
-            stack.back().seed = combine(stack.back().seed, std::hash<string_t> {}(frame.position.key()));
-        }
-
-        // advance before entering the element, which pushes onto the stack
-        const BasicJsonType& element = *frame.position;
-        ++stack.back().position;
-
-        if (element.is_structured())
-        {
-            stack.emplace_back(&element, combine(static_cast<std::size_t>(element.type()), element.size()));
-        }
-        else
-        {
-            stack.back().seed = combine(stack.back().seed, hash(element));
-        }
-    }
-}
-
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
@@ -22428,8 +22302,6 @@ NLOHMANN_JSON_NAMESPACE_END
 
 // #include <nlohmann/detail/output/output_adapters.hpp>
 
-// #include <nlohmann/detail/recursion_depth_limit.hpp>
-
 // #include <nlohmann/detail/string_concat.hpp>
 
 // #include <nlohmann/detail/value_t.hpp>
@@ -22535,7 +22407,7 @@ class serializer
 
     Serializing a container descends into its elements, so a value nested deeply
     enough used to exhaust the call stack and terminate the process with no
-    exception to catch. The descent is bounded here: once @ref recursion_depth_limit
+    exception to catch. The descent is bounded here: once @ref dump_depth_limit
     levels have been entered, @ref dump_iteratively writes out what is left
     without the call stack. A value nested less deeply than that - all but a
     vanishing minority - is written by exactly the code that always wrote it.
@@ -22550,7 +22422,7 @@ class serializer
         {
             case value_t::object:
             {
-                if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
+                if (JSON_HEDLEY_UNLIKELY(depth >= dump_depth_limit()))
                 {
                     dump_iteratively(val, current_indent);
                     return;
@@ -22625,7 +22497,7 @@ class serializer
 
             case value_t::array:
             {
-                if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
+                if (JSON_HEDLEY_UNLIKELY(depth >= dump_depth_limit()))
                 {
                     dump_iteratively(val, current_indent);
                     return;
@@ -22810,12 +22682,19 @@ class serializer
     }
 
   private:
+    /// the number of levels @ref dump_internal descends into before it hands
+    /// over to @ref dump_iteratively
+    static constexpr std::size_t dump_depth_limit()
+    {
+        return 128;
+    }
+
     /*!
     @brief write out @a val and everything below it without the call stack
 
     Emits the same bytes as @ref dump_internal, keeping the containers it has
     entered on an explicit stack instead of descending into them. Only reached
-    for values nested deeper than @ref recursion_depth_limit, which is why it is not
+    for values nested deeper than @ref dump_depth_limit, which is why it is not
     written for speed: walking every value this way measured up to 20% slower on
     object-heavy documents than letting the compiler drive the descent.
     */
@@ -24128,8 +24007,6 @@ class serializer
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
 
-// #include <nlohmann/detail/recursion_depth_limit.hpp>
-
 // #include <nlohmann/detail/value_t.hpp>
 
 // #include <nlohmann/json_fwd.hpp>
@@ -28371,54 +28248,17 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
             JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
         }
 
-        update_members(first, last, merge_objects, 0);
-    }
-
-  private:
-    /// @brief an object @ref update_members_iteratively or @ref
-    /// merge_patch_iteratively is merging into, and the members still to merge
-    struct merge_frame
-    {
-        merge_frame(basic_json* target_, const_iterator position_, const_iterator last_) noexcept
-            : target(target_), position(std::move(position_)), last(std::move(last_))
-        {}
-
-        basic_json* target;
-        const_iterator position;
-        const_iterator last;
-    };
-
-    /*!
-    @brief the members loop of @ref update, for this object and range
-
-    Merging a nested object calls this function again, once per nesting
-    level, so a value nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    update_members_iteratively merges what is left without the call stack.
-
-    @param[in] depth  nesting level of this object, counted from the object
-                      @ref update was called on
-    */
-    void update_members(const const_iterator& first, const const_iterator& last, const bool merge_objects, const std::size_t depth)
-    {
-        if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-        {
-            update_members_iteratively(first, last);
-            return;
-        }
-
         for (auto it = first; it != last; ++it)
         {
             if (merge_objects && it.value().is_object())
             {
-                const auto it2 = m_data.m_value.object->find(it.key());
+                auto it2 = m_data.m_value.object->find(it.key());
                 // Only recurse when the existing value is itself an object.
                 // Otherwise overwrite, matching the documented "all other values
                 // are overwritten as usual" behavior (see #5402).
                 if (it2 != m_data.m_value.object->end() && it2->second.is_object())
                 {
-                    it2->second.update_members(it.value().cbegin(), it.value().cend(), true, depth + 1);
+                    it2->second.update(it.value(), true);
 #if JSON_DIAGNOSTICS
                     it2->second.set_parents();
 #endif
@@ -28432,64 +28272,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-    /*!
-    @brief merge @a first to @a last into this object without the call stack
-
-    Does the same as @ref update_members with `merge_objects` set, keeping the
-    objects whose merge was interrupted by a nested one on an explicit stack
-    instead of descending into them. A nested object is still merged
-    completely before the next member, in the same order as the recursive
-    version. Only reached for values nested deeper than @ref
-    detail::recursion_depth_limit.
-    */
-    void update_members_iteratively(const_iterator first, const_iterator last)
-    {
-        std::vector<merge_frame> stack;
-
-        basic_json* target = this;
-        while (true)
-        {
-            if (first == last)
-            {
-                if (stack.empty())
-                {
-                    break;
-                }
-
-                // a nested object is merged: continue with its parent
-#if JSON_DIAGNOSTICS
-                target->set_parents();
-#endif
-                target = stack.back().target;
-                first = stack.back().position;
-                last = stack.back().last;
-                stack.pop_back();
-                continue;
-            }
-
-            if (first.value().is_object())
-            {
-                const auto it2 = target->m_data.m_value.object->find(first.key());
-                if (it2 != target->m_data.m_value.object->end() && it2->second.is_object())
-                {
-                    const basic_json& source = first.value();
-                    ++first;
-                    stack.emplace_back(target, first, last);
-                    target = &it2->second;
-                    first = source.cbegin();
-                    last = source.cend();
-                    continue;
-                }
-            }
-            target->m_data.m_value.object->operator[](first.key()) = first.value();
-#if JSON_DIAGNOSTICS
-            target->m_data.m_value.object->operator[](first.key()).m_parent = target;
-#endif
-            ++first;
-        }
-    }
-
-  public:
     /// @brief exchanges the values
     /// @sa https://json.nlohmann.me/api/basic_json/swap/
     void swap(reference other) noexcept (
@@ -30384,30 +30166,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
     /// @brief applies a JSON Merge Patch
     /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
     void merge_patch(const basic_json& apply_patch)
-    {
-        apply_merge_patch(apply_patch, 0);
-    }
-
-  private:
-    /*!
-    @brief @ref merge_patch, for a patch at nesting level @a depth
-
-    Applying a nested object calls this function again, once per nesting
-    level, so a patch nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    merge_patch_iteratively applies what is left without the call stack.
-    */
-    void apply_merge_patch(const basic_json& apply_patch, const std::size_t depth)
     {
         if (apply_patch.is_object())
         {
-            if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-            {
-                merge_patch_iteratively(apply_patch);
-                return;
-            }
-
             if (!is_object())
             {
                 *this = object();
@@ -30420,7 +30181,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                 }
                 else
                 {
-                    operator[](it.key()).apply_merge_patch(it.value(), depth + 1);
+                    operator[](it.key()).merge_patch(it.value());
                 }
             }
         }
@@ -30430,62 +30191,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
     }
 
-    /*!
-    @brief apply @a apply_patch to this value without the call stack
-
-    Does the same as @ref merge_patch, keeping the objects being patched on an
-    explicit stack instead of descending into them. A nested object is still
-    patched completely before the next member, in the same order as the
-    recursive version. Only reached for patches nested deeper than @ref
-    detail::recursion_depth_limit.
-    */
-    void merge_patch_iteratively(const basic_json& apply_patch)
-    {
-        std::vector<merge_frame> stack;
-
-        // patch `target` with `patch`, or start patching it member by member
-        const auto apply = [&stack](basic_json & target, const basic_json & patch)
-        {
-            if (patch.is_object())
-            {
-                if (!target.is_object())
-                {
-                    target = basic_json::object();
-                }
-                stack.emplace_back(&target, patch.cbegin(), patch.cend());
-            }
-            else
-            {
-                target = patch;
-            }
-        };
-
-        apply(*this, apply_patch);
-        while (!stack.empty())
-        {
-            // a copy, as applying a member below can reallocate the stack;
-            // the frame itself is only changed through stack.back()
-            const merge_frame frame = stack.back();
-            if (frame.position == frame.last)
-            {
-                stack.pop_back();
-                continue;
-            }
-
-            const const_iterator member = frame.position;
-            ++stack.back().position;
-            if (member.value().is_null())
-            {
-                frame.target->erase(member.key());
-            }
-            else
-            {
-                apply(frame.target->operator[](member.key()), member.value());
-            }
-        }
-    }
-
-  public:
     /// @}
 };
 
@@ -30728,7 +30433,6 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
 #undef JSON_NO_UNIQUE_ADDRESS
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_USE_GLOBAL_UDLS
-#undef JSON_STRICT_NUL_HANDLING
 
 #ifndef JSON_TEST_KEEP_MACROS
     #undef JSON_CATCH
@@ -30747,6 +30451,7 @@ struct formatter<nlohmann::NLOHMANN_BASIC_JSON_TPL, char> // NOLINT(cert-dcl58-c
     #undef JSON_HAS_STATIC_RTTI
     #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
     #undef JSON_BRACE_INIT_COPY_SEMANTICS
+    #undef JSON_STRICT_NUL_HANDLING
 #endif
 
 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>

single_include/nlohmann/json_fwd.hpp

@@ -56,6 +56,10 @@
     #define JSON_BRACE_INIT_COPY_SEMANTICS 0
 #endif
 
+#ifndef JSON_STRICT_NUL_HANDLING
+    #define JSON_STRICT_NUL_HANDLING 0
+#endif
+
 #if JSON_DIAGNOSTICS
     #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -80,21 +84,28 @@
     #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
 #endif
 
+#if JSON_STRICT_NUL_HANDLING
+    #define NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING _snul
+#else
+    #define NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING
+#endif
+
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
     #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif
 
 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e) json_abi ## a ## b ## c ## d ## e
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e)
 
 #define NLOHMANN_JSON_ABI_TAGS                                       \
     NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
             NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
             NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
+            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
+            NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING)
 
 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \

tests/abi/config/default.cpp

@@ -36,6 +36,10 @@ TEST_CASE("default namespace")
         expected += "_bics";
 #endif
 
+#if JSON_STRICT_NUL_HANDLING
+        expected += "_snul";
+#endif
+
         expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_MINOR);
         expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_PATCH) "::basic_json";

tests/abi/config/noversion.cpp

@@ -37,6 +37,10 @@ TEST_CASE("default namespace without version component")
         expected += "_bics";
 #endif
 
+#if JSON_STRICT_NUL_HANDLING
+        expected += "_snul";
+#endif
+
         expected += "::basic_json";
 
         // fallback for Clang

tests/src/unit-class_parser.cpp

@@ -11,11 +11,15 @@
 // capture whether JSON_STRICT_NUL_HANDLING was enabled on the command line
 // (e.g. -DJSON_STRICT_NUL_HANDLING=1) *before* including json.hpp, since the
 // library #undefs JSON_STRICT_NUL_HANDLING itself once the header has been
-// fully processed (see include/nlohmann/detail/macro_unscope.hpp)
+// fully processed unless JSON_TEST_KEEP_MACROS is defined (see
+// include/nlohmann/detail/macro_unscope.hpp)
 #if defined(JSON_STRICT_NUL_HANDLING) && (JSON_STRICT_NUL_HANDLING == 1)
     #define JSON_TEST_STRICT_NUL_HANDLING_ENABLED 1
 #endif
 
+#define JSON_TEST_STRINGIZE_EX(x) #x
+#define JSON_TEST_STRINGIZE(x) JSON_TEST_STRINGIZE_EX(x)
+
 #define JSON_TESTS_PRIVATE
 #include <nlohmann/json.hpp>
 using nlohmann::json;
@@ -566,6 +570,16 @@ TEST_CASE("parser class")
             // left at its default or forced to 1 (e.g. by the dedicated
             // ci_test_strict_nul_handling CI target), so only the section
             // matching the actual, compiled-in behavior can pass.
+            SECTION("the macro is part of the ABI tag")
+            {
+                const std::string ns = JSON_TEST_STRINGIZE(NLOHMANN_JSON_NAMESPACE);
+#if defined(JSON_TEST_STRICT_NUL_HANDLING_ENABLED)
+                CHECK(ns.find("_snul") != std::string::npos);
+#else
+                CHECK(ns.find("_snul") == std::string::npos);
+#endif
+            }
+
 #if !defined(JSON_TEST_STRICT_NUL_HANDLING_ENABLED)
             SECTION("default behavior (macro not enabled)")
             {

tests/src/unit-diagnostics.cpp

@@ -363,52 +363,3 @@ TEST_CASE("Regression tests for extended diagnostics")
     }
 }
 
-TEST_CASE("Better diagnostics past the descent bound of update() and merge_patch()")
-{
-    // Both merge objects nested more than detail::recursion_depth_limit()
-    // (128) levels deep without recursing; the values they add or replace
-    // there must still know their parents.
-    // The values are built rather than parsed, so that the expected messages
-    // carry no byte positions under JSON_DIAGNOSTIC_POSITIONS.
-    const std::size_t depth = 200;
-    json target = {{"x", 1}};
-    json patch = {{"y", 2}};
-    std::string path;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        target = json{{"a", std::move(target)}};
-        patch = json{{"a", std::move(patch)}};
-        path += "/a";
-    }
-    const std::string expected_x = "[json.exception.type_error.304] (" + path + "/x) cannot use at() with number";
-    const std::string expected_y = "[json.exception.type_error.304] (" + path + "/y) cannot use at() with number";
-
-    SECTION("update()")
-    {
-        json j = target;
-        j.update(patch, true);
-
-        // walk down through const references, which leave m_parent alone
-        const json* p = &j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        CHECK_THROWS_WITH_AS(p->at("x").at(0), expected_x.c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(p->at("y").at(0), expected_y.c_str(), json::type_error);
-    }
-
-    SECTION("merge_patch()")
-    {
-        json j = target;
-        j.merge_patch(patch);
-
-        const json* p = &j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        CHECK_THROWS_WITH_AS(p->at("x").at(0), expected_x.c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(p->at("y").at(0), expected_y.c_str(), json::type_error);
-    }
-}

tests/src/unit-hash.cpp

@@ -13,78 +13,6 @@ using json = nlohmann::json;
 using ordered_json = nlohmann::ordered_json;
 
 #include <set>
-#include <string>
-
-namespace
-{
-// how detail::hash defines the hash of an array or object: the seeds of the
-// elements, combined in order. Recursive, so only usable on values nested a
-// few hundred levels deep - which is exactly what is needed to check that the
-// iterative path taken below detail::recursion_depth_limit() computes the same.
-template<typename BasicJsonType>
-std::size_t reference_hash(const BasicJsonType& j)
-{
-    using nlohmann::detail::combine;
-    using string_t = typename BasicJsonType::string_t;
-
-    if (!j.is_structured())
-    {
-        return std::hash<BasicJsonType> {}(j);
-    }
-
-    auto seed = combine(static_cast<std::size_t>(j.type()), j.size());
-    for (const auto& element : j.items())
-    {
-        if (j.is_object())
-        {
-            seed = combine(seed, std::hash<string_t> {}(element.key()));
-        }
-        seed = combine(seed, reference_hash(element.value()));
-    }
-    return seed;
-}
-
-// a value nested `depth` levels deep, with siblings on every level
-template<typename BasicJsonType>
-BasicJsonType nested(const std::size_t depth, const bool objects)
-{
-    BasicJsonType value = "leaf";
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        if (objects)
-        {
-            value = BasicJsonType{{"before", i}, {"nested", std::move(value)}, {"after", {i, "x"}}};
-        }
-        else
-        {
-            value = BasicJsonType::array({i, std::move(value), BasicJsonType::object({{"k", i}})});
-        }
-    }
-    return value;
-}
-
-std::string nested_text(const std::size_t depth, const bool objects)
-{
-    std::string text;
-    if (objects)
-    {
-        text.reserve((6 * depth) + 1);
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            text += "{\"a\":";
-        }
-        text += "1";
-        text.append(depth, '}');
-    }
-    else
-    {
-        text.assign(depth, '[');
-        text += "1";
-        text.append(depth, ']');
-    }
-    return text;
-}
-} // namespace
 
 TEST_CASE("hash<nlohmann::json>")
 {
@@ -183,44 +111,3 @@ TEST_CASE("hash<nlohmann::ordered_json>")
 
     CHECK(hashes.size() == 21);
 }
-
-TEST_CASE("hash of deeply nested values")
-{
-    SECTION("hashing past the descent bound computes the same values")
-    {
-        // every depth on either side of where the iterative path takes over
-        for (std::size_t depth = 0; depth <= (2 * nlohmann::detail::recursion_depth_limit()) + 10; ++depth)
-        {
-            CAPTURE(depth);
-            const auto arrays = nested<json>(depth, false);
-            const auto objects = nested<json>(depth, true);
-            const auto ordered = nested<ordered_json>(depth, true);
-            CHECK(std::hash<json> {}(arrays) == reference_hash(arrays));
-            CHECK(std::hash<json> {}(objects) == reference_hash(objects));
-            CHECK(std::hash<ordered_json> {}(ordered) == reference_hash(ordered));
-        }
-    }
-
-    SECTION("values nested too deeply for the call stack (#5545)")
-    {
-        // recursing once per level used to exhaust the call stack here; the
-        // values are only parsed and hashed, never copied or compared, since
-        // those recurse as well
-        const std::size_t depth = 100000;
-        for (const bool objects :
-                {
-                    false, true
-                })
-        {
-            CAPTURE(objects);
-            const auto text = nested_text(depth, objects);
-            const auto a = json::parse(text);
-            const auto b = json::parse(text);
-            CHECK(std::hash<json> {}(a) == std::hash<json> {}(b));
-
-            const auto c = ordered_json::parse(text);
-            const auto d = ordered_json::parse(text);
-            CHECK(std::hash<ordered_json> {}(c) == std::hash<ordered_json> {}(d));
-        }
-    }
-}

tests/src/unit-merge_patch.cpp

@@ -14,60 +14,6 @@ using nlohmann::json;
     using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif
 
-#include <string>
-
-namespace
-{
-// RFC 7396's MergePatch, written recursively as in the RFC; only usable on
-// values nested a few hundred levels deep
-void reference_merge_patch(json& target, const json& patch)
-{
-    if (!patch.is_object())
-    {
-        target = patch;
-        return;
-    }
-    if (!target.is_object())
-    {
-        target = json::object();
-    }
-    for (auto it = patch.begin(); it != patch.end(); ++it)
-    {
-        if (it.value().is_null())
-        {
-            target.erase(it.key());
-        }
-        else
-        {
-            reference_merge_patch(target[it.key()], it.value());
-        }
-    }
-}
-
-// objects nested `depth` levels deep under the key "a", with members that
-// differ by `variant` on the way down
-std::string nested_objects(const std::size_t depth, const int variant)
-{
-    std::string text;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        text += "{";
-        if ((i + static_cast<std::size_t>(variant)) % 3 == 0)
-        {
-            text += "\"s" + std::to_string(variant) + "\":" + std::to_string(i) + ",";
-        }
-        if (variant == 2 && i % 5 == 0)
-        {
-            text += "\"s0\":null,";
-        }
-        text += "\"a\":";
-    }
-    text += variant == 1 ? "{\"x\":1,\"y\":null}" : "{\"y\":2}";
-    text.append(depth, '}');
-    return text;
-}
-} // namespace
-
 TEST_CASE("JSON Merge Patch")
 {
     SECTION("examples from RFC 7396")
@@ -296,52 +242,3 @@ TEST_CASE("JSON Merge Patch")
         }
     }
 }
-
-TEST_CASE("JSON Merge Patch on deeply nested values")
-{
-    SECTION("patching past the descent bound gives the same result")
-    {
-        // every depth on either side of where the iterative version takes
-        // over (detail::recursion_depth_limit(), 128)
-        for (std::size_t depth = 0; depth <= 300; ++depth)
-        {
-            CAPTURE(depth);
-            for (int variant = 0; variant < 3; ++variant)
-            {
-                CAPTURE(variant);
-                const json patch = json::parse(nested_objects(depth, variant));
-
-                json result = json::parse(nested_objects(depth, (variant + 1) % 3));
-                json expected = result;
-                result.merge_patch(patch);
-                reference_merge_patch(expected, patch);
-                CHECK(result == expected);
-
-                // a target that is not an object, and an empty one
-                json from_null;
-                from_null.merge_patch(patch);
-                json expected_from_null;
-                reference_merge_patch(expected_from_null, patch);
-                CHECK(from_null == expected_from_null);
-            }
-        }
-    }
-
-    SECTION("patches nested too deeply for the call stack (#5393)")
-    {
-        // applying a patch used to recurse once per nesting level. The result
-        // is only walked, never copied or compared, since those recurse too.
-        const std::size_t depth = 100000;
-        json target = json::parse(nested_objects(depth, 0));
-        target.merge_patch(json::parse(nested_objects(depth, 1)));
-
-        const json* p = &target;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        // {"y":2} patched with {"x":1,"y":null}
-        CHECK(p->size() == 1);
-        CHECK(p->at("x") == 1);
-    }
-}

tests/src/unit-modifiers.cpp

@@ -11,53 +11,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 
-#include <string>
-
-namespace
-{
-// update(source, true) as documented, written recursively; only usable on
-// values nested a few hundred levels deep
-void reference_update(json& target, const json& source)
-{
-    for (auto it = source.begin(); it != source.end(); ++it)
-    {
-        const auto existing = target.find(it.key());
-        if (it.value().is_object() && existing != target.end() && existing->is_object())
-        {
-            reference_update(*existing, it.value());
-        }
-        else
-        {
-            target[it.key()] = it.value();
-        }
-    }
-}
-
-// objects nested `depth` levels deep under the key "a", with members that
-// differ by `variant` on the way down
-std::string nested_objects(const std::size_t depth, const int variant)
-{
-    std::string text;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        text += "{";
-        if ((i + static_cast<std::size_t>(variant)) % 3 == 0)
-        {
-            text += "\"s" + std::to_string(variant) + "\":" + std::to_string(i) + ",";
-        }
-        if (variant == 2 && i % 5 == 0)
-        {
-            // an object replacing a primitive, which is not merged
-            text += "\"s0\":{\"o\":1},";
-        }
-        text += "\"a\":";
-    }
-    text += variant == 1 ? "{\"x\":1}" : "{\"y\":2}";
-    text.append(depth, '}');
-    return text;
-}
-} // namespace
-
 TEST_CASE("modifiers")
 {
     SECTION("clear()")
@@ -1035,44 +988,3 @@ TEST_CASE("modifiers")
         }
     }
 }
-
-TEST_CASE("update() on deeply nested values")
-{
-    SECTION("merging past the descent bound gives the same result")
-    {
-        // every depth on either side of where the iterative version takes
-        // over (detail::recursion_depth_limit(), 128)
-        for (std::size_t depth = 0; depth <= 300; ++depth)
-        {
-            CAPTURE(depth);
-            for (int variant = 0; variant < 3; ++variant)
-            {
-                CAPTURE(variant);
-                const json source = json::parse(nested_objects(depth, variant));
-                json result = json::parse(nested_objects(depth, (variant + 1) % 3));
-                json expected = result;
-                result.update(source, true);
-                reference_update(expected, source);
-                CHECK(result == expected);
-            }
-        }
-    }
-
-    SECTION("objects nested too deeply for the call stack (#5545)")
-    {
-        // merging used to recurse once per nesting level. The result is only
-        // walked, never copied or compared, since those recurse too.
-        const std::size_t depth = 100000;
-        json target = json::parse(nested_objects(depth, 0));
-        target.update(json::parse(nested_objects(depth, 1)), true);
-
-        const json* p = &target;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        CHECK(p->size() == 2);
-        CHECK(p->at("x") == 1);
-        CHECK(p->at("y") == 2);
-    }
-}

tools/generate_natvis/generate_natvis.py

@@ -20,7 +20,7 @@ if __name__ == '__main__':
 
     namespaces = ['nlohmann']
     abi_prefix = 'json_abi'
-    abi_tags = ['_diag', '_ldvcmp', '_dp', '_bics']
+    abi_tags = ['_diag', '_ldvcmp', '_dp', '_bics', '_snul']
     version = '_v' + args.version.replace('.', '_')
     inline_namespaces = []