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