ceph/src/jaegertracing/opentelemetry-cpp/third_party/nlohmann-json/include/nlohmann/thirdparty/hedley/hedley.hpp

   1 #pragma once
   2
   3 /* Hedley - https://nemequ.github.io/hedley
   4  * Created by Evan Nemerson <evan@nemerson.com>
   5  *
   6  * To the extent possible under law, the author(s) have dedicated all
   7  * copyright and related and neighboring rights to this software to
   8  * the public domain worldwide. This software is distributed without
   9  * any warranty.
  10  *
  11  * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
  12  * SPDX-License-Identifier: CC0-1.0
  13  */
  14
  15 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
  16 #if defined(JSON_HEDLEY_VERSION)
  17     #undef JSON_HEDLEY_VERSION
  18 #endif
  19 #define JSON_HEDLEY_VERSION 15
  20
  21 #if defined(JSON_HEDLEY_STRINGIFY_EX)
  22     #undef JSON_HEDLEY_STRINGIFY_EX
  23 #endif
  24 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
  25
  26 #if defined(JSON_HEDLEY_STRINGIFY)
  27     #undef JSON_HEDLEY_STRINGIFY
  28 #endif
  29 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
  30
  31 #if defined(JSON_HEDLEY_CONCAT_EX)
  32     #undef JSON_HEDLEY_CONCAT_EX
  33 #endif
  34 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
  35
  36 #if defined(JSON_HEDLEY_CONCAT)
  37     #undef JSON_HEDLEY_CONCAT
  38 #endif
  39 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
  40
  41 #if defined(JSON_HEDLEY_CONCAT3_EX)
  42     #undef JSON_HEDLEY_CONCAT3_EX
  43 #endif
  44 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
  45
  46 #if defined(JSON_HEDLEY_CONCAT3)
  47     #undef JSON_HEDLEY_CONCAT3
  48 #endif
  49 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
  50
  51 #if defined(JSON_HEDLEY_VERSION_ENCODE)
  52     #undef JSON_HEDLEY_VERSION_ENCODE
  53 #endif
  54 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
  55
  56 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
  57     #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
  58 #endif
  59 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
  60
  61 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
  62     #undef JSON_HEDLEY_VERSION_DECODE_MINOR
  63 #endif
  64 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
  65
  66 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
  67     #undef JSON_HEDLEY_VERSION_DECODE_REVISION
  68 #endif
  69 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
  70
  71 #if defined(JSON_HEDLEY_GNUC_VERSION)
  72     #undef JSON_HEDLEY_GNUC_VERSION
  73 #endif
  74 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
  75     #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
  76 #elif defined(__GNUC__)
  77     #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
  78 #endif
  79
  80 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
  81     #undef JSON_HEDLEY_GNUC_VERSION_CHECK
  82 #endif
  83 #if defined(JSON_HEDLEY_GNUC_VERSION)
  84     #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
  85 #else
  86     #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
  87 #endif
  88
  89 #if defined(JSON_HEDLEY_MSVC_VERSION)
  90     #undef JSON_HEDLEY_MSVC_VERSION
  91 #endif
  92 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
  93     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
  94 #elif defined(_MSC_FULL_VER) && !defined(__ICL)
  95     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
  96 #elif defined(_MSC_VER) && !defined(__ICL)
  97     #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
  98 #endif
  99
 100 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
 101     #undef JSON_HEDLEY_MSVC_VERSION_CHECK
 102 #endif
 103 #if !defined(JSON_HEDLEY_MSVC_VERSION)
 104     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
 105 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
 106     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
 107 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
 108     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
 109 #else
 110     #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
 111 #endif
 112
 113 #if defined(JSON_HEDLEY_INTEL_VERSION)
 114     #undef JSON_HEDLEY_INTEL_VERSION
 115 #endif
 116 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
 117     #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
 118 #elif defined(__INTEL_COMPILER) && !defined(__ICL)
 119     #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
 120 #endif
 121
 122 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
 123     #undef JSON_HEDLEY_INTEL_VERSION_CHECK
 124 #endif
 125 #if defined(JSON_HEDLEY_INTEL_VERSION)
 126     #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 127 #else
 128     #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
 129 #endif
 130
 131 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
 132     #undef JSON_HEDLEY_INTEL_CL_VERSION
 133 #endif
 134 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
 135     #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
 136 #endif
 137
 138 #if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
 139     #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
 140 #endif
 141 #if defined(JSON_HEDLEY_INTEL_CL_VERSION)
 142     #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 143 #else
 144     #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
 145 #endif
 146
 147 #if defined(JSON_HEDLEY_PGI_VERSION)
 148     #undef JSON_HEDLEY_PGI_VERSION
 149 #endif
 150 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
 151     #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
 152 #endif
 153
 154 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
 155     #undef JSON_HEDLEY_PGI_VERSION_CHECK
 156 #endif
 157 #if defined(JSON_HEDLEY_PGI_VERSION)
 158     #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 159 #else
 160     #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
 161 #endif
 162
 163 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
 164     #undef JSON_HEDLEY_SUNPRO_VERSION
 165 #endif
 166 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
 167     #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)
 168 #elif defined(__SUNPRO_C)
 169     #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
 170 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
 171     #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)
 172 #elif defined(__SUNPRO_CC)
 173     #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
 174 #endif
 175
 176 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
 177     #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
 178 #endif
 179 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
 180     #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 181 #else
 182     #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
 183 #endif
 184
 185 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
 186     #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
 187 #endif
 188 #if defined(__EMSCRIPTEN__)
 189     #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
 190 #endif
 191
 192 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
 193     #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
 194 #endif
 195 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
 196     #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 197 #else
 198     #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
 199 #endif
 200
 201 #if defined(JSON_HEDLEY_ARM_VERSION)
 202     #undef JSON_HEDLEY_ARM_VERSION
 203 #endif
 204 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
 205     #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
 206 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
 207     #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
 208 #endif
 209
 210 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
 211     #undef JSON_HEDLEY_ARM_VERSION_CHECK
 212 #endif
 213 #if defined(JSON_HEDLEY_ARM_VERSION)
 214     #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 215 #else
 216     #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
 217 #endif
 218
 219 #if defined(JSON_HEDLEY_IBM_VERSION)
 220     #undef JSON_HEDLEY_IBM_VERSION
 221 #endif
 222 #if defined(__ibmxl__)
 223     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
 224 #elif defined(__xlC__) && defined(__xlC_ver__)
 225     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
 226 #elif defined(__xlC__)
 227     #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
 228 #endif
 229
 230 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
 231     #undef JSON_HEDLEY_IBM_VERSION_CHECK
 232 #endif
 233 #if defined(JSON_HEDLEY_IBM_VERSION)
 234     #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 235 #else
 236     #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
 237 #endif
 238
 239 #if defined(JSON_HEDLEY_TI_VERSION)
 240     #undef JSON_HEDLEY_TI_VERSION
 241 #endif
 242 #if \
 243     defined(__TI_COMPILER_VERSION__) && \
 244     ( \
 245       defined(__TMS470__) || defined(__TI_ARM__) || \
 246       defined(__MSP430__) || \
 247       defined(__TMS320C2000__) \
 248     )
 249 #if (__TI_COMPILER_VERSION__ >= 16000000)
 250     #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 251 #endif
 252 #endif
 253
 254 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
 255     #undef JSON_HEDLEY_TI_VERSION_CHECK
 256 #endif
 257 #if defined(JSON_HEDLEY_TI_VERSION)
 258     #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 259 #else
 260     #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
 261 #endif
 262
 263 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
 264     #undef JSON_HEDLEY_TI_CL2000_VERSION
 265 #endif
 266 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
 267     #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 268 #endif
 269
 270 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
 271     #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
 272 #endif
 273 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
 274     #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 275 #else
 276     #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
 277 #endif
 278
 279 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
 280     #undef JSON_HEDLEY_TI_CL430_VERSION
 281 #endif
 282 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
 283     #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 284 #endif
 285
 286 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
 287     #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
 288 #endif
 289 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
 290     #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 291 #else
 292     #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
 293 #endif
 294
 295 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
 296     #undef JSON_HEDLEY_TI_ARMCL_VERSION
 297 #endif
 298 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
 299     #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 300 #endif
 301
 302 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
 303     #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
 304 #endif
 305 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
 306     #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 307 #else
 308     #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
 309 #endif
 310
 311 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
 312     #undef JSON_HEDLEY_TI_CL6X_VERSION
 313 #endif
 314 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
 315     #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 316 #endif
 317
 318 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
 319     #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
 320 #endif
 321 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
 322     #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 323 #else
 324     #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
 325 #endif
 326
 327 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
 328     #undef JSON_HEDLEY_TI_CL7X_VERSION
 329 #endif
 330 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
 331     #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 332 #endif
 333
 334 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
 335     #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
 336 #endif
 337 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
 338     #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 339 #else
 340     #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
 341 #endif
 342
 343 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
 344     #undef JSON_HEDLEY_TI_CLPRU_VERSION
 345 #endif
 346 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
 347     #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
 348 #endif
 349
 350 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
 351     #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
 352 #endif
 353 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
 354     #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 355 #else
 356     #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
 357 #endif
 358
 359 #if defined(JSON_HEDLEY_CRAY_VERSION)
 360     #undef JSON_HEDLEY_CRAY_VERSION
 361 #endif
 362 #if defined(_CRAYC)
 363     #if defined(_RELEASE_PATCHLEVEL)
 364         #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
 365     #else
 366         #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
 367     #endif
 368 #endif
 369
 370 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
 371     #undef JSON_HEDLEY_CRAY_VERSION_CHECK
 372 #endif
 373 #if defined(JSON_HEDLEY_CRAY_VERSION)
 374     #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 375 #else
 376     #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
 377 #endif
 378
 379 #if defined(JSON_HEDLEY_IAR_VERSION)
 380     #undef JSON_HEDLEY_IAR_VERSION
 381 #endif
 382 #if defined(__IAR_SYSTEMS_ICC__)
 383     #if __VER__ > 1000
 384         #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
 385     #else
 386         #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
 387     #endif
 388 #endif
 389
 390 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
 391     #undef JSON_HEDLEY_IAR_VERSION_CHECK
 392 #endif
 393 #if defined(JSON_HEDLEY_IAR_VERSION)
 394     #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 395 #else
 396     #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
 397 #endif
 398
 399 #if defined(JSON_HEDLEY_TINYC_VERSION)
 400     #undef JSON_HEDLEY_TINYC_VERSION
 401 #endif
 402 #if defined(__TINYC__)
 403     #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
 404 #endif
 405
 406 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
 407     #undef JSON_HEDLEY_TINYC_VERSION_CHECK
 408 #endif
 409 #if defined(JSON_HEDLEY_TINYC_VERSION)
 410     #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 411 #else
 412     #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
 413 #endif
 414
 415 #if defined(JSON_HEDLEY_DMC_VERSION)
 416     #undef JSON_HEDLEY_DMC_VERSION
 417 #endif
 418 #if defined(__DMC__)
 419     #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
 420 #endif
 421
 422 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
 423     #undef JSON_HEDLEY_DMC_VERSION_CHECK
 424 #endif
 425 #if defined(JSON_HEDLEY_DMC_VERSION)
 426     #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 427 #else
 428     #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
 429 #endif
 430
 431 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
 432     #undef JSON_HEDLEY_COMPCERT_VERSION
 433 #endif
 434 #if defined(__COMPCERT_VERSION__)
 435     #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
 436 #endif
 437
 438 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
 439     #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
 440 #endif
 441 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
 442     #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 443 #else
 444     #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
 445 #endif
 446
 447 #if defined(JSON_HEDLEY_PELLES_VERSION)
 448     #undef JSON_HEDLEY_PELLES_VERSION
 449 #endif
 450 #if defined(__POCC__)
 451     #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
 452 #endif
 453
 454 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
 455     #undef JSON_HEDLEY_PELLES_VERSION_CHECK
 456 #endif
 457 #if defined(JSON_HEDLEY_PELLES_VERSION)
 458     #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 459 #else
 460     #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
 461 #endif
 462
 463 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
 464     #undef JSON_HEDLEY_MCST_LCC_VERSION
 465 #endif
 466 #if defined(__LCC__) && defined(__LCC_MINOR__)
 467     #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
 468 #endif
 469
 470 #if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
 471     #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
 472 #endif
 473 #if defined(JSON_HEDLEY_MCST_LCC_VERSION)
 474     #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 475 #else
 476     #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
 477 #endif
 478
 479 #if defined(JSON_HEDLEY_GCC_VERSION)
 480     #undef JSON_HEDLEY_GCC_VERSION
 481 #endif
 482 #if \
 483     defined(JSON_HEDLEY_GNUC_VERSION) && \
 484     !defined(__clang__) && \
 485     !defined(JSON_HEDLEY_INTEL_VERSION) && \
 486     !defined(JSON_HEDLEY_PGI_VERSION) && \
 487     !defined(JSON_HEDLEY_ARM_VERSION) && \
 488     !defined(JSON_HEDLEY_CRAY_VERSION) && \
 489     !defined(JSON_HEDLEY_TI_VERSION) && \
 490     !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
 491     !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
 492     !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
 493     !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
 494     !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
 495     !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
 496     !defined(__COMPCERT__) && \
 497     !defined(JSON_HEDLEY_MCST_LCC_VERSION)
 498     #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
 499 #endif
 500
 501 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
 502     #undef JSON_HEDLEY_GCC_VERSION_CHECK
 503 #endif
 504 #if defined(JSON_HEDLEY_GCC_VERSION)
 505     #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
 506 #else
 507     #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
 508 #endif
 509
 510 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
 511     #undef JSON_HEDLEY_HAS_ATTRIBUTE
 512 #endif
 513 #if \
 514   defined(__has_attribute) && \
 515   ( \
 516     (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
 517   )
 518 #  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
 519 #else
 520 #  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
 521 #endif
 522
 523 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
 524     #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
 525 #endif
 526 #if defined(__has_attribute)
 527     #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
 528 #else
 529     #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 530 #endif
 531
 532 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
 533     #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
 534 #endif
 535 #if defined(__has_attribute)
 536     #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
 537 #else
 538     #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 539 #endif
 540
 541 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
 542     #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
 543 #endif
 544 #if \
 545     defined(__has_cpp_attribute) && \
 546     defined(__cplusplus) && \
 547     (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
 548     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
 549 #else
 550     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
 551 #endif
 552
 553 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
 554     #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
 555 #endif
 556 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
 557     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
 558 #elif \
 559     !defined(JSON_HEDLEY_PGI_VERSION) && \
 560     !defined(JSON_HEDLEY_IAR_VERSION) && \
 561     (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
 562     (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
 563     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
 564 #else
 565     #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
 566 #endif
 567
 568 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
 569     #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
 570 #endif
 571 #if defined(__has_cpp_attribute) && defined(__cplusplus)
 572     #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
 573 #else
 574     #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 575 #endif
 576
 577 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
 578     #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
 579 #endif
 580 #if defined(__has_cpp_attribute) && defined(__cplusplus)
 581     #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
 582 #else
 583     #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 584 #endif
 585
 586 #if defined(JSON_HEDLEY_HAS_BUILTIN)
 587     #undef JSON_HEDLEY_HAS_BUILTIN
 588 #endif
 589 #if defined(__has_builtin)
 590     #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
 591 #else
 592     #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
 593 #endif
 594
 595 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
 596     #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
 597 #endif
 598 #if defined(__has_builtin)
 599     #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
 600 #else
 601     #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 602 #endif
 603
 604 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
 605     #undef JSON_HEDLEY_GCC_HAS_BUILTIN
 606 #endif
 607 #if defined(__has_builtin)
 608     #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
 609 #else
 610     #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 611 #endif
 612
 613 #if defined(JSON_HEDLEY_HAS_FEATURE)
 614     #undef JSON_HEDLEY_HAS_FEATURE
 615 #endif
 616 #if defined(__has_feature)
 617     #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
 618 #else
 619     #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
 620 #endif
 621
 622 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
 623     #undef JSON_HEDLEY_GNUC_HAS_FEATURE
 624 #endif
 625 #if defined(__has_feature)
 626     #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
 627 #else
 628     #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 629 #endif
 630
 631 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
 632     #undef JSON_HEDLEY_GCC_HAS_FEATURE
 633 #endif
 634 #if defined(__has_feature)
 635     #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
 636 #else
 637     #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 638 #endif
 639
 640 #if defined(JSON_HEDLEY_HAS_EXTENSION)
 641     #undef JSON_HEDLEY_HAS_EXTENSION
 642 #endif
 643 #if defined(__has_extension)
 644     #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
 645 #else
 646     #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
 647 #endif
 648
 649 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
 650     #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
 651 #endif
 652 #if defined(__has_extension)
 653     #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
 654 #else
 655     #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 656 #endif
 657
 658 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
 659     #undef JSON_HEDLEY_GCC_HAS_EXTENSION
 660 #endif
 661 #if defined(__has_extension)
 662     #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
 663 #else
 664     #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 665 #endif
 666
 667 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
 668     #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
 669 #endif
 670 #if defined(__has_declspec_attribute)
 671     #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
 672 #else
 673     #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
 674 #endif
 675
 676 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
 677     #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
 678 #endif
 679 #if defined(__has_declspec_attribute)
 680     #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
 681 #else
 682     #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 683 #endif
 684
 685 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
 686     #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
 687 #endif
 688 #if defined(__has_declspec_attribute)
 689     #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
 690 #else
 691     #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 692 #endif
 693
 694 #if defined(JSON_HEDLEY_HAS_WARNING)
 695     #undef JSON_HEDLEY_HAS_WARNING
 696 #endif
 697 #if defined(__has_warning)
 698     #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
 699 #else
 700     #define JSON_HEDLEY_HAS_WARNING(warning) (0)
 701 #endif
 702
 703 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
 704     #undef JSON_HEDLEY_GNUC_HAS_WARNING
 705 #endif
 706 #if defined(__has_warning)
 707     #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
 708 #else
 709     #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
 710 #endif
 711
 712 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
 713     #undef JSON_HEDLEY_GCC_HAS_WARNING
 714 #endif
 715 #if defined(__has_warning)
 716     #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
 717 #else
 718     #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
 719 #endif
 720
 721 #if \
 722     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
 723     defined(__clang__) || \
 724     JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
 725     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
 726     JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
 727     JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
 728     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
 729     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
 730     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
 731     JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
 732     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
 733     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
 734     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
 735     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
 736     JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
 737     JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
 738     JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
 739     (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
 740     #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
 741 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
 742     #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
 743 #else
 744     #define JSON_HEDLEY_PRAGMA(value)
 745 #endif
 746
 747 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
 748     #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
 749 #endif
 750 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
 751     #undef JSON_HEDLEY_DIAGNOSTIC_POP
 752 #endif
 753 #if defined(__clang__)
 754     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
 755     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
 756 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
 757     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
 758     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
 759 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
 760     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
 761     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
 762 #elif \
 763     JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
 764     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
 765     #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
 766     #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
 767 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
 768     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
 769     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
 770 #elif \
 771     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
 772     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
 773     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
 774     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
 775     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
 776     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
 777     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
 778     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
 779 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
 780     #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
 781     #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
 782 #else
 783     #define JSON_HEDLEY_DIAGNOSTIC_PUSH
 784     #define JSON_HEDLEY_DIAGNOSTIC_POP
 785 #endif
 786
 787 /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
 788    HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
 789 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
 790     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
 791 #endif
 792 #if defined(__cplusplus)
 793 #  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
 794 #    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
 795 #      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
 796 #        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
 797     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 798     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
 799     _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
 800     _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
 801     xpr \
 802     JSON_HEDLEY_DIAGNOSTIC_POP
 803 #      else
 804 #        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
 805     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 806     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
 807     _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
 808     xpr \
 809     JSON_HEDLEY_DIAGNOSTIC_POP
 810 #      endif
 811 #    else
 812 #      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
 813     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 814     _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
 815     xpr \
 816     JSON_HEDLEY_DIAGNOSTIC_POP
 817 #    endif
 818 #  endif
 819 #endif
 820 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
 821     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
 822 #endif
 823
 824 #if defined(JSON_HEDLEY_CONST_CAST)
 825     #undef JSON_HEDLEY_CONST_CAST
 826 #endif
 827 #if defined(__cplusplus)
 828 #  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
 829 #elif \
 830   JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
 831   JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
 832   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
 833 #  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
 834         JSON_HEDLEY_DIAGNOSTIC_PUSH \
 835         JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
 836         ((T) (expr)); \
 837         JSON_HEDLEY_DIAGNOSTIC_POP \
 838     }))
 839 #else
 840 #  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
 841 #endif
 842
 843 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
 844     #undef JSON_HEDLEY_REINTERPRET_CAST
 845 #endif
 846 #if defined(__cplusplus)
 847     #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
 848 #else
 849     #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
 850 #endif
 851
 852 #if defined(JSON_HEDLEY_STATIC_CAST)
 853     #undef JSON_HEDLEY_STATIC_CAST
 854 #endif
 855 #if defined(__cplusplus)
 856     #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
 857 #else
 858     #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
 859 #endif
 860
 861 #if defined(JSON_HEDLEY_CPP_CAST)
 862     #undef JSON_HEDLEY_CPP_CAST
 863 #endif
 864 #if defined(__cplusplus)
 865 #  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
 866 #    define JSON_HEDLEY_CPP_CAST(T, expr) \
 867     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 868     _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
 869     ((T) (expr)) \
 870     JSON_HEDLEY_DIAGNOSTIC_POP
 871 #  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
 872 #    define JSON_HEDLEY_CPP_CAST(T, expr) \
 873     JSON_HEDLEY_DIAGNOSTIC_PUSH \
 874     _Pragma("diag_suppress=Pe137") \
 875     JSON_HEDLEY_DIAGNOSTIC_POP
 876 #  else
 877 #    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
 878 #  endif
 879 #else
 880 #  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
 881 #endif
 882
 883 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
 884     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
 885 #endif
 886 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
 887     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
 888 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
 889     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
 890 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
 891     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
 892 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
 893     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
 894 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
 895     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
 896 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
 897     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
 898 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
 899     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
 900 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
 901     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
 902 #elif \
 903     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
 904     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
 905     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
 906     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
 907     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
 908     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
 909     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
 910     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
 911     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
 912     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
 913     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
 914     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
 915 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
 916     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
 917 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
 918     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
 919 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
 920     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
 921 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
 922     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
 923 #else
 924     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
 925 #endif
 926
 927 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
 928     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
 929 #endif
 930 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
 931     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
 932 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
 933     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
 934 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
 935     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
 936 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
 937     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
 938 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
 939     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
 940 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
 941     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
 942 #elif \
 943     JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
 944     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
 945     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
 946     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
 947     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
 948 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
 949     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
 950 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
 951     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
 952 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
 953     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
 954 #else
 955     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
 956 #endif
 957
 958 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
 959     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
 960 #endif
 961 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
 962     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
 963 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
 964     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
 965 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
 966     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
 967 #elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
 968     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
 969 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
 970     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
 971 #elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
 972     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
 973 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
 974     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
 975 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
 976     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
 977 #elif \
 978     JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
 979     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
 980     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
 981     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
 982 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
 983     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
 984 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
 985     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
 986 #else
 987     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
 988 #endif
 989
 990 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
 991     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
 992 #endif
 993 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
 994     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
 995 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
 996     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
 997 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
 998     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
 999 #else
1000     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1001 #endif
1002
1003 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
1004     #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1005 #endif
1006 #if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
1007     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
1008 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
1009     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
1010 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
1011     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
1012 #elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1013     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
1014 #else
1015     #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
1016 #endif
1017
1018 #if defined(JSON_HEDLEY_DEPRECATED)
1019     #undef JSON_HEDLEY_DEPRECATED
1020 #endif
1021 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1022     #undef JSON_HEDLEY_DEPRECATED_FOR
1023 #endif
1024 #if \
1025     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1026     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1027     #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1028     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1029 #elif \
1030     (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1031     JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1032     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1033     JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1034     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1035     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1036     JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1037     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1038     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1039     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1040     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
1041     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1042     #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1043     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1044 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1045     #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1046     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1047 #elif \
1048     JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1049     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1050     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1051     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1052     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1053     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1054     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1055     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1056     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1057     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1058     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1059     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1060     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1061     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1062     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1063     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1064     #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1065     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1066 #elif \
1067     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1068     JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
1069     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1070     #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1071     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1072 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1073     #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1074     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1075 #else
1076     #define JSON_HEDLEY_DEPRECATED(since)
1077     #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1078 #endif
1079
1080 #if defined(JSON_HEDLEY_UNAVAILABLE)
1081     #undef JSON_HEDLEY_UNAVAILABLE
1082 #endif
1083 #if \
1084     JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1085     JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1086     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1087     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1088     #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1089 #else
1090     #define JSON_HEDLEY_UNAVAILABLE(available_since)
1091 #endif
1092
1093 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1094     #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1095 #endif
1096 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1097     #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1098 #endif
1099 #if \
1100     JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1101     JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1102     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1103     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1104     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1105     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1106     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1107     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1108     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1109     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1110     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1111     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1112     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1113     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1114     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1115     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1116     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1117     #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1118     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1119 #elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1120     #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1121     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1122 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1123     #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1124     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1125 #elif defined(_Check_return_) /* SAL */
1126     #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1127     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1128 #else
1129     #define JSON_HEDLEY_WARN_UNUSED_RESULT
1130     #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1131 #endif
1132
1133 #if defined(JSON_HEDLEY_SENTINEL)
1134     #undef JSON_HEDLEY_SENTINEL
1135 #endif
1136 #if \
1137     JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1138     JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1139     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1140     JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1141     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1142     #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1143 #else
1144     #define JSON_HEDLEY_SENTINEL(position)
1145 #endif
1146
1147 #if defined(JSON_HEDLEY_NO_RETURN)
1148     #undef JSON_HEDLEY_NO_RETURN
1149 #endif
1150 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1151     #define JSON_HEDLEY_NO_RETURN __noreturn
1152 #elif \
1153     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1154     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1155     #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1156 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1157     #define JSON_HEDLEY_NO_RETURN _Noreturn
1158 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1159     #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1160 #elif \
1161     JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1162     JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1163     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1164     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1165     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1166     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1167     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1168     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1169     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1170     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1171     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1172     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1173     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1174     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1175     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1176     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1177     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1178     #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1179 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1180     #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1181 #elif \
1182     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1183     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1184     #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1185 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1186     #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1187 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1188     #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1189 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1190     #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1191 #else
1192     #define JSON_HEDLEY_NO_RETURN
1193 #endif
1194
1195 #if defined(JSON_HEDLEY_NO_ESCAPE)
1196     #undef JSON_HEDLEY_NO_ESCAPE
1197 #endif
1198 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1199     #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1200 #else
1201     #define JSON_HEDLEY_NO_ESCAPE
1202 #endif
1203
1204 #if defined(JSON_HEDLEY_UNREACHABLE)
1205     #undef JSON_HEDLEY_UNREACHABLE
1206 #endif
1207 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1208     #undef JSON_HEDLEY_UNREACHABLE_RETURN
1209 #endif
1210 #if defined(JSON_HEDLEY_ASSUME)
1211     #undef JSON_HEDLEY_ASSUME
1212 #endif
1213 #if \
1214     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1215     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1216     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1217     #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1218 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1219     #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1220 #elif \
1221     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1222     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1223     #if defined(__cplusplus)
1224         #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1225     #else
1226         #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1227     #endif
1228 #endif
1229 #if \
1230     (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1231     JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1232     JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1233     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1234     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
1235     JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
1236     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1237     #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1238 #elif defined(JSON_HEDLEY_ASSUME)
1239     #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1240 #endif
1241 #if !defined(JSON_HEDLEY_ASSUME)
1242     #if defined(JSON_HEDLEY_UNREACHABLE)
1243         #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1244     #else
1245         #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1246     #endif
1247 #endif
1248 #if defined(JSON_HEDLEY_UNREACHABLE)
1249     #if  \
1250         JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1251         JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1252         #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1253     #else
1254         #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1255     #endif
1256 #else
1257     #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1258 #endif
1259 #if !defined(JSON_HEDLEY_UNREACHABLE)
1260     #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1261 #endif
1262
1263 JSON_HEDLEY_DIAGNOSTIC_PUSH
1264 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1265     #pragma clang diagnostic ignored "-Wpedantic"
1266 #endif
1267 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1268     #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1269 #endif
1270 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1271     #if defined(__clang__)
1272         #pragma clang diagnostic ignored "-Wvariadic-macros"
1273     #elif defined(JSON_HEDLEY_GCC_VERSION)
1274         #pragma GCC diagnostic ignored "-Wvariadic-macros"
1275     #endif
1276 #endif
1277 #if defined(JSON_HEDLEY_NON_NULL)
1278     #undef JSON_HEDLEY_NON_NULL
1279 #endif
1280 #if \
1281     JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1282     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1283     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1284     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1285     #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1286 #else
1287     #define JSON_HEDLEY_NON_NULL(...)
1288 #endif
1289 JSON_HEDLEY_DIAGNOSTIC_POP
1290
1291 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1292     #undef JSON_HEDLEY_PRINTF_FORMAT
1293 #endif
1294 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1295     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1296 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1297     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1298 #elif \
1299     JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1300     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1301     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1302     JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1303     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1304     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1305     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1306     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1307     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1308     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1309     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1310     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1311     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1312     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1313     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1314     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1315     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1316     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1317 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1318     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1319 #else
1320     #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1321 #endif
1322
1323 #if defined(JSON_HEDLEY_CONSTEXPR)
1324     #undef JSON_HEDLEY_CONSTEXPR
1325 #endif
1326 #if defined(__cplusplus)
1327     #if __cplusplus >= 201103L
1328         #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1329     #endif
1330 #endif
1331 #if !defined(JSON_HEDLEY_CONSTEXPR)
1332     #define JSON_HEDLEY_CONSTEXPR
1333 #endif
1334
1335 #if defined(JSON_HEDLEY_PREDICT)
1336     #undef JSON_HEDLEY_PREDICT
1337 #endif
1338 #if defined(JSON_HEDLEY_LIKELY)
1339     #undef JSON_HEDLEY_LIKELY
1340 #endif
1341 #if defined(JSON_HEDLEY_UNLIKELY)
1342     #undef JSON_HEDLEY_UNLIKELY
1343 #endif
1344 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1345     #undef JSON_HEDLEY_UNPREDICTABLE
1346 #endif
1347 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1348     #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1349 #endif
1350 #if \
1351   (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1352   JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
1353   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1354 #  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
1355 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
1356 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
1357 #  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
1358 #  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
1359 #elif \
1360   (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1361   JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1362   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1363   (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1364   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1365   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1366   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1367   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1368   JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1369   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1370   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1371   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1372   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1373   JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1374   JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1375   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1376 #  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1377     (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1378 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1379     (__extension__ ({ \
1380         double hedley_probability_ = (probability); \
1381         ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1382     }))
1383 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1384     (__extension__ ({ \
1385         double hedley_probability_ = (probability); \
1386         ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1387     }))
1388 #  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
1389 #  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1390 #else
1391 #  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1392 #  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1393 #  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1394 #  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1395 #  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1396 #endif
1397 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1398     #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1399 #endif
1400
1401 #if defined(JSON_HEDLEY_MALLOC)
1402     #undef JSON_HEDLEY_MALLOC
1403 #endif
1404 #if \
1405     JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1406     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1407     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1408     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1409     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1410     JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1411     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1412     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1413     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1414     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1415     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1416     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1417     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1418     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1419     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1420     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1421     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1422     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1423     #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1424 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1425     #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1426 #elif \
1427     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1428     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1429     #define JSON_HEDLEY_MALLOC __declspec(restrict)
1430 #else
1431     #define JSON_HEDLEY_MALLOC
1432 #endif
1433
1434 #if defined(JSON_HEDLEY_PURE)
1435     #undef JSON_HEDLEY_PURE
1436 #endif
1437 #if \
1438   JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1439   JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1440   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1441   JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1442   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1443   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1444   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1445   (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1446   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1447   (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1448   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1449   (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1450   JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1451   (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1452   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1453   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1454   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1455   JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1456   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1457 #  define JSON_HEDLEY_PURE __attribute__((__pure__))
1458 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1459 #  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1460 #elif defined(__cplusplus) && \
1461     ( \
1462       JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1463       JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1464       JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1465     )
1466 #  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1467 #else
1468 #  define JSON_HEDLEY_PURE
1469 #endif
1470
1471 #if defined(JSON_HEDLEY_CONST)
1472     #undef JSON_HEDLEY_CONST
1473 #endif
1474 #if \
1475     JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1476     JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1477     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1478     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1479     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1480     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1481     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1482     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1483     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1484     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1485     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1486     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1487     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1488     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1489     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1490     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1491     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1492     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1493     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1494     #define JSON_HEDLEY_CONST __attribute__((__const__))
1495 #elif \
1496     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1497     #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1498 #else
1499     #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1500 #endif
1501
1502 #if defined(JSON_HEDLEY_RESTRICT)
1503     #undef JSON_HEDLEY_RESTRICT
1504 #endif
1505 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1506     #define JSON_HEDLEY_RESTRICT restrict
1507 #elif \
1508     JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1509     JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1510     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1511     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1512     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1513     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1514     JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1515     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1516     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1517     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1518     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1519     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1520     JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1521     defined(__clang__) || \
1522     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1523     #define JSON_HEDLEY_RESTRICT __restrict
1524 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1525     #define JSON_HEDLEY_RESTRICT _Restrict
1526 #else
1527     #define JSON_HEDLEY_RESTRICT
1528 #endif
1529
1530 #if defined(JSON_HEDLEY_INLINE)
1531     #undef JSON_HEDLEY_INLINE
1532 #endif
1533 #if \
1534     (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1535     (defined(__cplusplus) && (__cplusplus >= 199711L))
1536     #define JSON_HEDLEY_INLINE inline
1537 #elif \
1538     defined(JSON_HEDLEY_GCC_VERSION) || \
1539     JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1540     #define JSON_HEDLEY_INLINE __inline__
1541 #elif \
1542     JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1543     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1544     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1545     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1546     JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1547     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1548     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1549     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1550     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1551     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1552     #define JSON_HEDLEY_INLINE __inline
1553 #else
1554     #define JSON_HEDLEY_INLINE
1555 #endif
1556
1557 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1558     #undef JSON_HEDLEY_ALWAYS_INLINE
1559 #endif
1560 #if \
1561   JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1562   JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1563   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1564   JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1565   JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1566   JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1567   JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1568   (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1569   JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1570   (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1571   JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1572   (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1573   JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1574   (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1575   JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1576   JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1577   JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1578   JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1579   JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1580 #  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1581 #elif \
1582   JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1583   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1584 #  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1585 #elif defined(__cplusplus) && \
1586     ( \
1587       JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1588       JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1589       JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1590       JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1591       JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1592       JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1593     )
1594 #  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1595 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1596 #  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1597 #else
1598 #  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1599 #endif
1600
1601 #if defined(JSON_HEDLEY_NEVER_INLINE)
1602     #undef JSON_HEDLEY_NEVER_INLINE
1603 #endif
1604 #if \
1605     JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1606     JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1607     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1608     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1609     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1610     JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1611     JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1612     (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1613     JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1614     (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1615     JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1616     (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1617     JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1618     (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1619     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1620     JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1621     JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1622     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
1623     JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
1624     #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1625 #elif \
1626     JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1627     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1628     #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1629 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1630     #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1631 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1632     #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1633 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1634     #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1635 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1636     #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1637 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1638     #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1639 #else
1640     #define JSON_HEDLEY_NEVER_INLINE
1641 #endif
1642
1643 #if defined(JSON_HEDLEY_PRIVATE)
1644     #undef JSON_HEDLEY_PRIVATE
1645 #endif
1646 #if defined(JSON_HEDLEY_PUBLIC)
1647     #undef JSON_HEDLEY_PUBLIC
1648 #endif
1649 #if defined(JSON_HEDLEY_IMPORT)
1650     #undef JSON_HEDLEY_IMPORT
1651 #endif
1652 #if defined(_WIN32) || defined(__CYGWIN__)
1653 #  define JSON_HEDLEY_PRIVATE
1654 #  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
1655 #  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
1656 #else
1657 #  if \
1658     JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1659     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1660     JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1661     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1662     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1663     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1664     ( \
1665       defined(__TI_EABI__) && \
1666       ( \
1667         (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1668         JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1669       ) \
1670     ) || \
1671     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1672 #    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1673 #    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
1674 #  else
1675 #    define JSON_HEDLEY_PRIVATE
1676 #    define JSON_HEDLEY_PUBLIC
1677 #  endif
1678 #  define JSON_HEDLEY_IMPORT    extern
1679 #endif
1680
1681 #if defined(JSON_HEDLEY_NO_THROW)
1682     #undef JSON_HEDLEY_NO_THROW
1683 #endif
1684 #if \
1685     JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1686     JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1687     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1688     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1689     #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1690 #elif \
1691     JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1692     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
1693     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1694     #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1695 #else
1696     #define JSON_HEDLEY_NO_THROW
1697 #endif
1698
1699 #if defined(JSON_HEDLEY_FALL_THROUGH)
1700     #undef JSON_HEDLEY_FALL_THROUGH
1701 #endif
1702 #if \
1703     JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1704     JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
1705     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1706     #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1707 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1708     #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1709 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1710     #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1711 #elif defined(__fallthrough) /* SAL */
1712     #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1713 #else
1714     #define JSON_HEDLEY_FALL_THROUGH
1715 #endif
1716
1717 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1718     #undef JSON_HEDLEY_RETURNS_NON_NULL
1719 #endif
1720 #if \
1721     JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1722     JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1723     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1724     #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1725 #elif defined(_Ret_notnull_) /* SAL */
1726     #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1727 #else
1728     #define JSON_HEDLEY_RETURNS_NON_NULL
1729 #endif
1730
1731 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1732     #undef JSON_HEDLEY_ARRAY_PARAM
1733 #endif
1734 #if \
1735     defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1736     !defined(__STDC_NO_VLA__) && \
1737     !defined(__cplusplus) && \
1738     !defined(JSON_HEDLEY_PGI_VERSION) && \
1739     !defined(JSON_HEDLEY_TINYC_VERSION)
1740     #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1741 #else
1742     #define JSON_HEDLEY_ARRAY_PARAM(name)
1743 #endif
1744
1745 #if defined(JSON_HEDLEY_IS_CONSTANT)
1746     #undef JSON_HEDLEY_IS_CONSTANT
1747 #endif
1748 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1749     #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1750 #endif
1751 /* JSON_HEDLEY_IS_CONSTEXPR_ is for
1752    HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
1753 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1754     #undef JSON_HEDLEY_IS_CONSTEXPR_
1755 #endif
1756 #if \
1757     JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1758     JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1759     JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1760     JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1761     JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1762     JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1763     JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1764     (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1765     JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1766     JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
1767     #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1768 #endif
1769 #if !defined(__cplusplus)
1770 #  if \
1771        JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1772        JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1773        JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1774        JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1775        JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1776        JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1777        JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1778 #if defined(__INTPTR_TYPE__)
1779     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1780 #else
1781     #include <stdint.h>
1782     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1783 #endif
1784 #  elif \
1785        ( \
1786           defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1787           !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1788           !defined(JSON_HEDLEY_PGI_VERSION) && \
1789           !defined(JSON_HEDLEY_IAR_VERSION)) || \
1790        (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
1791        JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1792        JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1793        JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1794        JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1795 #if defined(__INTPTR_TYPE__)
1796     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1797 #else
1798     #include <stdint.h>
1799     #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1800 #endif
1801 #  elif \
1802        defined(JSON_HEDLEY_GCC_VERSION) || \
1803        defined(JSON_HEDLEY_INTEL_VERSION) || \
1804        defined(JSON_HEDLEY_TINYC_VERSION) || \
1805        defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1806        JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1807        defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1808        defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1809        defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1810        defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1811        defined(__clang__)
1812 #    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1813         sizeof(void) != \
1814         sizeof(*( \
1815                   1 ? \
1816                   ((void*) ((expr) * 0L) ) : \
1817 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1818                 ) \
1819               ) \
1820                                             )
1821 #  endif
1822 #endif
1823 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1824     #if !defined(JSON_HEDLEY_IS_CONSTANT)
1825         #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1826     #endif
1827     #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1828 #else
1829     #if !defined(JSON_HEDLEY_IS_CONSTANT)
1830         #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1831     #endif
1832     #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1833 #endif
1834
1835 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1836     #undef JSON_HEDLEY_BEGIN_C_DECLS
1837 #endif
1838 #if defined(JSON_HEDLEY_END_C_DECLS)
1839     #undef JSON_HEDLEY_END_C_DECLS
1840 #endif
1841 #if defined(JSON_HEDLEY_C_DECL)
1842     #undef JSON_HEDLEY_C_DECL
1843 #endif
1844 #if defined(__cplusplus)
1845     #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
1846     #define JSON_HEDLEY_END_C_DECLS }
1847     #define JSON_HEDLEY_C_DECL extern "C"
1848 #else
1849     #define JSON_HEDLEY_BEGIN_C_DECLS
1850     #define JSON_HEDLEY_END_C_DECLS
1851     #define JSON_HEDLEY_C_DECL
1852 #endif
1853
1854 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1855     #undef JSON_HEDLEY_STATIC_ASSERT
1856 #endif
1857 #if \
1858   !defined(__cplusplus) && ( \
1859       (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1860       (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
1861       JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
1862       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1863       defined(_Static_assert) \
1864     )
1865 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1866 #elif \
1867   (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
1868   JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
1869   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1870 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1871 #else
1872 #  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1873 #endif
1874
1875 #if defined(JSON_HEDLEY_NULL)
1876     #undef JSON_HEDLEY_NULL
1877 #endif
1878 #if defined(__cplusplus)
1879     #if __cplusplus >= 201103L
1880         #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1881     #elif defined(NULL)
1882         #define JSON_HEDLEY_NULL NULL
1883     #else
1884         #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1885     #endif
1886 #elif defined(NULL)
1887     #define JSON_HEDLEY_NULL NULL
1888 #else
1889     #define JSON_HEDLEY_NULL ((void*) 0)
1890 #endif
1891
1892 #if defined(JSON_HEDLEY_MESSAGE)
1893     #undef JSON_HEDLEY_MESSAGE
1894 #endif
1895 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1896 #  define JSON_HEDLEY_MESSAGE(msg) \
1897     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1898     JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1899     JSON_HEDLEY_PRAGMA(message msg) \
1900     JSON_HEDLEY_DIAGNOSTIC_POP
1901 #elif \
1902   JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
1903   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1904 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
1905 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
1906 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
1907 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1908 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1909 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
1910 #  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1911 #else
1912 #  define JSON_HEDLEY_MESSAGE(msg)
1913 #endif
1914
1915 #if defined(JSON_HEDLEY_WARNING)
1916     #undef JSON_HEDLEY_WARNING
1917 #endif
1918 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1919 #  define JSON_HEDLEY_WARNING(msg) \
1920     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1921     JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1922     JSON_HEDLEY_PRAGMA(clang warning msg) \
1923     JSON_HEDLEY_DIAGNOSTIC_POP
1924 #elif \
1925   JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
1926   JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1927   JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1928 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
1929 #elif \
1930   JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
1931   JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1932 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
1933 #else
1934 #  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1935 #endif
1936
1937 #if defined(JSON_HEDLEY_REQUIRE)
1938     #undef JSON_HEDLEY_REQUIRE
1939 #endif
1940 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1941     #undef JSON_HEDLEY_REQUIRE_MSG
1942 #endif
1943 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1944 #  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
1945 #    define JSON_HEDLEY_REQUIRE(expr) \
1946     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1947     _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1948     __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1949     JSON_HEDLEY_DIAGNOSTIC_POP
1950 #    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
1951     JSON_HEDLEY_DIAGNOSTIC_PUSH \
1952     _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1953     __attribute__((diagnose_if(!(expr), msg, "error"))) \
1954     JSON_HEDLEY_DIAGNOSTIC_POP
1955 #  else
1956 #    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1957 #    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1958 #  endif
1959 #else
1960 #  define JSON_HEDLEY_REQUIRE(expr)
1961 #  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1962 #endif
1963
1964 #if defined(JSON_HEDLEY_FLAGS)
1965     #undef JSON_HEDLEY_FLAGS
1966 #endif
1967 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
1968     #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1969 #else
1970     #define JSON_HEDLEY_FLAGS
1971 #endif
1972
1973 #if defined(JSON_HEDLEY_FLAGS_CAST)
1974     #undef JSON_HEDLEY_FLAGS_CAST
1975 #endif
1976 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
1977 #  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
1978         JSON_HEDLEY_DIAGNOSTIC_PUSH \
1979         _Pragma("warning(disable:188)") \
1980         ((T) (expr)); \
1981         JSON_HEDLEY_DIAGNOSTIC_POP \
1982     }))
1983 #else
1984 #  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1985 #endif
1986
1987 #if defined(JSON_HEDLEY_EMPTY_BASES)
1988     #undef JSON_HEDLEY_EMPTY_BASES
1989 #endif
1990 #if \
1991     (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
1992     JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
1993     #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
1994 #else
1995     #define JSON_HEDLEY_EMPTY_BASES
1996 #endif
1997
1998 /* Remaining macros are deprecated. */
1999
2000 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
2001     #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
2002 #endif
2003 #if defined(__clang__)
2004     #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
2005 #else
2006     #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
2007 #endif
2008
2009 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
2010     #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
2011 #endif
2012 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
2013
2014 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
2015     #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
2016 #endif
2017 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
2018
2019 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
2020     #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
2021 #endif
2022 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
2023
2024 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2025     #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2026 #endif
2027 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2028
2029 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2030     #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2031 #endif
2032 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2033
2034 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2035     #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2036 #endif
2037 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2038
2039 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2040     #undef JSON_HEDLEY_CLANG_HAS_WARNING
2041 #endif
2042 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2043
2044 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */