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