13 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 13)
14 #if defined(JSON_HEDLEY_VERSION)
15 #undef JSON_HEDLEY_VERSION
17 #define JSON_HEDLEY_VERSION 13
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_CONCAT3_EX)
40 #undef JSON_HEDLEY_CONCAT3_EX
42 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
44 #if defined(JSON_HEDLEY_CONCAT3)
45 #undef JSON_HEDLEY_CONCAT3
47 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
49 #if defined(JSON_HEDLEY_VERSION_ENCODE)
50 #undef JSON_HEDLEY_VERSION_ENCODE
52 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
54 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
55 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
57 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
59 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
60 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
62 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
64 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
65 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
67 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
69 #if defined(JSON_HEDLEY_GNUC_VERSION)
70 #undef JSON_HEDLEY_GNUC_VERSION
72 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
73 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
74 #elif defined(__GNUC__)
75 #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
78 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
79 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
81 #if defined(JSON_HEDLEY_GNUC_VERSION)
82 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
84 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
87 #if defined(JSON_HEDLEY_MSVC_VERSION)
88 #undef JSON_HEDLEY_MSVC_VERSION
90 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
91 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
92 #elif defined(_MSC_FULL_VER)
93 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
94 #elif defined(_MSC_VER)
95 #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
98 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
99 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
101 #if !defined(_MSC_VER)
102 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
103 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
104 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
105 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
106 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
108 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
111 #if defined(JSON_HEDLEY_INTEL_VERSION)
112 #undef JSON_HEDLEY_INTEL_VERSION
114 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
115 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
116 #elif defined(__INTEL_COMPILER)
117 #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
120 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
121 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
123 #if defined(JSON_HEDLEY_INTEL_VERSION)
124 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
126 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
129 #if defined(JSON_HEDLEY_PGI_VERSION)
130 #undef JSON_HEDLEY_PGI_VERSION
132 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
133 #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
136 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
137 #undef JSON_HEDLEY_PGI_VERSION_CHECK
139 #if defined(JSON_HEDLEY_PGI_VERSION)
140 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
142 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
145 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
146 #undef JSON_HEDLEY_SUNPRO_VERSION
148 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
149 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
150 #elif defined(__SUNPRO_C)
151 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
152 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
153 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
154 #elif defined(__SUNPRO_CC)
155 #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
158 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
159 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
161 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
162 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
164 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
167 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
168 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
170 #if defined(__EMSCRIPTEN__)
171 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
174 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
175 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
177 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
178 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
180 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
183 #if defined(JSON_HEDLEY_ARM_VERSION)
184 #undef JSON_HEDLEY_ARM_VERSION
186 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
187 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
188 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
189 #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
192 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
193 #undef JSON_HEDLEY_ARM_VERSION_CHECK
195 #if defined(JSON_HEDLEY_ARM_VERSION)
196 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
198 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
201 #if defined(JSON_HEDLEY_IBM_VERSION)
202 #undef JSON_HEDLEY_IBM_VERSION
204 #if defined(__ibmxl__)
205 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
206 #elif defined(__xlC__) && defined(__xlC_ver__)
207 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
208 #elif defined(__xlC__)
209 #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
212 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
213 #undef JSON_HEDLEY_IBM_VERSION_CHECK
215 #if defined(JSON_HEDLEY_IBM_VERSION)
216 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
218 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
221 #if defined(JSON_HEDLEY_TI_VERSION)
222 #undef JSON_HEDLEY_TI_VERSION
225 defined(__TI_COMPILER_VERSION__) && \
227 defined(__TMS470__) || defined(__TI_ARM__) || \
228 defined(__MSP430__) || \
229 defined(__TMS320C2000__) \
231 #if (__TI_COMPILER_VERSION__ >= 16000000)
232 #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
236 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
237 #undef JSON_HEDLEY_TI_VERSION_CHECK
239 #if defined(JSON_HEDLEY_TI_VERSION)
240 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
242 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
245 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
246 #undef JSON_HEDLEY_TI_CL2000_VERSION
248 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
249 #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
252 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
253 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
255 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
256 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
258 #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
261 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
262 #undef JSON_HEDLEY_TI_CL430_VERSION
264 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
265 #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
268 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
269 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
271 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
272 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
274 #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
277 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
278 #undef JSON_HEDLEY_TI_ARMCL_VERSION
280 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
281 #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
284 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
285 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
287 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
288 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
290 #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
293 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
294 #undef JSON_HEDLEY_TI_CL6X_VERSION
296 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
297 #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
300 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
301 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
303 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
304 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
306 #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
309 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
310 #undef JSON_HEDLEY_TI_CL7X_VERSION
312 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
313 #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
316 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
317 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
319 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
320 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
322 #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
325 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
326 #undef JSON_HEDLEY_TI_CLPRU_VERSION
328 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
329 #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
332 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
333 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
335 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
336 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
338 #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
341 #if defined(JSON_HEDLEY_CRAY_VERSION)
342 #undef JSON_HEDLEY_CRAY_VERSION
345 #if defined(_RELEASE_PATCHLEVEL)
346 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
348 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
352 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
353 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
355 #if defined(JSON_HEDLEY_CRAY_VERSION)
356 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
358 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
361 #if defined(JSON_HEDLEY_IAR_VERSION)
362 #undef JSON_HEDLEY_IAR_VERSION
364 #if defined(__IAR_SYSTEMS_ICC__)
366 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
368 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
372 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
373 #undef JSON_HEDLEY_IAR_VERSION_CHECK
375 #if defined(JSON_HEDLEY_IAR_VERSION)
376 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
378 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
381 #if defined(JSON_HEDLEY_TINYC_VERSION)
382 #undef JSON_HEDLEY_TINYC_VERSION
384 #if defined(__TINYC__)
385 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
388 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
389 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
391 #if defined(JSON_HEDLEY_TINYC_VERSION)
392 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
394 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
397 #if defined(JSON_HEDLEY_DMC_VERSION)
398 #undef JSON_HEDLEY_DMC_VERSION
401 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
404 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
405 #undef JSON_HEDLEY_DMC_VERSION_CHECK
407 #if defined(JSON_HEDLEY_DMC_VERSION)
408 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
410 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
413 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
414 #undef JSON_HEDLEY_COMPCERT_VERSION
416 #if defined(__COMPCERT_VERSION__)
417 #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
420 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
421 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
423 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
424 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
426 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
429 #if defined(JSON_HEDLEY_PELLES_VERSION)
430 #undef JSON_HEDLEY_PELLES_VERSION
432 #if defined(__POCC__)
433 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
436 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
437 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
439 #if defined(JSON_HEDLEY_PELLES_VERSION)
440 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
442 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
445 #if defined(JSON_HEDLEY_GCC_VERSION)
446 #undef JSON_HEDLEY_GCC_VERSION
449 defined(JSON_HEDLEY_GNUC_VERSION) && \
450 !defined(__clang__) && \
451 !defined(JSON_HEDLEY_INTEL_VERSION) && \
452 !defined(JSON_HEDLEY_PGI_VERSION) && \
453 !defined(JSON_HEDLEY_ARM_VERSION) && \
454 !defined(JSON_HEDLEY_TI_VERSION) && \
455 !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
456 !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
457 !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
458 !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
459 !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
460 !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
461 !defined(__COMPCERT__)
462 #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
465 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
466 #undef JSON_HEDLEY_GCC_VERSION_CHECK
468 #if defined(JSON_HEDLEY_GCC_VERSION)
469 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
471 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
474 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
475 #undef JSON_HEDLEY_HAS_ATTRIBUTE
477 #if defined(__has_attribute)
478 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
480 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
483 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
484 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
486 #if defined(__has_attribute)
487 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
489 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
492 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
493 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
495 #if defined(__has_attribute)
496 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
498 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
501 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
502 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
505 defined(__has_cpp_attribute) && \
506 defined(__cplusplus) && \
507 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
508 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
510 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
513 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
514 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
516 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
517 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
519 !defined(JSON_HEDLEY_PGI_VERSION) && \
520 !defined(JSON_HEDLEY_IAR_VERSION) && \
521 (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
522 (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
523 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
525 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
528 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
529 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
531 #if defined(__has_cpp_attribute) && defined(__cplusplus)
532 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
534 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
537 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
538 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
540 #if defined(__has_cpp_attribute) && defined(__cplusplus)
541 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
543 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
546 #if defined(JSON_HEDLEY_HAS_BUILTIN)
547 #undef JSON_HEDLEY_HAS_BUILTIN
549 #if defined(__has_builtin)
550 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
552 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
555 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
556 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
558 #if defined(__has_builtin)
559 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
561 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
564 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
565 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
567 #if defined(__has_builtin)
568 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
570 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
573 #if defined(JSON_HEDLEY_HAS_FEATURE)
574 #undef JSON_HEDLEY_HAS_FEATURE
576 #if defined(__has_feature)
577 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
579 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
582 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
583 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
585 #if defined(__has_feature)
586 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
588 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
591 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
592 #undef JSON_HEDLEY_GCC_HAS_FEATURE
594 #if defined(__has_feature)
595 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
597 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
600 #if defined(JSON_HEDLEY_HAS_EXTENSION)
601 #undef JSON_HEDLEY_HAS_EXTENSION
603 #if defined(__has_extension)
604 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
606 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
609 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
610 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
612 #if defined(__has_extension)
613 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
615 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
618 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
619 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
621 #if defined(__has_extension)
622 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
624 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
627 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
628 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
630 #if defined(__has_declspec_attribute)
631 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
633 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
636 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
637 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
639 #if defined(__has_declspec_attribute)
640 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
642 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
645 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
646 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
648 #if defined(__has_declspec_attribute)
649 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
651 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
654 #if defined(JSON_HEDLEY_HAS_WARNING)
655 #undef JSON_HEDLEY_HAS_WARNING
657 #if defined(__has_warning)
658 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
660 #define JSON_HEDLEY_HAS_WARNING(warning) (0)
663 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
664 #undef JSON_HEDLEY_GNUC_HAS_WARNING
666 #if defined(__has_warning)
667 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
669 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
672 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
673 #undef JSON_HEDLEY_GCC_HAS_WARNING
675 #if defined(__has_warning)
676 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
678 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
683 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
684 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
686 #if defined(__cplusplus)
687 # if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
688 # if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
689 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
690 JSON_HEDLEY_DIAGNOSTIC_PUSH \
691 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
692 _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
694 JSON_HEDLEY_DIAGNOSTIC_POP
696 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
697 JSON_HEDLEY_DIAGNOSTIC_PUSH \
698 _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
700 JSON_HEDLEY_DIAGNOSTIC_POP
704 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
705 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
708 #if defined(JSON_HEDLEY_CONST_CAST)
709 #undef JSON_HEDLEY_CONST_CAST
711 #if defined(__cplusplus)
712 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
714 JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
715 JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
716 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
717 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
718 JSON_HEDLEY_DIAGNOSTIC_PUSH \
719 JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
721 JSON_HEDLEY_DIAGNOSTIC_POP \
724 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
727 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
728 #undef JSON_HEDLEY_REINTERPRET_CAST
730 #if defined(__cplusplus)
731 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
733 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
736 #if defined(JSON_HEDLEY_STATIC_CAST)
737 #undef JSON_HEDLEY_STATIC_CAST
739 #if defined(__cplusplus)
740 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
742 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
745 #if defined(JSON_HEDLEY_CPP_CAST)
746 #undef JSON_HEDLEY_CPP_CAST
748 #if defined(__cplusplus)
749 # if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
750 # define JSON_HEDLEY_CPP_CAST(T, expr) \
751 JSON_HEDLEY_DIAGNOSTIC_PUSH \
752 _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
754 JSON_HEDLEY_DIAGNOSTIC_POP
755 # elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
756 # define JSON_HEDLEY_CPP_CAST(T, expr) \
757 JSON_HEDLEY_DIAGNOSTIC_PUSH \
758 _Pragma("diag_suppress=Pe137") \
759 JSON_HEDLEY_DIAGNOSTIC_POP \
761 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
764 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
768 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
769 defined(__clang__) || \
770 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
771 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
772 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
773 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
774 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
775 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
776 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
777 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
778 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
779 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
780 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
781 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
782 JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
783 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
784 JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
785 (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
786 #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
787 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
788 #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
790 #define JSON_HEDLEY_PRAGMA(value)
793 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
794 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
796 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
797 #undef JSON_HEDLEY_DIAGNOSTIC_POP
799 #if defined(__clang__)
800 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
801 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
802 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
803 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
804 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
805 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
806 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
807 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
808 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
809 #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
810 #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
811 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
812 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
813 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
815 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
816 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
817 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
818 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
819 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
820 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
821 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
822 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
823 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
824 #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
825 #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
827 #define JSON_HEDLEY_DIAGNOSTIC_PUSH
828 #define JSON_HEDLEY_DIAGNOSTIC_POP
831 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
832 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
834 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
835 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
836 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
837 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
838 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
839 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
840 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
841 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
842 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
843 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
845 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
846 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
847 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
848 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
849 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
850 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
851 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
852 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
853 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
854 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
855 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
856 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
857 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
858 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
859 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
860 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
861 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
862 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
863 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
864 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
866 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
869 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
870 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
872 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
873 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
874 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
875 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
876 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
877 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
878 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
879 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
880 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
881 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
883 JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
884 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
885 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
886 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
887 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
888 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
889 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
890 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
891 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
893 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
896 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
897 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
899 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
900 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
901 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
902 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
903 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
904 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
905 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
906 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
907 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
908 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
909 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
910 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
912 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
913 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
914 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
915 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
916 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
917 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
919 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
922 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
923 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
925 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
926 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
927 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
928 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
929 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
930 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
932 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
935 #if defined(JSON_HEDLEY_DEPRECATED)
936 #undef JSON_HEDLEY_DEPRECATED
938 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
939 #undef JSON_HEDLEY_DEPRECATED_FOR
941 #if JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
942 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
943 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
944 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
945 #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
946 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
948 JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
949 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
950 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
951 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
952 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
953 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
954 JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
955 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
956 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
957 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
958 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
959 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
960 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
962 JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
963 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
964 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
965 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
966 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
967 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
968 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
969 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
970 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
971 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
972 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
973 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
974 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
975 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
976 #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
977 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
979 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
980 JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
981 #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
982 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
983 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
984 #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
985 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
987 #define JSON_HEDLEY_DEPRECATED(since)
988 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
991 #if defined(JSON_HEDLEY_UNAVAILABLE)
992 #undef JSON_HEDLEY_UNAVAILABLE
995 JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
996 JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
997 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
998 #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1000 #define JSON_HEDLEY_UNAVAILABLE(available_since)
1003 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1004 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1006 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1007 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1009 #if (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1010 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1011 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1012 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1013 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1014 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1016 JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1017 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1018 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1019 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1020 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1021 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1022 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1023 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1024 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1025 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1026 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1027 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1028 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1029 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1030 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1031 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1032 #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1033 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1034 #elif defined(_Check_return_)
1035 #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1036 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1038 #define JSON_HEDLEY_WARN_UNUSED_RESULT
1039 #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1042 #if defined(JSON_HEDLEY_SENTINEL)
1043 #undef JSON_HEDLEY_SENTINEL
1046 JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1047 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1048 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1049 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
1050 #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1052 #define JSON_HEDLEY_SENTINEL(position)
1055 #if defined(JSON_HEDLEY_NO_RETURN)
1056 #undef JSON_HEDLEY_NO_RETURN
1058 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1059 #define JSON_HEDLEY_NO_RETURN __noreturn
1060 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1061 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1062 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1063 #define JSON_HEDLEY_NO_RETURN _Noreturn
1064 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1065 #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1067 JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1068 JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1069 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1070 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1071 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1072 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1073 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1074 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1075 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1076 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1077 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1078 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1079 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1080 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1081 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1082 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1083 #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1084 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1085 #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1086 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1087 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1088 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1089 #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1090 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1091 #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1092 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1093 #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1095 #define JSON_HEDLEY_NO_RETURN
1098 #if defined(JSON_HEDLEY_NO_ESCAPE)
1099 #undef JSON_HEDLEY_NO_ESCAPE
1101 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1102 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1104 #define JSON_HEDLEY_NO_ESCAPE
1107 #if defined(JSON_HEDLEY_UNREACHABLE)
1108 #undef JSON_HEDLEY_UNREACHABLE
1110 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1111 #undef JSON_HEDLEY_UNREACHABLE_RETURN
1113 #if defined(JSON_HEDLEY_ASSUME)
1114 #undef JSON_HEDLEY_ASSUME
1117 JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1118 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1119 #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1120 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1121 #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1123 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1124 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1125 #if defined(__cplusplus)
1126 #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1128 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1132 (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1133 JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1134 JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1135 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1136 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
1137 #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1138 #elif defined(JSON_HEDLEY_ASSUME)
1139 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1141 #if !defined(JSON_HEDLEY_ASSUME)
1142 #if defined(JSON_HEDLEY_UNREACHABLE)
1143 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1145 #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1148 #if defined(JSON_HEDLEY_UNREACHABLE)
1150 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1151 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1152 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1154 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1157 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1159 #if !defined(JSON_HEDLEY_UNREACHABLE)
1160 #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1163 JSON_HEDLEY_DIAGNOSTIC_PUSH
1164 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1165 #pragma clang diagnostic ignored "-Wpedantic"
1167 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1168 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1170 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1171 #if defined(__clang__)
1172 #pragma clang diagnostic ignored "-Wvariadic-macros"
1173 #elif defined(JSON_HEDLEY_GCC_VERSION)
1174 #pragma GCC diagnostic ignored "-Wvariadic-macros"
1177 #if defined(JSON_HEDLEY_NON_NULL)
1178 #undef JSON_HEDLEY_NON_NULL
1181 JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1182 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1183 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1184 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1185 #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1187 #define JSON_HEDLEY_NON_NULL(...)
1189 JSON_HEDLEY_DIAGNOSTIC_POP
1191 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1192 #undef JSON_HEDLEY_PRINTF_FORMAT
1194 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1195 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1196 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1197 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1199 JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1200 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1201 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1202 JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1203 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1204 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1205 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1206 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1207 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1208 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1209 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1210 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1211 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1212 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1213 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1214 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1215 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1216 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1217 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1219 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1222 #if defined(JSON_HEDLEY_CONSTEXPR)
1223 #undef JSON_HEDLEY_CONSTEXPR
1225 #if defined(__cplusplus)
1226 #if __cplusplus >= 201103L
1227 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1230 #if !defined(JSON_HEDLEY_CONSTEXPR)
1231 #define JSON_HEDLEY_CONSTEXPR
1234 #if defined(JSON_HEDLEY_PREDICT)
1235 #undef JSON_HEDLEY_PREDICT
1237 #if defined(JSON_HEDLEY_LIKELY)
1238 #undef JSON_HEDLEY_LIKELY
1240 #if defined(JSON_HEDLEY_UNLIKELY)
1241 #undef JSON_HEDLEY_UNLIKELY
1243 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1244 #undef JSON_HEDLEY_UNPREDICTABLE
1246 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1247 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1250 JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
1251 JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
1252 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))
1253 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))
1254 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))
1255 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )
1256 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )
1258 JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
1259 JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1260 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1261 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1262 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1263 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1264 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1265 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1266 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1267 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1268 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1269 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1270 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1271 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1272 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1273 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1274 (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1275 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1277 double hedley_probability_ = (probability); \
1278 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1280 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1282 double hedley_probability_ = (probability); \
1283 ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1285 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1286 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1288 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1289 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1290 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1291 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1292 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1294 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1295 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1298 #if defined(JSON_HEDLEY_MALLOC)
1299 #undef JSON_HEDLEY_MALLOC
1302 JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1303 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1304 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1305 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1306 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1307 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1308 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1309 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1310 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1311 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1312 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1313 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1314 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1315 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1316 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1317 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1318 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1319 #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1320 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1321 #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1322 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
1323 #define JSON_HEDLEY_MALLOC __declspec(restrict)
1325 #define JSON_HEDLEY_MALLOC
1328 #if defined(JSON_HEDLEY_PURE)
1329 #undef JSON_HEDLEY_PURE
1332 JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1333 JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1334 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1335 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1336 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1337 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1338 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1339 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1340 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1341 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1342 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1343 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1344 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1345 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1346 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1347 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1348 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1349 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1350 # define JSON_HEDLEY_PURE __attribute__((__pure__))
1351 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1352 # define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1353 #elif defined(__cplusplus) && \
1355 JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1356 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1357 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1359 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1361 # define JSON_HEDLEY_PURE
1364 #if defined(JSON_HEDLEY_CONST)
1365 #undef JSON_HEDLEY_CONST
1368 JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1369 JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1370 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1371 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1372 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1373 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1374 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1375 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1376 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1377 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1378 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1379 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1380 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1381 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1382 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1383 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1384 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1385 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1386 #define JSON_HEDLEY_CONST __attribute__((__const__))
1388 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1389 #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1391 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1394 #if defined(JSON_HEDLEY_RESTRICT)
1395 #undef JSON_HEDLEY_RESTRICT
1397 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1398 #define JSON_HEDLEY_RESTRICT restrict
1400 JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1401 JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1402 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1403 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1404 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1405 JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1406 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1407 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1408 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1409 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1410 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1411 JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1413 #define JSON_HEDLEY_RESTRICT __restrict
1414 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1415 #define JSON_HEDLEY_RESTRICT _Restrict
1417 #define JSON_HEDLEY_RESTRICT
1420 #if defined(JSON_HEDLEY_INLINE)
1421 #undef JSON_HEDLEY_INLINE
1424 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1425 (defined(__cplusplus) && (__cplusplus >= 199711L))
1426 #define JSON_HEDLEY_INLINE inline
1428 defined(JSON_HEDLEY_GCC_VERSION) || \
1429 JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1430 #define JSON_HEDLEY_INLINE __inline__
1432 JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1433 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1434 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1435 JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1436 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1437 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1438 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1439 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1440 #define JSON_HEDLEY_INLINE __inline
1442 #define JSON_HEDLEY_INLINE
1445 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1446 #undef JSON_HEDLEY_ALWAYS_INLINE
1449 JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1450 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1451 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1452 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1453 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1454 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1455 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1456 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1457 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1458 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1459 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1460 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1461 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1462 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1463 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1464 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1465 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1466 # define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1467 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
1468 # define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1469 #elif defined(__cplusplus) && \
1471 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1472 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1473 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1474 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1475 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1476 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1478 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1479 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1480 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1482 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1485 #if defined(JSON_HEDLEY_NEVER_INLINE)
1486 #undef JSON_HEDLEY_NEVER_INLINE
1489 JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1490 JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1491 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1492 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1493 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1494 JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1495 JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1496 (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1497 JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1498 (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1499 JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1500 (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1501 JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1502 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1503 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1504 JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1505 JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1506 #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1507 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1508 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1509 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1510 #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1511 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1512 #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1513 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1514 #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1515 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1516 #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1517 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1518 #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1520 #define JSON_HEDLEY_NEVER_INLINE
1523 #if defined(JSON_HEDLEY_PRIVATE)
1524 #undef JSON_HEDLEY_PRIVATE
1526 #if defined(JSON_HEDLEY_PUBLIC)
1527 #undef JSON_HEDLEY_PUBLIC
1529 #if defined(JSON_HEDLEY_IMPORT)
1530 #undef JSON_HEDLEY_IMPORT
1532 #if defined(_WIN32) || defined(__CYGWIN__)
1533 # define JSON_HEDLEY_PRIVATE
1534 # define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1535 # define JSON_HEDLEY_IMPORT __declspec(dllimport)
1538 JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1539 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1540 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1541 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1542 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1543 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1545 defined(__TI_EABI__) && \
1547 (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1548 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1551 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1552 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1554 # define JSON_HEDLEY_PRIVATE
1555 # define JSON_HEDLEY_PUBLIC
1557 # define JSON_HEDLEY_IMPORT extern
1560 #if defined(JSON_HEDLEY_NO_THROW)
1561 #undef JSON_HEDLEY_NO_THROW
1564 JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1565 JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1566 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1567 #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1569 JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1570 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1571 #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1573 #define JSON_HEDLEY_NO_THROW
1576 #if defined(JSON_HEDLEY_FALL_THROUGH)
1577 #undef JSON_HEDLEY_FALL_THROUGH
1580 JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1581 JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0)
1582 #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1583 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1584 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1585 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1586 #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1587 #elif defined(__fallthrough)
1588 #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1590 #define JSON_HEDLEY_FALL_THROUGH
1593 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1594 #undef JSON_HEDLEY_RETURNS_NON_NULL
1597 JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1598 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
1599 #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1600 #elif defined(_Ret_notnull_)
1601 #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1603 #define JSON_HEDLEY_RETURNS_NON_NULL
1606 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1607 #undef JSON_HEDLEY_ARRAY_PARAM
1610 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1611 !defined(__STDC_NO_VLA__) && \
1612 !defined(__cplusplus) && \
1613 !defined(JSON_HEDLEY_PGI_VERSION) && \
1614 !defined(JSON_HEDLEY_TINYC_VERSION)
1615 #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1617 #define JSON_HEDLEY_ARRAY_PARAM(name)
1620 #if defined(JSON_HEDLEY_IS_CONSTANT)
1621 #undef JSON_HEDLEY_IS_CONSTANT
1623 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1624 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1628 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1629 #undef JSON_HEDLEY_IS_CONSTEXPR_
1632 JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1633 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1634 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1635 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1636 JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1637 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1638 JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1639 (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1640 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1641 #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1643 #if !defined(__cplusplus)
1645 JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1646 JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1647 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1648 JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1649 JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1650 JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1651 JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1652 #if defined(__INTPTR_TYPE__)
1653 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1656 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1660 defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1661 !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1662 !defined(JSON_HEDLEY_PGI_VERSION) && \
1663 !defined(JSON_HEDLEY_IAR_VERSION)) || \
1664 JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
1665 JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1666 JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1667 JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1668 JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1669 #if defined(__INTPTR_TYPE__)
1670 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1673 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1676 defined(JSON_HEDLEY_GCC_VERSION) || \
1677 defined(JSON_HEDLEY_INTEL_VERSION) || \
1678 defined(JSON_HEDLEY_TINYC_VERSION) || \
1679 defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1680 JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1681 defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1682 defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1683 defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1684 defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1686 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1690 ((void*) ((expr) * 0L) ) : \
1691 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1697 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1698 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1699 #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1701 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1703 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1704 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1706 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1709 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1710 #undef JSON_HEDLEY_BEGIN_C_DECLS
1712 #if defined(JSON_HEDLEY_END_C_DECLS)
1713 #undef JSON_HEDLEY_END_C_DECLS
1715 #if defined(JSON_HEDLEY_C_DECL)
1716 #undef JSON_HEDLEY_C_DECL
1718 #if defined(__cplusplus)
1719 #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
1720 #define JSON_HEDLEY_END_C_DECLS }
1721 #define JSON_HEDLEY_C_DECL extern "C"
1723 #define JSON_HEDLEY_BEGIN_C_DECLS
1724 #define JSON_HEDLEY_END_C_DECLS
1725 #define JSON_HEDLEY_C_DECL
1728 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1729 #undef JSON_HEDLEY_STATIC_ASSERT
1732 !defined(__cplusplus) && ( \
1733 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1734 JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
1735 JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
1736 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1737 defined(_Static_assert) \
1739 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1741 (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
1742 JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0)
1743 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1745 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1748 #if defined(JSON_HEDLEY_NULL)
1749 #undef JSON_HEDLEY_NULL
1751 #if defined(__cplusplus)
1752 #if __cplusplus >= 201103L
1753 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1755 #define JSON_HEDLEY_NULL NULL
1757 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1760 #define JSON_HEDLEY_NULL NULL
1762 #define JSON_HEDLEY_NULL ((void*) 0)
1765 #if defined(JSON_HEDLEY_MESSAGE)
1766 #undef JSON_HEDLEY_MESSAGE
1768 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1769 # define JSON_HEDLEY_MESSAGE(msg) \
1770 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1771 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1772 JSON_HEDLEY_PRAGMA(message msg) \
1773 JSON_HEDLEY_DIAGNOSTIC_POP
1775 JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
1776 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1777 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
1778 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
1779 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
1780 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1781 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1782 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
1783 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1785 # define JSON_HEDLEY_MESSAGE(msg)
1788 #if defined(JSON_HEDLEY_WARNING)
1789 #undef JSON_HEDLEY_WARNING
1791 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1792 # define JSON_HEDLEY_WARNING(msg) \
1793 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1794 JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1795 JSON_HEDLEY_PRAGMA(clang warning msg) \
1796 JSON_HEDLEY_DIAGNOSTIC_POP
1798 JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
1799 JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1800 JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1801 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
1802 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1803 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
1805 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1808 #if defined(JSON_HEDLEY_REQUIRE)
1809 #undef JSON_HEDLEY_REQUIRE
1811 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1812 #undef JSON_HEDLEY_REQUIRE_MSG
1814 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1815 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
1816 # define JSON_HEDLEY_REQUIRE(expr) \
1817 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1818 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1819 __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1820 JSON_HEDLEY_DIAGNOSTIC_POP
1821 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
1822 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1823 _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1824 __attribute__((diagnose_if(!(expr), msg, "error"))) \
1825 JSON_HEDLEY_DIAGNOSTIC_POP
1827 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1828 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1831 # define JSON_HEDLEY_REQUIRE(expr)
1832 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1835 #if defined(JSON_HEDLEY_FLAGS)
1836 #undef JSON_HEDLEY_FLAGS
1838 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
1839 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1842 #if defined(JSON_HEDLEY_FLAGS_CAST)
1843 #undef JSON_HEDLEY_FLAGS_CAST
1845 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
1846 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
1847 JSON_HEDLEY_DIAGNOSTIC_PUSH \
1848 _Pragma("warning(disable:188)") \
1850 JSON_HEDLEY_DIAGNOSTIC_POP \
1853 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1856 #if defined(JSON_HEDLEY_EMPTY_BASES)
1857 #undef JSON_HEDLEY_EMPTY_BASES
1859 #if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
1860 #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
1862 #define JSON_HEDLEY_EMPTY_BASES
1867 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1868 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1870 #if defined(__clang__)
1871 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
1873 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1876 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
1877 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
1879 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
1881 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1882 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1884 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1886 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
1887 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
1889 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
1891 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
1892 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
1894 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
1896 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
1897 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
1899 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
1901 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
1902 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
1904 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
1906 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
1907 #undef JSON_HEDLEY_CLANG_HAS_WARNING
1909 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)