Test escaped object keys decoded through NLOHMANN_DEFINE_TYPE from a json_view

A json_view or json_document decodes a macro-defined struct directly and looks
the members up by their decoded keys. Only plain keys were covered so far.

The new section decodes structs defined with NLOHMANN_DEFINE_TYPE_INTRUSIVE,
..._WITH_DEFAULT and ..._WITH_NAMES from documents whose keys contain escape
sequences, and compares the result with the conversion of the materialized
value. It also pins the difference for a duplicate key written once plain and
once escaped (the view takes the first member, the materialized value keeps
the last one), and that an escaped backslash is part of the decoded key.

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

docs/mkdocs/docs/api/basic_json_document/accept.md

@@ -13,15 +13,9 @@ function never throws an exception for invalid input, and the returned `#!cpp bo
 is returned.
 
 The result is the same as that of `BasicJsonType::accept()` by design; the difference is how the check is made. This
-function runs the document's builder, which checks the text as [`parse()`](parse.md) does, while
-`BasicJsonType::accept()` runs the SAX parser with a handler that ignores every event. Use this one if you go on to
-parse the same input with [`parse()`](parse.md) anyway, so that both use the same code; either is fine for a plain
-yes/no answer.
-
-When both `ignore_comments` and `ignore_trailing_commas` are `#!cpp false` (the default), the builder writes no index.
-With either option set, it builds the index as [`parse()`](parse.md) does and discards it: the result is the same, only
-the time differs. (Neither option needs the index; the variant that skips it exists only for the default options to
-keep the code size down.)
+function runs the document's index builder (and discards the index), while `BasicJsonType::accept()` runs the SAX
+parser with a handler that ignores every event. Use this one if you go on to parse the same input with
+[`parse()`](parse.md) anyway, so that both use the same code; either is fine for a plain yes/no answer.
 
 ## Template parameters
 

include/nlohmann/detail/view/builder.hpp

@@ -16,7 +16,6 @@
 #include <cstring> // memcmp, memcpy
 #include <limits> // numeric_limits
 #include <string> // string
-#include <type_traits> // false_type, integral_constant, true_type
 #include <vector> // vector
 
 #include <nlohmann/json.hpp>
@@ -70,8 +69,7 @@ struct parse_failure
 };
 
 /// FloatType: the number_float_t of the document, whose overflow parse() rejects
-/// Store: false for accept(): the grammar, number, string and UTF-8 checks run as for parse(), but no node is written
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel>
 class builder
 {
   public:
@@ -247,88 +245,6 @@ class builder
         return p;
     }
 
-    /// the string from p, the first backslash, control character, ill-formed UTF-8 byte, or the end, checked and not
-    /// decoded (accept() stores nothing, so the arena is not written): the checks, errors and error positions of
-    /// slow_string(), for everything up to the closing quote
-    NLOHMANN_VIEW_NOINLINE decoded check_string(const unsigned char* p)
-    {
-        const unsigned char* const end = m_end;
-        for (;;)
-        {
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char c = *p;
-            if (c == '"')
-            {
-                ++p;
-                return decoded{p, 0, 0};
-            }
-            if (c != '\\')
-            {
-                return failed(c < 0x20 ? error_code::string_control_character : error_code::string_utf8, p);
-            }
-            ++p;
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char d = *p++;
-            if (d == 'u')
-            {
-                const int cp = hex4(p); // (moves p past the four digits)
-                if (NLOHMANN_VIEW_UNLIKELY(cp < 0))
-                {
-                    return failed(error_code::string_unicode_hex, p);
-                }
-                if (NLOHMANN_VIEW_UNLIKELY((cp & 0xF800) == 0xD800)) // a surrogate
-                {
-                    if (cp >= 0xDC00)
-                    {
-                        return failed(error_code::string_surrogate_low, p);
-                    }
-                    if (end - p < 2 || p[0] != '\\' || p[1] != 'u')
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                    p += 2;
-                    const int lo = hex4(p); // (moves p past the four digits)
-                    if (lo < 0)
-                    {
-                        return failed(error_code::string_unicode_hex, p);
-                    }
-                    if (lo < 0xDC00 || lo > 0xDFFF)
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                }
-            }
-            else if (!(d == '"' || d == '\\' || d == '/' || d == 'b' || d == 'f' || d == 'n' || d == 'r' || d == 't'))
-            {
-                --p;
-                return failed(error_code::string_escape, p);
-            }
-            p = scan_string_run(p, end); // the text up to the next backslash, quote, control character, or ill-formed UTF-8
-        }
-    }
-
-    /// the string from p, decoded into the arena, or only checked (Store == false)
-    decoded decode_string(const unsigned char* s, const unsigned char* p)
-    {
-        return decode_string(s, p, std::integral_constant<bool, Store>());
-    }
-
-    decoded decode_string(const unsigned char* s, const unsigned char* p, std::true_type /*unused*/)
-    {
-        return slow_string(s, p);
-    }
-
-    decoded decode_string(const unsigned char* /*unused*/, const unsigned char* p, std::false_type /*unused*/)
-    {
-        return check_string(p);
-    }
-
     /// s points to the start of the string, p to a backslash, a control
     /// character, an ill-formed UTF-8 byte, or the end: decode the string into
     /// the arena
@@ -694,13 +610,10 @@ run_found:
 
         NLOHMANN_VIEW_ALWAYS_INLINE bool run()
         {
-            if (enabled(Store))
-            {
-                cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
-                base = cold.m_doc.nodes;
-                out = base;
-                cap = base + cold.m_doc.node_capacity;
-            }
+            cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
+            base = cold.m_doc.nodes;
+            out = base;
+            cap = base + cold.m_doc.node_capacity;
 
             if (e - p >= 3 && p[0] == 0xEF && p[1] == 0xBB && p[2] == 0xBF)
             {
@@ -884,10 +797,7 @@ close_object:
             // an array pays nothing for this)
             if (NLOHMANN_VIEW_UNLIKELY(cur_count >= document_data::index_min_members))
             {
-                if (enabled(Store))
-                {
-                    cold.note_large_object(cur_idx);
-                }
+                cold.note_large_object(cur_idx);
             }
 
 close_container:
@@ -1047,12 +957,6 @@ indent_done:
         /// an integer's value); two stores on little-endian targets
         NLOHMANN_VIEW_ALWAYS_INLINE node* push_node(node_kind k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
         {
-            if (!enabled(Store))
-            {
-                // accept(): nothing is stored, so what computes the arguments is not run either. base and out stay
-                // null: their difference, which open() takes, is 0.
-                return out;
-            }
             if (NLOHMANN_VIEW_UNLIKELY(out == cap))
             {
                 const auto n = static_cast<std::size_t>(out - base);
@@ -1111,12 +1015,9 @@ indent_done:
 
         NLOHMANN_VIEW_ALWAYS_INLINE void close()
         {
-            if (enabled(Store))
-            {
-                node& n = base[cur_idx];
-                n.len = cur_count;
-                n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
-            }
+            node& n = base[cur_idx];
+            n.len = cur_count;
+            n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
             if (--depth != 0)
             {
                 if (NLOHMANN_VIEW_LIKELY(depth <= 64))
@@ -1271,7 +1172,7 @@ indent_done:
                 ++p;
                 return true;
             }
-            const decoded r = cold.decode_string(s, p);
+            const decoded r = cold.slow_string(s, p);
             if (r.p == nullptr)
             {
                 return false;
@@ -1291,44 +1192,34 @@ indent_done:
 };
 
 /// run the builder with compile-time options
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd>
 inline bool build_with(document_data& d, const char* src, std::size_t size, bool sentinel, parse_failure& failure)
 {
     if (sentinel)
     {
-        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true, Store> bld(d, src, size);
+        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true> bld(d, src, size);
         const bool ok = bld.run();
         failure = bld.failure();
         return ok;
     }
-    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false, Store> bld(d, src, size);
+    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false> bld(d, src, size);
     const bool ok = bld.run();
     failure = bld.failure();
     return ok;
 }
 
 /// sentinel: src[size] is readable and 0 (e.g. std::string); FloatType: the
-/// number_float_t of the document; validate_only: accept(), only the result is
-/// used
+/// number_float_t of the document
 template<typename FloatType, bool NulIsEnd>
-inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, bool validate_only,
-                  parse_failure& failure)
+inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, parse_failure& failure)
 {
-    if (validate_only && !comments && !trailing_commas)
-    {
-        // accept() of plain JSON: nothing is stored. The other option sets
-        // could skip the stores just as well; they keep the builder that
-        // stores only so that there are two more instantiations of the parse
-        // loop, not eight.
-        return build_with<FloatType, false, false, NulIsEnd, false>(d, src, size, sentinel, failure);
-    }
     if (comments)
     {
-        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-               : build_with<FloatType, true, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd>(d, src, size, sentinel, failure)
+               : build_with<FloatType, true, false, NulIsEnd>(d, src, size, sentinel, failure);
     }
-    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-           : build_with<FloatType, false, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd>(d, src, size, sentinel, failure)
+           : build_with<FloatType, false, false, NulIsEnd>(d, src, size, sentinel, failure);
 }
 
 }  // namespace view

include/nlohmann/json_view.hpp

@@ -1060,7 +1060,7 @@ class basic_json_document
                                      const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_range(first, last, error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.read_range(first, last, allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -1075,7 +1075,7 @@ class basic_json_document
         basic_json_document d;
         std::string buf;
         append_input(buf, std::forward<InputType>(input));
-        d.build_owned(std::move(buf), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.build_owned(std::move(buf), allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -1088,8 +1088,7 @@ class basic_json_document
     static bool accept(InputType&& input, const bool ignore_comments = false, const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_kind(std::forward<InputType>(input), on_error::validate, ignore_comments, ignore_trailing_commas,
-                    std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
+        d.read(std::forward<InputType>(input), false, ignore_comments, ignore_trailing_commas);
         return !d.is_discarded();
     }
 
@@ -1105,7 +1104,7 @@ class basic_json_document
               const bool ignore_comments = false,
               const bool ignore_trailing_commas = false)
     {
-        read_kind(std::forward<InputType>(input), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas,
+        read_kind(std::forward<InputType>(input), allow_exceptions, ignore_comments, ignore_trailing_commas,
                   std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
     }
 
@@ -1464,22 +1463,6 @@ class basic_json_document
         return idx;
     }
 
-    /// what a failed parse does
-    enum class on_error : std::uint8_t
-    {
-        discard, ///< the document is discarded
-        raise,   ///< parse_error is thrown
-        validate ///< accept(): the document is discarded, and no node is stored while parsing
-    };
-
-    static on_error error_mode(bool allow_exceptions) noexcept
-    {
-        return allow_exceptions ? on_error::raise : on_error::discard;
-    }
-
-    /// NulIsEnd of the builder: a null byte ends the input unless strict_nul_handling
-    static constexpr bool nul_is_end = !detail::abi_config::strict_nul_handling;
-
     /// create the storage (sized for the input) on first use
     void ensure_data(const char* src, std::size_t size)
     {
@@ -1491,7 +1474,7 @@ class basic_json_document
 
     /// parse a buffer the document takes ownership of (it replaces the
     /// previous owned copy)
-    void build_owned(std::string&& buf, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_owned(std::string&& buf, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         ensure_data(buf.data(), buf.size());
         m_data->owned = std::move(buf);
@@ -1501,7 +1484,7 @@ class basic_json_document
     /// parse a copy of the input; the copy is appended to the cleared owned
     /// buffer, so that its capacity is reused
     template<typename T>
-    void build_copy(T&& input, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_copy(T&& input, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         if (!m_data)
         {
@@ -1522,7 +1505,7 @@ class basic_json_document
     }
 
     /// sentinel: src[size] is readable and 0 (std::string, C strings)
-    void build(const char* src, std::size_t size, on_error allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
+    void build(const char* src, std::size_t size, bool allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
     {
         ensure_data(src, size);
         document_data& d = *m_data;
@@ -1549,8 +1532,7 @@ class basic_json_document
         }
         else
         {
-            ok = detail::view::build<typename BasicJsonType::number_float_t, nul_is_end>(d, src, size, comments, trailing_commas, sentinel,
-                 allow_exceptions == on_error::validate, failure);
+            ok = detail::view::build < typename BasicJsonType::number_float_t, !detail::abi_config::strict_nul_handling > (d, src, size, comments, trailing_commas, sentinel, failure);
         }
         if (NLOHMANN_VIEW_LIKELY(ok))
         {
@@ -1563,7 +1545,7 @@ class basic_json_document
             return;
         }
         std::vector<std::uint32_t>().swap(d.large_objects);
-        if (allow_exceptions == on_error::raise)
+        if (allow_exceptions)
         {
             detail::view::throw_parse_failure<BasicJsonType>(failure, src, size, comments, trailing_commas);
         }
@@ -1571,13 +1553,13 @@ class basic_json_document
 
     // --- input dispatch (see detail::view::input_kind) ---
 
-    void read_kind(std::string&& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
+    void read_kind(std::string&& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
     {
         build_owned(std::move(s), ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -1591,7 +1573,7 @@ class basic_json_document
     }
 
     template<typename Array>
-    void read_kind(Array& a, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
+    void read_kind(Array& a, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
     {
         using CharT = typename std::remove_cv<typename std::remove_extent<Array>::type>::type;
         const std::size_t n = std::extent<Array>::value;
@@ -1602,7 +1584,7 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
     {
         // std::basic_string guarantees data()[size()] == 0: use it as sentinel
         const auto size = static_cast<std::size_t>(s.size());
@@ -1611,13 +1593,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
     {
         build_copy(s, ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -1629,13 +1611,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(T&& input, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
+    void read_kind(T&& input, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
     {
         build_copy(std::forward<T>(input), ae, c, tc);
     }
 
     template<typename IteratorType>
-    void read_range(IteratorType first, IteratorType last, on_error ae, bool c, bool tc)
+    void read_range(IteratorType first, IteratorType last, bool ae, bool c, bool tc)
     {
         using value_type = typename std::remove_cv<typename std::iterator_traits<IteratorType>::value_type>::type;
         // borrow the range where the library's input adapter scans it as one
@@ -1646,14 +1628,14 @@ class basic_json_document
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
     {
         const auto size = static_cast<std::size_t>(std::distance(first, last));
         build(size == 0 ? "" : reinterpret_cast<const char*>(&*first), size, ae, c, tc, false, size == 0); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::false_type /*other*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::false_type /*other*/)
     {
         build_copy(detail::view::make_adapter_input(detail::input_adapter(first, last)), ae, c, tc);
     }

single_include/nlohmann/json_view.hpp

@@ -88,7 +88,6 @@
 #include <cstring> // memcmp, memcpy
 #include <limits> // numeric_limits
 #include <string> // string
-#include <type_traits> // false_type, integral_constant, true_type
 #include <vector> // vector
 
 // #include <nlohmann/json.hpp>
@@ -1312,8 +1311,7 @@ struct parse_failure
 };
 
 /// FloatType: the number_float_t of the document, whose overflow parse() rejects
-/// Store: false for accept(): the grammar, number, string and UTF-8 checks run as for parse(), but no node is written
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Sentinel>
 class builder
 {
   public:
@@ -1489,88 +1487,6 @@ class builder
         return p;
     }
 
-    /// the string from p, the first backslash, control character, ill-formed UTF-8 byte, or the end, checked and not
-    /// decoded (accept() stores nothing, so the arena is not written): the checks, errors and error positions of
-    /// slow_string(), for everything up to the closing quote
-    NLOHMANN_VIEW_NOINLINE decoded check_string(const unsigned char* p)
-    {
-        const unsigned char* const end = m_end;
-        for (;;)
-        {
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char c = *p;
-            if (c == '"')
-            {
-                ++p;
-                return decoded{p, 0, 0};
-            }
-            if (c != '\\')
-            {
-                return failed(c < 0x20 ? error_code::string_control_character : error_code::string_utf8, p);
-            }
-            ++p;
-            if (p == end)
-            {
-                return failed(error_code::string_missing_quote, p);
-            }
-            const unsigned char d = *p++;
-            if (d == 'u')
-            {
-                const int cp = hex4(p); // (moves p past the four digits)
-                if (NLOHMANN_VIEW_UNLIKELY(cp < 0))
-                {
-                    return failed(error_code::string_unicode_hex, p);
-                }
-                if (NLOHMANN_VIEW_UNLIKELY((cp & 0xF800) == 0xD800)) // a surrogate
-                {
-                    if (cp >= 0xDC00)
-                    {
-                        return failed(error_code::string_surrogate_low, p);
-                    }
-                    if (end - p < 2 || p[0] != '\\' || p[1] != 'u')
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                    p += 2;
-                    const int lo = hex4(p); // (moves p past the four digits)
-                    if (lo < 0)
-                    {
-                        return failed(error_code::string_unicode_hex, p);
-                    }
-                    if (lo < 0xDC00 || lo > 0xDFFF)
-                    {
-                        return failed(error_code::string_surrogate_high, p);
-                    }
-                }
-            }
-            else if (!(d == '"' || d == '\\' || d == '/' || d == 'b' || d == 'f' || d == 'n' || d == 'r' || d == 't'))
-            {
-                --p;
-                return failed(error_code::string_escape, p);
-            }
-            p = scan_string_run(p, end); // the text up to the next backslash, quote, control character, or ill-formed UTF-8
-        }
-    }
-
-    /// the string from p, decoded into the arena, or only checked (Store == false)
-    decoded decode_string(const unsigned char* s, const unsigned char* p)
-    {
-        return decode_string(s, p, std::integral_constant<bool, Store>());
-    }
-
-    decoded decode_string(const unsigned char* s, const unsigned char* p, std::true_type /*unused*/)
-    {
-        return slow_string(s, p);
-    }
-
-    decoded decode_string(const unsigned char* /*unused*/, const unsigned char* p, std::false_type /*unused*/)
-    {
-        return check_string(p);
-    }
-
     /// s points to the start of the string, p to a backslash, a control
     /// character, an ill-formed UTF-8 byte, or the end: decode the string into
     /// the arena
@@ -1936,13 +1852,10 @@ run_found:
 
         NLOHMANN_VIEW_ALWAYS_INLINE bool run()
         {
-            if (enabled(Store))
-            {
-                cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
-                base = cold.m_doc.nodes;
-                out = base;
-                cap = base + cold.m_doc.node_capacity;
-            }
+            cold.m_doc.reserve(estimate_nodes(reinterpret_cast<const char*>(b), static_cast<std::size_t>(e - b)));
+            base = cold.m_doc.nodes;
+            out = base;
+            cap = base + cold.m_doc.node_capacity;
 
             if (e - p >= 3 && p[0] == 0xEF && p[1] == 0xBB && p[2] == 0xBF)
             {
@@ -2126,10 +2039,7 @@ close_object:
             // an array pays nothing for this)
             if (NLOHMANN_VIEW_UNLIKELY(cur_count >= document_data::index_min_members))
             {
-                if (enabled(Store))
-                {
-                    cold.note_large_object(cur_idx);
-                }
+                cold.note_large_object(cur_idx);
             }
 
 close_container:
@@ -2289,12 +2199,6 @@ indent_done:
         /// an integer's value); two stores on little-endian targets
         NLOHMANN_VIEW_ALWAYS_INLINE node* push_node(node_kind k, std::uint8_t flags, std::uint16_t extra, std::size_t off, std::uint64_t second)
         {
-            if (!enabled(Store))
-            {
-                // accept(): nothing is stored, so what computes the arguments is not run either. base and out stay
-                // null: their difference, which open() takes, is 0.
-                return out;
-            }
             if (NLOHMANN_VIEW_UNLIKELY(out == cap))
             {
                 const auto n = static_cast<std::size_t>(out - base);
@@ -2353,12 +2257,9 @@ indent_done:
 
         NLOHMANN_VIEW_ALWAYS_INLINE void close()
         {
-            if (enabled(Store))
-            {
-                node& n = base[cur_idx];
-                n.len = cur_count;
-                n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
-            }
+            node& n = base[cur_idx];
+            n.len = cur_count;
+            n.next = static_cast<std::uint32_t>(out - base) - cur_idx;
             if (--depth != 0)
             {
                 if (NLOHMANN_VIEW_LIKELY(depth <= 64))
@@ -2513,7 +2414,7 @@ indent_done:
                 ++p;
                 return true;
             }
-            const decoded r = cold.decode_string(s, p);
+            const decoded r = cold.slow_string(s, p);
             if (r.p == nullptr)
             {
                 return false;
@@ -2533,44 +2434,34 @@ indent_done:
 };
 
 /// run the builder with compile-time options
-template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd, bool Store>
+template<typename FloatType, bool Comments, bool TrailingCommas, bool NulIsEnd>
 inline bool build_with(document_data& d, const char* src, std::size_t size, bool sentinel, parse_failure& failure)
 {
     if (sentinel)
     {
-        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true, Store> bld(d, src, size);
+        builder<FloatType, Comments, TrailingCommas, NulIsEnd, true> bld(d, src, size);
         const bool ok = bld.run();
         failure = bld.failure();
         return ok;
     }
-    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false, Store> bld(d, src, size);
+    builder<FloatType, Comments, TrailingCommas, NulIsEnd, false> bld(d, src, size);
     const bool ok = bld.run();
     failure = bld.failure();
     return ok;
 }
 
 /// sentinel: src[size] is readable and 0 (e.g. std::string); FloatType: the
-/// number_float_t of the document; validate_only: accept(), only the result is
-/// used
+/// number_float_t of the document
 template<typename FloatType, bool NulIsEnd>
-inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, bool validate_only,
-                  parse_failure& failure)
+inline bool build(document_data& d, const char* src, std::size_t size, bool comments, bool trailing_commas, bool sentinel, parse_failure& failure)
 {
-    if (validate_only && !comments && !trailing_commas)
-    {
-        // accept() of plain JSON: nothing is stored. The other option sets
-        // could skip the stores just as well; they keep the builder that
-        // stores only so that there are two more instantiations of the parse
-        // loop, not eight.
-        return build_with<FloatType, false, false, NulIsEnd, false>(d, src, size, sentinel, failure);
-    }
     if (comments)
     {
-        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-               : build_with<FloatType, true, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+        return trailing_commas ? build_with<FloatType, true, true, NulIsEnd>(d, src, size, sentinel, failure)
+               : build_with<FloatType, true, false, NulIsEnd>(d, src, size, sentinel, failure);
     }
-    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd, true>(d, src, size, sentinel, failure)
-           : build_with<FloatType, false, false, NulIsEnd, true>(d, src, size, sentinel, failure);
+    return trailing_commas ? build_with<FloatType, false, true, NulIsEnd>(d, src, size, sentinel, failure)
+           : build_with<FloatType, false, false, NulIsEnd>(d, src, size, sentinel, failure);
 }
 
 }  // namespace view
@@ -10210,7 +10101,7 @@ class basic_json_document
                                      const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_range(first, last, error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.read_range(first, last, allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -10225,7 +10116,7 @@ class basic_json_document
         basic_json_document d;
         std::string buf;
         append_input(buf, std::forward<InputType>(input));
-        d.build_owned(std::move(buf), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas);
+        d.build_owned(std::move(buf), allow_exceptions, ignore_comments, ignore_trailing_commas);
         return d;
     }
 
@@ -10238,8 +10129,7 @@ class basic_json_document
     static bool accept(InputType&& input, const bool ignore_comments = false, const bool ignore_trailing_commas = false)
     {
         basic_json_document d;
-        d.read_kind(std::forward<InputType>(input), on_error::validate, ignore_comments, ignore_trailing_commas,
-                    std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
+        d.read(std::forward<InputType>(input), false, ignore_comments, ignore_trailing_commas);
         return !d.is_discarded();
     }
 
@@ -10255,7 +10145,7 @@ class basic_json_document
               const bool ignore_comments = false,
               const bool ignore_trailing_commas = false)
     {
-        read_kind(std::forward<InputType>(input), error_mode(allow_exceptions), ignore_comments, ignore_trailing_commas,
+        read_kind(std::forward<InputType>(input), allow_exceptions, ignore_comments, ignore_trailing_commas,
                   std::integral_constant<detail::view::input_kind, detail::view::classify_input<InputType>::value> {});
     }
 
@@ -10614,22 +10504,6 @@ class basic_json_document
         return idx;
     }
 
-    /// what a failed parse does
-    enum class on_error : std::uint8_t
-    {
-        discard, ///< the document is discarded
-        raise,   ///< parse_error is thrown
-        validate ///< accept(): the document is discarded, and no node is stored while parsing
-    };
-
-    static on_error error_mode(bool allow_exceptions) noexcept
-    {
-        return allow_exceptions ? on_error::raise : on_error::discard;
-    }
-
-    /// NulIsEnd of the builder: a null byte ends the input unless strict_nul_handling
-    static constexpr bool nul_is_end = !detail::abi_config::strict_nul_handling;
-
     /// create the storage (sized for the input) on first use
     void ensure_data(const char* src, std::size_t size)
     {
@@ -10641,7 +10515,7 @@ class basic_json_document
 
     /// parse a buffer the document takes ownership of (it replaces the
     /// previous owned copy)
-    void build_owned(std::string&& buf, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_owned(std::string&& buf, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         ensure_data(buf.data(), buf.size());
         m_data->owned = std::move(buf);
@@ -10651,7 +10525,7 @@ class basic_json_document
     /// parse a copy of the input; the copy is appended to the cleared owned
     /// buffer, so that its capacity is reused
     template<typename T>
-    void build_copy(T&& input, on_error allow_exceptions, bool comments, bool trailing_commas)
+    void build_copy(T&& input, bool allow_exceptions, bool comments, bool trailing_commas)
     {
         if (!m_data)
         {
@@ -10672,7 +10546,7 @@ class basic_json_document
     }
 
     /// sentinel: src[size] is readable and 0 (std::string, C strings)
-    void build(const char* src, std::size_t size, on_error allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
+    void build(const char* src, std::size_t size, bool allow_exceptions, bool comments, bool trailing_commas, bool owned, bool sentinel)
     {
         ensure_data(src, size);
         document_data& d = *m_data;
@@ -10699,8 +10573,7 @@ class basic_json_document
         }
         else
         {
-            ok = detail::view::build<typename BasicJsonType::number_float_t, nul_is_end>(d, src, size, comments, trailing_commas, sentinel,
-                 allow_exceptions == on_error::validate, failure);
+            ok = detail::view::build < typename BasicJsonType::number_float_t, !detail::abi_config::strict_nul_handling > (d, src, size, comments, trailing_commas, sentinel, failure);
         }
         if (NLOHMANN_VIEW_LIKELY(ok))
         {
@@ -10713,7 +10586,7 @@ class basic_json_document
             return;
         }
         std::vector<std::uint32_t>().swap(d.large_objects);
-        if (allow_exceptions == on_error::raise)
+        if (allow_exceptions)
         {
             detail::view::throw_parse_failure<BasicJsonType>(failure, src, size, comments, trailing_commas);
         }
@@ -10721,13 +10594,13 @@ class basic_json_document
 
     // --- input dispatch (see detail::view::input_kind) ---
 
-    void read_kind(std::string&& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
+    void read_kind(std::string&& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::move_string> /*unused*/)
     {
         build_owned(std::move(s), ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -10741,7 +10614,7 @@ class basic_json_document
     }
 
     template<typename Array>
-    void read_kind(Array& a, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
+    void read_kind(Array& a, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::char_array> /*unused*/)
     {
         using CharT = typename std::remove_cv<typename std::remove_extent<Array>::type>::type;
         const std::size_t n = std::extent<Array>::value;
@@ -10752,7 +10625,7 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::borrow_range> /*unused*/)
     {
         // std::basic_string guarantees data()[size()] == 0: use it as sentinel
         const auto size = static_cast<std::size_t>(s.size());
@@ -10761,13 +10634,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(const T& s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
+    void read_kind(const T& s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::copy_range> /*unused*/)
     {
         build_copy(s, ae, c, tc);
     }
 
     template<typename CharT>
-    void read_kind(CharT* s, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
+    void read_kind(CharT* s, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::wide_c_string> /*unused*/)
     {
         if (s == nullptr)
         {
@@ -10779,13 +10652,13 @@ class basic_json_document
     }
 
     template<typename T>
-    void read_kind(T&& input, on_error ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
+    void read_kind(T&& input, bool ae, bool c, bool tc, std::integral_constant<input_kind, input_kind::adapter> /*unused*/)
     {
         build_copy(std::forward<T>(input), ae, c, tc);
     }
 
     template<typename IteratorType>
-    void read_range(IteratorType first, IteratorType last, on_error ae, bool c, bool tc)
+    void read_range(IteratorType first, IteratorType last, bool ae, bool c, bool tc)
     {
         using value_type = typename std::remove_cv<typename std::iterator_traits<IteratorType>::value_type>::type;
         // borrow the range where the library's input adapter scans it as one
@@ -10796,14 +10669,14 @@ class basic_json_document
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::true_type /*contiguous bytes*/)
     {
         const auto size = static_cast<std::size_t>(std::distance(first, last));
         build(size == 0 ? "" : reinterpret_cast<const char*>(&*first), size, ae, c, tc, false, size == 0); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
     }
 
     template<typename IteratorType>
-    void read_range_impl(IteratorType first, IteratorType last, on_error ae, bool c, bool tc, std::false_type /*other*/)
+    void read_range_impl(IteratorType first, IteratorType last, bool ae, bool c, bool tc, std::false_type /*other*/)
     {
         build_copy(detail::view::make_adapter_input(detail::input_adapter(first, last)), ae, c, tc);
     }

tests/src/unit-json_view_builder.cpp

@@ -59,7 +59,7 @@ built build(const std::string& text, bool comments, bool trailing_commas, bool s
         r.copy.assign(text.begin(), text.end());
         src = r.copy.data();
     }
-    r.ok = nlohmann::detail::view::build < FloatType, !nlohmann::detail::abi_config::strict_nul_handling > (*r.data, src, text.size(), comments, trailing_commas, sentinel, false, r.failure);
+    r.ok = nlohmann::detail::view::build < FloatType, !nlohmann::detail::abi_config::strict_nul_handling > (*r.data, src, text.size(), comments, trailing_commas, sentinel, r.failure);
     r.data->src = src;
     r.data->base[0] = src;
     r.data->base[1] = r.data->arena.data();
@@ -172,22 +172,6 @@ void check_string(const std::string& content)
     }
 }
 
-// accept() stores no nodes: it must accept and reject what json::accept does, for all options and for inputs with
-// and without a terminating NUL
-void check_accept(const std::string& text)
-{
-    CAPTURE(text)
-    const std::vector<char> bytes(text.begin(), text.end());
-    for (int options = 0; options < 4; ++options)
-    {
-        const bool comments = (options & 1) != 0;
-        const bool trailing_commas = (options & 2) != 0;
-        const bool accepted = json::accept(text, comments, trailing_commas);
-        CHECK(nlohmann::json_document::accept(text, comments, trailing_commas) == accepted);
-        CHECK(nlohmann::json_document::accept(bytes, comments, trailing_commas) == accepted);
-    }
-}
-
 // a small deterministic generator of documents
 struct generator
 {
@@ -439,119 +423,6 @@ TEST_CASE("json_view builder")
         }
     }
 
-    SECTION("accept() without an index")
-    {
-        for (const char* text :
-                {
-                    "", " ", "\n", "null", "nul", "true", "[", "]", "[]", "{}", "[1,2,3]", "[1,2,3", "[1,2,3,]", "{\"a\":1,}", "{\"a\"}", "{\"a\":}",
-                    "[1] x", "[1][2]", "\xEF\xBB\xBF[1]", "[\"a\\", "[\"\\u12\"]", "[\"\\ud800\"]", "[\"\x01\"]", "[\"\xff\"]", "[01]", "[1.]",
-                    "[.5]", "[-]", "[1e]", "// c\n[1]", "/* c */ {\"a\" /* x */ : 1}", "/* c", "[1] // c", "1e400", "-1e400", "123456789012345678901234567890",
-                    "{\"a\":1,\"a\":2}", "[[[]]]", "\"\\u00e4\\n\\ud83d\\ude00\""
-                })
-        {
-            check_accept(text);
-        }
-        // a null byte inside the text, and after it
-        check_accept(std::string("[1,\0]", 5));
-        check_accept(std::string("[1]\0", 4));
-        check_accept(std::string("\0", 1));
-
-        // generated documents and damaged copies, as for the builder above
-        generator g;
-        for (int i = 0; i < 2000; ++i)
-        {
-            std::string text;
-            g.value(text, 0);
-            check_accept(text);
-            std::string damaged = text;
-            const auto at = static_cast<std::size_t>(g.r(static_cast<int>(damaged.size())));
-            static const char replacements[] = {'x', '"', '\\', ',', ':', ']', '}', '[', '{', '1', '-', '.', 'e', '\0', '\n', '/'}; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-            damaged[at] = replacements[g.r(16)];
-            check_accept(damaged);
-            check_accept(text.substr(0, at));
-        }
-
-        // nesting beyond the 64 levels that are kept on the builder's own stack, closed and not closed
-        for (const std::size_t depth :
-                {
-                    63, 64, 65, 66, 200, 1000
-                })
-        {
-            check_accept(std::string(depth, '[') + std::string(depth, ']'));
-            check_accept(std::string(depth, '[') + std::string(depth - 1, ']'));
-            std::string objects;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                objects += "{\"k\":";
-            }
-            objects += "1" + std::string(depth, '}');
-            check_accept(objects);
-            check_accept(objects.substr(0, objects.size() - 1));
-        }
-
-        // objects with enough members to get a hash index when they are indexed (and duplicate keys)
-        std::string large = "{";
-        for (int i = 0; i < 300; ++i)
-        {
-            large += (i == 0 ? "\"k" : ",\"k") + std::to_string(i % 200) + "\":" + std::to_string(i);
-        }
-        check_accept(large + "}");
-        check_accept(large);
-        check_accept("[" + large + "},{" + large.substr(1) + "}]");
-
-        // the overflow check uses the floating-point type of the document
-        using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;
-        for (const char* text :
-                {
-                    "1e39", "-1e39", "3.4028235e38", "3.4028236e38", "[1.5e38, 3.5e38]", "{\"a\": 1e-50, \"b\": 1e39}", "340282356779733661637539395458142568448"
-                })
-        {
-            CAPTURE(text)
-            CHECK(nlohmann::basic_json_document<float_json>::accept(text) == float_json::accept(text));
-        }
-
-        // strings are checked and not decoded: runs of text of every length from 0 to 40 between valid and invalid
-        // escapes, UTF-8 sequences and control characters, in values and in keys, cut near the end of the text
-        const std::array<const char*, 9> valid = {{"\\n", "\\\"", "\\\\", "\\/", "\\t", "\\u00e4", "\\u20ac", "\\ud83d\\ude00", "\\u0000"}};
-        const std::array<const char*, 12> invalid = {{"\\x", "\\ud800", "\\udc00", "\\u12G4", "\\u12", "\\ud83dx", "\\ud83d\\u0041", "\\ud83d\\ud83d", "\\", "\x01", "\x1f", "\x7f"}};
-        const std::array<const char*, 6> utf8 = {{"\xc3\xa4", "\xe2\x82\xac", "\xf0\x9f\x98\x80", "\xc3", "\xff", "\x80"}};
-        std::mt19937 rng(2029); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible
-        for (std::size_t run = 0; run <= 40; ++run)
-        {
-            for (int i = 0; i < 30; ++i)
-            {
-                std::string content = std::string(rng() % 20, 'a');
-                const auto pieces = 1 + (rng() % 6);
-                for (unsigned k = 0; k < pieces; ++k)
-                {
-                    content += valid[rng() % valid.size()];
-                    content += std::string(k == 0 ? run : rng() % 41, static_cast<char>('b' + (rng() % 20)));
-                    switch (rng() % 8)
-                    {
-                        case 0:
-                            content += utf8[rng() % 3];
-                            break;
-                        case 1:
-                            content += utf8[rng() % utf8.size()];
-                            break;
-                        case 2:
-                            content += invalid[rng() % invalid.size()];
-                            break;
-                        default:
-                            break;
-                    }
-                }
-                for (const std::string& text :
-                        {
-                            "[\"" + content + "\"]", "{\"" + content + "\":1}", "[\"" + content, "[\"" + content.substr(0, content.size() - (rng() % 4)) + "\"]"
-                        })
-                {
-                    check_accept(text);
-                }
-            }
-        }
-    }
-
     SECTION("test files")
     {
         for (const char* name :

tests/src/unit-json_view_from_json.cpp

@@ -443,6 +443,30 @@ TEST_CASE("json_view from_json")
         CHECK(d.root().materialize().get<point>().x == 3);
     }
 
+    SECTION("escaped keys: members are found by their decoded names")
+    {
+        // keys are decoded before they are compared, as by parse(); a lookup
+        // that compares the raw bytes of the source would miss these members
+        const json_document d = json_document::parse(R"([{"\u0078": 1, "y": 2}, {"V\u0061lue": 3, "Te\u0078t": "t"}, {"\u0062": "escaped"}, {"x": 1, "\u0078": 3, "y": 2}])");
+        const json j = d.root().materialize();
+        CHECK(d.root()[0].get<point>().x == 1);
+        CHECK(d.root()[0].get<point>().y == 2);
+        CHECK((d.root()[0].get<point>() == j[0].get<point>()));
+        CHECK(d.root()[1].get<with_names>().value == 3);
+        CHECK(d.root()[1].get<with_names>().text == "t");
+        CHECK(d.root()[2].get<with_defaults>().b == "escaped");
+        CHECK(d.root()[2].get<with_defaults>().a == 1);
+        // a duplicate key written once plain and once escaped: still the first member
+        CHECK(d.root()[3].get<point>().x == 1);
+        CHECK(j[3].get<point>().x == 3);
+#if !defined(JSON_NOEXCEPTION) && !JSON_DIAGNOSTICS && !JSON_DIAGNOSTIC_POSITIONS
+        // an escaped backslash is part of the decoded key: "x\\" is not "x"
+        const json_document e = json_document::parse(R"({"x\\": 1, "y": 2})");
+        CHECK(exception_of_call([&] { static_cast<void>(e.root().get<point>()); }) == exception_of_call([&] { static_cast<void>(e.root().materialize().get<point>()); }));
+        CHECK(exception_of_call([&] { static_cast<void>(e.root().get<point>()); }) == "[json.exception.out_of_range.403] key 'x' not found");
+#endif
+    }
+
     SECTION("editable documents and ordered_json")
     {
         json_editable_document e = json_editable_document::parse(R"({"x": 1, "y": 2})");