Codeprocastinator/optimized-tinyllama-covalent
0119
1// __ _____ _____ _____2// __| | __| | | | JSON for Modern C++3// | | |__ | | | | | | version 3.11.34// |_____|_____|_____|_|___| https://github.com/nlohmann/json5//6// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>7// SPDX-License-Identifier: MIT8 9/****************************************************************************\10 * Note on documentation: The source files contain links to the online *11 * documentation of the public API at https://json.nlohmann.me. This URL *12 * contains the most recent documentation and should also be applicable to *13 * previous versions; documentation for deprecated functions is not *14 * removed, but marked deprecated. See "Generate documentation" section in *15 * file docs/README.md. *16\****************************************************************************/17 18#ifndef INCLUDE_NLOHMANN_JSON_HPP_19#define INCLUDE_NLOHMANN_JSON_HPP_20 21#include <algorithm> // all_of, find, for_each22#include <cstddef> // nullptr_t, ptrdiff_t, size_t23#include <functional> // hash, less24#include <initializer_list> // initializer_list25#ifndef JSON_NO_IO26 #include <iosfwd> // istream, ostream27#endif // JSON_NO_IO28#include <iterator> // random_access_iterator_tag29#include <memory> // unique_ptr30#include <string> // string, stoi, to_string31#include <utility> // declval, forward, move, pair, swap32#include <vector> // vector33 34// #include <nlohmann/adl_serializer.hpp>35// __ _____ _____ _____36// __| | __| | | | JSON for Modern C++37// | | |__ | | | | | | version 3.11.338// |_____|_____|_____|_|___| https://github.com/nlohmann/json39//40// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>41// SPDX-License-Identifier: MIT42 43 44 45#include <utility>46 47// #include <nlohmann/detail/abi_macros.hpp>48// __ _____ _____ _____49// __| | __| | | | JSON for Modern C++50// | | |__ | | | | | | version 3.11.351// |_____|_____|_____|_|___| https://github.com/nlohmann/json52//53// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>54// SPDX-License-Identifier: MIT55 56 57 58// This file contains all macro definitions affecting or depending on the ABI59 60#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK61 #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)62 #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 363 #warning "Already included a different version of the library!"64 #endif65 #endif66#endif67 68#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum)69#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum)70#define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum)71 72#ifndef JSON_DIAGNOSTICS73 #define JSON_DIAGNOSTICS 074#endif75 76#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON77 #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 078#endif79 80#if JSON_DIAGNOSTICS81 #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag82#else83 #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS84#endif85 86#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON87 #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp88#else89 #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON90#endif91 92#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION93 #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 094#endif95 96// Construct the namespace ABI tags component97#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b98#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \99 NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)100 101#define NLOHMANN_JSON_ABI_TAGS \102 NLOHMANN_JSON_ABI_TAGS_CONCAT( \103 NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \104 NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)105 106// Construct the namespace version component107#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \108 _v ## major ## _ ## minor ## _ ## patch109#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \110 NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)111 112#if NLOHMANN_JSON_NAMESPACE_NO_VERSION113#define NLOHMANN_JSON_NAMESPACE_VERSION114#else115#define NLOHMANN_JSON_NAMESPACE_VERSION \116 NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \117 NLOHMANN_JSON_VERSION_MINOR, \118 NLOHMANN_JSON_VERSION_PATCH)119#endif120 121// Combine namespace components122#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b123#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \124 NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)125 126#ifndef NLOHMANN_JSON_NAMESPACE127#define NLOHMANN_JSON_NAMESPACE \128 nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \129 NLOHMANN_JSON_ABI_TAGS, \130 NLOHMANN_JSON_NAMESPACE_VERSION)131#endif132 133#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN134#define NLOHMANN_JSON_NAMESPACE_BEGIN \135 namespace nlohmann \136 { \137 inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \138 NLOHMANN_JSON_ABI_TAGS, \139 NLOHMANN_JSON_NAMESPACE_VERSION) \140 {141#endif142 143#ifndef NLOHMANN_JSON_NAMESPACE_END144#define NLOHMANN_JSON_NAMESPACE_END \145 } /* namespace (inline namespace) NOLINT(readability/namespace) */ \146 } // namespace nlohmann147#endif148 149// #include <nlohmann/detail/conversions/from_json.hpp>150// __ _____ _____ _____151// __| | __| | | | JSON for Modern C++152// | | |__ | | | | | | version 3.11.3153// |_____|_____|_____|_|___| https://github.com/nlohmann/json154//155// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>156// SPDX-License-Identifier: MIT157 158 159 160#include <algorithm> // transform161#include <array> // array162#include <forward_list> // forward_list163#include <iterator> // inserter, front_inserter, end164#include <map> // map165#include <string> // string166#include <tuple> // tuple, make_tuple167#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible168#include <unordered_map> // unordered_map169#include <utility> // pair, declval170#include <valarray> // valarray171 172// #include <nlohmann/detail/exceptions.hpp>173// __ _____ _____ _____174// __| | __| | | | JSON for Modern C++175// | | |__ | | | | | | version 3.11.3176// |_____|_____|_____|_|___| https://github.com/nlohmann/json177//178// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>179// SPDX-License-Identifier: MIT180 181 182 183#include <cstddef> // nullptr_t184#include <exception> // exception185#if JSON_DIAGNOSTICS186 #include <numeric> // accumulate187#endif188#include <stdexcept> // runtime_error189#include <string> // to_string190#include <vector> // vector191 192// #include <nlohmann/detail/value_t.hpp>193// __ _____ _____ _____194// __| | __| | | | JSON for Modern C++195// | | |__ | | | | | | version 3.11.3196// |_____|_____|_____|_|___| https://github.com/nlohmann/json197//198// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>199// SPDX-License-Identifier: MIT200 201 202 203#include <array> // array204#include <cstddef> // size_t205#include <cstdint> // uint8_t206#include <string> // string207 208// #include <nlohmann/detail/macro_scope.hpp>209// __ _____ _____ _____210// __| | __| | | | JSON for Modern C++211// | | |__ | | | | | | version 3.11.3212// |_____|_____|_____|_|___| https://github.com/nlohmann/json213//214// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>215// SPDX-License-Identifier: MIT216 217 218 219#include <utility> // declval, pair220// #include <nlohmann/detail/meta/detected.hpp>221// __ _____ _____ _____222// __| | __| | | | JSON for Modern C++223// | | |__ | | | | | | version 3.11.3224// |_____|_____|_____|_|___| https://github.com/nlohmann/json225//226// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>227// SPDX-License-Identifier: MIT228 229 230 231#include <type_traits>232 233// #include <nlohmann/detail/meta/void_t.hpp>234// __ _____ _____ _____235// __| | __| | | | JSON for Modern C++236// | | |__ | | | | | | version 3.11.3237// |_____|_____|_____|_|___| https://github.com/nlohmann/json238//239// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>240// SPDX-License-Identifier: MIT241 242 243 244// #include <nlohmann/detail/abi_macros.hpp>245 246 247NLOHMANN_JSON_NAMESPACE_BEGIN248namespace detail249{250 251template<typename ...Ts> struct make_void252{253 using type = void;254};255template<typename ...Ts> using void_t = typename make_void<Ts...>::type;256 257} // namespace detail258NLOHMANN_JSON_NAMESPACE_END259 260 261NLOHMANN_JSON_NAMESPACE_BEGIN262namespace detail263{264 265// https://en.cppreference.com/w/cpp/experimental/is_detected266struct nonesuch267{268 nonesuch() = delete;269 ~nonesuch() = delete;270 nonesuch(nonesuch const&) = delete;271 nonesuch(nonesuch const&&) = delete;272 void operator=(nonesuch const&) = delete;273 void operator=(nonesuch&&) = delete;274};275 276template<class Default,277 class AlwaysVoid,278 template<class...> class Op,279 class... Args>280struct detector281{282 using value_t = std::false_type;283 using type = Default;284};285 286template<class Default, template<class...> class Op, class... Args>287struct detector<Default, void_t<Op<Args...>>, Op, Args...>288{289 using value_t = std::true_type;290 using type = Op<Args...>;291};292 293template<template<class...> class Op, class... Args>294using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;295 296template<template<class...> class Op, class... Args>297struct is_detected_lazy : is_detected<Op, Args...> { };298 299template<template<class...> class Op, class... Args>300using detected_t = typename detector<nonesuch, void, Op, Args...>::type;301 302template<class Default, template<class...> class Op, class... Args>303using detected_or = detector<Default, void, Op, Args...>;304 305template<class Default, template<class...> class Op, class... Args>306using detected_or_t = typename detected_or<Default, Op, Args...>::type;307 308template<class Expected, template<class...> class Op, class... Args>309using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;310 311template<class To, template<class...> class Op, class... Args>312using is_detected_convertible =313 std::is_convertible<detected_t<Op, Args...>, To>;314 315} // namespace detail316NLOHMANN_JSON_NAMESPACE_END317 318// #include <nlohmann/thirdparty/hedley/hedley.hpp>319 320 321// __ _____ _____ _____322// __| | __| | | | JSON for Modern C++323// | | |__ | | | | | | version 3.11.3324// |_____|_____|_____|_|___| https://github.com/nlohmann/json325//326// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>327// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>328// SPDX-License-Identifier: MIT329 330/* Hedley - https://nemequ.github.io/hedley331 * Created by Evan Nemerson <evan@nemerson.com>332 */333 334#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)335#if defined(JSON_HEDLEY_VERSION)336 #undef JSON_HEDLEY_VERSION337#endif338#define JSON_HEDLEY_VERSION 15339 340#if defined(JSON_HEDLEY_STRINGIFY_EX)341 #undef JSON_HEDLEY_STRINGIFY_EX342#endif343#define JSON_HEDLEY_STRINGIFY_EX(x) #x344 345#if defined(JSON_HEDLEY_STRINGIFY)346 #undef JSON_HEDLEY_STRINGIFY347#endif348#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)349 350#if defined(JSON_HEDLEY_CONCAT_EX)351 #undef JSON_HEDLEY_CONCAT_EX352#endif353#define JSON_HEDLEY_CONCAT_EX(a,b) a##b354 355#if defined(JSON_HEDLEY_CONCAT)356 #undef JSON_HEDLEY_CONCAT357#endif358#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)359 360#if defined(JSON_HEDLEY_CONCAT3_EX)361 #undef JSON_HEDLEY_CONCAT3_EX362#endif363#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c364 365#if defined(JSON_HEDLEY_CONCAT3)366 #undef JSON_HEDLEY_CONCAT3367#endif368#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)369 370#if defined(JSON_HEDLEY_VERSION_ENCODE)371 #undef JSON_HEDLEY_VERSION_ENCODE372#endif373#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))374 375#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)376 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR377#endif378#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)379 380#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)381 #undef JSON_HEDLEY_VERSION_DECODE_MINOR382#endif383#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)384 385#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)386 #undef JSON_HEDLEY_VERSION_DECODE_REVISION387#endif388#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)389 390#if defined(JSON_HEDLEY_GNUC_VERSION)391 #undef JSON_HEDLEY_GNUC_VERSION392#endif393#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)394 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)395#elif defined(__GNUC__)396 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)397#endif398 399#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)400 #undef JSON_HEDLEY_GNUC_VERSION_CHECK401#endif402#if defined(JSON_HEDLEY_GNUC_VERSION)403 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))404#else405 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)406#endif407 408#if defined(JSON_HEDLEY_MSVC_VERSION)409 #undef JSON_HEDLEY_MSVC_VERSION410#endif411#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)412 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)413#elif defined(_MSC_FULL_VER) && !defined(__ICL)414 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)415#elif defined(_MSC_VER) && !defined(__ICL)416 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)417#endif418 419#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)420 #undef JSON_HEDLEY_MSVC_VERSION_CHECK421#endif422#if !defined(JSON_HEDLEY_MSVC_VERSION)423 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)424#elif defined(_MSC_VER) && (_MSC_VER >= 1400)425 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))426#elif defined(_MSC_VER) && (_MSC_VER >= 1200)427 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))428#else429 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))430#endif431 432#if defined(JSON_HEDLEY_INTEL_VERSION)433 #undef JSON_HEDLEY_INTEL_VERSION434#endif435#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)436 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)437#elif defined(__INTEL_COMPILER) && !defined(__ICL)438 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)439#endif440 441#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)442 #undef JSON_HEDLEY_INTEL_VERSION_CHECK443#endif444#if defined(JSON_HEDLEY_INTEL_VERSION)445 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))446#else447 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)448#endif449 450#if defined(JSON_HEDLEY_INTEL_CL_VERSION)451 #undef JSON_HEDLEY_INTEL_CL_VERSION452#endif453#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)454 #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)455#endif456 457#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)458 #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK459#endif460#if defined(JSON_HEDLEY_INTEL_CL_VERSION)461 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))462#else463 #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)464#endif465 466#if defined(JSON_HEDLEY_PGI_VERSION)467 #undef JSON_HEDLEY_PGI_VERSION468#endif469#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)470 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)471#endif472 473#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)474 #undef JSON_HEDLEY_PGI_VERSION_CHECK475#endif476#if defined(JSON_HEDLEY_PGI_VERSION)477 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))478#else479 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)480#endif481 482#if defined(JSON_HEDLEY_SUNPRO_VERSION)483 #undef JSON_HEDLEY_SUNPRO_VERSION484#endif485#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)486 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)487#elif defined(__SUNPRO_C)488 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)489#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)490 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)491#elif defined(__SUNPRO_CC)492 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)493#endif494 495#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)496 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK497#endif498#if defined(JSON_HEDLEY_SUNPRO_VERSION)499 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))500#else501 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)502#endif503 504#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)505 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION506#endif507#if defined(__EMSCRIPTEN__)508 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)509#endif510 511#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)512 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK513#endif514#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)515 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))516#else517 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)518#endif519 520#if defined(JSON_HEDLEY_ARM_VERSION)521 #undef JSON_HEDLEY_ARM_VERSION522#endif523#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)524 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)525#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)526 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)527#endif528 529#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)530 #undef JSON_HEDLEY_ARM_VERSION_CHECK531#endif532#if defined(JSON_HEDLEY_ARM_VERSION)533 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))534#else535 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)536#endif537 538#if defined(JSON_HEDLEY_IBM_VERSION)539 #undef JSON_HEDLEY_IBM_VERSION540#endif541#if defined(__ibmxl__)542 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)543#elif defined(__xlC__) && defined(__xlC_ver__)544 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)545#elif defined(__xlC__)546 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)547#endif548 549#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)550 #undef JSON_HEDLEY_IBM_VERSION_CHECK551#endif552#if defined(JSON_HEDLEY_IBM_VERSION)553 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))554#else555 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)556#endif557 558#if defined(JSON_HEDLEY_TI_VERSION)559 #undef JSON_HEDLEY_TI_VERSION560#endif561#if \562 defined(__TI_COMPILER_VERSION__) && \563 ( \564 defined(__TMS470__) || defined(__TI_ARM__) || \565 defined(__MSP430__) || \566 defined(__TMS320C2000__) \567 )568#if (__TI_COMPILER_VERSION__ >= 16000000)569 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))570#endif571#endif572 573#if defined(JSON_HEDLEY_TI_VERSION_CHECK)574 #undef JSON_HEDLEY_TI_VERSION_CHECK575#endif576#if defined(JSON_HEDLEY_TI_VERSION)577 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))578#else579 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)580#endif581 582#if defined(JSON_HEDLEY_TI_CL2000_VERSION)583 #undef JSON_HEDLEY_TI_CL2000_VERSION584#endif585#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)586 #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))587#endif588 589#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)590 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK591#endif592#if defined(JSON_HEDLEY_TI_CL2000_VERSION)593 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))594#else595 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)596#endif597 598#if defined(JSON_HEDLEY_TI_CL430_VERSION)599 #undef JSON_HEDLEY_TI_CL430_VERSION600#endif601#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)602 #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))603#endif604 605#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)606 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK607#endif608#if defined(JSON_HEDLEY_TI_CL430_VERSION)609 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))610#else611 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)612#endif613 614#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)615 #undef JSON_HEDLEY_TI_ARMCL_VERSION616#endif617#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))618 #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))619#endif620 621#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)622 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK623#endif624#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)625 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))626#else627 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)628#endif629 630#if defined(JSON_HEDLEY_TI_CL6X_VERSION)631 #undef JSON_HEDLEY_TI_CL6X_VERSION632#endif633#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)634 #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))635#endif636 637#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)638 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK639#endif640#if defined(JSON_HEDLEY_TI_CL6X_VERSION)641 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))642#else643 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)644#endif645 646#if defined(JSON_HEDLEY_TI_CL7X_VERSION)647 #undef JSON_HEDLEY_TI_CL7X_VERSION648#endif649#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)650 #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))651#endif652 653#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)654 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK655#endif656#if defined(JSON_HEDLEY_TI_CL7X_VERSION)657 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))658#else659 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)660#endif661 662#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)663 #undef JSON_HEDLEY_TI_CLPRU_VERSION664#endif665#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)666 #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))667#endif668 669#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)670 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK671#endif672#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)673 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))674#else675 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)676#endif677 678#if defined(JSON_HEDLEY_CRAY_VERSION)679 #undef JSON_HEDLEY_CRAY_VERSION680#endif681#if defined(_CRAYC)682 #if defined(_RELEASE_PATCHLEVEL)683 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)684 #else685 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)686 #endif687#endif688 689#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)690 #undef JSON_HEDLEY_CRAY_VERSION_CHECK691#endif692#if defined(JSON_HEDLEY_CRAY_VERSION)693 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))694#else695 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)696#endif697 698#if defined(JSON_HEDLEY_IAR_VERSION)699 #undef JSON_HEDLEY_IAR_VERSION700#endif701#if defined(__IAR_SYSTEMS_ICC__)702 #if __VER__ > 1000703 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))704 #else705 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)706 #endif707#endif708 709#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)710 #undef JSON_HEDLEY_IAR_VERSION_CHECK711#endif712#if defined(JSON_HEDLEY_IAR_VERSION)713 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))714#else715 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)716#endif717 718#if defined(JSON_HEDLEY_TINYC_VERSION)719 #undef JSON_HEDLEY_TINYC_VERSION720#endif721#if defined(__TINYC__)722 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)723#endif724 725#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)726 #undef JSON_HEDLEY_TINYC_VERSION_CHECK727#endif728#if defined(JSON_HEDLEY_TINYC_VERSION)729 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))730#else731 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)732#endif733 734#if defined(JSON_HEDLEY_DMC_VERSION)735 #undef JSON_HEDLEY_DMC_VERSION736#endif737#if defined(__DMC__)738 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)739#endif740 741#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)742 #undef JSON_HEDLEY_DMC_VERSION_CHECK743#endif744#if defined(JSON_HEDLEY_DMC_VERSION)745 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))746#else747 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)748#endif749 750#if defined(JSON_HEDLEY_COMPCERT_VERSION)751 #undef JSON_HEDLEY_COMPCERT_VERSION752#endif753#if defined(__COMPCERT_VERSION__)754 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)755#endif756 757#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)758 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK759#endif760#if defined(JSON_HEDLEY_COMPCERT_VERSION)761 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))762#else763 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)764#endif765 766#if defined(JSON_HEDLEY_PELLES_VERSION)767 #undef JSON_HEDLEY_PELLES_VERSION768#endif769#if defined(__POCC__)770 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)771#endif772 773#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)774 #undef JSON_HEDLEY_PELLES_VERSION_CHECK775#endif776#if defined(JSON_HEDLEY_PELLES_VERSION)777 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))778#else779 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)780#endif781 782#if defined(JSON_HEDLEY_MCST_LCC_VERSION)783 #undef JSON_HEDLEY_MCST_LCC_VERSION784#endif785#if defined(__LCC__) && defined(__LCC_MINOR__)786 #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)787#endif788 789#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)790 #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK791#endif792#if defined(JSON_HEDLEY_MCST_LCC_VERSION)793 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))794#else795 #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)796#endif797 798#if defined(JSON_HEDLEY_GCC_VERSION)799 #undef JSON_HEDLEY_GCC_VERSION800#endif801#if \802 defined(JSON_HEDLEY_GNUC_VERSION) && \803 !defined(__clang__) && \804 !defined(JSON_HEDLEY_INTEL_VERSION) && \805 !defined(JSON_HEDLEY_PGI_VERSION) && \806 !defined(JSON_HEDLEY_ARM_VERSION) && \807 !defined(JSON_HEDLEY_CRAY_VERSION) && \808 !defined(JSON_HEDLEY_TI_VERSION) && \809 !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \810 !defined(JSON_HEDLEY_TI_CL430_VERSION) && \811 !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \812 !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \813 !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \814 !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \815 !defined(__COMPCERT__) && \816 !defined(JSON_HEDLEY_MCST_LCC_VERSION)817 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION818#endif819 820#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)821 #undef JSON_HEDLEY_GCC_VERSION_CHECK822#endif823#if defined(JSON_HEDLEY_GCC_VERSION)824 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))825#else826 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)827#endif828 829#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)830 #undef JSON_HEDLEY_HAS_ATTRIBUTE831#endif832#if \833 defined(__has_attribute) && \834 ( \835 (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \836 )837# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)838#else839# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)840#endif841 842#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)843 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE844#endif845#if defined(__has_attribute)846 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)847#else848 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)849#endif850 851#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)852 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE853#endif854#if defined(__has_attribute)855 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)856#else857 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)858#endif859 860#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)861 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE862#endif863#if \864 defined(__has_cpp_attribute) && \865 defined(__cplusplus) && \866 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))867 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)868#else869 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)870#endif871 872#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)873 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS874#endif875#if !defined(__cplusplus) || !defined(__has_cpp_attribute)876 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)877#elif \878 !defined(JSON_HEDLEY_PGI_VERSION) && \879 !defined(JSON_HEDLEY_IAR_VERSION) && \880 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \881 (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))882 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)883#else884 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)885#endif886 887#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)888 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE889#endif890#if defined(__has_cpp_attribute) && defined(__cplusplus)891 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)892#else893 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)894#endif895 896#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)897 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE898#endif899#if defined(__has_cpp_attribute) && defined(__cplusplus)900 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)901#else902 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)903#endif904 905#if defined(JSON_HEDLEY_HAS_BUILTIN)906 #undef JSON_HEDLEY_HAS_BUILTIN907#endif908#if defined(__has_builtin)909 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)910#else911 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)912#endif913 914#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)915 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN916#endif917#if defined(__has_builtin)918 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)919#else920 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)921#endif922 923#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)924 #undef JSON_HEDLEY_GCC_HAS_BUILTIN925#endif926#if defined(__has_builtin)927 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)928#else929 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)930#endif931 932#if defined(JSON_HEDLEY_HAS_FEATURE)933 #undef JSON_HEDLEY_HAS_FEATURE934#endif935#if defined(__has_feature)936 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)937#else938 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)939#endif940 941#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)942 #undef JSON_HEDLEY_GNUC_HAS_FEATURE943#endif944#if defined(__has_feature)945 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)946#else947 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)948#endif949 950#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)951 #undef JSON_HEDLEY_GCC_HAS_FEATURE952#endif953#if defined(__has_feature)954 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)955#else956 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)957#endif958 959#if defined(JSON_HEDLEY_HAS_EXTENSION)960 #undef JSON_HEDLEY_HAS_EXTENSION961#endif962#if defined(__has_extension)963 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)964#else965 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)966#endif967 968#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)969 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION970#endif971#if defined(__has_extension)972 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)973#else974 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)975#endif976 977#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)978 #undef JSON_HEDLEY_GCC_HAS_EXTENSION979#endif980#if defined(__has_extension)981 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)982#else983 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)984#endif985 986#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)987 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE988#endif989#if defined(__has_declspec_attribute)990 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)991#else992 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)993#endif994 995#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)996 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE997#endif998#if defined(__has_declspec_attribute)999 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)1000#else1001 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)1002#endif1003 1004#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)1005 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE1006#endif1007#if defined(__has_declspec_attribute)1008 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)1009#else1010 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)1011#endif1012 1013#if defined(JSON_HEDLEY_HAS_WARNING)1014 #undef JSON_HEDLEY_HAS_WARNING1015#endif1016#if defined(__has_warning)1017 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)1018#else1019 #define JSON_HEDLEY_HAS_WARNING(warning) (0)1020#endif1021 1022#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)1023 #undef JSON_HEDLEY_GNUC_HAS_WARNING1024#endif1025#if defined(__has_warning)1026 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)1027#else1028 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)1029#endif1030 1031#if defined(JSON_HEDLEY_GCC_HAS_WARNING)1032 #undef JSON_HEDLEY_GCC_HAS_WARNING1033#endif1034#if defined(__has_warning)1035 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)1036#else1037 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)1038#endif1039 1040#if \1041 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \1042 defined(__clang__) || \1043 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \1044 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \1045 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \1046 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \1047 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \1048 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \1049 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \1050 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \1051 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \1052 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \1053 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \1054 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \1055 JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \1056 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \1057 JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \1058 (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))1059 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)1060#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)1061 #define JSON_HEDLEY_PRAGMA(value) __pragma(value)1062#else1063 #define JSON_HEDLEY_PRAGMA(value)1064#endif1065 1066#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)1067 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH1068#endif1069#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)1070 #undef JSON_HEDLEY_DIAGNOSTIC_POP1071#endif1072#if defined(__clang__)1073 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")1074 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")1075#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)1076 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")1077 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")1078#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)1079 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")1080 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")1081#elif \1082 JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \1083 JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)1084 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))1085 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))1086#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)1087 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")1088 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")1089#elif \1090 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \1091 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \1092 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \1093 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \1094 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \1095 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)1096 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")1097 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")1098#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)1099 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")1100 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")1101#else1102 #define JSON_HEDLEY_DIAGNOSTIC_PUSH1103 #define JSON_HEDLEY_DIAGNOSTIC_POP1104#endif1105 1106/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for1107 HEDLEY INTERNAL USE ONLY. API subject to change without notice. */1108#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)1109 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_1110#endif1111#if defined(__cplusplus)1112# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")1113# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")1114# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")1115# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \1116 JSON_HEDLEY_DIAGNOSTIC_PUSH \1117 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \1118 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \1119 _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \1120 xpr \1121 JSON_HEDLEY_DIAGNOSTIC_POP1122# else1123# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \1124 JSON_HEDLEY_DIAGNOSTIC_PUSH \1125 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \1126 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \1127 xpr \1128 JSON_HEDLEY_DIAGNOSTIC_POP1129# endif1130# else1131# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \1132 JSON_HEDLEY_DIAGNOSTIC_PUSH \1133 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \1134 xpr \1135 JSON_HEDLEY_DIAGNOSTIC_POP1136# endif1137# endif1138#endif1139#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)1140 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x1141#endif1142 1143#if defined(JSON_HEDLEY_CONST_CAST)1144 #undef JSON_HEDLEY_CONST_CAST1145#endif1146#if defined(__cplusplus)1147# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))1148#elif \1149 JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \1150 JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \1151 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)1152# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \1153 JSON_HEDLEY_DIAGNOSTIC_PUSH \1154 JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \1155 ((T) (expr)); \1156 JSON_HEDLEY_DIAGNOSTIC_POP \1157 }))1158#else1159# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))1160#endif1161 1162#if defined(JSON_HEDLEY_REINTERPRET_CAST)1163 #undef JSON_HEDLEY_REINTERPRET_CAST1164#endif1165#if defined(__cplusplus)1166 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))1167#else1168 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))1169#endif1170 1171#if defined(JSON_HEDLEY_STATIC_CAST)1172 #undef JSON_HEDLEY_STATIC_CAST1173#endif1174#if defined(__cplusplus)1175 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))1176#else1177 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))1178#endif1179 1180#if defined(JSON_HEDLEY_CPP_CAST)1181 #undef JSON_HEDLEY_CPP_CAST1182#endif1183#if defined(__cplusplus)1184# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")1185# define JSON_HEDLEY_CPP_CAST(T, expr) \1186 JSON_HEDLEY_DIAGNOSTIC_PUSH \1187 _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \1188 ((T) (expr)) \1189 JSON_HEDLEY_DIAGNOSTIC_POP1190# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)1191# define JSON_HEDLEY_CPP_CAST(T, expr) \1192 JSON_HEDLEY_DIAGNOSTIC_PUSH \1193 _Pragma("diag_suppress=Pe137") \1194 JSON_HEDLEY_DIAGNOSTIC_POP1195# else1196# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))1197# endif1198#else1199# define JSON_HEDLEY_CPP_CAST(T, expr) (expr)1200#endif