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