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