1/* Hedley - https://nemequ.github.io/hedley
2 * Created by Evan Nemerson <evan@nemerson.com>
3 *
4 * To the extent possible under law, the author(s) have dedicated all
5 * copyright and related and neighboring rights to this software to
6 * the public domain worldwide. This software is distributed without
7 * any warranty.
8 *
9 * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
10 * SPDX-License-Identifier: CC0-1.0
11 */
12
13#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 11)
14#if defined(JSON_HEDLEY_VERSION)
15 #undef JSON_HEDLEY_VERSION
16#endif
17#define JSON_HEDLEY_VERSION 11
18
19#if defined(JSON_HEDLEY_STRINGIFY_EX)
20 #undef JSON_HEDLEY_STRINGIFY_EX
21#endif
22#define JSON_HEDLEY_STRINGIFY_EX(x) #x
23
24#if defined(JSON_HEDLEY_STRINGIFY)
25 #undef JSON_HEDLEY_STRINGIFY
26#endif
27#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
28
29#if defined(JSON_HEDLEY_CONCAT_EX)
30 #undef JSON_HEDLEY_CONCAT_EX
31#endif
32#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
33
34#if defined(JSON_HEDLEY_CONCAT)
35 #undef JSON_HEDLEY_CONCAT
36#endif
37#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
38
39#if defined(JSON_HEDLEY_VERSION_ENCODE)
40 #undef JSON_HEDLEY_VERSION_ENCODE
41#endif
42#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
43
44#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
45 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
46#endif
47#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
48
49#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
50 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
51#endif
52#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
53
54#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
55 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
56#endif
57#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
58
59#if defined(JSON_HEDLEY_GNUC_VERSION)
60 #undef JSON_HEDLEY_GNUC_VERSION
61#endif
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)
66#endif
67
68#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
69 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
70#endif
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))
73#else
74 #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
75#endif
76
77#if defined(JSON_HEDLEY_MSVC_VERSION)
78 #undef JSON_HEDLEY_MSVC_VERSION
79#endif
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)
86#endif
87
88#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
89 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
90#endif
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)))
97#else
98 #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
99#endif
100
101#if defined(JSON_HEDLEY_INTEL_VERSION)
102 #undef JSON_HEDLEY_INTEL_VERSION
103#endif
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)
108#endif
109
110#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
111 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
112#endif
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))
115#else
116 #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
117#endif
118
119#if defined(JSON_HEDLEY_PGI_VERSION)
120 #undef JSON_HEDLEY_PGI_VERSION
121#endif
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__)
124#endif
125
126#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
127 #undef JSON_HEDLEY_PGI_VERSION_CHECK
128#endif
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))
131#else
132 #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
133#endif
134
135#if defined(JSON_HEDLEY_SUNPRO_VERSION)
136 #undef JSON_HEDLEY_SUNPRO_VERSION
137#endif
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)
146#endif
147
148#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
149 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
150#endif
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))
153#else
154 #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
155#endif
156
157#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
158 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
159#endif
160#if defined(__EMSCRIPTEN__)
161 #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
162#endif
163
164#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
165 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
166#endif
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))
169#else
170 #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
171#endif
172
173#if defined(JSON_HEDLEY_ARM_VERSION)
174 #undef JSON_HEDLEY_ARM_VERSION
175#endif
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)
180#endif
181
182#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
183 #undef JSON_HEDLEY_ARM_VERSION_CHECK
184#endif
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))
187#else
188 #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
189#endif
190
191#if defined(JSON_HEDLEY_IBM_VERSION)
192 #undef JSON_HEDLEY_IBM_VERSION
193#endif
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)
200#endif
201
202#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
203 #undef JSON_HEDLEY_IBM_VERSION_CHECK
204#endif
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))
207#else
208 #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
209#endif
210
211#if defined(JSON_HEDLEY_TI_VERSION)
212 #undef JSON_HEDLEY_TI_VERSION
213#endif
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))
216#endif
217
218#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
219 #undef JSON_HEDLEY_TI_VERSION_CHECK
220#endif
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))
223#else
224 #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
225#endif
226
227#if defined(JSON_HEDLEY_CRAY_VERSION)
228 #undef JSON_HEDLEY_CRAY_VERSION
229#endif
230#if defined(_CRAYC)
231 #if defined(_RELEASE_PATCHLEVEL)
232 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
233 #else
234 #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
235 #endif
236#endif
237
238#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
239 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
240#endif
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))
243#else
244 #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
245#endif
246
247#if defined(JSON_HEDLEY_IAR_VERSION)
248 #undef JSON_HEDLEY_IAR_VERSION
249#endif
250#if defined(__IAR_SYSTEMS_ICC__)
251 #if __VER__ > 1000
252 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
253 #else
254 #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
255 #endif
256#endif
257
258#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
259 #undef JSON_HEDLEY_IAR_VERSION_CHECK
260#endif
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))
263#else
264 #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
265#endif
266
267#if defined(JSON_HEDLEY_TINYC_VERSION)
268 #undef JSON_HEDLEY_TINYC_VERSION
269#endif
270#if defined(__TINYC__)
271 #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
272#endif
273
274#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
275 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
276#endif
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))
279#else
280 #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
281#endif
282
283#if defined(JSON_HEDLEY_DMC_VERSION)
284 #undef JSON_HEDLEY_DMC_VERSION
285#endif
286#if defined(__DMC__)
287 #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
288#endif
289
290#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
291 #undef JSON_HEDLEY_DMC_VERSION_CHECK
292#endif
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))
295#else
296 #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
297#endif
298
299#if defined(JSON_HEDLEY_COMPCERT_VERSION)
300 #undef JSON_HEDLEY_COMPCERT_VERSION
301#endif
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)
304#endif
305
306#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
307 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
308#endif
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))
311#else
312 #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
313#endif
314
315#if defined(JSON_HEDLEY_PELLES_VERSION)
316 #undef JSON_HEDLEY_PELLES_VERSION
317#endif
318#if defined(__POCC__)
319 #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
320#endif
321
322#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
323 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
324#endif
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))
327#else
328 #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
329#endif
330
331#if defined(JSON_HEDLEY_GCC_VERSION)
332 #undef JSON_HEDLEY_GCC_VERSION
333#endif
334#if \
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
343#endif
344
345#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
346 #undef JSON_HEDLEY_GCC_VERSION_CHECK
347#endif
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))
350#else
351 #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
352#endif
353
354#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
355 #undef JSON_HEDLEY_HAS_ATTRIBUTE
356#endif
357#if defined(__has_attribute)
358 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
359#else
360 #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
361#endif
362
363#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
364 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
365#endif
366#if defined(__has_attribute)
367 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
368#else
369 #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
370#endif
371
372#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
373 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
374#endif
375#if defined(__has_attribute)
376 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
377#else
378 #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
379#endif
380
381#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
382 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
383#endif
384#if \
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)
389#else
390 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
391#endif
392
393#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
394 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
395#endif
396#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
397 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
398#elif \
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)
403#else
404 #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
405#endif
406
407#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
408 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
409#endif
410#if defined(__has_cpp_attribute) && defined(__cplusplus)
411 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
412#else
413 #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
414#endif
415
416#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
417 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
418#endif
419#if defined(__has_cpp_attribute) && defined(__cplusplus)
420 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
421#else
422 #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
423#endif
424
425#if defined(JSON_HEDLEY_HAS_BUILTIN)
426 #undef JSON_HEDLEY_HAS_BUILTIN
427#endif
428#if defined(__has_builtin)
429 #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
430#else
431 #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
432#endif
433
434#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
435 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
436#endif
437#if defined(__has_builtin)
438 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
439#else
440 #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
441#endif
442
443#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
444 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
445#endif
446#if defined(__has_builtin)
447 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
448#else
449 #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
450#endif
451
452#if defined(JSON_HEDLEY_HAS_FEATURE)
453 #undef JSON_HEDLEY_HAS_FEATURE
454#endif
455#if defined(__has_feature)
456 #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
457#else
458 #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
459#endif
460
461#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
462 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
463#endif
464#if defined(__has_feature)
465 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
466#else
467 #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
468#endif
469
470#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
471 #undef JSON_HEDLEY_GCC_HAS_FEATURE
472#endif
473#if defined(__has_feature)
474 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
475#else
476 #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
477#endif
478
479#if defined(JSON_HEDLEY_HAS_EXTENSION)
480 #undef JSON_HEDLEY_HAS_EXTENSION
481#endif
482#if defined(__has_extension)
483 #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
484#else
485 #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
486#endif
487
488#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
489 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
490#endif
491#if defined(__has_extension)
492 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
493#else
494 #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
495#endif
496
497#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
498 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
499#endif
500#if defined(__has_extension)
501 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
502#else
503 #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
504#endif
505
506#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
507 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
508#endif
509#if defined(__has_declspec_attribute)
510 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
511#else
512 #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
513#endif
514
515#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
516 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
517#endif
518#if defined(__has_declspec_attribute)
519 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
520#else
521 #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
522#endif
523
524#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
525 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
526#endif
527#if defined(__has_declspec_attribute)
528 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
529#else
530 #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
531#endif
532
533#if defined(JSON_HEDLEY_HAS_WARNING)
534 #undef JSON_HEDLEY_HAS_WARNING
535#endif
536#if defined(__has_warning)
537 #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
538#else
539 #define JSON_HEDLEY_HAS_WARNING(warning) (0)
540#endif
541
542#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
543 #undef JSON_HEDLEY_GNUC_HAS_WARNING
544#endif
545#if defined(__has_warning)
546 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
547#else
548 #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
549#endif
550
551#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
552 #undef JSON_HEDLEY_GCC_HAS_WARNING
553#endif
554#if defined(__has_warning)
555 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
556#else
557 #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
558#endif
559
560/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
561 HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
562#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
563 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
564#endif
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\"") \
569 xpr \
570 JSON_HEDLEY_DIAGNOSTIC_POP
571#else
572# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
573#endif
574
575#if \
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)
591#else
592 #define JSON_HEDLEY_PRAGMA(value)
593#endif
594
595#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
596 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
597#endif
598#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
599 #undef JSON_HEDLEY_DIAGNOSTIC_POP
600#endif
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)")
622#else
623 #define JSON_HEDLEY_DIAGNOSTIC_PUSH
624 #define JSON_HEDLEY_DIAGNOSTIC_POP
625#endif
626
627#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
628 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
629#endif
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)")
650#else
651 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
652#endif
653
654#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
655 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
656#endif
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")
671#else
672 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
673#endif
674
675#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
676 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
677#endif
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")
692#else
693 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
694#endif
695
696#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
697 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
698#endif
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\"")
705#else
706 #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
707#endif
708
709#if defined(JSON_HEDLEY_DEPRECATED)
710 #undef JSON_HEDLEY_DEPRECATED
711#endif
712#if defined(JSON_HEDLEY_DEPRECATED_FOR)
713 #undef JSON_HEDLEY_DEPRECATED_FOR
714#endif
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)]])
718#elif \
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)))
728#elif \
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))
739#elif \
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")
747#else
748 #define JSON_HEDLEY_DEPRECATED(since)
749 #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
750#endif
751
752#if defined(JSON_HEDLEY_UNAVAILABLE)
753 #undef JSON_HEDLEY_UNAVAILABLE
754#endif
755#if \
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)))
760#else
761 #define JSON_HEDLEY_UNAVAILABLE(available_since)
762#endif
763
764#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
765 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
766#endif
767#if defined(__cplusplus) && (__cplusplus >= 201703L)
768 #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
769#elif \
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_) /* SAL */
779 #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
780#else
781 #define JSON_HEDLEY_WARN_UNUSED_RESULT
782#endif
783
784#if defined(JSON_HEDLEY_SENTINEL)
785 #undef JSON_HEDLEY_SENTINEL
786#endif
787#if \
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)))
793#else
794 #define JSON_HEDLEY_SENTINEL(position)
795#endif
796
797#if defined(JSON_HEDLEY_NO_RETURN)
798 #undef JSON_HEDLEY_NO_RETURN
799#endif
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]])
808#elif \
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)
827#else
828 #define JSON_HEDLEY_NO_RETURN
829#endif
830
831#if defined(JSON_HEDLEY_NO_ESCAPE)
832 #undef JSON_HEDLEY_NO_ESCAPE
833#endif
834#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
835 #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
836#else
837 #define JSON_HEDLEY_NO_ESCAPE
838#endif
839
840#if defined(JSON_HEDLEY_UNREACHABLE)
841 #undef JSON_HEDLEY_UNREACHABLE
842#endif
843#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
844 #undef JSON_HEDLEY_UNREACHABLE_RETURN
845#endif
846#if \
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)
857 #else
858 #define JSON_HEDLEY_UNREACHABLE() _nassert(0)
859 #endif
860 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
861#elif defined(EXIT_FAILURE)
862 #define JSON_HEDLEY_UNREACHABLE() abort()
863#else
864 #define JSON_HEDLEY_UNREACHABLE()
865 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
866#endif
867#if !defined(JSON_HEDLEY_UNREACHABLE_RETURN)
868 #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
869#endif
870
871#if defined(JSON_HEDLEY_ASSUME)
872 #undef JSON_HEDLEY_ASSUME
873#endif
874#if \
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)
883 #else
884 #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
885 #endif
886#elif \
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)))
892#else
893 #define JSON_HEDLEY_ASSUME(expr) ((void) (expr))
894#endif
895
896JSON_HEDLEY_DIAGNOSTIC_PUSH
897#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
898 #pragma clang diagnostic ignored "-Wpedantic"
899#endif
900#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
901 #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
902#endif
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"
908 #endif
909#endif
910#if defined(JSON_HEDLEY_NON_NULL)
911 #undef JSON_HEDLEY_NON_NULL
912#endif
913#if \
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__)))
919#else
920 #define JSON_HEDLEY_NON_NULL(...)
921#endif
922JSON_HEDLEY_DIAGNOSTIC_POP
923
924#if defined(JSON_HEDLEY_PRINTF_FORMAT)
925 #undef JSON_HEDLEY_PRINTF_FORMAT
926#endif
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)))
931#elif \
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))
942#else
943 #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
944#endif
945
946#if defined(JSON_HEDLEY_CONSTEXPR)
947 #undef JSON_HEDLEY_CONSTEXPR
948#endif
949#if defined(__cplusplus)
950 #if __cplusplus >= 201103L
951 #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
952 #endif
953#endif
954#if !defined(JSON_HEDLEY_CONSTEXPR)
955 #define JSON_HEDLEY_CONSTEXPR
956#endif
957
958#if defined(JSON_HEDLEY_PREDICT)
959 #undef JSON_HEDLEY_PREDICT
960#endif
961#if defined(JSON_HEDLEY_LIKELY)
962 #undef JSON_HEDLEY_LIKELY
963#endif
964#if defined(JSON_HEDLEY_UNLIKELY)
965 #undef JSON_HEDLEY_UNLIKELY
966#endif
967#if defined(JSON_HEDLEY_UNPREDICTABLE)
968 #undef JSON_HEDLEY_UNPREDICTABLE
969#endif
970#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
971 #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable(!!(expr))
972#endif
973#if \
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)
983#endif
984#elif \
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) \
996 (__extension__ ({ \
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))); \
999 }))
1000# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1001 (__extension__ ({ \
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))); \
1004 }))
1005# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1006# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1007#else
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))
1013#endif
1014#if !defined(JSON_HEDLEY_UNPREDICTABLE)
1015 #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1016#endif
1017
1018#if defined(JSON_HEDLEY_MALLOC)
1019 #undef JSON_HEDLEY_MALLOC
1020#endif
1021#if \
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)
1035#else
1036 #define JSON_HEDLEY_MALLOC
1037#endif
1038
1039#if defined(JSON_HEDLEY_PURE)
1040 #undef JSON_HEDLEY_PURE
1041#endif
1042#if \
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;")
1057#else
1058 #define JSON_HEDLEY_PURE
1059#endif
1060
1061#if defined(JSON_HEDLEY_CONST)
1062 #undef JSON_HEDLEY_CONST
1063#endif
1064#if \
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__))
1075#elif \
1076 JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1077 #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1078#else
1079 #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1080#endif
1081
1082#if defined(JSON_HEDLEY_RESTRICT)
1083 #undef JSON_HEDLEY_RESTRICT
1084#endif
1085#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1086 #define JSON_HEDLEY_RESTRICT restrict
1087#elif \
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) || \
1097 defined(__clang__)
1098 #define JSON_HEDLEY_RESTRICT __restrict
1099#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1100 #define JSON_HEDLEY_RESTRICT _Restrict
1101#else
1102 #define JSON_HEDLEY_RESTRICT
1103#endif
1104
1105#if defined(JSON_HEDLEY_INLINE)
1106 #undef JSON_HEDLEY_INLINE
1107#endif
1108#if \
1109 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1110 (defined(__cplusplus) && (__cplusplus >= 199711L))
1111 #define JSON_HEDLEY_INLINE inline
1112#elif \
1113 defined(JSON_HEDLEY_GCC_VERSION) || \
1114 JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1115 #define JSON_HEDLEY_INLINE __inline__
1116#elif \
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
1121#else
1122 #define JSON_HEDLEY_INLINE
1123#endif
1124
1125#if defined(JSON_HEDLEY_ALWAYS_INLINE)
1126 #undef JSON_HEDLEY_ALWAYS_INLINE
1127#endif
1128#if \
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")
1144#else
1145 #define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1146#endif
1147
1148#if defined(JSON_HEDLEY_NEVER_INLINE)
1149 #undef JSON_HEDLEY_NEVER_INLINE
1150#endif
1151#if \
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)
1173#else
1174 #define JSON_HEDLEY_NEVER_INLINE
1175#endif
1176
1177#if defined(JSON_HEDLEY_PRIVATE)
1178 #undef JSON_HEDLEY_PRIVATE
1179#endif
1180#if defined(JSON_HEDLEY_PUBLIC)
1181 #undef JSON_HEDLEY_PUBLIC
1182#endif
1183#if defined(JSON_HEDLEY_IMPORT)
1184 #undef JSON_HEDLEY_IMPORT
1185#endif
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)
1190#else
1191 #if \
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")))
1202 #else
1203 #define JSON_HEDLEY_PRIVATE
1204 #define JSON_HEDLEY_PUBLIC
1205 #endif
1206 #define JSON_HEDLEY_IMPORT extern
1207#endif
1208
1209#if defined(JSON_HEDLEY_NO_THROW)
1210 #undef JSON_HEDLEY_NO_THROW
1211#endif
1212#if \
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__))
1217#elif \
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)
1221#else
1222 #define JSON_HEDLEY_NO_THROW
1223#endif
1224
1225#if defined(JSON_HEDLEY_FALL_THROUGH)
1226 #undef JSON_HEDLEY_FALL_THROUGH
1227#endif
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) /* SAL */
1235 #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1236#else
1237 #define JSON_HEDLEY_FALL_THROUGH
1238#endif
1239
1240#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1241 #undef JSON_HEDLEY_RETURNS_NON_NULL
1242#endif
1243#if \
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_) /* SAL */
1248 #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1249#else
1250 #define JSON_HEDLEY_RETURNS_NON_NULL
1251#endif
1252
1253#if defined(JSON_HEDLEY_ARRAY_PARAM)
1254 #undef JSON_HEDLEY_ARRAY_PARAM
1255#endif
1256#if \
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)
1263#else
1264 #define JSON_HEDLEY_ARRAY_PARAM(name)
1265#endif
1266
1267#if defined(JSON_HEDLEY_IS_CONSTANT)
1268 #undef JSON_HEDLEY_IS_CONSTANT
1269#endif
1270#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1271 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1272#endif
1273/* JSON_HEDLEY_IS_CONSTEXPR_ is for
1274 HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
1275#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1276 #undef JSON_HEDLEY_IS_CONSTEXPR_
1277#endif
1278#if \
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)
1289#endif
1290#if !defined(__cplusplus)
1291# if \
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*)
1301#else
1302 #include <stdint.h>
1303 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1304#endif
1305# elif \
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)
1314#else
1315 #include <stdint.h>
1316 #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1317#endif
1318# elif \
1319 defined(JSON_HEDLEY_GCC_VERSION) || \
1320 defined(JSON_HEDLEY_INTEL_VERSION) || \
1321 defined(JSON_HEDLEY_TINYC_VERSION) || \
1322 defined(JSON_HEDLEY_TI_VERSION) || \
1323 defined(__clang__)
1324# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1325 sizeof(void) != \
1326 sizeof(*( \
1327 1 ? \
1328 ((void*) ((expr) * 0L) ) : \
1329((struct { char v[sizeof(void) * 2]; } *) 1) \
1330 ) \
1331 ) \
1332 )
1333# endif
1334#endif
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)
1338 #endif
1339 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1340#else
1341 #if !defined(JSON_HEDLEY_IS_CONSTANT)
1342 #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1343 #endif
1344 #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1345#endif
1346
1347#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1348 #undef JSON_HEDLEY_BEGIN_C_DECLS
1349#endif
1350#if defined(JSON_HEDLEY_END_C_DECLS)
1351 #undef JSON_HEDLEY_END_C_DECLS
1352#endif
1353#if defined(JSON_HEDLEY_C_DECL)
1354 #undef JSON_HEDLEY_C_DECL
1355#endif
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"
1360#else
1361 #define JSON_HEDLEY_BEGIN_C_DECLS
1362 #define JSON_HEDLEY_END_C_DECLS
1363 #define JSON_HEDLEY_C_DECL
1364#endif
1365
1366#if defined(JSON_HEDLEY_STATIC_ASSERT)
1367 #undef JSON_HEDLEY_STATIC_ASSERT
1368#endif
1369#if \
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) \
1376 )
1377# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1378#elif \
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))
1383#else
1384# define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1385#endif
1386
1387#if defined(JSON_HEDLEY_CONST_CAST)
1388 #undef JSON_HEDLEY_CONST_CAST
1389#endif
1390#if defined(__cplusplus)
1391# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
1392#elif \
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 \
1399 ((T) (expr)); \
1400 JSON_HEDLEY_DIAGNOSTIC_POP \
1401 }))
1402#else
1403# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
1404#endif
1405
1406#if defined(JSON_HEDLEY_REINTERPRET_CAST)
1407 #undef JSON_HEDLEY_REINTERPRET_CAST
1408#endif
1409#if defined(__cplusplus)
1410 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
1411#else
1412 #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (*((T*) &(expr)))
1413#endif
1414
1415#if defined(JSON_HEDLEY_STATIC_CAST)
1416 #undef JSON_HEDLEY_STATIC_CAST
1417#endif
1418#if defined(__cplusplus)
1419 #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
1420#else
1421 #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
1422#endif
1423
1424#if defined(JSON_HEDLEY_CPP_CAST)
1425 #undef JSON_HEDLEY_CPP_CAST
1426#endif
1427#if defined(__cplusplus)
1428 #define JSON_HEDLEY_CPP_CAST(T, expr) static_cast<T>(expr)
1429#else
1430 #define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
1431#endif
1432
1433#if defined(JSON_HEDLEY_NULL)
1434 #undef JSON_HEDLEY_NULL
1435#endif
1436#if defined(__cplusplus)
1437 #if __cplusplus >= 201103L
1438 #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1439 #elif defined(NULL)
1440 #define JSON_HEDLEY_NULL NULL
1441 #else
1442 #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1443 #endif
1444#elif defined(NULL)
1445 #define JSON_HEDLEY_NULL NULL
1446#else
1447 #define JSON_HEDLEY_NULL ((void*) 0)
1448#endif
1449
1450#if defined(JSON_HEDLEY_MESSAGE)
1451 #undef JSON_HEDLEY_MESSAGE
1452#endif
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
1459#elif \
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))
1469#else
1470# define JSON_HEDLEY_MESSAGE(msg)
1471#endif
1472
1473#if defined(JSON_HEDLEY_WARNING)
1474 #undef JSON_HEDLEY_WARNING
1475#endif
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
1482#elif \
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))
1488#else
1489# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1490#endif
1491
1492#if defined(JSON_HEDLEY_REQUIRE)
1493 #undef JSON_HEDLEY_REQUIRE
1494#endif
1495#if defined(JSON_HEDLEY_REQUIRE_MSG)
1496 #undef JSON_HEDLEY_REQUIRE_MSG
1497#endif
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
1510# else
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")))
1513# endif
1514#else
1515# define JSON_HEDLEY_REQUIRE(expr)
1516# define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1517#endif
1518
1519#if defined(JSON_HEDLEY_FLAGS)
1520 #undef JSON_HEDLEY_FLAGS
1521#endif
1522#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
1523 #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1524#endif
1525
1526#if defined(JSON_HEDLEY_FLAGS_CAST)
1527 #undef JSON_HEDLEY_FLAGS_CAST
1528#endif
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)") \
1533 ((T) (expr)); \
1534 JSON_HEDLEY_DIAGNOSTIC_POP \
1535 }))
1536#else
1537# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1538#endif
1539
1540#if defined(JSON_HEDLEY_EMPTY_BASES)
1541 #undef JSON_HEDLEY_EMPTY_BASES
1542#endif
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)
1545#else
1546 #define JSON_HEDLEY_EMPTY_BASES
1547#endif
1548
1549/* Remaining macros are deprecated. */
1550
1551#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1552 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1553#endif
1554#if defined(__clang__)
1555 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
1556#else
1557 #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1558#endif
1559
1560#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
1561 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
1562#endif
1563#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
1564
1565#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1566 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1567#endif
1568#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1569
1570#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
1571 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
1572#endif
1573#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
1574
1575#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
1576 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
1577#endif
1578#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
1579
1580#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
1581 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
1582#endif
1583#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
1584
1585#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
1586 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
1587#endif
1588#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
1589
1590#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
1591 #undef JSON_HEDLEY_CLANG_HAS_WARNING
1592#endif
1593#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
1594
1595#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
1596