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