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