thirdparty/hedley/hedley.hpp

0001 #pragma once
0002
0003 //     __ _____ _____ _____
0004 //  __|  |   __|     |   | |  JSON for Modern C++
0005 // |  |  |__   |  |  | | | |  version 3.11.3
0006 // |_____|_____|_____|_|___|  https://github.com/nlohmann/json
0007 //
0008 // SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
0009 // SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
0010 // SPDX-License-Identifier: MIT
0011
0012 /* Hedley - https://nemequ.github.io/hedley
0013  * Created by Evan Nemerson <evan@nemerson.com>
0014  */
0015
0016 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
0017 #if defined(JSON_HEDLEY_VERSION)
0018     #undef JSON_HEDLEY_VERSION
0019 #endif
0020 #define JSON_HEDLEY_VERSION 15
0021
0022 #if defined(JSON_HEDLEY_STRINGIFY_EX)
0023     #undef JSON_HEDLEY_STRINGIFY_EX
0024 #endif
0025 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
0026
0027 #if defined(JSON_HEDLEY_STRINGIFY)
0028     #undef JSON_HEDLEY_STRINGIFY
0029 #endif
0030 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
0031
0032 #if defined(JSON_HEDLEY_CONCAT_EX)
0033     #undef JSON_HEDLEY_CONCAT_EX
0034 #endif
0035 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
0036
0037 #if defined(JSON_HEDLEY_CONCAT)
0038     #undef JSON_HEDLEY_CONCAT
0039 #endif
0040 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
0041
0042 #if defined(JSON_HEDLEY_CONCAT3_EX)
0043     #undef JSON_HEDLEY_CONCAT3_EX
0044 #endif
0045 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
0046
0047 #if defined(JSON_HEDLEY_CONCAT3)
0048     #undef JSON_HEDLEY_CONCAT3
0049 #endif
0050 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
0051
0052 #if defined(JSON_HEDLEY_VERSION_ENCODE)
0053     #undef JSON_HEDLEY_VERSION_ENCODE
0054 #endif
0055 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
0056
0057 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
0058     #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
0059 #endif
0060 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
0061
0062 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
0063     #undef JSON_HEDLEY_VERSION_DECODE_MINOR
0064 #endif
0065 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
0066
0067 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
0068     #undef JSON_HEDLEY_VERSION_DECODE_REVISION
0069 #endif
0070 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
0071
0072 #if defined(JSON_HEDLEY_GNUC_VERSION)
0073     #undef JSON_HEDLEY_GNUC_VERSION
0074 #endif
0075 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
0076     #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
0077 #elif defined(__GNUC__)
0078     #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
0079 #endif
0080
0081 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
0082     #undef JSON_HEDLEY_GNUC_VERSION_CHECK
0083 #endif
0084 #if defined(JSON_HEDLEY_GNUC_VERSION)
0085     #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0086 #else
0087     #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
0088 #endif
0089
0090 #if defined(JSON_HEDLEY_MSVC_VERSION)
0091     #undef JSON_HEDLEY_MSVC_VERSION
0092 #endif
0093 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
0094     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
0095 #elif defined(_MSC_FULL_VER) && !defined(__ICL)
0096     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
0097 #elif defined(_MSC_VER) && !defined(__ICL)
0098     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
0099 #endif
0100
0101 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
0102     #undef JSON_HEDLEY_MSVC_VERSION_CHECK
0103 #endif
0104 #if !defined(JSON_HEDLEY_MSVC_VERSION)
0105     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
0106 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
0107     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
0108 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
0109     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
0110 #else
0111     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
0112 #endif
0113
0114 #if defined(JSON_HEDLEY_INTEL_VERSION)
0115     #undef JSON_HEDLEY_INTEL_VERSION
0116 #endif
0117 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
0118     #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
0119 #elif defined(__INTEL_COMPILER) && !defined(__ICL)
0120     #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
0121 #endif
0122
0123 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
0124     #undef JSON_HEDLEY_INTEL_VERSION_CHECK
0125 #endif
0126 #if defined(JSON_HEDLEY_INTEL_VERSION)
0127     #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0128 #else
0129     #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
0130 #endif
0131
0132 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
0133     #undef JSON_HEDLEY_INTEL_CL_VERSION
0134 #endif
0135 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
0136     #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
0137 #endif
0138
0139 #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
0140     #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
0141 #endif
0142 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
0143     #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0144 #else
0145     #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
0146 #endif
0147
0148 #if defined(JSON_HEDLEY_PGI_VERSION)
0149     #undef JSON_HEDLEY_PGI_VERSION
0150 #endif
0151 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
0152     #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
0153 #endif
0154
0155 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
0156     #undef JSON_HEDLEY_PGI_VERSION_CHECK
0157 #endif
0158 #if defined(JSON_HEDLEY_PGI_VERSION)
0159     #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0160 #else
0161     #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
0162 #endif
0163
0164 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
0165     #undef JSON_HEDLEY_SUNPRO_VERSION
0166 #endif
0167 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
0168     #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)
0169 #elif defined(__SUNPRO_C)
0170     #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
0171 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
0172     #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)
0173 #elif defined(__SUNPRO_CC)
0174     #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
0175 #endif
0176
0177 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
0178     #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
0179 #endif
0180 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
0181     #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0182 #else
0183     #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
0184 #endif
0185
0186 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
0187     #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
0188 #endif
0189 #if defined(__EMSCRIPTEN__)
0190     #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
0191 #endif
0192
0193 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
0194     #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
0195 #endif
0196 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
0197     #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0198 #else
0199     #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
0200 #endif
0201
0202 #if defined(JSON_HEDLEY_ARM_VERSION)
0203     #undef JSON_HEDLEY_ARM_VERSION
0204 #endif
0205 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
0206     #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
0207 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
0208     #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
0209 #endif
0210
0211 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
0212     #undef JSON_HEDLEY_ARM_VERSION_CHECK
0213 #endif
0214 #if defined(JSON_HEDLEY_ARM_VERSION)
0215     #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0216 #else
0217     #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
0218 #endif
0219
0220 #if defined(JSON_HEDLEY_IBM_VERSION)
0221     #undef JSON_HEDLEY_IBM_VERSION
0222 #endif
0223 #if defined(__ibmxl__)
0224     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
0225 #elif defined(__xlC__) && defined(__xlC_ver__)
0226     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
0227 #elif defined(__xlC__)
0228     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
0229 #endif
0230
0231 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
0232     #undef JSON_HEDLEY_IBM_VERSION_CHECK
0233 #endif
0234 #if defined(JSON_HEDLEY_IBM_VERSION)
0235     #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0236 #else
0237     #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
0238 #endif
0239
0240 #if defined(JSON_HEDLEY_TI_VERSION)
0241     #undef JSON_HEDLEY_TI_VERSION
0242 #endif
0243 #if \
0244     defined(__TI_COMPILER_VERSION__) && \
0245     ( \
0246       defined(__TMS470__) || defined(__TI_ARM__) || \
0247       defined(__MSP430__) || \
0248       defined(__TMS320C2000__) \
0249     )
0250 #if (__TI_COMPILER_VERSION__ >= 16000000)
0251     #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
0252 #endif
0253 #endif
0254
0255 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
0256     #undef JSON_HEDLEY_TI_VERSION_CHECK
0257 #endif
0258 #if defined(JSON_HEDLEY_TI_VERSION)
0259     #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0260 #else
0261     #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
0262 #endif
0263
0264 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
0265     #undef JSON_HEDLEY_TI_CL2000_VERSION
0266 #endif
0267 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
0268     #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
0269 #endif
0270
0271 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
0272     #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
0273 #endif
0274 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
0275     #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0276 #else
0277     #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
0278 #endif
0279
0280 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
0281     #undef JSON_HEDLEY_TI_CL430_VERSION
0282 #endif
0283 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
0284     #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
0285 #endif
0286
0287 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
0288     #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
0289 #endif
0290 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
0291     #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0292 #else
0293     #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
0294 #endif
0295
0296 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
0297     #undef JSON_HEDLEY_TI_ARMCL_VERSION
0298 #endif
0299 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
0300     #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
0301 #endif
0302
0303 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
0304     #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
0305 #endif
0306 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
0307     #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0308 #else
0309     #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
0310 #endif
0311
0312 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
0313     #undef JSON_HEDLEY_TI_CL6X_VERSION
0314 #endif
0315 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
0316     #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
0317 #endif
0318
0319 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
0320     #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
0321 #endif
0322 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
0323     #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0324 #else
0325     #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
0326 #endif
0327
0328 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
0329     #undef JSON_HEDLEY_TI_CL7X_VERSION
0330 #endif
0331 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
0332     #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
0333 #endif
0334
0335 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
0336     #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
0337 #endif
0338 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
0339     #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0340 #else
0341     #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
0342 #endif
0343
0344 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
0345     #undef JSON_HEDLEY_TI_CLPRU_VERSION
0346 #endif
0347 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
0348     #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
0349 #endif
0350
0351 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
0352     #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
0353 #endif
0354 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
0355     #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0356 #else
0357     #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
0358 #endif
0359
0360 #if defined(JSON_HEDLEY_CRAY_VERSION)
0361     #undef JSON_HEDLEY_CRAY_VERSION
0362 #endif
0363 #if defined(_CRAYC)
0364     #if defined(_RELEASE_PATCHLEVEL)
0365         #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
0366     #else
0367         #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
0368     #endif
0369 #endif
0370
0371 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
0372     #undef JSON_HEDLEY_CRAY_VERSION_CHECK
0373 #endif
0374 #if defined(JSON_HEDLEY_CRAY_VERSION)
0375     #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0376 #else
0377     #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
0378 #endif
0379
0380 #if defined(JSON_HEDLEY_IAR_VERSION)
0381     #undef JSON_HEDLEY_IAR_VERSION
0382 #endif
0383 #if defined(__IAR_SYSTEMS_ICC__)
0384     #if __VER__ > 1000
0385         #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
0386     #else
0387         #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
0388     #endif
0389 #endif
0390
0391 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
0392     #undef JSON_HEDLEY_IAR_VERSION_CHECK
0393 #endif
0394 #if defined(JSON_HEDLEY_IAR_VERSION)
0395     #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0396 #else
0397     #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
0398 #endif
0399
0400 #if defined(JSON_HEDLEY_TINYC_VERSION)
0401     #undef JSON_HEDLEY_TINYC_VERSION
0402 #endif
0403 #if defined(__TINYC__)
0404     #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
0405 #endif
0406
0407 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
0408     #undef JSON_HEDLEY_TINYC_VERSION_CHECK
0409 #endif
0410 #if defined(JSON_HEDLEY_TINYC_VERSION)
0411     #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0412 #else
0413     #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
0414 #endif
0415
0416 #if defined(JSON_HEDLEY_DMC_VERSION)
0417     #undef JSON_HEDLEY_DMC_VERSION
0418 #endif
0419 #if defined(__DMC__)
0420     #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
0421 #endif
0422
0423 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
0424     #undef JSON_HEDLEY_DMC_VERSION_CHECK
0425 #endif
0426 #if defined(JSON_HEDLEY_DMC_VERSION)
0427     #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0428 #else
0429     #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
0430 #endif
0431
0432 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
0433     #undef JSON_HEDLEY_COMPCERT_VERSION
0434 #endif
0435 #if defined(__COMPCERT_VERSION__)
0436     #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
0437 #endif
0438
0439 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
0440     #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
0441 #endif
0442 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
0443     #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0444 #else
0445     #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
0446 #endif
0447
0448 #if defined(JSON_HEDLEY_PELLES_VERSION)
0449     #undef JSON_HEDLEY_PELLES_VERSION
0450 #endif
0451 #if defined(__POCC__)
0452     #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
0453 #endif
0454
0455 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
0456     #undef JSON_HEDLEY_PELLES_VERSION_CHECK
0457 #endif
0458 #if defined(JSON_HEDLEY_PELLES_VERSION)
0459     #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0460 #else
0461     #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
0462 #endif
0463
0464 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
0465     #undef JSON_HEDLEY_MCST_LCC_VERSION
0466 #endif
0467 #if defined(__LCC__) && defined(__LCC_MINOR__)
0468     #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
0469 #endif
0470
0471 #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
0472     #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
0473 #endif
0474 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
0475     #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0476 #else
0477     #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
0478 #endif
0479
0480 #if defined(JSON_HEDLEY_GCC_VERSION)
0481     #undef JSON_HEDLEY_GCC_VERSION
0482 #endif
0483 #if \
0484     defined(JSON_HEDLEY_GNUC_VERSION) && \
0485     !defined(__clang__) && \
0486     !defined(JSON_HEDLEY_INTEL_VERSION) && \
0487     !defined(JSON_HEDLEY_PGI_VERSION) && \
0488     !defined(JSON_HEDLEY_ARM_VERSION) && \
0489     !defined(JSON_HEDLEY_CRAY_VERSION) && \
0490     !defined(JSON_HEDLEY_TI_VERSION) && \
0491     !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
0492     !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
0493     !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
0494     !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
0495     !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
0496     !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
0497     !defined(__COMPCERT__) && \
0498     !defined(JSON_HEDLEY_MCST_LCC_VERSION)
0499     #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
0500 #endif
0501
0502 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
0503     #undef JSON_HEDLEY_GCC_VERSION_CHECK
0504 #endif
0505 #if defined(JSON_HEDLEY_GCC_VERSION)
0506     #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
0507 #else
0508     #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
0509 #endif
0510
0511 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
0512     #undef JSON_HEDLEY_HAS_ATTRIBUTE
0513 #endif
0514 #if \
0515   defined(__has_attribute) && \
0516   ( \
0517     (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
0518   )
0519 #  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
0520 #else
0521 #  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
0522 #endif
0523
0524 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
0525     #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
0526 #endif
0527 #if defined(__has_attribute)
0528     #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
0529 #else
0530     #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
0531 #endif
0532
0533 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
0534     #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
0535 #endif
0536 #if defined(__has_attribute)
0537     #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
0538 #else
0539     #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
0540 #endif
0541
0542 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
0543     #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
0544 #endif
0545 #if \
0546     defined(__has_cpp_attribute) && \
0547     defined(__cplusplus) && \
0548     (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
0549     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
0550 #else
0551     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
0552 #endif
0553
0554 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
0555     #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
0556 #endif
0557 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
0558     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
0559 #elif \
0560     !defined(JSON_HEDLEY_PGI_VERSION) && \
0561     !defined(JSON_HEDLEY_IAR_VERSION) && \
0562     (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
0563     (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
0564     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
0565 #else
0566     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
0567 #endif
0568
0569 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
0570     #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
0571 #endif
0572 #if defined(__has_cpp_attribute) && defined(__cplusplus)
0573     #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
0574 #else
0575     #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
0576 #endif
0577
0578 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
0579     #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
0580 #endif
0581 #if defined(__has_cpp_attribute) && defined(__cplusplus)
0582     #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
0583 #else
0584     #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
0585 #endif
0586
0587 #if defined(JSON_HEDLEY_HAS_BUILTIN)
0588     #undef JSON_HEDLEY_HAS_BUILTIN
0589 #endif
0590 #if defined(__has_builtin)
0591     #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
0592 #else
0593     #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
0594 #endif
0595
0596 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
0597     #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
0598 #endif
0599 #if defined(__has_builtin)
0600     #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
0601 #else
0602     #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
0603 #endif
0604
0605 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
0606     #undef JSON_HEDLEY_GCC_HAS_BUILTIN
0607 #endif
0608 #if defined(__has_builtin)
0609     #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
0610 #else
0611     #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
0612 #endif
0613
0614 #if defined(JSON_HEDLEY_HAS_FEATURE)
0615     #undef JSON_HEDLEY_HAS_FEATURE
0616 #endif
0617 #if defined(__has_feature)
0618     #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
0619 #else
0620     #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
0621 #endif
0622
0623 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
0624     #undef JSON_HEDLEY_GNUC_HAS_FEATURE
0625 #endif
0626 #if defined(__has_feature)
0627     #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
0628 #else
0629     #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
0630 #endif
0631
0632 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
0633     #undef JSON_HEDLEY_GCC_HAS_FEATURE
0634 #endif
0635 #if defined(__has_feature)
0636     #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
0637 #else
0638     #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
0639 #endif
0640
0641 #if defined(JSON_HEDLEY_HAS_EXTENSION)
0642     #undef JSON_HEDLEY_HAS_EXTENSION
0643 #endif
0644 #if defined(__has_extension)
0645     #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
0646 #else
0647     #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
0648 #endif
0649
0650 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
0651     #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
0652 #endif
0653 #if defined(__has_extension)
0654     #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
0655 #else
0656     #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
0657 #endif
0658
0659 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
0660     #undef JSON_HEDLEY_GCC_HAS_EXTENSION
0661 #endif
0662 #if defined(__has_extension)
0663     #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
0664 #else
0665     #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
0666 #endif
0667
0668 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
0669     #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
0670 #endif
0671 #if defined(__has_declspec_attribute)
0672     #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
0673 #else
0674     #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
0675 #endif
0676
0677 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
0678     #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
0679 #endif
0680 #if defined(__has_declspec_attribute)
0681     #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
0682 #else
0683     #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
0684 #endif
0685
0686 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
0687     #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
0688 #endif
0689 #if defined(__has_declspec_attribute)
0690     #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
0691 #else
0692     #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
0693 #endif
0694
0695 #if defined(JSON_HEDLEY_HAS_WARNING)
0696     #undef JSON_HEDLEY_HAS_WARNING
0697 #endif
0698 #if defined(__has_warning)
0699     #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
0700 #else
0701     #define JSON_HEDLEY_HAS_WARNING(warning) (0)
0702 #endif
0703
0704 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
0705     #undef JSON_HEDLEY_GNUC_HAS_WARNING
0706 #endif
0707 #if defined(__has_warning)
0708     #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
0709 #else
0710     #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
0711 #endif
0712
0713 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
0714     #undef JSON_HEDLEY_GCC_HAS_WARNING
0715 #endif
0716 #if defined(__has_warning)
0717     #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
0718 #else
0719     #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
0720 #endif
0721
0722 #if \
0723     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
0724     defined(__clang__) || \
0725     JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
0726     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
0727     JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
0728     JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
0729     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
0730     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
0731     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
0732     JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
0733     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
0734     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
0735     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
0736     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
0737     JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
0738     JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
0739     JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
0740     (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
0741     #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
0742 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
0743     #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
0744 #else
0745     #define JSON_HEDLEY_PRAGMA(value)
0746 #endif
0747
0748 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
0749     #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
0750 #endif
0751 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
0752     #undef JSON_HEDLEY_DIAGNOSTIC_POP
0753 #endif
0754 #if defined(__clang__)
0755     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
0756     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
0757 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
0758     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
0759     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
0760 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
0761     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
0762     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
0763 #elif \
0764     JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
0765     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
0766     #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
0767     #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
0768 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
0769     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
0770     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
0771 #elif \
0772     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
0773     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
0774     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
0775     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
0776     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
0777     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
0778     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
0779     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
0780 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
0781     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
0782     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
0783 #else
0784     #define JSON_HEDLEY_DIAGNOSTIC_PUSH
0785     #define JSON_HEDLEY_DIAGNOSTIC_POP
0786 #endif
0787
0788 /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
0789    HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
0790 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
0791     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
0792 #endif
0793 #if defined(__cplusplus)
0794 #  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
0795 #    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
0796 #      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
0797 #        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
0798     JSON_HEDLEY_DIAGNOSTIC_PUSH \
0799     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
0800     _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
0801     _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
0802     xpr \
0803     JSON_HEDLEY_DIAGNOSTIC_POP
0804 #      else
0805 #        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
0806     JSON_HEDLEY_DIAGNOSTIC_PUSH \
0807     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
0808     _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
0809     xpr \
0810     JSON_HEDLEY_DIAGNOSTIC_POP
0811 #      endif
0812 #    else
0813 #      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
0814     JSON_HEDLEY_DIAGNOSTIC_PUSH \
0815     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
0816     xpr \
0817     JSON_HEDLEY_DIAGNOSTIC_POP
0818 #    endif
0819 #  endif
0820 #endif
0821 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
0822     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
0823 #endif
0824
0825 #if defined(JSON_HEDLEY_CONST_CAST)
0826     #undef JSON_HEDLEY_CONST_CAST
0827 #endif
0828 #if defined(__cplusplus)
0829 #  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
0830 #elif \
0831   JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
0832   JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
0833   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
0834 #  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
0835         JSON_HEDLEY_DIAGNOSTIC_PUSH \
0836         JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
0837         ((T) (expr)); \
0838         JSON_HEDLEY_DIAGNOSTIC_POP \
0839     }))
0840 #else
0841 #  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
0842 #endif
0843
0844 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
0845     #undef JSON_HEDLEY_REINTERPRET_CAST
0846 #endif
0847 #if defined(__cplusplus)
0848     #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
0849 #else
0850     #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
0851 #endif
0852
0853 #if defined(JSON_HEDLEY_STATIC_CAST)
0854     #undef JSON_HEDLEY_STATIC_CAST
0855 #endif
0856 #if defined(__cplusplus)
0857     #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
0858 #else
0859     #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
0860 #endif
0861
0862 #if defined(JSON_HEDLEY_CPP_CAST)
0863     #undef JSON_HEDLEY_CPP_CAST
0864 #endif
0865 #if defined(__cplusplus)
0866 #  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
0867 #    define JSON_HEDLEY_CPP_CAST(T, expr) \
0868     JSON_HEDLEY_DIAGNOSTIC_PUSH \
0869     _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
0870     ((T) (expr)) \
0871     JSON_HEDLEY_DIAGNOSTIC_POP
0872 #  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
0873 #    define JSON_HEDLEY_CPP_CAST(T, expr) \
0874     JSON_HEDLEY_DIAGNOSTIC_PUSH \
0875     _Pragma("diag_suppress=Pe137") \
0876     JSON_HEDLEY_DIAGNOSTIC_POP
0877 #  else
0878 #    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
0879 #  endif
0880 #else
0881 #  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
0882 #endif
0883
0884 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
0885     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
0886 #endif
0887 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
0888     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
0889 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
0890     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
0891 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
0892     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
0893 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
0894     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
0895 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
0896     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
0897 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
0898     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
0899 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
0900     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
0901 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
0902     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
0903 #elif \
0904     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
0905     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
0906     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
0907     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
0908     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
0909     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
0910     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
0911     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
0912     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
0913     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
0914     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
0915     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
0916 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
0917     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
0918 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
0919     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
0920 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
0921     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
0922 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
0923     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
0924 #else
0925     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
0926 #endif
0927
0928 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
0929     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
0930 #endif
0931 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
0932     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
0933 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
0934     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
0935 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
0936     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
0937 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
0938     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
0939 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
0940     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
0941 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
0942     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
0943 #elif \
0944     JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
0945     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
0946     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
0947     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
0948     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
0949 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
0950     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
0951 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
0952     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
0953 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
0954     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
0955 #else
0956     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
0957 #endif
0958
0959 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
0960     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
0961 #endif
0962 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
0963     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
0964 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
0965     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
0966 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
0967     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
0968 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
0969     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
0970 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
0971     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
0972 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
0973     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
0974 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
0975     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
0976 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
0977     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
0978 #elif \
0979     JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
0980     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
0981     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
0982     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
0983 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
0984     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
0985 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
0986     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
0987 #else
0988     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
0989 #endif
0990
0991 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
0992     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
0993 #endif
0994 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
0995     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
0996 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
0997     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
0998 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
0999     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1000 #else
1001     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1002 #endif
1003
1004 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1005     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1006 #endif
1007 #if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1008     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1009 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1010     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1011 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1012     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1013 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1014     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1015 #else
1016     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1017 #endif
1018
1019 #if defined(JSON_HEDLEY_DEPRECATED)
1020     #undef JSON_HEDLEY_DEPRECATED
1021 #endif
1022 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1023     #undef JSON_HEDLEY_DEPRECATED_FOR
1024 #endif
1025 #if \
1026     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1027     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1028     #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1029     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1030 #elif \
1031     (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1032     JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1033     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1034     JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1035     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1036     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1037     JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1038     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1039     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1040     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1041     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1042     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1043     #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1044     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1045 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1046     #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1047     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1048 #elif \
1049     JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1050     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1051     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1052     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1053     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1054     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1055     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1056     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1057     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1058     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1059     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1060     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1061     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1062     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1063     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1064     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1065     #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1066     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1067 #elif \
1068     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1069     JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1070     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1071     #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1072     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1073 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1074     #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1075     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1076 #else
1077     #define JSON_HEDLEY_DEPRECATED(since)
1078     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1079 #endif
1080
1081 #if defined(JSON_HEDLEY_UNAVAILABLE)
1082     #undef JSON_HEDLEY_UNAVAILABLE
1083 #endif
1084 #if \
1085     JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1086     JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1087     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1088     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1089     #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1090 #else
1091     #define JSON_HEDLEY_UNAVAILABLE(available_since)
1092 #endif
1093
1094 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1095     #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1096 #endif
1097 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1098     #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1099 #endif
1100 #if \
1101     JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1102     JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1103     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1104     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1105     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1106     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1107     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1108     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1109     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1110     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1111     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1112     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1113     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1114     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1115     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1116     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1117     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1118     #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1119     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1120 #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1121     #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1122     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1123 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1124     #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1125     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1126 #elif defined(_Check_return_) /* SAL */
1127     #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1128     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1129 #else
1130     #define JSON_HEDLEY_WARN_UNUSED_RESULT
1131     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1132 #endif
1133
1134 #if defined(JSON_HEDLEY_SENTINEL)
1135     #undef JSON_HEDLEY_SENTINEL
1136 #endif
1137 #if \
1138     JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1139     JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1140     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1141     JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1142     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1143     #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1144 #else
1145     #define JSON_HEDLEY_SENTINEL(position)
1146 #endif
1147
1148 #if defined(JSON_HEDLEY_NO_RETURN)
1149     #undef JSON_HEDLEY_NO_RETURN
1150 #endif
1151 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1152     #define JSON_HEDLEY_NO_RETURN __noreturn
1153 #elif \
1154     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1155     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1156     #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1157 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1158     #define JSON_HEDLEY_NO_RETURN _Noreturn
1159 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1160     #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1161 #elif \
1162     JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1163     JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1164     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1165     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1166     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1167     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1168     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1169     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1170     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1171     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1172     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1173     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1174     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1175     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1176     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1177     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1178     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1179     #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1180 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1181     #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1182 #elif \
1183     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1184     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1185     #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1186 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1187     #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1188 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1189     #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1190 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1191     #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1192 #else
1193     #define JSON_HEDLEY_NO_RETURN
1194 #endif
1195
1196 #if defined(JSON_HEDLEY_NO_ESCAPE)
1197     #undef JSON_HEDLEY_NO_ESCAPE
1198 #endif
1199 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1200     #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1201 #else
1202     #define JSON_HEDLEY_NO_ESCAPE
1203 #endif
1204
1205 #if defined(JSON_HEDLEY_UNREACHABLE)
1206     #undef JSON_HEDLEY_UNREACHABLE
1207 #endif
1208 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1209     #undef JSON_HEDLEY_UNREACHABLE_RETURN
1210 #endif
1211 #if defined(JSON_HEDLEY_ASSUME)
1212     #undef JSON_HEDLEY_ASSUME
1213 #endif
1214 #if \
1215     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1216     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1217     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1218     #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1219 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1220     #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1221 #elif \
1222     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1223     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1224     #if defined(__cplusplus)
1225         #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1226     #else
1227         #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1228     #endif
1229 #endif
1230 #if \
1231     (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1232     JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1233     JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1234     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1235     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1236     JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1237     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1238     #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1239 #elif defined(JSON_HEDLEY_ASSUME)
1240     #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1241 #endif
1242 #if !defined(JSON_HEDLEY_ASSUME)
1243     #if defined(JSON_HEDLEY_UNREACHABLE)
1244         #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1245     #else
1246         #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1247     #endif
1248 #endif
1249 #if defined(JSON_HEDLEY_UNREACHABLE)
1250     #if  \
1251         JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1252         JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1253         #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1254     #else
1255         #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1256     #endif
1257 #else
1258     #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1259 #endif
1260 #if !defined(JSON_HEDLEY_UNREACHABLE)
1261     #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1262 #endif
1263
1264 JSON_HEDLEY_DIAGNOSTIC_PUSH
1265 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1266     #pragma clang diagnostic ignored "-Wpedantic"
1267 #endif
1268 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1269     #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1270 #endif
1271 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1272     #if defined(__clang__)
1273         #pragma clang diagnostic ignored "-Wvariadic-macros"
1274     #elif defined(JSON_HEDLEY_GCC_VERSION)
1275         #pragma GCC diagnostic ignored "-Wvariadic-macros"
1276     #endif
1277 #endif
1278 #if defined(JSON_HEDLEY_NON_NULL)
1279     #undef JSON_HEDLEY_NON_NULL
1280 #endif
1281 #if \
1282     JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1283     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1284     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1285     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1286     #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1287 #else
1288     #define JSON_HEDLEY_NON_NULL(...)
1289 #endif
1290 JSON_HEDLEY_DIAGNOSTIC_POP
1291
1292 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1293     #undef JSON_HEDLEY_PRINTF_FORMAT
1294 #endif
1295 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1296     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1297 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1298     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1299 #elif \
1300     JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1301     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1302     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1303     JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1304     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1305     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1306     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1307     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1308     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1309     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1310     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1311     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1312     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1313     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1314     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1315     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1316     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1317     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1318 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1319     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1320 #else
1321     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1322 #endif
1323
1324 #if defined(JSON_HEDLEY_CONSTEXPR)
1325     #undef JSON_HEDLEY_CONSTEXPR
1326 #endif
1327 #if defined(__cplusplus)
1328     #if __cplusplus >= 201103L
1329         #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1330     #endif
1331 #endif
1332 #if !defined(JSON_HEDLEY_CONSTEXPR)
1333     #define JSON_HEDLEY_CONSTEXPR
1334 #endif
1335
1336 #if defined(JSON_HEDLEY_PREDICT)
1337     #undef JSON_HEDLEY_PREDICT
1338 #endif
1339 #if defined(JSON_HEDLEY_LIKELY)
1340     #undef JSON_HEDLEY_LIKELY
1341 #endif
1342 #if defined(JSON_HEDLEY_UNLIKELY)
1343     #undef JSON_HEDLEY_UNLIKELY
1344 #endif
1345 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1346     #undef JSON_HEDLEY_UNPREDICTABLE
1347 #endif
1348 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1349     #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1350 #endif
1351 #if \
1352   (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1353   JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1354   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1355 #  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
1356 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
1357 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
1358 #  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
1359 #  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
1360 #elif \
1361   (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1362   JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1363   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1364   (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1365   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1366   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1367   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1368   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1369   JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1370   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1371   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1372   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1373   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1374   JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1375   JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1376   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1377 #  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1378     (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1379 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1380     (__extension__ ({ \
1381         double hedley_probability_ = (probability); \
1382         ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1383     }))
1384 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1385     (__extension__ ({ \
1386         double hedley_probability_ = (probability); \
1387         ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1388     }))
1389 #  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
1390 #  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1391 #else
1392 #  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1393 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1394 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1395 #  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1396 #  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1397 #endif
1398 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1399     #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1400 #endif
1401
1402 #if defined(JSON_HEDLEY_MALLOC)
1403     #undef JSON_HEDLEY_MALLOC
1404 #endif
1405 #if \
1406     JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1407     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1408     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1409     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1410     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1411     JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1412     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1413     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1414     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1415     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1416     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1417     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1418     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1419     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1420     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1421     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1422     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1423     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1424     #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1425 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1426     #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1427 #elif \
1428     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1429     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1430     #define JSON_HEDLEY_MALLOC __declspec(restrict)
1431 #else
1432     #define JSON_HEDLEY_MALLOC
1433 #endif
1434
1435 #if defined(JSON_HEDLEY_PURE)
1436     #undef JSON_HEDLEY_PURE
1437 #endif
1438 #if \
1439   JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1440   JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1441   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1442   JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1443   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1444   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1445   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1446   (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1447   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1448   (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1449   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1450   (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1451   JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1452   (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1453   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1454   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1455   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1456   JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1457   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1458 #  define JSON_HEDLEY_PURE __attribute__((__pure__))
1459 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1460 #  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1461 #elif defined(__cplusplus) && \
1462     ( \
1463       JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1464       JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1465       JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1466     )
1467 #  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1468 #else
1469 #  define JSON_HEDLEY_PURE
1470 #endif
1471
1472 #if defined(JSON_HEDLEY_CONST)
1473     #undef JSON_HEDLEY_CONST
1474 #endif
1475 #if \
1476     JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1477     JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1478     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1479     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1480     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1481     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1482     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1483     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1484     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1485     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1486     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1487     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1488     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1489     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1490     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1491     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1492     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1493     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1494     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1495     #define JSON_HEDLEY_CONST __attribute__((__const__))
1496 #elif \
1497     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1498     #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1499 #else
1500     #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1501 #endif
1502
1503 #if defined(JSON_HEDLEY_RESTRICT)
1504     #undef JSON_HEDLEY_RESTRICT
1505 #endif
1506 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1507     #define JSON_HEDLEY_RESTRICT restrict
1508 #elif \
1509     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1510     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1511     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1512     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1513     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1514     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1515     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1516     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1517     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1518     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1519     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1520     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1521     JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1522     defined(__clang__) || \
1523     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1524     #define JSON_HEDLEY_RESTRICT __restrict
1525 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1526     #define JSON_HEDLEY_RESTRICT _Restrict
1527 #else
1528     #define JSON_HEDLEY_RESTRICT
1529 #endif
1530
1531 #if defined(JSON_HEDLEY_INLINE)
1532     #undef JSON_HEDLEY_INLINE
1533 #endif
1534 #if \
1535     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1536     (defined(__cplusplus) && (__cplusplus >= 199711L))
1537     #define JSON_HEDLEY_INLINE inline
1538 #elif \
1539     defined(JSON_HEDLEY_GCC_VERSION) || \
1540     JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1541     #define JSON_HEDLEY_INLINE __inline__
1542 #elif \
1543     JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1544     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1545     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1546     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1547     JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1548     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1549     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1550     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1551     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1552     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1553     #define JSON_HEDLEY_INLINE __inline
1554 #else
1555     #define JSON_HEDLEY_INLINE
1556 #endif
1557
1558 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1559     #undef JSON_HEDLEY_ALWAYS_INLINE
1560 #endif
1561 #if \
1562   JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1563   JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1564   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1565   JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1566   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1567   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1568   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1569   (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1570   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1571   (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1572   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1573   (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1574   JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1575   (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1576   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1577   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1578   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1579   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1580   JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1581 #  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1582 #elif \
1583   JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1584   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1585 #  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1586 #elif defined(__cplusplus) && \
1587     ( \
1588       JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1589       JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1590       JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1591       JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1592       JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1593       JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1594     )
1595 #  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1596 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1597 #  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1598 #else
1599 #  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1600 #endif
1601
1602 #if defined(JSON_HEDLEY_NEVER_INLINE)
1603     #undef JSON_HEDLEY_NEVER_INLINE
1604 #endif
1605 #if \
1606     JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1607     JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1608     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1609     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1610     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1611     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1612     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1613     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1614     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1615     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1616     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1617     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1618     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1619     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1620     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1621     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1622     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1623     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1624     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1625     #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1626 #elif \
1627     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1628     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1629     #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1630 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1631     #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1632 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1633     #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1634 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1635     #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1636 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1637     #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1638 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1639     #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1640 #else
1641     #define JSON_HEDLEY_NEVER_INLINE
1642 #endif
1643
1644 #if defined(JSON_HEDLEY_PRIVATE)
1645     #undef JSON_HEDLEY_PRIVATE
1646 #endif
1647 #if defined(JSON_HEDLEY_PUBLIC)
1648     #undef JSON_HEDLEY_PUBLIC
1649 #endif
1650 #if defined(JSON_HEDLEY_IMPORT)
1651     #undef JSON_HEDLEY_IMPORT
1652 #endif
1653 #if defined(_WIN32) || defined(__CYGWIN__)
1654 #  define JSON_HEDLEY_PRIVATE
1655 #  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
1656 #  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
1657 #else
1658 #  if \
1659     JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1660     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1661     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1662     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1663     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1664     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1665     ( \
1666       defined(__TI_EABI__) && \
1667       ( \
1668         (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1669         JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1670       ) \
1671     ) || \
1672     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1673 #    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1674 #    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
1675 #  else
1676 #    define JSON_HEDLEY_PRIVATE
1677 #    define JSON_HEDLEY_PUBLIC
1678 #  endif
1679 #  define JSON_HEDLEY_IMPORT    extern
1680 #endif
1681
1682 #if defined(JSON_HEDLEY_NO_THROW)
1683     #undef JSON_HEDLEY_NO_THROW
1684 #endif
1685 #if \
1686     JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1687     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1688     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1689     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1690     #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1691 #elif \
1692     JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1693     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1694     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1695     #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1696 #else
1697     #define JSON_HEDLEY_NO_THROW
1698 #endif
1699
1700 #if defined(JSON_HEDLEY_FALL_THROUGH)
1701     #undef JSON_HEDLEY_FALL_THROUGH
1702 #endif
1703 #if \
1704     JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1705     JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
1706     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1707     #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1708 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1709     #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1710 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1711     #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1712 #elif defined(__fallthrough) /* SAL */
1713     #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1714 #else
1715     #define JSON_HEDLEY_FALL_THROUGH
1716 #endif
1717
1718 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1719     #undef JSON_HEDLEY_RETURNS_NON_NULL
1720 #endif
1721 #if \
1722     JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1723     JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1724     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1725     #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1726 #elif defined(_Ret_notnull_) /* SAL */
1727     #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1728 #else
1729     #define JSON_HEDLEY_RETURNS_NON_NULL
1730 #endif
1731
1732 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1733     #undef JSON_HEDLEY_ARRAY_PARAM
1734 #endif
1735 #if \
1736     defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1737     !defined(__STDC_NO_VLA__) && \
1738     !defined(__cplusplus) && \
1739     !defined(JSON_HEDLEY_PGI_VERSION) && \
1740     !defined(JSON_HEDLEY_TINYC_VERSION)
1741     #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1742 #else
1743     #define JSON_HEDLEY_ARRAY_PARAM(name)
1744 #endif
1745
1746 #if defined(JSON_HEDLEY_IS_CONSTANT)
1747     #undef JSON_HEDLEY_IS_CONSTANT
1748 #endif
1749 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1750     #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1751 #endif
1752 /* JSON_HEDLEY_IS_CONSTEXPR_ is for
1753    HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
1754 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1755     #undef JSON_HEDLEY_IS_CONSTEXPR_
1756 #endif
1757 #if \
1758     JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1759     JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1760     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1761     JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1762     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1763     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1764     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1765     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1766     JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1767     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1768     #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1769 #endif
1770 #if !defined(__cplusplus)
1771 #  if \
1772        JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1773        JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1774        JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1775        JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1776        JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1777        JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1778        JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1779 #if defined(__INTPTR_TYPE__)
1780     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1781 #else
1782     #include <stdint.h>
1783     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1784 #endif
1785 #  elif \
1786        ( \
1787           defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1788           !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1789           !defined(JSON_HEDLEY_PGI_VERSION) && \
1790           !defined(JSON_HEDLEY_IAR_VERSION)) || \
1791        (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1792        JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1793        JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1794        JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1795        JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1796 #if defined(__INTPTR_TYPE__)
1797     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1798 #else
1799     #include <stdint.h>
1800     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1801 #endif
1802 #  elif \
1803        defined(JSON_HEDLEY_GCC_VERSION) || \
1804        defined(JSON_HEDLEY_INTEL_VERSION) || \
1805        defined(JSON_HEDLEY_TINYC_VERSION) || \
1806        defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1807        JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1808        defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1809        defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1810        defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1811        defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1812        defined(__clang__)
1813 #    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1814         sizeof(void) != \
1815         sizeof(*( \
1816                   1 ? \
1817                   ((void*) ((expr) * 0L) ) : \
1818 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1819                 ) \
1820               ) \
1821                                             )
1822 #  endif
1823 #endif
1824 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1825     #if !defined(JSON_HEDLEY_IS_CONSTANT)
1826         #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1827     #endif
1828     #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1829 #else
1830     #if !defined(JSON_HEDLEY_IS_CONSTANT)
1831         #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1832     #endif
1833     #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1834 #endif
1835
1836 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1837     #undef JSON_HEDLEY_BEGIN_C_DECLS
1838 #endif
1839 #if defined(JSON_HEDLEY_END_C_DECLS)
1840     #undef JSON_HEDLEY_END_C_DECLS
1841 #endif
1842 #if defined(JSON_HEDLEY_C_DECL)
1843     #undef JSON_HEDLEY_C_DECL
1844 #endif
1845 #if defined(__cplusplus)
1846     #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
1847     #define JSON_HEDLEY_END_C_DECLS }
1848     #define JSON_HEDLEY_C_DECL extern "C"
1849 #else
1850     #define JSON_HEDLEY_BEGIN_C_DECLS
1851     #define JSON_HEDLEY_END_C_DECLS
1852     #define JSON_HEDLEY_C_DECL
1853 #endif
1854
1855 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1856     #undef JSON_HEDLEY_STATIC_ASSERT
1857 #endif
1858 #if \
1859   !defined(__cplusplus) && ( \
1860       (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1861       (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1862       JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
1863       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1864       defined(_Static_assert) \
1865     )
1866 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1867 #elif \
1868   (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
1869   JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
1870   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1871 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1872 #else
1873 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1874 #endif
1875
1876 #if defined(JSON_HEDLEY_NULL)
1877     #undef JSON_HEDLEY_NULL
1878 #endif
1879 #if defined(__cplusplus)
1880     #if __cplusplus >= 201103L
1881         #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1882     #elif defined(NULL)
1883         #define JSON_HEDLEY_NULL NULL
1884     #else
1885         #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1886     #endif
1887 #elif defined(NULL)
1888     #define JSON_HEDLEY_NULL NULL
1889 #else
1890     #define JSON_HEDLEY_NULL ((void*) 0)
1891 #endif
1892
1893 #if defined(JSON_HEDLEY_MESSAGE)
1894     #undef JSON_HEDLEY_MESSAGE
1895 #endif
1896 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1897 #  define JSON_HEDLEY_MESSAGE(msg) \
1898     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1899     JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1900     JSON_HEDLEY_PRAGMA(message msg) \
1901     JSON_HEDLEY_DIAGNOSTIC_POP
1902 #elif \
1903   JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
1904   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1905 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
1906 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
1907 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
1908 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1909 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1910 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
1911 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1912 #else
1913 #  define JSON_HEDLEY_MESSAGE(msg)
1914 #endif
1915
1916 #if defined(JSON_HEDLEY_WARNING)
1917     #undef JSON_HEDLEY_WARNING
1918 #endif
1919 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1920 #  define JSON_HEDLEY_WARNING(msg) \
1921     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1922     JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1923     JSON_HEDLEY_PRAGMA(clang warning msg) \
1924     JSON_HEDLEY_DIAGNOSTIC_POP
1925 #elif \
1926   JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
1927   JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1928   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1929 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
1930 #elif \
1931   JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
1932   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1933 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
1934 #else
1935 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1936 #endif
1937
1938 #if defined(JSON_HEDLEY_REQUIRE)
1939     #undef JSON_HEDLEY_REQUIRE
1940 #endif
1941 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1942     #undef JSON_HEDLEY_REQUIRE_MSG
1943 #endif
1944 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1945 #  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
1946 #    define JSON_HEDLEY_REQUIRE(expr) \
1947     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1948     _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1949     __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1950     JSON_HEDLEY_DIAGNOSTIC_POP
1951 #    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
1952     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1953     _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1954     __attribute__((diagnose_if(!(expr), msg, "error"))) \
1955     JSON_HEDLEY_DIAGNOSTIC_POP
1956 #  else
1957 #    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1958 #    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1959 #  endif
1960 #else
1961 #  define JSON_HEDLEY_REQUIRE(expr)
1962 #  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1963 #endif
1964
1965 #if defined(JSON_HEDLEY_FLAGS)
1966     #undef JSON_HEDLEY_FLAGS
1967 #endif
1968 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
1969     #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1970 #else
1971     #define JSON_HEDLEY_FLAGS
1972 #endif
1973
1974 #if defined(JSON_HEDLEY_FLAGS_CAST)
1975     #undef JSON_HEDLEY_FLAGS_CAST
1976 #endif
1977 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
1978 #  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
1979         JSON_HEDLEY_DIAGNOSTIC_PUSH \
1980         _Pragma("warning(disable:188)") \
1981         ((T) (expr)); \
1982         JSON_HEDLEY_DIAGNOSTIC_POP \
1983     }))
1984 #else
1985 #  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1986 #endif
1987
1988 #if defined(JSON_HEDLEY_EMPTY_BASES)
1989     #undef JSON_HEDLEY_EMPTY_BASES
1990 #endif
1991 #if \
1992     (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
1993     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1994     #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
1995 #else
1996     #define JSON_HEDLEY_EMPTY_BASES
1997 #endif
1998
1999 /* Remaining macros are deprecated. */
2000
2001 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2002     #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2003 #endif
2004 #if defined(__clang__)
2005     #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2006 #else
2007     #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2008 #endif
2009
2010 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2011     #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2012 #endif
2013 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2014
2015 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2016     #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2017 #endif
2018 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2019
2020 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2021     #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2022 #endif
2023 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2024
2025 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2026     #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2027 #endif
2028 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2029
2030 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2031     #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2032 #endif
2033 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2034
2035 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2036     #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2037 #endif
2038 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2039
2040 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2041     #undef JSON_HEDLEY_CLANG_HAS_WARNING
2042 #endif
2043 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2044
2045 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */