Add review-like-gregmarr Claude skill

Distilled from gregmarr's inline review and conversation comments on
nlohmann/json: checklist of recurring review topics and his review voice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N5NasBGrV1SGwx7n1eo75g

.claude/skills/review-like-gregmarr/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: review-like-gregmarr
+description: Review a diff, branch, or PR of nlohmann/json the way long-time contributor gregmarr does — a line-by-line read focused on C++11 correctness, reference invalidation, backward/source compatibility, ODR/ABI, duplicated logic, hidden costs, repo conventions (amalgamation, astyle, macros) and precise docs, phrased as short courteous questions. Use when asked to "review like Greg", "gregmarr review", or for a careful maintainer-style review of changes to this library.
+---
+
+# Review like gregmarr
+
+Distilled from ~1,400 inline review comments and ~1,300 issue/PR comments by
+@gregmarr on nlohmann/json. He is a careful, courteous, line-by-line reviewer
+who ("just a contributor") defers final decisions to @nlohmann.
+
+## Workflow
+
+1. Determine the target: a PR number (`gh pr diff <n>`), a branch
+   (`git diff $(git merge-base HEAD develop)...HEAD`), or the working tree
+   (`git diff`). Read the full diff, and open surrounding code in `include/nlohmann/`
+   whenever a hunk's context is not enough to judge it.
+2. Walk the diff **file by file, hunk by hunk**, applying the checklist below.
+   Comment on specific lines; don't write a big essay.
+3. Write the review in his voice (see "Voice"). Group nothing artificially —
+   emit one comment per location, in file/line order, with `path:line`.
+4. If the same issue repeats, comment fully once, then "As above" /
+   "Same here (and N other places in this file)."
+5. End with a 1–3 line summary only if useful (e.g. "Just this remaining and
+   then LGTM." or "@nlohmann thoughts on the naming?"). Don't post to GitHub
+   unless the user asks.
+
+## Checklist (roughly in order of how often he raises them)
+
+### Duplication and simplification (most frequent)
+- Copy-pasted bodies, duplicated `#if/#elif` blocks, or "a copy of this function
+  that can get out of sync" → propose a shared helper or alias, with a code sketch.
+- **Diverging limits/constants**: a new depth/recursion limit or magic number
+  where one already exists → "Should this reuse the existing recursion limit?
+  Different limits per operation invites them to diverge over time."
+- Unneeded variables, parameters that can be deduced, values passed to a
+  function that the constructor already has, output parameter == return value.
+- Verbose type spellings → `using` alias / alias template; `decltype()` where the
+  type is known.
+- Disabling a lint warning instead of fixing the code ("why not just add the parens?").
+
+### Lifetime, invalidation, UB
+- A reference/pointer/iterator into a container (`stack.back()`,
+  `container_stack.back()`, `ordered_map` elements) held across `push_back`,
+  `pop_back`, `emplace`, or reallocation → "This invalidates `top`." Prefer a
+  `const` copy, or at least a comment warning future editors.
+- Dangling refs from rvalue arguments stored in adapters; views outliving documents.
+- Wrong logic operators (`&&` vs `||`), lost `!`, unreachable code, `continue`
+  that should be `break`, missing `return`, off-by-one in counters
+  (`chars_read` incremented twice).
+- Uninitialized members → default member initializers; parameters that
+  "should not have a default so it's never left off by accident".
+- Exception safety: leaks when `to_json` is called on a non-null value, partial
+  state, destructors that allocate, swallowed exceptions (`noexcept` that hides
+  throws — "The library shouldn't try to swallow the exception").
+- Thread-unsafe calls (`setlocale`), specializations that redefine `std::` things
+  (ODR / UB).
+- Narrowing/truncation: `static_cast<std::make_unsigned<...>>`, signed/unsigned
+  `char` cases, `n == 0` edge cases, buffer overruns guarded only by `JSON_ASSERT`.
+
+### C++11 floor and portability
+- The library requires only **C++11**: flag `if constexpr`, C++14 generic
+  lambdas/variable templates, `std::clamp`, C++17 library features, etc. unless
+  gated.
+- Gate on the library's macros (`JSON_HAS_CPP_17`, `JSON_HAS_CPP_20`,
+  `JSON_HAS_THREE_WAY_COMPARISON`, `JSON_HAS_FILESYSTEM`) or feature-test macros
+  with `defined()` checks and exact values
+  (`#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811`), not raw
+  `__cplusplus`. Don't silently disable a feature for an existing config.
+- User-overridable macros: if externally defined, leave as-is — never clobber to
+  `1` (breaks `#define X 0`). `#if X` vs `#ifdef X` must match the convention.
+- New macros start with `JSON_` / `NLOHMANN_JSON_` consistently with neighbors.
+- `throw` must be `JSON_THROW` (and `try/catch` → `JSON_TRY/JSON_CATCH`) so
+  `JSON_NOEXCEPTION` builds work.
+- `(std::min)(a, b)` / `(std::max)` for Windows macros; MSVC warnings (C4100
+  etc.); `string_t` not being `std::string`/`char`.
+- Code relying on operations not required of user-supplied `array_t`/`object_t`
+  (range ctor, `emplace_hint`, allocator) → ask whether that's allowed.
+- Does it work with `JSON_USE_IMPLICIT_CONVERSIONS=0`? With `JSON_DIAGNOSTICS`?
+
+### Compatibility, ABI, API design
+- Behavior changes to existing APIs/macros (e.g. `NLOHMANN_DEFINE_TYPE_*`,
+  released in 3.11.0) are breaking → needs opt-in macro or wait for 4.0; must be
+  prominently documented in release notes. Cite when the behavior shipped.
+- Header-only: source compatibility matters, binary doesn't — adding a
+  **defaulted** parameter is fine; new overloads add ambiguity risk.
+- Anything that changes layout or semantics per-config → should it be part of the
+  ABI tag (`json_abi_diag...`)? Mismatched config macros across TUs = ODR violation.
+- Brand-new API shouldn't be added as deprecated — use `= delete` or omit.
+- Naming consistency with existing options (`ignore_trailing_commas` vs
+  `ignore_comments`; singular "diagnostic"); names that read like functions;
+  single-letter or inconsistently `m_`-prefixed members.
+- Prefer a type-safe template over passing a `value_t` that could be invalid.
+- "Why would this belong in this library?" for very niche features.
+
+### Hidden costs
+- Extra copies (lost `std::move`, removed C++17 path), temporaries
+  (`push_back(std::string(...))` vs two `push_back`s), repeated `.back()` calls,
+  casting more than once, `reserve()` inside loops, quadratic recomputation for
+  deep nesting, dynamic allocation replacing stack allocation.
+- `push_back` → `emplace_back`; `rbegin()`, `.data()`, `std::array`, `pop_back()`
+  to keep counters in sync.
+- Struct member order/padding (put `bool` after `int`; "store value before type"),
+  `sizeof(basic_json)` growth, per-node pointer cost. "Don't pay for what you
+  don't use."
+- Compile-time impact of new includes/templates.
+- Ask for measurement instead of asserting a win.
+
+### Style and repo conventions
+- Formatting must match `make pretty` (astyle): spaced `template <`, `!` in traits
+  → suggest `detail::negation<>`; 4-space indents; brace style; blank lines.
+- Redundant keywords: `inline` inside class bodies or on templates (full
+  specializations do need it), `noexcept` on destructors, `public` in `struct`,
+  `{}` after defaulted init, C-style casts → `static_cast`.
+- Sorted includes (cpplint: system before others), sorted lists in docs/CMake.
+- **Amalgamation**: changes must be in `include/nlohmann/...` and
+  `single_include/` regenerated via `make amalgamate` — flag edits made only in
+  `single_include`, or amalgamated output that doesn't match / contains unrelated
+  changes.
+- Merge debris, stray files at repo root, accidental changes to vendored files
+  (doctest.h), Makefile tweaks from local testing, missing trailing newline,
+  whitespace churn mixed with real changes ("separate commit or PR?").
+- Comments: explain non-obvious code ("Comment about why this iterates
+  backwards?"); no change-log wording like "still" in live code; comment
+  blocks must stay attached to their function.
+
+### Docs (`docs/mkdocs/docs/...`, README)
+- Typos as `s/varry/vary/` or "typo: interal".
+- Accuracy vs. actual behavior; state preconditions ("array is not empty"),
+  costs (one pointer per value with `JSON_DIAGNOSTICS`), defaults, which overloads
+  a sentence applies to, version numbers ("3.13.0").
+- Consistency with sibling pages; unexplained claims ("Why is that a problem?
+  It's not obvious here."); markdown table column alignment.
+- New macros/features need a docs page and an example.
+
+### Tests
+- Not his main focus, but: new macro/feature needs tests in `tests/src/unit-*.cpp`
+  that always build with the option (coverage build); test both with and
+  without the option; tests should use different values than the
+  initial ones; put tests in the existing file instead of duplicating a SAX class;
+  static_asserts where possible.
+
+### Usually NOT commented on
+Commit messages/PR titles, licensing, local variable naming bikeshedding,
+demanding benchmarks, rejecting the overall feature idea. CI YAML gets
+comments only for merge debris.
+
+## Voice
+
+- **Mostly questions**: "Is there a reason…?", "Should this…?", "Would it make
+  sense to…?", "Why not…?", "Any reason not to…?", "Is this needed?",
+  "Intentional?"
+- **Flat statements only for clear bugs**, with the reason: "This `if` will
+  never be true. You want `||` not `&&`." "Remove the noexcept. The library
+  shouldn't try to swallow the exception."
+- **Terse when trivial**: "`emplace_back`", "typo: alse", "astyle, negation",
+  "as above", "Lost a blank line here."
+- **Concrete sketches** in plain fenced code blocks introduced with "Maybe like
+  this?" / "Something like this:" / "Untested:". Rarely ```suggestion blocks.
+- **Hedge taste**: "minor nit:", "Personally I prefer…", "I'm on the fence…",
+  "not something for which I would hold up the PR", "(If this was just moved,
+  ignore this.)", "not the fault of this PR".
+- Cite evidence: cppreference, godbolt, the standard, related issues/PRs by
+  number, existing code ("see `NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS`").
+- Light humor allowed sparingly (":)", "astyle strikes again", "Ugh").
+- Praise is rare and short ("Good change.", "Looks reasonable.").
+- Defer design calls: "@nlohmann has the final say here."
+- Never invent facts about the code: if unsure, phrase it as a question rather than a claim.
+
+## Example output
+
+```
+include/nlohmann/detail/input/parser.hpp:212
+This invalidates `top`. Make it a `const` copy so it can't be read after the
+`push_back` by a future change?
+
+include/nlohmann/detail/input/parser.hpp:240
+Should this reuse the existing recursion limit rather than adding a new one?
+Different limits per operation invites them to diverge over time.
+
+include/nlohmann/detail/macro_scope.hpp:88
+If this has been externally defined, we should leave it as-is. This will break
+if someone has `#define JSON_HAS_FOO 0`.
+
+include/nlohmann/json.hpp:1534
+`throw` → `JSON_THROW`, or this can't be used by people that disable exceptions.
+
+single_include/nlohmann/json.hpp:9001
+Looks like this was edited directly. Changes go in `include/` and then
+`make amalgamate`.
+
+docs/mkdocs/docs/api/basic_json/back.md:12
+Should this list the precondition that the array is not empty?
+```

include/nlohmann/detail/input/binary_reader.hpp

@@ -741,13 +741,11 @@ class binary_reader
     bool get_cbor_negative_integer()
     {
         NumberType number{};
-        return get_number(number) && emit_cbor_negative_integer(number);
-    }
+        if (JSON_HEDLEY_UNLIKELY(!get_number(number)))
+        {
+            return false;
+        }
 
-    /// pass the CBOR negative integer -1 - @a number to the SAX parser
-    template<typename NumberType>
-    bool emit_cbor_negative_integer(const NumberType number)
-    {
         // the value is -1 - number, which fits into number_integer_t
         // whenever number does; the outer cast undoes the integral promotion
         // for number_integer_t types narrower than int
@@ -972,7 +970,7 @@ class binary_reader
             case 0x95:
             case 0x96:
             case 0x97:
-                return enter_cbor_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
+                return enter_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
 
             case 0x98: // array (one-byte uint8_t for n follows)
             case 0x99: // array (two-byte uint16_t for n follow)
@@ -981,7 +979,7 @@ class binary_reader
             {
                 std::uint64_t len{};
                 std::size_t size{};
-                return get_cbor_argument(len) && get_cbor_container_size(len, size, "array") && enter_cbor_array(size);
+                return get_cbor_argument(len) && get_cbor_container_size(len, size, "array") && enter_array(size);
             }
 
             case 0x9F: // array (indefinite length)
@@ -1678,171 +1676,6 @@ class binary_reader
         return true;
     }
 
-    /*!
-    @brief read a big-endian number of type @a NumberType at @a data
-    */
-    template<typename NumberType>
-    NumberType load_big_endian(const unsigned char* data) const noexcept
-    {
-        NumberType result{};
-        std::memcpy(&result, data, sizeof(NumberType));
-        if (is_little_endian)
-        {
-            byte_swap(result);
-        }
-        return result;
-    }
-
-    /*!
-    @brief read the integers, floats, booleans, and nulls that follow in a
-           definite-length array, without the per-element bookkeeping of
-           @ref parse_cbor_internal
-
-    Stops at the end of the array, at any other kind of value, and when fewer
-    than 9 bytes (the longest of these values) are left in the input, leaving
-    those to @ref parse_cbor_value, which reads them the same way.
-
-    @param[in,out] remaining  the number of elements of the array not yet read
-    @return whether the SAX parser accepted the values
-    */
-    bool parse_cbor_scalar_run(std::size_t& remaining)
-    {
-        while (remaining != 0 && ia.bulk_remaining() >= 9)
-        {
-            const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
-            const unsigned char head = data[0];
-            std::size_t size = 1;
-            bool accepted = true;
-            switch (head)
-            {
-                case 0x18:
-                    size = 2;
-                    accepted = emit_unsigned(data[1]);
-                    break;
-                case 0x19:
-                    size = 3;
-                    accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
-                    break;
-                case 0x1A:
-                    size = 5;
-                    accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
-                    break;
-                case 0x1B:
-                    size = 9;
-                    accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
-                    break;
-                case 0x38:
-                    size = 2;
-                    accepted = emit_cbor_negative_integer(data[1]);
-                    break;
-                case 0x39:
-                    size = 3;
-                    accepted = emit_cbor_negative_integer(load_big_endian<std::uint16_t>(data + 1));
-                    break;
-                case 0x3A:
-                    size = 5;
-                    accepted = emit_cbor_negative_integer(load_big_endian<std::uint32_t>(data + 1));
-                    break;
-                case 0x3B:
-                    size = 9;
-                    accepted = emit_cbor_negative_integer(load_big_endian<std::uint64_t>(data + 1));
-                    break;
-                case 0xF4:
-                    accepted = sax->boolean(false);
-                    break;
-                case 0xF5:
-                    accepted = sax->boolean(true);
-                    break;
-                case 0xF6:
-                    accepted = sax->null();
-                    break;
-                case 0xFA:
-                    size = 5;
-                    accepted = emit_float(load_big_endian<float>(data + 1));
-                    break;
-                case 0xFB:
-                    size = 9;
-                    accepted = emit_float(load_big_endian<double>(data + 1));
-                    break;
-                default:
-                    if (head <= 0x17)
-                    {
-                        accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
-                    }
-                    else if (head >= 0x20 && head <= 0x37)
-                    {
-                        accepted = sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - head));
-                    }
-                    else
-                    {
-                        // any other value is read by parse_cbor_value
-                        return true;
-                    }
-                    break;
-            }
-            // as if read by get() and get_number(): current is the head byte
-            ia.bulk_skip(size);
-            chars_read += size;
-            current = head;
-            --remaining;
-            if (JSON_HEDLEY_UNLIKELY(!accepted))
-            {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /*!
-    @brief open a definite-length array and read the scalars it begins with
-           (see @ref parse_cbor_scalar_run)
-
-    Only the start of an array is tried, which covers arrays of numbers
-    (e.g. coordinates) but costs arrays of other values only one test, not one
-    per element.
-
-    @param[in] len  the number of elements
-    @return whether the SAX parser accepted the array and the values read
-    */
-    bool enter_cbor_array(const std::size_t len)
-    {
-        return enter_array(len) && (len == 0 || parse_cbor_array_start(std::integral_constant<bool, bulk_scan> {}));
-    }
-
-    /// read the scalars the array just opened begins with; out of line, so
-    /// that @ref parse_cbor_value stays small enough to be inlined into
-    /// @ref parse_cbor_internal
-    JSON_HEDLEY_NEVER_INLINE
-    bool parse_cbor_array_start(std::true_type /*bulk*/)
-    {
-        return !cbor_scalar_follows() || parse_cbor_scalar_run(container_stack.back().remaining);
-    }
-
-    /// input that is not contiguous: every value is read by parse_cbor_value
-    bool parse_cbor_array_start(std::false_type /*bulk*/) const noexcept
-    {
-        return true;
-    }
-
-    /*!
-    @brief whether @ref parse_cbor_scalar_run can read the next value: one of
-           the heads it handles, with at least 9 bytes of input left
-    */
-    bool cbor_scalar_follows() const
-    {
-        if (ia.bulk_remaining() < 9)
-        {
-            return false;
-        }
-        const auto head = static_cast<unsigned int>(*reinterpret_cast<const unsigned char*>(ia.bulk_data()));
-        // major types 0 and 1 (unsigned and negative integers) up to an
-        // 8-byte argument, or false, true, null, float32, float64 (0xF4,
-        // 0xF5, 0xF6, 0xFA, 0xFB: bits 0, 1, 2, 6, 7 of 0xC7)
-        return ((head & 0xC0u) == 0 && (head & 0x1Fu) <= 0x1Bu)
-               || (head >= 0xF4u && ((0xC7u >> (head - 0xF4u)) & 1u) != 0);
-    }
-
-
     /*!
     @brief read a CBOR value and everything nested inside it
 
@@ -1868,8 +1701,10 @@ class binary_reader
         {
             if (!container_stack.empty())
             {
+                // a copy, not a reference: it must stay valid across the
+                // pop_back() below, which destroys the container_stack element
+                // it would otherwise alias
                 const container_frame top = container_stack.back();
-                const bool is_object = top.is_object;
                 bool at_end = false;
 
                 if (top.remaining != npos)
@@ -1881,7 +1716,7 @@ class binary_reader
                     {
                         // claim the element about to be read
                         --container_stack.back().remaining;
-                        if (is_object)
+                        if (top.is_object)
                         {
                             get();
                         }
@@ -1894,7 +1729,7 @@ class binary_reader
                     // Testing for it consumes a byte, which is the first byte
                     // of the next element when it is not one.
                     at_end = (get() == 0xFF);
-                    fetch = is_object;
+                    fetch = top.is_object;
                 }
 
                 if (at_end)
@@ -1911,7 +1746,7 @@ class binary_reader
                     continue;
                 }
 
-                if (is_object)
+                if (top.is_object)
                 {
                     if (JSON_HEDLEY_UNLIKELY(!skip_cbor_key_tags(tag_handler)))
                     {
@@ -3856,13 +3691,13 @@ class binary_reader
                 return sax->null();
 
             case 0xFB:
-                return sax->number_float(static_cast<number_float_t>(-1.0), no_source);
+                return sax->number_float(static_cast<number_float_t>(-1.0), "");
 
             case 0xFC:
-                return sax->number_float(static_cast<number_float_t>(0.0), no_source);
+                return sax->number_float(static_cast<number_float_t>(0.0), "");
 
             case 0xFD:
-                return sax->number_float(static_cast<number_float_t>(1.0), no_source);
+                return sax->number_float(static_cast<number_float_t>(1.0), "");
 
             case 0xFF: // empty string
             {
@@ -4366,7 +4201,7 @@ class binary_reader
         {
             return out_of_range_error(exception_id::number_overflow, "number overflow", "value");
         }
-        return sax->number_float(result, no_source);
+        return sax->number_float(result, "");
     }
 
     /*!
@@ -4426,7 +4261,7 @@ class binary_reader
         }();
         return sax->number_float((half & 0x8000u) != 0
                                  ? static_cast<number_float_t>(-val)
-                                 : static_cast<number_float_t>(val), no_source);
+                                 : static_cast<number_float_t>(val), "");
     }
 
     /*!
@@ -4751,10 +4586,6 @@ class binary_reader
     /// the SAX parser
     json_sax_t* sax = nullptr;
 
-    /// the (empty) source text of every number_float event: binary formats
-    /// have none, and a string_t built for each float would cost more
-    const string_t no_source{};
-
     /// the containers that have been opened and not closed yet; see @ref container_frame
     std::vector<container_frame> container_stack{};
 

single_include/nlohmann/json.hpp

@@ -18517,13 +18517,11 @@ class binary_reader
     bool get_cbor_negative_integer()
     {
         NumberType number{};
-        return get_number(number) && emit_cbor_negative_integer(number);
-    }
+        if (JSON_HEDLEY_UNLIKELY(!get_number(number)))
+        {
+            return false;
+        }
 
-    /// pass the CBOR negative integer -1 - @a number to the SAX parser
-    template<typename NumberType>
-    bool emit_cbor_negative_integer(const NumberType number)
-    {
         // the value is -1 - number, which fits into number_integer_t
         // whenever number does; the outer cast undoes the integral promotion
         // for number_integer_t types narrower than int
@@ -18748,7 +18746,7 @@ class binary_reader
             case 0x95:
             case 0x96:
             case 0x97:
-                return enter_cbor_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
+                return enter_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
 
             case 0x98: // array (one-byte uint8_t for n follows)
             case 0x99: // array (two-byte uint16_t for n follow)
@@ -18757,7 +18755,7 @@ class binary_reader
             {
                 std::uint64_t len{};
                 std::size_t size{};
-                return get_cbor_argument(len) && get_cbor_container_size(len, size, "array") && enter_cbor_array(size);
+                return get_cbor_argument(len) && get_cbor_container_size(len, size, "array") && enter_array(size);
             }
 
             case 0x9F: // array (indefinite length)
@@ -19454,171 +19452,6 @@ class binary_reader
         return true;
     }
 
-    /*!
-    @brief read a big-endian number of type @a NumberType at @a data
-    */
-    template<typename NumberType>
-    NumberType load_big_endian(const unsigned char* data) const noexcept
-    {
-        NumberType result{};
-        std::memcpy(&result, data, sizeof(NumberType));
-        if (is_little_endian)
-        {
-            byte_swap(result);
-        }
-        return result;
-    }
-
-    /*!
-    @brief read the integers, floats, booleans, and nulls that follow in a
-           definite-length array, without the per-element bookkeeping of
-           @ref parse_cbor_internal
-
-    Stops at the end of the array, at any other kind of value, and when fewer
-    than 9 bytes (the longest of these values) are left in the input, leaving
-    those to @ref parse_cbor_value, which reads them the same way.
-
-    @param[in,out] remaining  the number of elements of the array not yet read
-    @return whether the SAX parser accepted the values
-    */
-    bool parse_cbor_scalar_run(std::size_t& remaining)
-    {
-        while (remaining != 0 && ia.bulk_remaining() >= 9)
-        {
-            const auto* const data = reinterpret_cast<const unsigned char*>(ia.bulk_data());
-            const unsigned char head = data[0];
-            std::size_t size = 1;
-            bool accepted = true;
-            switch (head)
-            {
-                case 0x18:
-                    size = 2;
-                    accepted = emit_unsigned(data[1]);
-                    break;
-                case 0x19:
-                    size = 3;
-                    accepted = emit_unsigned(load_big_endian<std::uint16_t>(data + 1));
-                    break;
-                case 0x1A:
-                    size = 5;
-                    accepted = emit_unsigned(load_big_endian<std::uint32_t>(data + 1));
-                    break;
-                case 0x1B:
-                    size = 9;
-                    accepted = emit_unsigned(load_big_endian<std::uint64_t>(data + 1));
-                    break;
-                case 0x38:
-                    size = 2;
-                    accepted = emit_cbor_negative_integer(data[1]);
-                    break;
-                case 0x39:
-                    size = 3;
-                    accepted = emit_cbor_negative_integer(load_big_endian<std::uint16_t>(data + 1));
-                    break;
-                case 0x3A:
-                    size = 5;
-                    accepted = emit_cbor_negative_integer(load_big_endian<std::uint32_t>(data + 1));
-                    break;
-                case 0x3B:
-                    size = 9;
-                    accepted = emit_cbor_negative_integer(load_big_endian<std::uint64_t>(data + 1));
-                    break;
-                case 0xF4:
-                    accepted = sax->boolean(false);
-                    break;
-                case 0xF5:
-                    accepted = sax->boolean(true);
-                    break;
-                case 0xF6:
-                    accepted = sax->null();
-                    break;
-                case 0xFA:
-                    size = 5;
-                    accepted = emit_float(load_big_endian<float>(data + 1));
-                    break;
-                case 0xFB:
-                    size = 9;
-                    accepted = emit_float(load_big_endian<double>(data + 1));
-                    break;
-                default:
-                    if (head <= 0x17)
-                    {
-                        accepted = sax->number_unsigned(static_cast<number_unsigned_t>(head));
-                    }
-                    else if (head >= 0x20 && head <= 0x37)
-                    {
-                        accepted = sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - head));
-                    }
-                    else
-                    {
-                        // any other value is read by parse_cbor_value
-                        return true;
-                    }
-                    break;
-            }
-            // as if read by get() and get_number(): current is the head byte
-            ia.bulk_skip(size);
-            chars_read += size;
-            current = head;
-            --remaining;
-            if (JSON_HEDLEY_UNLIKELY(!accepted))
-            {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /*!
-    @brief open a definite-length array and read the scalars it begins with
-           (see @ref parse_cbor_scalar_run)
-
-    Only the start of an array is tried, which covers arrays of numbers
-    (e.g. coordinates) but costs arrays of other values only one test, not one
-    per element.
-
-    @param[in] len  the number of elements
-    @return whether the SAX parser accepted the array and the values read
-    */
-    bool enter_cbor_array(const std::size_t len)
-    {
-        return enter_array(len) && (len == 0 || parse_cbor_array_start(std::integral_constant<bool, bulk_scan> {}));
-    }
-
-    /// read the scalars the array just opened begins with; out of line, so
-    /// that @ref parse_cbor_value stays small enough to be inlined into
-    /// @ref parse_cbor_internal
-    JSON_HEDLEY_NEVER_INLINE
-    bool parse_cbor_array_start(std::true_type /*bulk*/)
-    {
-        return !cbor_scalar_follows() || parse_cbor_scalar_run(container_stack.back().remaining);
-    }
-
-    /// input that is not contiguous: every value is read by parse_cbor_value
-    bool parse_cbor_array_start(std::false_type /*bulk*/) const noexcept
-    {
-        return true;
-    }
-
-    /*!
-    @brief whether @ref parse_cbor_scalar_run can read the next value: one of
-           the heads it handles, with at least 9 bytes of input left
-    */
-    bool cbor_scalar_follows() const
-    {
-        if (ia.bulk_remaining() < 9)
-        {
-            return false;
-        }
-        const auto head = static_cast<unsigned int>(*reinterpret_cast<const unsigned char*>(ia.bulk_data()));
-        // major types 0 and 1 (unsigned and negative integers) up to an
-        // 8-byte argument, or false, true, null, float32, float64 (0xF4,
-        // 0xF5, 0xF6, 0xFA, 0xFB: bits 0, 1, 2, 6, 7 of 0xC7)
-        return ((head & 0xC0u) == 0 && (head & 0x1Fu) <= 0x1Bu)
-               || (head >= 0xF4u && ((0xC7u >> (head - 0xF4u)) & 1u) != 0);
-    }
-
-
     /*!
     @brief read a CBOR value and everything nested inside it
 
@@ -19644,8 +19477,10 @@ class binary_reader
         {
             if (!container_stack.empty())
             {
+                // a copy, not a reference: it must stay valid across the
+                // pop_back() below, which destroys the container_stack element
+                // it would otherwise alias
                 const container_frame top = container_stack.back();
-                const bool is_object = top.is_object;
                 bool at_end = false;
 
                 if (top.remaining != npos)
@@ -19657,7 +19492,7 @@ class binary_reader
                     {
                         // claim the element about to be read
                         --container_stack.back().remaining;
-                        if (is_object)
+                        if (top.is_object)
                         {
                             get();
                         }
@@ -19670,7 +19505,7 @@ class binary_reader
                     // Testing for it consumes a byte, which is the first byte
                     // of the next element when it is not one.
                     at_end = (get() == 0xFF);
-                    fetch = is_object;
+                    fetch = top.is_object;
                 }
 
                 if (at_end)
@@ -19687,7 +19522,7 @@ class binary_reader
                     continue;
                 }
 
-                if (is_object)
+                if (top.is_object)
                 {
                     if (JSON_HEDLEY_UNLIKELY(!skip_cbor_key_tags(tag_handler)))
                     {
@@ -21632,13 +21467,13 @@ class binary_reader
                 return sax->null();
 
             case 0xFB:
-                return sax->number_float(static_cast<number_float_t>(-1.0), no_source);
+                return sax->number_float(static_cast<number_float_t>(-1.0), "");
 
             case 0xFC:
-                return sax->number_float(static_cast<number_float_t>(0.0), no_source);
+                return sax->number_float(static_cast<number_float_t>(0.0), "");
 
             case 0xFD:
-                return sax->number_float(static_cast<number_float_t>(1.0), no_source);
+                return sax->number_float(static_cast<number_float_t>(1.0), "");
 
             case 0xFF: // empty string
             {
@@ -22142,7 +21977,7 @@ class binary_reader
         {
             return out_of_range_error(exception_id::number_overflow, "number overflow", "value");
         }
-        return sax->number_float(result, no_source);
+        return sax->number_float(result, "");
     }
 
     /*!
@@ -22202,7 +22037,7 @@ class binary_reader
         }();
         return sax->number_float((half & 0x8000u) != 0
                                  ? static_cast<number_float_t>(-val)
-                                 : static_cast<number_float_t>(val), no_source);
+                                 : static_cast<number_float_t>(val), "");
     }
 
     /*!
@@ -22527,10 +22362,6 @@ class binary_reader
     /// the SAX parser
     json_sax_t* sax = nullptr;
 
-    /// the (empty) source text of every number_float event: binary formats
-    /// have none, and a string_t built for each float would cost more
-    const string_t no_source{};
-
     /// the containers that have been opened and not closed yet; see @ref container_frame
     std::vector<container_frame> container_stack{};
 

tests/src/unit-cbor.cpp

@@ -29,9 +29,7 @@ using nlohmann::json;
 #include "round_trip_corpus.hpp"
 #include "test_utils.hpp"
 #include "sax_countdown.hpp"
-#include "sax_event_loggers.hpp"
 using utils::SaxCountdown;
-using utils::SaxEventLogger;
 
 
 TEST_CASE("CBOR")
@@ -2448,78 +2446,6 @@ TEST_CASE("CBOR SAX parsing stops at every event")
     CHECK(count_events(std::vector<std::uint8_t>({0xBF, 0x61, 'a', 0x9F, 0x01, 0xFF, 0xFF})) == 6);
 }
 
-TEST_CASE("CBOR arrays of scalars from contiguous and non-contiguous input")
-{
-    // contiguous input reads the integers, floats, booleans, and nulls an
-    // array begins with in one loop, other input value by value; both must
-    // give the same events, value, or error for the complete document and for
-    // every truncation of it, and stop at every event a SAX handler rejects
-    const std::vector<std::uint8_t> cbor =
-    {
-        0xA3,                                                       // map(3)
-        0x61, 'a',                                                  // "a"
-        0x98, 0x16,                                                 // array(22)
-        0x00, 0x17, 0x18, 0xFF, 0x19, 0x01, 0x00,                   // 0, 23, 255, 256
-        0x1A, 0x00, 0x01, 0x00, 0x00,                               // 65536
-        0x1B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,       // 18446744073709551615
-        0x20, 0x37, 0x38, 0xFF, 0x39, 0x01, 0x00,                   // -1, -24, -256, -257
-        0x3A, 0x00, 0x01, 0x00, 0x00,                               // -65537
-        0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,       // -18446744073709551616 (a float)
-        0x3B, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,       // -9223372036854775808
-        0xF4, 0xF5, 0xF6,                                           // false, true, null
-        0xFA, 0x3F, 0xC0, 0x00, 0x00,                               // 1.5 (float32)
-        0xFB, 0xBF, 0xB9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9A,       // -0.1
-        0xF9, 0x3C, 0x00,                                           // 1.0 (float16, ends the loop)
-        0x01, 0x61, 'a',                                            // 1, "a"
-        0xFB, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,       // 2.5
-        0x61, 'b',                                                  // "b"
-        0x83,                                                       // array(3)
-        0x82, 0xFB, 0x3F, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // [1.25,
-        0xFB, 0xC0, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,       //  -3.75]
-        0x82, 0xFB, 0x3F, 0xF4, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // [1.25,
-        0xFB, 0xC0, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,       //  -3.75]
-        0x80,                                                       // []
-        0x61, 'c',                                                  // "c"
-        0x84, 0xA0, 0x01, 0xC1, 0x02, 0x81, 0x03                    // [{}, 1, tag(1) 2, [3]]
-    };
-    const auto tags = json::cbor_tag_handler_t::ignore;
-
-    const json j = json::from_cbor(cbor, true, true, tags);
-    CHECK(j["a"].size() == 22);
-    CHECK(j["a"][5] == 18446744073709551615u);
-    CHECK(j["a"][11].is_number_float());
-    CHECK(j["a"][11] == -18446744073709551616.0);
-    CHECK(j["a"][12] == (std::numeric_limits<std::int64_t>::min)());
-    CHECK(j["a"][17] == -0.1);
-    CHECK(j["b"] == json::parse("[[1.25, -3.75], [1.25, -3.75], []]"));
-    CHECK(j["c"] == json::parse("[{}, 1, 2, [3]]"));
-
-    for (std::size_t length = 0; length <= cbor.size(); ++length)
-    {
-        CAPTURE(length)
-        const std::vector<std::uint8_t> contiguous(cbor.begin(), cbor.begin() + static_cast<std::ptrdiff_t>(length));
-        const std::list<std::uint8_t> bytewise(contiguous.begin(), contiguous.end());
-
-        CHECK(json::from_cbor(contiguous, true, false, tags).dump() == json::from_cbor(bytewise.begin(), bytewise.end(), true, false, tags).dump());
-
-        SaxEventLogger from_contiguous;
-        SaxEventLogger from_bytewise;
-        CHECK(json::sax_parse(contiguous, &from_contiguous, json::input_format_t::cbor, true, false, false, tags)
-              == json::sax_parse(bytewise.begin(), bytewise.end(), &from_bytewise, json::input_format_t::cbor, true, false, false, tags));
-        CHECK(from_contiguous.events == from_bytewise.events);
-    }
-
-    for (int events = 0; events <= 60; ++events)
-    {
-        CAPTURE(events)
-        const std::list<std::uint8_t> bytewise(cbor.begin(), cbor.end());
-        SaxCountdown from_contiguous(events);
-        SaxCountdown from_bytewise(events);
-        CHECK(json::sax_parse(cbor, &from_contiguous, json::input_format_t::cbor, true, false, false, tags)
-              == json::sax_parse(bytewise.begin(), bytewise.end(), &from_bytewise, json::input_format_t::cbor, true, false, false, tags));
-    }
-}
-
 TEST_CASE("CBOR indefinite-length strings do not recurse per chunk")
 {
     // Reading an indefinite-length string or byte array used to call itself