Horizon
Loading...
Searching...
No Matches
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
1263JSON_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
1289JSON_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) */