13 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 11)
14 #if defined(JSON_HEDLEY_VERSION)
15 #undef JSON_HEDLEY_VERSION
17 #define JSON_HEDLEY_VERSION 11
19 #if defined(JSON_HEDLEY_STRINGIFY_EX)
20 #undef JSON_HEDLEY_STRINGIFY_EX
22 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
24 #if defined(JSON_HEDLEY_STRINGIFY)
25 #undef JSON_HEDLEY_STRINGIFY
27 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
29 #if defined(JSON_HEDLEY_CONCAT_EX)
30 #undef JSON_HEDLEY_CONCAT_EX
32 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
34 #if defined(JSON_HEDLEY_CONCAT)
35 #undef JSON_HEDLEY_CONCAT
37 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
39 #if defined(JSON_HEDLEY_VERSION_ENCODE)
40 #undef JSON_HEDLEY_VERSION_ENCODE
42 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
44 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
45 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
47 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
49 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
50 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
52 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
54 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
55 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
57 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
59 #if defined(JSON_HEDLEY_GNUC_VERSION)
60 #undef JSON_HEDLEY_GNUC_VERSION
62 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
63 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
64 #elif defined(__GNUC__)
65 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
68 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
69 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
71 #if defined(JSON_HEDLEY_GNUC_VERSION)
72 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
74 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
77 #if defined(JSON_HEDLEY_MSVC_VERSION)
78 #undef JSON_HEDLEY_MSVC_VERSION
80 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
81 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
82 #elif defined(_MSC_FULL_VER)
83 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
84 #elif defined(_MSC_VER)
85 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
88 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
89 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
91 #if !defined(_MSC_VER)
92 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
93 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
94 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
95 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
96 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
98 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
101 #if defined(JSON_HEDLEY_INTEL_VERSION)
102 #undef JSON_HEDLEY_INTEL_VERSION
104 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
105 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
106 #elif defined(__INTEL_COMPILER)
107 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
110 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
111 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
113 #if defined(JSON_HEDLEY_INTEL_VERSION)
114 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
116 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
119 #if defined(JSON_HEDLEY_PGI_VERSION)
120 #undef JSON_HEDLEY_PGI_VERSION
122 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
123 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
126 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
127 #undef JSON_HEDLEY_PGI_VERSION_CHECK
129 #if defined(JSON_HEDLEY_PGI_VERSION)
130 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
132 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
135 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
136 #undef JSON_HEDLEY_SUNPRO_VERSION
138 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
139 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
140 #elif defined(__SUNPRO_C)
141 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
142 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
143 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
144 #elif defined(__SUNPRO_CC)
145 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
148 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
149 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
151 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
152 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
154 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
157 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
158 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
160 #if defined(__EMSCRIPTEN__)
161 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
164 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
165 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
167 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
168 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
170 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
173 #if defined(JSON_HEDLEY_ARM_VERSION)
174 #undef JSON_HEDLEY_ARM_VERSION
176 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
177 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
178 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
179 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
182 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
183 #undef JSON_HEDLEY_ARM_VERSION_CHECK
185 #if defined(JSON_HEDLEY_ARM_VERSION)
186 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
188 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
191 #if defined(JSON_HEDLEY_IBM_VERSION)
192 #undef JSON_HEDLEY_IBM_VERSION
194 #if defined(__ibmxl__)
195 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
196 #elif defined(__xlC__) && defined(__xlC_ver__)
197 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
198 #elif defined(__xlC__)
199 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
202 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
203 #undef JSON_HEDLEY_IBM_VERSION_CHECK
205 #if defined(JSON_HEDLEY_IBM_VERSION)
206 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
208 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
211 #if defined(JSON_HEDLEY_TI_VERSION)
212 #undef JSON_HEDLEY_TI_VERSION
214 #if defined(__TI_COMPILER_VERSION__)
215 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
218 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
219 #undef JSON_HEDLEY_TI_VERSION_CHECK
221 #if defined(JSON_HEDLEY_TI_VERSION)
222 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
224 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
227 #if defined(JSON_HEDLEY_CRAY_VERSION)
228 #undef JSON_HEDLEY_CRAY_VERSION
231 #if defined(_RELEASE_PATCHLEVEL)
232 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
234 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
238 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
239 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
241 #if defined(JSON_HEDLEY_CRAY_VERSION)
242 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
244 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
247 #if defined(JSON_HEDLEY_IAR_VERSION)
248 #undef JSON_HEDLEY_IAR_VERSION
250 #if defined(__IAR_SYSTEMS_ICC__)
252 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
254 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
258 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
259 #undef JSON_HEDLEY_IAR_VERSION_CHECK
261 #if defined(JSON_HEDLEY_IAR_VERSION)
262 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
264 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
267 #if defined(JSON_HEDLEY_TINYC_VERSION)
268 #undef JSON_HEDLEY_TINYC_VERSION
270 #if defined(__TINYC__)
271 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
274 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
275 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
277 #if defined(JSON_HEDLEY_TINYC_VERSION)
278 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
280 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
283 #if defined(JSON_HEDLEY_DMC_VERSION)
284 #undef JSON_HEDLEY_DMC_VERSION
287 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
290 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
291 #undef JSON_HEDLEY_DMC_VERSION_CHECK
293 #if defined(JSON_HEDLEY_DMC_VERSION)
294 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
296 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
299 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
300 #undef JSON_HEDLEY_COMPCERT_VERSION
302 #if defined(__COMPCERT_VERSION__)
303 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
306 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
307 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
309 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
310 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
312 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
315 #if defined(JSON_HEDLEY_PELLES_VERSION)
316 #undef JSON_HEDLEY_PELLES_VERSION
318 #if defined(__POCC__)
319 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
322 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
323 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
325 #if defined(JSON_HEDLEY_PELLES_VERSION)
326 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
328 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
331 #if defined(JSON_HEDLEY_GCC_VERSION)
332 #undef JSON_HEDLEY_GCC_VERSION
335 defined(JSON_HEDLEY_GNUC_VERSION) && \
336 !defined(__clang__) && \
337 !defined(JSON_HEDLEY_INTEL_VERSION) && \
338 !defined(JSON_HEDLEY_PGI_VERSION) && \
339 !defined(JSON_HEDLEY_ARM_VERSION) && \
340 !defined(JSON_HEDLEY_TI_VERSION) && \
341 !defined(__COMPCERT__)
342 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
345 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
346 #undef JSON_HEDLEY_GCC_VERSION_CHECK
348 #if defined(JSON_HEDLEY_GCC_VERSION)
349 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
351 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
354 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
355 #undef JSON_HEDLEY_HAS_ATTRIBUTE
357 #if defined(__has_attribute)
358 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
360 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
363 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
364 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
366 #if defined(__has_attribute)
367 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
369 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
372 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
373 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
375 #if defined(__has_attribute)
376 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
378 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
381 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
382 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
385 defined(__has_cpp_attribute) && \
386 defined(__cplusplus) && \
387 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
388 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
390 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
393 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
394 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
396 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
397 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
399 !defined(JSON_HEDLEY_PGI_VERSION) && \
400 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
401 (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
402 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
404 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
407 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
408 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
410 #if defined(__has_cpp_attribute) && defined(__cplusplus)
411 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
413 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
416 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
417 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
419 #if defined(__has_cpp_attribute) && defined(__cplusplus)
420 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
422 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
425 #if defined(JSON_HEDLEY_HAS_BUILTIN)
426 #undef JSON_HEDLEY_HAS_BUILTIN
428 #if defined(__has_builtin)
429 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
431 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
434 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
435 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
437 #if defined(__has_builtin)
438 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
440 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
443 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
444 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
446 #if defined(__has_builtin)
447 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
449 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
452 #if defined(JSON_HEDLEY_HAS_FEATURE)
453 #undef JSON_HEDLEY_HAS_FEATURE
455 #if defined(__has_feature)
456 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
458 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
461 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
462 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
464 #if defined(__has_feature)
465 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
467 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
470 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
471 #undef JSON_HEDLEY_GCC_HAS_FEATURE
473 #if defined(__has_feature)
474 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
476 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
479 #if defined(JSON_HEDLEY_HAS_EXTENSION)
480 #undef JSON_HEDLEY_HAS_EXTENSION
482 #if defined(__has_extension)
483 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
485 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
488 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
489 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
491 #if defined(__has_extension)
492 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
494 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
497 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
498 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
500 #if defined(__has_extension)
501 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
503 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
506 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
507 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
509 #if defined(__has_declspec_attribute)
510 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
512 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
515 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
516 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
518 #if defined(__has_declspec_attribute)
519 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
521 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
524 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
525 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
527 #if defined(__has_declspec_attribute)
528 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
530 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
533 #if defined(JSON_HEDLEY_HAS_WARNING)
534 #undef JSON_HEDLEY_HAS_WARNING
536 #if defined(__has_warning)
537 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
539 #define JSON_HEDLEY_HAS_WARNING(warning) (0)
542 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
543 #undef JSON_HEDLEY_GNUC_HAS_WARNING
545 #if defined(__has_warning)
546 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
548 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
551 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
552 #undef JSON_HEDLEY_GCC_HAS_WARNING
554 #if defined(__has_warning)
555 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
557 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
562 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
563 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
565 #if defined(__cplusplus) && JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
566 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
567 JSON_HEDLEY_DIAGNOSTIC_PUSH \
568 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
570 JSON_HEDLEY_DIAGNOSTIC_POP
572 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
576 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
577 defined(__clang__) || \
578 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
579 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
580 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
581 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
582 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
583 JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) || \
584 JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
585 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
586 JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
587 (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
588 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
589 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
590 #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
592 #define JSON_HEDLEY_PRAGMA(value)
595 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
596 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
598 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
599 #undef JSON_HEDLEY_DIAGNOSTIC_POP
601 #if defined(__clang__)
602 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
603 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
604 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
605 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
606 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
607 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
608 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
609 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
610 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
611 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
612 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
613 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
614 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
615 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
616 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,1,0)
617 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
618 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
619 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
620 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
621 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
623 #define JSON_HEDLEY_DIAGNOSTIC_PUSH
624 #define JSON_HEDLEY_DIAGNOSTIC_POP
627 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
628 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
630 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
631 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
632 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
633 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
634 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
635 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
636 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
637 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
638 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
639 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
640 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
641 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
642 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
643 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
644 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
645 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
646 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
647 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
648 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
649 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
651 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
654 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
655 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
657 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
658 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
659 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
660 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
661 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
662 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
663 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
664 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
665 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
666 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
667 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
668 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
669 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
670 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
672 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
675 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
676 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
678 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
679 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
680 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
681 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
682 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
683 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
684 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
685 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
686 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
687 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
688 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
689 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
690 #elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
691 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
693 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
696 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
697 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
699 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
700 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
701 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
702 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
703 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
704 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
706 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
709 #if defined(JSON_HEDLEY_DEPRECATED)
710 #undef JSON_HEDLEY_DEPRECATED
712 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
713 #undef JSON_HEDLEY_DEPRECATED_FOR
715 #if defined(__cplusplus) && (__cplusplus >= 201402L)
716 #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
717 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
719 JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
720 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
721 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
722 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
723 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
724 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
725 JSON_HEDLEY_TI_VERSION_CHECK(8,3,0)
726 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
727 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
729 JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
730 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
731 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
732 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
733 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
734 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
735 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
736 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
737 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
738 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
740 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
741 JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
742 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
743 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
744 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
745 #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
746 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
748 #define JSON_HEDLEY_DEPRECATED(since)
749 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
752 #if defined(JSON_HEDLEY_UNAVAILABLE)
753 #undef JSON_HEDLEY_UNAVAILABLE
756 JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
757 JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
758 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
759 #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
761 #define JSON_HEDLEY_UNAVAILABLE(available_since)
764 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
765 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
767 #if defined(__cplusplus) && (__cplusplus >= 201703L)
768 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
770 JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
771 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
772 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
773 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
774 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
775 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
776 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
777 #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
778 #elif defined(_Check_return_)
779 #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
781 #define JSON_HEDLEY_WARN_UNUSED_RESULT
784 #if defined(JSON_HEDLEY_SENTINEL)
785 #undef JSON_HEDLEY_SENTINEL
788 JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
789 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
790 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
791 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
792 #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
794 #define JSON_HEDLEY_SENTINEL(position)
797 #if defined(JSON_HEDLEY_NO_RETURN)
798 #undef JSON_HEDLEY_NO_RETURN
800 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
801 #define JSON_HEDLEY_NO_RETURN __noreturn
802 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
803 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
804 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
805 #define JSON_HEDLEY_NO_RETURN _Noreturn
806 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
807 #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
809 JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
810 JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
811 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
812 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
813 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
814 JSON_HEDLEY_TI_VERSION_CHECK(18,0,0) || \
815 (JSON_HEDLEY_TI_VERSION_CHECK(17,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
816 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
817 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
818 #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
819 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
820 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
821 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
822 #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
823 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
824 #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
825 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
826 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
828 #define JSON_HEDLEY_NO_RETURN
831 #if defined(JSON_HEDLEY_NO_ESCAPE)
832 #undef JSON_HEDLEY_NO_ESCAPE
834 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
835 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
837 #define JSON_HEDLEY_NO_ESCAPE
840 #if defined(JSON_HEDLEY_UNREACHABLE)
841 #undef JSON_HEDLEY_UNREACHABLE
843 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
844 #undef JSON_HEDLEY_UNREACHABLE_RETURN
847 (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
848 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
849 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
850 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
851 #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
852 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
853 #define JSON_HEDLEY_UNREACHABLE() __assume(0)
854 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
855 #if defined(__cplusplus)
856 #define JSON_HEDLEY_UNREACHABLE() std::_nassert(0)
858 #define JSON_HEDLEY_UNREACHABLE() _nassert(0)
860 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
861 #elif defined(EXIT_FAILURE)
862 #define JSON_HEDLEY_UNREACHABLE() abort()
864 #define JSON_HEDLEY_UNREACHABLE()
865 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
867 #if !defined(JSON_HEDLEY_UNREACHABLE_RETURN)
868 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
871 #if defined(JSON_HEDLEY_ASSUME)
872 #undef JSON_HEDLEY_ASSUME
875 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
876 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
877 #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
878 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
879 #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
880 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
881 #if defined(__cplusplus)
882 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
884 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
887 (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && !defined(JSON_HEDLEY_ARM_VERSION)) || \
888 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
889 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
890 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
891 #define JSON_HEDLEY_ASSUME(expr) ((void) ((expr) ? 1 : (__builtin_unreachable(), 1)))
893 #define JSON_HEDLEY_ASSUME(expr) ((void) (expr))
896 JSON_HEDLEY_DIAGNOSTIC_PUSH
897 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
898 #pragma clang diagnostic ignored "-Wpedantic"
900 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
901 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
903 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
904 #if defined(__clang__)
905 #pragma clang diagnostic ignored "-Wvariadic-macros"
906 #elif defined(JSON_HEDLEY_GCC_VERSION)
907 #pragma GCC diagnostic ignored "-Wvariadic-macros"
910 #if defined(JSON_HEDLEY_NON_NULL)
911 #undef JSON_HEDLEY_NON_NULL
914 JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
915 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
916 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
917 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
918 #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
920 #define JSON_HEDLEY_NON_NULL(...)
922 JSON_HEDLEY_DIAGNOSTIC_POP
924 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
925 #undef JSON_HEDLEY_PRINTF_FORMAT
927 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
928 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
929 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
930 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
932 JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
933 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
934 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
935 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
936 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
937 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
938 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
939 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
940 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
941 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
943 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
946 #if defined(JSON_HEDLEY_CONSTEXPR)
947 #undef JSON_HEDLEY_CONSTEXPR
949 #if defined(__cplusplus)
950 #if __cplusplus >= 201103L
951 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
954 #if !defined(JSON_HEDLEY_CONSTEXPR)
955 #define JSON_HEDLEY_CONSTEXPR
958 #if defined(JSON_HEDLEY_PREDICT)
959 #undef JSON_HEDLEY_PREDICT
961 #if defined(JSON_HEDLEY_LIKELY)
962 #undef JSON_HEDLEY_LIKELY
964 #if defined(JSON_HEDLEY_UNLIKELY)
965 #undef JSON_HEDLEY_UNLIKELY
967 #if defined(JSON_HEDLEY_UNPREDICTABLE)
968 #undef JSON_HEDLEY_UNPREDICTABLE
970 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
971 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable(!!(expr))
974 JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
975 JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
976 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(expr, value, probability)
977 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1, probability)
978 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0, probability)
979 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
980 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
981 #if !defined(JSON_HEDLEY_BUILTIN_UNPREDICTABLE)
982 #define JSON_HEDLEY_BUILTIN_UNPREDICTABLE(expr) __builtin_expect_with_probability(!!(expr), 1, 0.5)
985 JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
986 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
987 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
988 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
989 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
990 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
991 JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
992 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27)
993 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
994 (((probability) >= 0.9) ? __builtin_expect(!!(expr), (expected)) : (((void) (expected)), !!(expr)))
995 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
997 JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
998 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1000 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1002 JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
1003 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1005 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1006 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1008 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (((void) (expected)), !!(expr))
1009 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1010 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1011 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1012 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1014 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1015 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1018 #if defined(JSON_HEDLEY_MALLOC)
1019 #undef JSON_HEDLEY_MALLOC
1022 JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1023 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1024 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1025 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1026 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1027 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1028 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1029 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1030 #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1031 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1032 #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1033 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
1034 #define JSON_HEDLEY_MALLOC __declspec(restrict)
1036 #define JSON_HEDLEY_MALLOC
1039 #if defined(JSON_HEDLEY_PURE)
1040 #undef JSON_HEDLEY_PURE
1043 JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1044 JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1045 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1046 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1047 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1048 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1049 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1050 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1051 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1052 #define JSON_HEDLEY_PURE __attribute__((__pure__))
1053 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1054 #define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1055 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1056 #define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1058 #define JSON_HEDLEY_PURE
1061 #if defined(JSON_HEDLEY_CONST)
1062 #undef JSON_HEDLEY_CONST
1065 JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1066 JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1067 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1068 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1069 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1070 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1071 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1072 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1073 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1074 #define JSON_HEDLEY_CONST __attribute__((__const__))
1076 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1077 #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1079 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1082 #if defined(JSON_HEDLEY_RESTRICT)
1083 #undef JSON_HEDLEY_RESTRICT
1085 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1086 #define JSON_HEDLEY_RESTRICT restrict
1088 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1089 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1090 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1091 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1092 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1093 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1094 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1095 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1096 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1098 #define JSON_HEDLEY_RESTRICT __restrict
1099 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1100 #define JSON_HEDLEY_RESTRICT _Restrict
1102 #define JSON_HEDLEY_RESTRICT
1105 #if defined(JSON_HEDLEY_INLINE)
1106 #undef JSON_HEDLEY_INLINE
1109 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1110 (defined(__cplusplus) && (__cplusplus >= 199711L))
1111 #define JSON_HEDLEY_INLINE inline
1113 defined(JSON_HEDLEY_GCC_VERSION) || \
1114 JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1115 #define JSON_HEDLEY_INLINE __inline__
1117 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1118 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1119 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
1120 #define JSON_HEDLEY_INLINE __inline
1122 #define JSON_HEDLEY_INLINE
1125 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1126 #undef JSON_HEDLEY_ALWAYS_INLINE
1129 JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1130 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1131 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1132 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1133 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1134 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1135 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1136 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1137 #define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1138 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
1139 #define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1140 #elif JSON_HEDLEY_TI_VERSION_CHECK(7,0,0) && defined(__cplusplus)
1141 #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1142 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1143 #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1145 #define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1148 #if defined(JSON_HEDLEY_NEVER_INLINE)
1149 #undef JSON_HEDLEY_NEVER_INLINE
1152 JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1153 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1154 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1155 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1156 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1157 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1158 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1159 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1160 #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1161 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1162 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1163 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1164 #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1165 #elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1166 #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1167 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1168 #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1169 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1170 #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1171 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1172 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1174 #define JSON_HEDLEY_NEVER_INLINE
1177 #if defined(JSON_HEDLEY_PRIVATE)
1178 #undef JSON_HEDLEY_PRIVATE
1180 #if defined(JSON_HEDLEY_PUBLIC)
1181 #undef JSON_HEDLEY_PUBLIC
1183 #if defined(JSON_HEDLEY_IMPORT)
1184 #undef JSON_HEDLEY_IMPORT
1186 #if defined(_WIN32) || defined(__CYGWIN__)
1187 #define JSON_HEDLEY_PRIVATE
1188 #define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1189 #define JSON_HEDLEY_IMPORT __declspec(dllimport)
1192 JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1193 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1194 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1195 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1196 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1197 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1198 JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
1199 (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_EABI__) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
1200 #define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1201 #define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1203 #define JSON_HEDLEY_PRIVATE
1204 #define JSON_HEDLEY_PUBLIC
1206 #define JSON_HEDLEY_IMPORT extern
1209 #if defined(JSON_HEDLEY_NO_THROW)
1210 #undef JSON_HEDLEY_NO_THROW
1213 JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1214 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1215 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1216 #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1218 JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1219 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1220 #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1222 #define JSON_HEDLEY_NO_THROW
1225 #if defined(JSON_HEDLEY_FALL_THROUGH)
1226 #undef JSON_HEDLEY_FALL_THROUGH
1228 #if JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(fallthrough,7,0,0) && !defined(JSON_HEDLEY_PGI_VERSION)
1229 #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1230 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1231 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1232 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1233 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1234 #elif defined(__fallthrough)
1235 #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1237 #define JSON_HEDLEY_FALL_THROUGH
1240 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1241 #undef JSON_HEDLEY_RETURNS_NON_NULL
1244 JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1245 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
1246 #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1247 #elif defined(_Ret_notnull_)
1248 #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1250 #define JSON_HEDLEY_RETURNS_NON_NULL
1253 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1254 #undef JSON_HEDLEY_ARRAY_PARAM
1257 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1258 !defined(__STDC_NO_VLA__) && \
1259 !defined(__cplusplus) && \
1260 !defined(JSON_HEDLEY_PGI_VERSION) && \
1261 !defined(JSON_HEDLEY_TINYC_VERSION)
1262 #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1264 #define JSON_HEDLEY_ARRAY_PARAM(name)
1267 #if defined(JSON_HEDLEY_IS_CONSTANT)
1268 #undef JSON_HEDLEY_IS_CONSTANT
1270 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1271 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1275 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1276 #undef JSON_HEDLEY_IS_CONSTEXPR_
1279 JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1280 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1281 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1282 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1283 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1284 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1285 JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
1286 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1287 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1288 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1290 #if !defined(__cplusplus)
1292 JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1293 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1294 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1295 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1296 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1297 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1298 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1299 #if defined(__INTPTR_TYPE__)
1300 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1303 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1306 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(JSON_HEDLEY_SUNPRO_VERSION) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
1307 JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
1308 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1309 JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1310 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1311 JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1312 #if defined(__INTPTR_TYPE__)
1313 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1316 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1319 defined(JSON_HEDLEY_GCC_VERSION) || \
1320 defined(JSON_HEDLEY_INTEL_VERSION) || \
1321 defined(JSON_HEDLEY_TINYC_VERSION) || \
1322 defined(JSON_HEDLEY_TI_VERSION) || \
1324 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1328 ((void*) ((expr) * 0L) ) : \
1329 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1335 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1336 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1337 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1339 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1341 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1342 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1344 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1347 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1348 #undef JSON_HEDLEY_BEGIN_C_DECLS
1350 #if defined(JSON_HEDLEY_END_C_DECLS)
1351 #undef JSON_HEDLEY_END_C_DECLS
1353 #if defined(JSON_HEDLEY_C_DECL)
1354 #undef JSON_HEDLEY_C_DECL
1356 #if defined(__cplusplus)
1357 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
1358 #define JSON_HEDLEY_END_C_DECLS }
1359 #define JSON_HEDLEY_C_DECL extern "C"
1361 #define JSON_HEDLEY_BEGIN_C_DECLS
1362 #define JSON_HEDLEY_END_C_DECLS
1363 #define JSON_HEDLEY_C_DECL
1366 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1367 #undef JSON_HEDLEY_STATIC_ASSERT
1370 !defined(__cplusplus) && ( \
1371 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1372 JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
1373 JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
1374 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1375 defined(_Static_assert) \
1377 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1379 (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
1380 JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
1381 (defined(__cplusplus) && JSON_HEDLEY_TI_VERSION_CHECK(8,3,0))
1382 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1384 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1387 #if defined(JSON_HEDLEY_CONST_CAST)
1388 #undef JSON_HEDLEY_CONST_CAST
1390 #if defined(__cplusplus)
1391 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1393 JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
1394 JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
1395 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1396 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
1397 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1398 JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
1400 JSON_HEDLEY_DIAGNOSTIC_POP \
1403 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1406 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
1407 #undef JSON_HEDLEY_REINTERPRET_CAST
1409 #if defined(__cplusplus)
1410 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1412 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (*((T*) &(expr)))
1415 #if defined(JSON_HEDLEY_STATIC_CAST)
1416 #undef JSON_HEDLEY_STATIC_CAST
1418 #if defined(__cplusplus)
1419 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1421 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1424 #if defined(JSON_HEDLEY_CPP_CAST)
1425 #undef JSON_HEDLEY_CPP_CAST
1427 #if defined(__cplusplus)
1428 #define JSON_HEDLEY_CPP_CAST(T, expr) static_cast<T>(expr)
1430 #define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1433 #if defined(JSON_HEDLEY_NULL)
1434 #undef JSON_HEDLEY_NULL
1436 #if defined(__cplusplus)
1437 #if __cplusplus >= 201103L
1438 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1440 #define JSON_HEDLEY_NULL NULL
1442 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1445 #define JSON_HEDLEY_NULL NULL
1447 #define JSON_HEDLEY_NULL ((void*) 0)
1450 #if defined(JSON_HEDLEY_MESSAGE)
1451 #undef JSON_HEDLEY_MESSAGE
1453 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1454 # define JSON_HEDLEY_MESSAGE(msg) \
1455 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1456 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1457 JSON_HEDLEY_PRAGMA(message msg) \
1458 JSON_HEDLEY_DIAGNOSTIC_POP
1460 JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
1461 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1462 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
1463 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
1464 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
1465 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1466 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1467 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
1468 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1470 # define JSON_HEDLEY_MESSAGE(msg)
1473 #if defined(JSON_HEDLEY_WARNING)
1474 #undef JSON_HEDLEY_WARNING
1476 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1477 # define JSON_HEDLEY_WARNING(msg) \
1478 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1479 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1480 JSON_HEDLEY_PRAGMA(clang warning msg) \
1481 JSON_HEDLEY_DIAGNOSTIC_POP
1483 JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
1484 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0)
1485 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
1486 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1487 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
1489 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1492 #if defined(JSON_HEDLEY_REQUIRE)
1493 #undef JSON_HEDLEY_REQUIRE
1495 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1496 #undef JSON_HEDLEY_REQUIRE_MSG
1498 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1499 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
1500 # define JSON_HEDLEY_REQUIRE(expr) \
1501 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1502 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1503 __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1504 JSON_HEDLEY_DIAGNOSTIC_POP
1505 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
1506 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1507 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1508 __attribute__((diagnose_if(!(expr), msg, "error"))) \
1509 JSON_HEDLEY_DIAGNOSTIC_POP
1511 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1512 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1515 # define JSON_HEDLEY_REQUIRE(expr)
1516 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1519 #if defined(JSON_HEDLEY_FLAGS)
1520 #undef JSON_HEDLEY_FLAGS
1522 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
1523 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1526 #if defined(JSON_HEDLEY_FLAGS_CAST)
1527 #undef JSON_HEDLEY_FLAGS_CAST
1529 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
1530 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
1531 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1532 _Pragma("warning(disable:188)") \
1534 JSON_HEDLEY_DIAGNOSTIC_POP \
1537 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1540 #if defined(JSON_HEDLEY_EMPTY_BASES)
1541 #undef JSON_HEDLEY_EMPTY_BASES
1543 #if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
1544 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
1546 #define JSON_HEDLEY_EMPTY_BASES
1551 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1552 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1554 #if defined(__clang__)
1555 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
1557 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1560 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
1561 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
1563 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
1565 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1566 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1568 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1570 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
1571 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
1573 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
1575 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
1576 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
1578 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
1580 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
1581 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
1583 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
1585 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
1586 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
1588 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
1590 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
1591 #undef JSON_HEDLEY_CLANG_HAS_WARNING
1593 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)