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