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