diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml index bbc1ef48b..6f1cf8cae 100644 --- a/.github/workflows/windows.yml +++ b/.github/workflows/windows.yml @@ -166,19 +166,21 @@ jobs: # link, but the binaries clang 11.0.1 and clang 18.1.8 then produce crash # before doctest prints its first line - 39 of 102 tests on clang 18. # Keep the objects small by splitting the test files instead. - # Objects with more than 65535 sections fail to link with "relocation - # truncated to fit: IMAGE_REL_AMD64_REL32 against `.rdata'": the MinGW - # linker stores the section an associative COMDAT section belongs to in - # 16 bits (x_associated in binutils' include/coff/internal.h), so it - # discards the jump tables of inline functions together with the wrong - # function. Each basic_json specialization a test file instantiates adds - # many sections, so test a second one in a file of its own. + # The tests link with LLD: GNU ld fails on objects with more than 32767 + # sections with "relocation truncated to fit: IMAGE_REL_AMD64_REL32 + # against `.rdata'", as it stores the section an associative COMDAT + # section belongs to in 16 bits (x_associated in binutils' + # include/coff/internal.h) and so discards the jump tables of inline + # functions together with the wrong function. Each basic_json + # specialization and input type a test file instantiates adds many + # sections, so unit-msgpack.cpp and unit-regression2.cpp kept crossing + # that limit as the library grew. - name: Run CMake run: cmake -S . -B build ^ -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" ^ -DCMAKE_CXX_FLAGS="--target=x86_64-w64-mingw32 -stdlib=libstdc++ -pthread" ^ -DCMAKE_CXX_FLAGS_DEBUG="-g0" ^ - -DCMAKE_EXE_LINKER_FLAGS="-lwinpthread" ^ + -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=lld -lwinpthread" ^ -G"MinGW Makefiles" ^ -DCMAKE_BUILD_TYPE=Debug ^ -DJSON_BuildTests=On diff --git a/include/nlohmann/detail/conversions/to_json.hpp b/include/nlohmann/detail/conversions/to_json.hpp index 5b217d7fe..05ae82370 100644 --- a/include/nlohmann/detail/conversions/to_json.hpp +++ b/include/nlohmann/detail/conversions/to_json.hpp @@ -13,7 +13,7 @@ #include // optional #endif -#include // begin, end +#include // begin, end, make_move_iterator, move_iterator #include // allocator_traits #include // basic_string, char_traits #include // tuple, get @@ -48,6 +48,32 @@ namespace detail * leave j with the type of the new value, but the pointer to the destroyed old one. */ +// a move iterator over the elements of an rvalue container, unless they are +// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a +// std::move_iterator as value_type&&, which cannot bind to a const element +template +std::move_iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/) +{ + return std::make_move_iterator(it); +} + +template +Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/) +{ + return it; +} + +template +using is_mutable_iterator = std::integral_constant < bool, + !std::is_const())>::type>::value >; + +template +auto make_move_iterator_if_mutable(const Iterator& it) +-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator {})) +{ + return make_move_iterator_if_mutable_impl(it, is_mutable_iterator {}); +} + template struct external_constructor; template<> @@ -174,7 +200,7 @@ struct external_constructor using std::begin; using std::end; - const typename BasicJsonType::json_value value(j.template create(std::make_move_iterator(begin(arr)), std::make_move_iterator(end(arr)))); + const typename BasicJsonType::json_value value(j.template create(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr)))); j.replace_value(value_t::array, value); } @@ -235,7 +261,7 @@ struct external_constructor using std::begin; using std::end; - const typename BasicJsonType::json_value value(j.template create(std::make_move_iterator(begin(obj)), std::make_move_iterator(end(obj)))); + const typename BasicJsonType::json_value value(j.template create(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj)))); j.replace_value(value_t::object, value); } @@ -413,25 +439,27 @@ using is_movable_container_rvalue = negation, has_dedicated_to_json, is_basic_json, - is_range_view_type, is_enum_keyed_map_type, std::is_same>>>; -// rvalue array-like containers +// rvalue array-like containers; object types are ruled out before views are +// checked, as std::ranges::view for the object_t of an ordered_json would +// need that ordered_json to be complete (GCC 11, see #3312) template using is_rvalue_array_to_json = conjunction, + negation>, + negation>, is_compatible_array_type, negation, std::is_same, - is_compatible_object_type, is_compatible_string_type, is_compatible_binary_type>>>; // rvalue containers: their elements are moved instead of copied template::value, int> = 0> -inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) +inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward) { external_constructor::construct_moving(j, arr); } @@ -509,7 +537,8 @@ inline void to_json(BasicJsonType& j, const EnumKeyedMap& map) } #endif -// rvalue object-like containers +// rvalue object-like containers (views have no key_type and mapped_type, so +// they are no compatible object type) template using is_rvalue_object_to_json = conjunction, negation>, @@ -517,7 +546,7 @@ using is_rvalue_object_to_json = conjunction, template::value, int> = 0> -inline void to_json(BasicJsonType& j, CompatibleObjectType && obj) +inline void to_json(BasicJsonType& j, CompatibleObjectType && obj) // NOLINT(cppcoreguidelines-missing-std-forward) { external_constructor::construct_moving(j, obj); } diff --git a/include/nlohmann/detail/conversions/zmij.hpp b/include/nlohmann/detail/conversions/zmij.hpp index 3820d891a..3b2e8e7a3 100644 --- a/include/nlohmann/detail/conversions/zmij.hpp +++ b/include/nlohmann/detail/conversions/zmij.hpp @@ -185,7 +185,7 @@ JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexc const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast(shift)); std::uint64_t integral = p.high >> static_cast(extra_shift); // (no casts in the shifts: MSVC 2015 warns C4554 on them despite the parentheses) - constexpr unsigned fractional_low_shift = static_cast(extra_shift); + constexpr auto fractional_low_shift = static_cast(extra_shift); constexpr unsigned fractional_high_shift = 64u - fractional_low_shift; const std::uint64_t fractional = (p.high << fractional_high_shift) | (p.low >> fractional_low_shift); std::uint64_t digit = 0; diff --git a/include/nlohmann/detail/exceptions.hpp b/include/nlohmann/detail/exceptions.hpp index b2b5f36dd..7d7f4e038 100644 --- a/include/nlohmann/detail/exceptions.hpp +++ b/include/nlohmann/detail/exceptions.hpp @@ -494,8 +494,7 @@ JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE void throw_patch_missing_member(c static_cast(string_type); static_cast(val); // context-sensitive error message - const std::string error_msg = (op == "op") ? std::string("operation") : concat("operation '", op, '\''); - JSON_THROW(parse_error::create(exception_id::patch_invalid_operation, 0, concat(error_msg, string_type ? " must have string member '" : " must have member '", member, "'"), &val)); + JSON_THROW(parse_error::create(exception_id::patch_invalid_operation, 0, concat((op == "op") ? std::string("operation") : concat("operation '", op, '\''), string_type ? " must have string member '" : " must have member '", member, "'"), &val)); } template diff --git a/include/nlohmann/detail/iterators/iter_impl.hpp b/include/nlohmann/detail/iterators/iter_impl.hpp index b7c1df24a..120c1b893 100644 --- a/include/nlohmann/detail/iterators/iter_impl.hpp +++ b/include/nlohmann/detail/iterators/iter_impl.hpp @@ -680,12 +680,12 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci { JSON_ASSERT(m_object != nullptr); - if (JSON_HEDLEY_LIKELY(m_object->is_object())) + if (JSON_HEDLEY_UNLIKELY(!m_object->is_object())) { - return m_it.object_iterator->first; + throw_literal(exception_id::iterator_key_not_object, "cannot use key() for non-object iterators", m_object); } - throw_literal(exception_id::iterator_key_not_object, "cannot use key() for non-object iterators", m_object); + return m_it.object_iterator->first; } /*! diff --git a/include/nlohmann/detail/json_pointer.hpp b/include/nlohmann/detail/json_pointer.hpp index e5fb3750b..63ab49f7d 100644 --- a/include/nlohmann/detail/json_pointer.hpp +++ b/include/nlohmann/detail/json_pointer.hpp @@ -11,6 +11,7 @@ #include // all_of #include // isdigit #include // errno, ERANGE +#include // size_t #include // strtoull #ifndef JSON_NO_IO #include // ostream @@ -334,7 +335,7 @@ class json_pointer { break; // not a plain number: let strtoull decide } - acc = static_cast(acc * 10 + static_cast(c - '0')); + acc = static_cast((acc * 10) + static_cast(c - '0')); if (JSON_HEDLEY_UNLIKELY(i == s.size() - 1)) { idx = acc; @@ -529,10 +530,10 @@ class json_pointer static std::size_t hash_of(std::size_t parent, const string_t& token) noexcept { - std::size_t h = parent * static_cast(0x9E3779B97F4A7C15ULL); + std::size_t h = parent * static_cast(0x9E3779B97F4A7C15ULL & (std::numeric_limits::max)()); for (std::size_t i = 0; i < token.size(); ++i) { - h = (h ^ static_cast(token[i])) * static_cast(0x100000001B3ULL); + h = (h ^ static_cast(token[i])) * static_cast(0x100000001B3ULL & (std::numeric_limits::max)()); } return h ^ (h >> 29u); } diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp index 37447262e..595fe11e5 100644 --- a/include/nlohmann/json.hpp +++ b/include/nlohmann/json.hpp @@ -29,6 +29,7 @@ #endif // JSON_NO_IO #include // make_move_iterator, random_access_iterator_tag #include // numeric_limits +#include // map #include // unique_ptr #include // swap, operator!= #include // length_error @@ -754,26 +755,20 @@ private: // one level deep); stops at the first structured child it meets static bool all_children_leaves(const basic_json& v) noexcept { + // array_t only needs forward iterators (see custom_array_type) if (v.m_data.m_type == value_t::array) { const auto& a = *v.m_data.m_value.array; - for (auto it = a.rbegin(); it != a.rend(); ++it) + return std::all_of(a.begin(), a.end(), [](const basic_json & el) { - if (!has_no_children(*it)) - { - return false; - } - } - return true; + return has_no_children(el); + }); } - for (const auto& el : *v.m_data.m_value.object) + const auto& o = *v.m_data.m_value.object; + return std::all_of(o.begin(), o.end(), [](const typename object_t::value_type & el) { - if (!has_no_children(el.second)) - { - return false; - } - } - return true; + return has_no_children(el.second); + }); } // The walk in destroy_container() may take the children of a @@ -1230,7 +1225,7 @@ public: } template < typename O = object_t, detail::enable_if_t < detail::has_stable_elements::value, int > = 0 > - static constexpr std::size_t object_capacity() noexcept + std::size_t object_capacity() const noexcept { return 0; } @@ -1242,7 +1237,7 @@ public: } template < typename O = object_t, detail::enable_if_t < !detail::has_stable_elements::value && !detail::is_nlohmann_ordered_map::value, int > = 0 > - static constexpr std::size_t object_capacity() noexcept + std::size_t object_capacity() const noexcept { return detail::unknown_size(); } @@ -3043,18 +3038,21 @@ public: JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_iterator_range_of_null(const basic_json* obj) { + static_cast(obj); // unused when JSON_NOEXCEPTION is defined JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_range_of_null, detail::concat("cannot construct with iterators from ", obj->type_name()), obj)); } JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_incompatible_reference_type(const basic_json& obj) { + static_cast(obj); // unused when JSON_NOEXCEPTION is defined JSON_THROW(type_error::create(detail::exception_id::incompatible_reference_type, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj)); } JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_array_index_exceeds_size_type(size_type idx) { + static_cast(idx); // unused when JSON_NOEXCEPTION is defined JSON_THROW(std::length_error(detail::concat("array index ", std::to_string(idx), " exceeds size_type"))); } @@ -3062,6 +3060,8 @@ public: JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_array_index_out_of_range(size_type idx, const basic_json& j) { + static_cast(idx); // unused when JSON_NOEXCEPTION is defined + static_cast(j); JSON_THROW(out_of_range::create(detail::exception_id::array_index_out_of_range, detail::concat("array index ", std::to_string(idx), " is out of range"), &j)); } @@ -3070,6 +3070,8 @@ public: JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_key_not_found(const KeyType& key, const basic_json& j) { + static_cast(key); // unused when JSON_NOEXCEPTION is defined + static_cast(j); JSON_THROW(out_of_range::create(detail::exception_id::key_not_found, detail::concat("key '", key, "' not found"), &j)); } @@ -4893,19 +4895,19 @@ public: iterator insert(const_iterator pos, const basic_json& val) // NOLINT(performance-unnecessary-value-param) { // insert only works for arrays - if (JSON_HEDLEY_LIKELY(is_array())) + if (JSON_HEDLEY_UNLIKELY(!is_array())) { - // check if iterator pos fits to this JSON value - if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) - { - detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); - } - - // insert to array and return iterator - return insert_iterator(pos, val); + detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); } - detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); + // check if iterator pos fits to this JSON value + if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) + { + detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); + } + + // insert to array and return iterator + return insert_iterator(pos, val); } /// @brief inserts element into array @@ -4913,21 +4915,21 @@ public: iterator insert(const_iterator pos, basic_json&& val) // NOLINT(performance-unnecessary-value-param) { // insert only works for arrays - if (JSON_HEDLEY_LIKELY(is_array())) + if (JSON_HEDLEY_UNLIKELY(!is_array())) { - // check if iterator pos fits to this JSON value - if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) - { - detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); - } - - // moving into a local first keeps this safe even if val aliases - // an element of this array - basic_json tmp(std::move(val)); - return insert_iterator(pos, std::move(tmp)); + detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); } - detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); + // check if iterator pos fits to this JSON value + if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) + { + detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); + } + + // moving into a local first keeps this safe even if val aliases + // an element of this array + basic_json tmp(std::move(val)); + return insert_iterator(pos, std::move(tmp)); } /// @brief inserts copies of element into array @@ -4935,19 +4937,19 @@ public: iterator insert(const_iterator pos, size_type cnt, const basic_json& val) // NOLINT(performance-unnecessary-value-param) { // insert only works for arrays - if (JSON_HEDLEY_LIKELY(is_array())) + if (JSON_HEDLEY_UNLIKELY(!is_array())) { - // check if iterator pos fits to this JSON value - if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) - { - detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); - } - - // insert to array and return iterator - return insert_iterator(pos, cnt, val); + detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); } - detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); + // check if iterator pos fits to this JSON value + if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) + { + detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); + } + + // insert to array and return iterator + return insert_iterator(pos, cnt, val); } /// @brief inserts range of elements into array @@ -5453,7 +5455,7 @@ public: // inline fast path for two values of the same non-owning scalar type; anything // else falls through to the out-of-line general comparison #define JSON_IMPLEMENT_SCALAR_FAST(op, null_result) \ - if (lhs.m_data.m_type == rhs.m_data.m_type) \ + if (lhs.m_data.m_type == rhs.m_data.m_type) /* NOLINT(readability/braces) */ \ { \ switch (lhs.m_data.m_type) \ { \ diff --git a/include/nlohmann/ordered_map.hpp b/include/nlohmann/ordered_map.hpp index 10fc764ea..e5f9164f6 100644 --- a/include/nlohmann/ordered_map.hpp +++ b/include/nlohmann/ordered_map.hpp @@ -23,6 +23,7 @@ #include #include #include +#include NLOHMANN_JSON_NAMESPACE_BEGIN diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp index bcc8e5831..4debe551f 100644 --- a/single_include/nlohmann/json.hpp +++ b/single_include/nlohmann/json.hpp @@ -29,6 +29,7 @@ #endif // JSON_NO_IO #include // make_move_iterator, random_access_iterator_tag #include // numeric_limits +#include // map #include // unique_ptr #include // swap, operator!= #include // length_error @@ -5794,8 +5795,7 @@ JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE void throw_patch_missing_member(c static_cast(string_type); static_cast(val); // context-sensitive error message - const std::string error_msg = (op == "op") ? std::string("operation") : concat("operation '", op, '\''); - JSON_THROW(parse_error::create(exception_id::patch_invalid_operation, 0, concat(error_msg, string_type ? " must have string member '" : " must have member '", member, "'"), &val)); + JSON_THROW(parse_error::create(exception_id::patch_invalid_operation, 0, concat((op == "op") ? std::string("operation") : concat("operation '", op, '\''), string_type ? " must have string member '" : " must have member '", member, "'"), &val)); } template @@ -6555,7 +6555,7 @@ NLOHMANN_JSON_NAMESPACE_END #include // optional #endif -#include // begin, end +#include // begin, end, make_move_iterator, move_iterator #include // allocator_traits #include // basic_string, char_traits #include // tuple, get @@ -7204,6 +7204,32 @@ namespace detail * leave j with the type of the new value, but the pointer to the destroyed old one. */ +// a move iterator over the elements of an rvalue container, unless they are +// const (e.g., std::set): libstdc++ before GCC 5 defines the reference of a +// std::move_iterator as value_type&&, which cannot bind to a const element +template +std::move_iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::true_type /*mutable*/) +{ + return std::make_move_iterator(it); +} + +template +Iterator make_move_iterator_if_mutable_impl(const Iterator& it, std::false_type /*mutable*/) +{ + return it; +} + +template +using is_mutable_iterator = std::integral_constant < bool, + !std::is_const())>::type>::value >; + +template +auto make_move_iterator_if_mutable(const Iterator& it) +-> decltype(make_move_iterator_if_mutable_impl(it, is_mutable_iterator {})) +{ + return make_move_iterator_if_mutable_impl(it, is_mutable_iterator {}); +} + template struct external_constructor; template<> @@ -7330,7 +7356,7 @@ struct external_constructor using std::begin; using std::end; - const typename BasicJsonType::json_value value(j.template create(std::make_move_iterator(begin(arr)), std::make_move_iterator(end(arr)))); + const typename BasicJsonType::json_value value(j.template create(make_move_iterator_if_mutable(begin(arr)), make_move_iterator_if_mutable(end(arr)))); j.replace_value(value_t::array, value); } @@ -7391,7 +7417,7 @@ struct external_constructor using std::begin; using std::end; - const typename BasicJsonType::json_value value(j.template create(std::make_move_iterator(begin(obj)), std::make_move_iterator(end(obj)))); + const typename BasicJsonType::json_value value(j.template create(make_move_iterator_if_mutable(begin(obj)), make_move_iterator_if_mutable(end(obj)))); j.replace_value(value_t::object, value); } @@ -7569,25 +7595,27 @@ using is_movable_container_rvalue = negation, has_dedicated_to_json, is_basic_json, - is_range_view_type, is_enum_keyed_map_type, std::is_same>>>; -// rvalue array-like containers +// rvalue array-like containers; object types are ruled out before views are +// checked, as std::ranges::view for the object_t of an ordered_json would +// need that ordered_json to be complete (GCC 11, see #3312) template using is_rvalue_array_to_json = conjunction, + negation>, + negation>, is_compatible_array_type, negation, std::is_same, - is_compatible_object_type, is_compatible_string_type, is_compatible_binary_type>>>; // rvalue containers: their elements are moved instead of copied template::value, int> = 0> -inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) +inline void to_json(BasicJsonType& j, CompatibleArrayType && arr) // NOLINT(cppcoreguidelines-missing-std-forward) { external_constructor::construct_moving(j, arr); } @@ -7665,7 +7693,8 @@ inline void to_json(BasicJsonType& j, const EnumKeyedMap& map) } #endif -// rvalue object-like containers +// rvalue object-like containers (views have no key_type and mapped_type, so +// they are no compatible object type) template using is_rvalue_object_to_json = conjunction, negation>, @@ -7673,7 +7702,7 @@ using is_rvalue_object_to_json = conjunction, template::value, int> = 0> -inline void to_json(BasicJsonType& j, CompatibleObjectType && obj) +inline void to_json(BasicJsonType& j, CompatibleObjectType && obj) // NOLINT(cppcoreguidelines-missing-std-forward) { external_constructor::construct_moving(j, obj); } @@ -20715,12 +20744,12 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci { JSON_ASSERT(m_object != nullptr); - if (JSON_HEDLEY_LIKELY(m_object->is_object())) + if (JSON_HEDLEY_UNLIKELY(!m_object->is_object())) { - return m_it.object_iterator->first; + throw_literal(exception_id::iterator_key_not_object, "cannot use key() for non-object iterators", m_object); } - throw_literal(exception_id::iterator_key_not_object, "cannot use key() for non-object iterators", m_object); + return m_it.object_iterator->first; } /*! @@ -20947,6 +20976,7 @@ NLOHMANN_JSON_NAMESPACE_END #include // all_of #include // isdigit #include // errno, ERANGE +#include // size_t #include // strtoull #ifndef JSON_NO_IO #include // ostream @@ -21277,7 +21307,7 @@ class json_pointer { break; // not a plain number: let strtoull decide } - acc = static_cast(acc * 10 + static_cast(c - '0')); + acc = static_cast((acc * 10) + static_cast(c - '0')); if (JSON_HEDLEY_UNLIKELY(i == s.size() - 1)) { idx = acc; @@ -21472,10 +21502,10 @@ class json_pointer static std::size_t hash_of(std::size_t parent, const string_t& token) noexcept { - std::size_t h = parent * static_cast(0x9E3779B97F4A7C15ULL); + std::size_t h = parent * static_cast(0x9E3779B97F4A7C15ULL & (std::numeric_limits::max)()); for (std::size_t i = 0; i < token.size(); ++i) { - h = (h ^ static_cast(token[i])) * static_cast(0x100000001B3ULL); + h = (h ^ static_cast(token[i])) * static_cast(0x100000001B3ULL & (std::numeric_limits::max)()); } return h ^ (h >> 29u); } @@ -26454,7 +26484,7 @@ JSON_HEDLEY_ALWAYS_INLINE shortest_decimal to_shortest(std::uint64_t bits) noexc const uint128_parts p = umul192_hi128(p10.high, p10.low, bin_sig << static_cast(shift)); std::uint64_t integral = p.high >> static_cast(extra_shift); // (no casts in the shifts: MSVC 2015 warns C4554 on them despite the parentheses) - constexpr unsigned fractional_low_shift = static_cast(extra_shift); + constexpr auto fractional_low_shift = static_cast(extra_shift); constexpr unsigned fractional_high_shift = 64u - fractional_low_shift; const std::uint64_t fractional = (p.high << fractional_high_shift) | (p.low >> fractional_low_shift); std::uint64_t digit = 0; @@ -29704,6 +29734,8 @@ NLOHMANN_JSON_NAMESPACE_END // #include +// #include + NLOHMANN_JSON_NAMESPACE_BEGIN @@ -30788,26 +30820,20 @@ private: // one level deep); stops at the first structured child it meets static bool all_children_leaves(const basic_json& v) noexcept { + // array_t only needs forward iterators (see custom_array_type) if (v.m_data.m_type == value_t::array) { const auto& a = *v.m_data.m_value.array; - for (auto it = a.rbegin(); it != a.rend(); ++it) + return std::all_of(a.begin(), a.end(), [](const basic_json & el) { - if (!has_no_children(*it)) - { - return false; - } - } - return true; + return has_no_children(el); + }); } - for (const auto& el : *v.m_data.m_value.object) + const auto& o = *v.m_data.m_value.object; + return std::all_of(o.begin(), o.end(), [](const typename object_t::value_type & el) { - if (!has_no_children(el.second)) - { - return false; - } - } - return true; + return has_no_children(el.second); + }); } // The walk in destroy_container() may take the children of a @@ -31264,7 +31290,7 @@ public: } template < typename O = object_t, detail::enable_if_t < detail::has_stable_elements::value, int > = 0 > - static constexpr std::size_t object_capacity() noexcept + std::size_t object_capacity() const noexcept { return 0; } @@ -31276,7 +31302,7 @@ public: } template < typename O = object_t, detail::enable_if_t < !detail::has_stable_elements::value && !detail::is_nlohmann_ordered_map::value, int > = 0 > - static constexpr std::size_t object_capacity() noexcept + std::size_t object_capacity() const noexcept { return detail::unknown_size(); } @@ -33077,18 +33103,21 @@ public: JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_iterator_range_of_null(const basic_json* obj) { + static_cast(obj); // unused when JSON_NOEXCEPTION is defined JSON_THROW(invalid_iterator::create(detail::exception_id::iterator_range_of_null, detail::concat("cannot construct with iterators from ", obj->type_name()), obj)); } JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_incompatible_reference_type(const basic_json& obj) { + static_cast(obj); // unused when JSON_NOEXCEPTION is defined JSON_THROW(type_error::create(detail::exception_id::incompatible_reference_type, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj)); } JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_array_index_exceeds_size_type(size_type idx) { + static_cast(idx); // unused when JSON_NOEXCEPTION is defined JSON_THROW(std::length_error(detail::concat("array index ", std::to_string(idx), " exceeds size_type"))); } @@ -33096,6 +33125,8 @@ public: JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_array_index_out_of_range(size_type idx, const basic_json& j) { + static_cast(idx); // unused when JSON_NOEXCEPTION is defined + static_cast(j); JSON_THROW(out_of_range::create(detail::exception_id::array_index_out_of_range, detail::concat("array index ", std::to_string(idx), " is out of range"), &j)); } @@ -33104,6 +33135,8 @@ public: JSON_HEDLEY_NO_RETURN JSON_HEDLEY_NEVER_INLINE static void throw_key_not_found(const KeyType& key, const basic_json& j) { + static_cast(key); // unused when JSON_NOEXCEPTION is defined + static_cast(j); JSON_THROW(out_of_range::create(detail::exception_id::key_not_found, detail::concat("key '", key, "' not found"), &j)); } @@ -34927,19 +34960,19 @@ public: iterator insert(const_iterator pos, const basic_json& val) // NOLINT(performance-unnecessary-value-param) { // insert only works for arrays - if (JSON_HEDLEY_LIKELY(is_array())) + if (JSON_HEDLEY_UNLIKELY(!is_array())) { - // check if iterator pos fits to this JSON value - if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) - { - detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); - } - - // insert to array and return iterator - return insert_iterator(pos, val); + detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); } - detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); + // check if iterator pos fits to this JSON value + if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) + { + detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); + } + + // insert to array and return iterator + return insert_iterator(pos, val); } /// @brief inserts element into array @@ -34947,21 +34980,21 @@ public: iterator insert(const_iterator pos, basic_json&& val) // NOLINT(performance-unnecessary-value-param) { // insert only works for arrays - if (JSON_HEDLEY_LIKELY(is_array())) + if (JSON_HEDLEY_UNLIKELY(!is_array())) { - // check if iterator pos fits to this JSON value - if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) - { - detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); - } - - // moving into a local first keeps this safe even if val aliases - // an element of this array - basic_json tmp(std::move(val)); - return insert_iterator(pos, std::move(tmp)); + detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); } - detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); + // check if iterator pos fits to this JSON value + if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) + { + detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); + } + + // moving into a local first keeps this safe even if val aliases + // an element of this array + basic_json tmp(std::move(val)); + return insert_iterator(pos, std::move(tmp)); } /// @brief inserts copies of element into array @@ -34969,19 +35002,19 @@ public: iterator insert(const_iterator pos, size_type cnt, const basic_json& val) // NOLINT(performance-unnecessary-value-param) { // insert only works for arrays - if (JSON_HEDLEY_LIKELY(is_array())) + if (JSON_HEDLEY_UNLIKELY(!is_array())) { - // check if iterator pos fits to this JSON value - if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) - { - detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); - } - - // insert to array and return iterator - return insert_iterator(pos, cnt, val); + detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); } - detail::throw_cannot_use_with(detail::exception_id::insert_wrong_type, "insert()", *this); + // check if iterator pos fits to this JSON value + if (JSON_HEDLEY_UNLIKELY(pos.m_object != this)) + { + detail::throw_literal(detail::exception_id::iterator_from_other_value, "iterator does not fit current value", this); + } + + // insert to array and return iterator + return insert_iterator(pos, cnt, val); } /// @brief inserts range of elements into array @@ -35487,7 +35520,7 @@ public: // inline fast path for two values of the same non-owning scalar type; anything // else falls through to the out-of-line general comparison #define JSON_IMPLEMENT_SCALAR_FAST(op, null_result) \ - if (lhs.m_data.m_type == rhs.m_data.m_type) \ + if (lhs.m_data.m_type == rhs.m_data.m_type) /* NOLINT(readability/braces) */ \ { \ switch (lhs.m_data.m_type) \ { \ diff --git a/tests/src/unit-constructor2.cpp b/tests/src/unit-constructor2.cpp index 4896bb1f0..f17d0ad3a 100644 --- a/tests/src/unit-constructor2.cpp +++ b/tests/src/unit-constructor2.cpp @@ -198,11 +198,11 @@ TEST_CASE("copy constructor and destructor across value types") const json src_uint = 7u; const json src_float = 2.5; - json c_null(src_null); - json c_bool(src_bool); - json c_int(src_int); - json c_uint(src_uint); - json c_float(src_float); + json c_null(src_null); // NOLINT(performance-unnecessary-copy-initialization): tests the copy constructor + json c_bool(src_bool); // NOLINT(performance-unnecessary-copy-initialization): tests the copy constructor + json c_int(src_int); // NOLINT(performance-unnecessary-copy-initialization): tests the copy constructor + json c_uint(src_uint); // NOLINT(performance-unnecessary-copy-initialization): tests the copy constructor + json c_float(src_float); // NOLINT(performance-unnecessary-copy-initialization): tests the copy constructor CHECK(c_null.is_null()); CHECK(c_bool == true); @@ -300,12 +300,12 @@ TEST_CASE("copy constructor and destructor across value types") REQUIRE(v.size() == 70); std::vector copy(v); - CHECK(copy == v); + CHECK((copy == v)); // mutating the copy leaves the original alone copy[5] = "changed"; copy[6].push_back(1); - CHECK(copy != v); + CHECK((copy != v)); CHECK(v[5] == std::string(5, 'x')); CHECK(v[6].size() == 3); diff --git a/tests/src/unit-diagnostics.cpp b/tests/src/unit-diagnostics.cpp index 1d7b45a97..504a95322 100644 --- a/tests/src/unit-diagnostics.cpp +++ b/tests/src/unit-diagnostics.cpp @@ -817,8 +817,8 @@ template, struct relocating_map : nlohmann::ordered_map { using base_type = nlohmann::ordered_map; - using typename base_type::iterator; - using typename base_type::Container; + using iterator = typename base_type::iterator; + using Container = typename base_type::Container; using base_type::base_type; template diff --git a/tests/src/unit-iterators1.cpp b/tests/src/unit-iterators1.cpp index 629c6abd7..1f0a6ba4b 100644 --- a/tests/src/unit-iterators1.cpp +++ b/tests/src/unit-iterators1.cpp @@ -1637,6 +1637,7 @@ TEST_CASE_TEMPLATE("reverse iteration and member access", Json, nlohmann::json, { Json j = {1, 2, 3, 4}; + const std::vector reversed = {4, 3, 2, 1}; auto it = j.end(); std::vector seen; while (it != j.begin()) @@ -1644,7 +1645,7 @@ TEST_CASE_TEMPLATE("reverse iteration and member access", Json, nlohmann::json, --it; seen.push_back(it->template get()); } - CHECK(seen == std::vector {4, 3, 2, 1}); + CHECK(seen == reversed); auto it2 = j.end(); auto old = it2--; @@ -1656,14 +1657,14 @@ TEST_CASE_TEMPLATE("reverse iteration and member access", Json, nlohmann::json, { seen.push_back(r->template get()); } - CHECK(seen == std::vector {4, 3, 2, 1}); + CHECK(seen == reversed); seen.clear(); for (auto r = j.crbegin(); r != j.crend(); ++r) { - seen.push_back(*r); + seen.push_back(r->template get()); } - CHECK(seen == std::vector {4, 3, 2, 1}); + CHECK(seen == reversed); } SECTION("object: -- and rbegin/rend") diff --git a/tests/src/unit-json_pointer.cpp b/tests/src/unit-json_pointer.cpp index 39c4f790c..7748a375a 100644 --- a/tests/src/unit-json_pointer.cpp +++ b/tests/src/unit-json_pointer.cpp @@ -1230,11 +1230,11 @@ TEST_CASE("JSON pointer array index tokens match strtoull semantics") SECTION("random tokens") { - std::mt19937 gen(42); + std::mt19937 gen(42); // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed): reproducible const std::string alphabet = "0123456789012345678901234567890123456789-+ ex"; for (int i = 0; i < 5000; ++i) { - std::string token(static_cast(gen() % 23), '0'); + std::string token(gen() % 23, '0'); for (auto& c : token) { c = alphabet[gen() % alphabet.size()]; diff --git a/tests/src/unit-serialization.cpp b/tests/src/unit-serialization.cpp index 4913c30a6..b6608a49a 100644 --- a/tests/src/unit-serialization.cpp +++ b/tests/src/unit-serialization.cpp @@ -1374,7 +1374,13 @@ void check_dump_against_reference(const std::string& s, const bool with_strict = }; for (const auto error_handler : error_handlers) { +#if defined(JSON_NOEXCEPTION) + // a strict dump of invalid UTF-8 calls std::abort() instead of throwing + static_cast(with_strict); + if (error_handler == json::error_handler_t::strict) +#else if (!with_strict && error_handler == json::error_handler_t::strict) +#endif { continue; } @@ -1429,7 +1435,7 @@ TEST_CASE("invalid UTF-8 at every position is handled like the reference") "\xF4\x90\x80\x80", // sequences cut short by ASCII, a control character, a quote, a // backslash, DEL, or the lead byte of a well-formed character - "\xC3" "a", "\xE2\x82" "\n", "\xE2\x82\"", "\xF0\x9F\x98\\", "\xC3\x7F", "\xC3\xC3\xA4", "\xE2\xF0\x9F\x98\x80", + "\xC3" "a", "\xE2\x82" "\n", "\xE2\x82\"", "\xF0\x9F\x98\\", "\xC3\x7F", "\xC3\xC3\xA4", "\xE2\xF0\x9F\x98\x80", // NOLINT(bugprone-suspicious-missing-comma): "\xC3" "a" ends the hex escape // truncated sequences "\xC3", "\xE2\x82", "\xF0\x9F\x98" }; @@ -1489,7 +1495,7 @@ TEST_CASE("invalid UTF-8 at every position is handled like the reference") { for (const auto& pattern : patterns) { - check_dump_against_reference(make_string(filler, pos, pattern, length - pos), bytes <= (filler.size() == 1 ? 17 : 8)); + check_dump_against_reference(make_string(filler, pos, pattern, length - pos), bytes <= (filler.size() == 1 ? 17u : 8u)); } } } diff --git a/tests/src/unit-testsuites.cpp b/tests/src/unit-testsuites.cpp index 672981967..52d189457 100644 --- a/tests/src/unit-testsuites.cpp +++ b/tests/src/unit-testsuites.cpp @@ -218,7 +218,11 @@ TEST_CASE("compliance tests from nativejson-benchmark") n1e308[0] = '['; n1e308[1] = '1'; n1e308[310] = ']'; +#if JSON_STRICT_NUL_HANDLING + n1e308.pop_back(); // a NUL byte after the value is a syntax error in strict mode +#else n1e308[311] = '\0'; +#endif TEST_DOUBLE(n1e308, 1E308); } diff --git a/tests/src/unit-throw_messages.cpp b/tests/src/unit-throw_messages.cpp index 1c2289626..d7546cc93 100644 --- a/tests/src/unit-throw_messages.cpp +++ b/tests/src/unit-throw_messages.cpp @@ -54,8 +54,8 @@ TEST_CASE("exception messages of out-of-line throw sites") SECTION("at") { - const json carr = arr; - const json cobj = obj; + const json& carr = arr; + const json& cobj = obj; CHECK_MSG((void)arr.at(static_cast(10)), "[json.exception.out_of_range.401] array index 10 is out of range"); CHECK_MSG((void)carr.at(static_cast(3)), "[json.exception.out_of_range.401] array index 3 is out of range"); CHECK_MSG((void)num.at(static_cast(0)), "[json.exception.type_error.304] cannot use at() with number"); @@ -65,7 +65,7 @@ TEST_CASE("exception messages of out-of-line throw sites") CHECK_MSG((void)num.at("a"), "[json.exception.type_error.304] cannot use at() with number"); nlohmann::ordered_json oobj = {{"a", 1}}; - const nlohmann::ordered_json coobj = oobj; + const nlohmann::ordered_json& coobj = oobj; CHECK_MSG((void)oobj.at("z"), "[json.exception.out_of_range.403] key 'z' not found"); CHECK_MSG((void)coobj.at("z"), "[json.exception.out_of_range.403] key 'z' not found"); CHECK_MSG((void)coobj.at(std::string("zz")), "[json.exception.out_of_range.403] key 'zz' not found"); @@ -94,9 +94,10 @@ TEST_CASE("exception messages of out-of-line throw sites") CHECK_MSG(obj.update(arr.begin(), arr2.end()), "[json.exception.invalid_iterator.210] iterators do not fit"); } +#if !defined(JSON_NOEXCEPTION) // patch_msg() catches the exceptions, which JSON_NOEXCEPTION turns into std::abort() SECTION("patch") { - const auto patch_msg = [](const char* doc, const char* patch) + const auto patch_msg = [](const char* doc, const char* patch) -> std::string { try { @@ -105,16 +106,23 @@ TEST_CASE("exception messages of out-of-line throw sites") } catch (const json::exception& e) { - // with JSON_DIAGNOSTICS, what() names the offending value like "(/0) "; drop it + // with JSON_DIAGNOSTICS, what() names the offending value like "(/0) ", + // and with JSON_DIAGNOSTIC_POSITIONS its position like "(bytes 0-2) "; drop both std::string msg = e.what(); - const auto pos = msg.find(" (/"); - if (pos != std::string::npos) + for (const char* marker : + { + " (/", " (bytes " + }) { - msg.erase(pos + 1, msg.find(") ", pos) - pos + 1); + const auto pos = msg.find(marker); + if (pos != std::string::npos) + { + msg.erase(pos + 1, msg.find(") ", pos) - pos + 1); + } } return msg; } - return std::string(); + return {}; }; CHECK(patch_msg("{}", "{}") == "[json.exception.parse_error.104] parse error: JSON patch must be an array of objects"); @@ -132,4 +140,5 @@ TEST_CASE("exception messages of out-of-line throw sites") CHECK(patch_msg("{\"a\":1}", "[{\"op\":\"test\",\"path\":\"/a\",\"value\":2}]") == "[json.exception.other_error.501] unsuccessful: {\"op\":\"test\",\"path\":\"/a\",\"value\":2}"); CHECK(patch_msg("{\"a\":1}", "[{\"op\":\"move\",\"path\":\"/a\"}]") == "[json.exception.parse_error.105] parse error: operation 'move' must have member 'from'"); } +#endif }