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