Horizon
hedley.hpp
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 
896 JSON_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
922 JSON_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) */