Nuitka
The Python compiler
Loading...
Searching...
No Matches
hedley.h
1
/* Hedley - https://nemequ.github.io/hedley
2
* Created by Evan Nemerson <evan@nemerson.com>
3
*
4
* To the extent possible under law, the author(s) have dedicated all
5
* copyright and related and neighboring rights to this software to
6
* the public domain worldwide. This software is distributed without
7
* any warranty.
8
*
9
* For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
10
* SPDX-License-Identifier: CC0-1.0
11
*/
12
13
#if !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < 14)
14
#if defined(HEDLEY_VERSION)
15
#undef HEDLEY_VERSION
16
#endif
17
#define HEDLEY_VERSION 14
18
19
#if defined(HEDLEY_STRINGIFY_EX)
20
#undef HEDLEY_STRINGIFY_EX
21
#endif
22
#define HEDLEY_STRINGIFY_EX(x) #x
23
24
#if defined(HEDLEY_STRINGIFY)
25
#undef HEDLEY_STRINGIFY
26
#endif
27
#define HEDLEY_STRINGIFY(x) HEDLEY_STRINGIFY_EX(x)
28
29
#if defined(HEDLEY_CONCAT_EX)
30
#undef HEDLEY_CONCAT_EX
31
#endif
32
#define HEDLEY_CONCAT_EX(a, b) a##b
33
34
#if defined(HEDLEY_CONCAT)
35
#undef HEDLEY_CONCAT
36
#endif
37
#define HEDLEY_CONCAT(a, b) HEDLEY_CONCAT_EX(a, b)
38
39
#if defined(HEDLEY_CONCAT3_EX)
40
#undef HEDLEY_CONCAT3_EX
41
#endif
42
#define HEDLEY_CONCAT3_EX(a, b, c) a##b##c
43
44
#if defined(HEDLEY_CONCAT3)
45
#undef HEDLEY_CONCAT3
46
#endif
47
#define HEDLEY_CONCAT3(a, b, c) HEDLEY_CONCAT3_EX(a, b, c)
48
49
#if defined(HEDLEY_VERSION_ENCODE)
50
#undef HEDLEY_VERSION_ENCODE
51
#endif
52
#define HEDLEY_VERSION_ENCODE(major, minor, revision) (((major)*1000000) + ((minor)*1000) + (revision))
53
54
#if defined(HEDLEY_VERSION_DECODE_MAJOR)
55
#undef HEDLEY_VERSION_DECODE_MAJOR
56
#endif
57
#define HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
58
59
#if defined(HEDLEY_VERSION_DECODE_MINOR)
60
#undef HEDLEY_VERSION_DECODE_MINOR
61
#endif
62
#define HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
63
64
#if defined(HEDLEY_VERSION_DECODE_REVISION)
65
#undef HEDLEY_VERSION_DECODE_REVISION
66
#endif
67
#define HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
68
69
#if defined(HEDLEY_GNUC_VERSION)
70
#undef HEDLEY_GNUC_VERSION
71
#endif
72
#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
73
#define HEDLEY_GNUC_VERSION HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
74
#elif defined(__GNUC__)
75
#define HEDLEY_GNUC_VERSION HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
76
#endif
77
78
#if defined(HEDLEY_GNUC_VERSION_CHECK)
79
#undef HEDLEY_GNUC_VERSION_CHECK
80
#endif
81
#if defined(HEDLEY_GNUC_VERSION)
82
#define HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) \
83
(HEDLEY_GNUC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
84
#else
85
#define HEDLEY_GNUC_VERSION_CHECK(major, minor, patch) (0)
86
#endif
87
88
#if defined(HEDLEY_MSVC_VERSION)
89
#undef HEDLEY_MSVC_VERSION
90
#endif
91
#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
92
#define HEDLEY_MSVC_VERSION \
93
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 HEDLEY_MSVC_VERSION \
96
HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
97
#elif defined(_MSC_VER) && !defined(__ICL)
98
#define HEDLEY_MSVC_VERSION HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
99
#endif
100
101
#if defined(HEDLEY_MSVC_VERSION_CHECK)
102
#undef HEDLEY_MSVC_VERSION_CHECK
103
#endif
104
#if !defined(HEDLEY_MSVC_VERSION)
105
#define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) (0)
106
#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
107
#define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \
108
(_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
109
#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
110
#define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) \
111
(_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
112
#else
113
#define HEDLEY_MSVC_VERSION_CHECK(major, minor, patch) (_MSC_VER >= ((major * 100) + (minor)))
114
#endif
115
116
#if defined(HEDLEY_INTEL_VERSION)
117
#undef HEDLEY_INTEL_VERSION
118
#endif
119
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
120
#define HEDLEY_INTEL_VERSION \
121
HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
122
#elif defined(__INTEL_COMPILER) && !defined(__ICL)
123
#define HEDLEY_INTEL_VERSION HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
124
#endif
125
126
#if defined(HEDLEY_INTEL_VERSION_CHECK)
127
#undef HEDLEY_INTEL_VERSION_CHECK
128
#endif
129
#if defined(HEDLEY_INTEL_VERSION)
130
#define HEDLEY_INTEL_VERSION_CHECK(major, minor, patch) \
131
(HEDLEY_INTEL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
132
#else
133
#define HEDLEY_INTEL_VERSION_CHECK(major, minor, patch) (0)
134
#endif
135
136
#if defined(HEDLEY_INTEL_CL_VERSION)
137
#undef HEDLEY_INTEL_CL_VERSION
138
#endif
139
#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
140
#define HEDLEY_INTEL_CL_VERSION HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
141
#endif
142
143
#if defined(HEDLEY_INTEL_CL_VERSION_CHECK)
144
#undef HEDLEY_INTEL_CL_VERSION_CHECK
145
#endif
146
#if defined(HEDLEY_INTEL_CL_VERSION)
147
#define HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) \
148
(HEDLEY_INTEL_CL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
149
#else
150
#define HEDLEY_INTEL_CL_VERSION_CHECK(major, minor, patch) (0)
151
#endif
152
153
#if defined(HEDLEY_PGI_VERSION)
154
#undef HEDLEY_PGI_VERSION
155
#endif
156
#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
157
#define HEDLEY_PGI_VERSION HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
158
#endif
159
160
#if defined(HEDLEY_PGI_VERSION_CHECK)
161
#undef HEDLEY_PGI_VERSION_CHECK
162
#endif
163
#if defined(HEDLEY_PGI_VERSION)
164
#define HEDLEY_PGI_VERSION_CHECK(major, minor, patch) (HEDLEY_PGI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
165
#else
166
#define HEDLEY_PGI_VERSION_CHECK(major, minor, patch) (0)
167
#endif
168
169
#if defined(HEDLEY_SUNPRO_VERSION)
170
#undef HEDLEY_SUNPRO_VERSION
171
#endif
172
#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
173
#define HEDLEY_SUNPRO_VERSION \
174
HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), \
175
(((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
176
#elif defined(__SUNPRO_C)
177
#define HEDLEY_SUNPRO_VERSION HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C)&0xf)
178
#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
179
#define HEDLEY_SUNPRO_VERSION \
180
HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), \
181
(((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
182
#elif defined(__SUNPRO_CC)
183
#define HEDLEY_SUNPRO_VERSION \
184
HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC)&0xf)
185
#endif
186
187
#if defined(HEDLEY_SUNPRO_VERSION_CHECK)
188
#undef HEDLEY_SUNPRO_VERSION_CHECK
189
#endif
190
#if defined(HEDLEY_SUNPRO_VERSION)
191
#define HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch) \
192
(HEDLEY_SUNPRO_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
193
#else
194
#define HEDLEY_SUNPRO_VERSION_CHECK(major, minor, patch) (0)
195
#endif
196
197
#if defined(HEDLEY_EMSCRIPTEN_VERSION)
198
#undef HEDLEY_EMSCRIPTEN_VERSION
199
#endif
200
#if defined(__EMSCRIPTEN__)
201
#define HEDLEY_EMSCRIPTEN_VERSION HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
202
#endif
203
204
#if defined(HEDLEY_EMSCRIPTEN_VERSION_CHECK)
205
#undef HEDLEY_EMSCRIPTEN_VERSION_CHECK
206
#endif
207
#if defined(HEDLEY_EMSCRIPTEN_VERSION)
208
#define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch) \
209
(HEDLEY_EMSCRIPTEN_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
210
#else
211
#define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major, minor, patch) (0)
212
#endif
213
214
#if defined(HEDLEY_ARM_VERSION)
215
#undef HEDLEY_ARM_VERSION
216
#endif
217
#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
218
#define HEDLEY_ARM_VERSION \
219
HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, \
220
(__ARMCOMPILER_VERSION % 10000) / 100)
221
#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
222
#define HEDLEY_ARM_VERSION \
223
HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, \
224
(__ARMCC_VERSION % 10000) / 100)
225
#endif
226
227
#if defined(HEDLEY_ARM_VERSION_CHECK)
228
#undef HEDLEY_ARM_VERSION_CHECK
229
#endif
230
#if defined(HEDLEY_ARM_VERSION)
231
#define HEDLEY_ARM_VERSION_CHECK(major, minor, patch) (HEDLEY_ARM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
232
#else
233
#define HEDLEY_ARM_VERSION_CHECK(major, minor, patch) (0)
234
#endif
235
236
#if defined(HEDLEY_IBM_VERSION)
237
#undef HEDLEY_IBM_VERSION
238
#endif
239
#if defined(__ibmxl__)
240
#define HEDLEY_IBM_VERSION HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
241
#elif defined(__xlC__) && defined(__xlC_ver__)
242
#define HEDLEY_IBM_VERSION HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
243
#elif defined(__xlC__)
244
#define HEDLEY_IBM_VERSION HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
245
#endif
246
247
#if defined(HEDLEY_IBM_VERSION_CHECK)
248
#undef HEDLEY_IBM_VERSION_CHECK
249
#endif
250
#if defined(HEDLEY_IBM_VERSION)
251
#define HEDLEY_IBM_VERSION_CHECK(major, minor, patch) (HEDLEY_IBM_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
252
#else
253
#define HEDLEY_IBM_VERSION_CHECK(major, minor, patch) (0)
254
#endif
255
256
#if defined(HEDLEY_TI_VERSION)
257
#undef HEDLEY_TI_VERSION
258
#endif
259
#if defined(__TI_COMPILER_VERSION__) && \
260
(defined(__TMS470__) || defined(__TI_ARM__) || defined(__MSP430__) || defined(__TMS320C2000__))
261
#if (__TI_COMPILER_VERSION__ >= 16000000)
262
#define HEDLEY_TI_VERSION \
263
HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
264
(__TI_COMPILER_VERSION__ % 1000))
265
#endif
266
#endif
267
268
#if defined(HEDLEY_TI_VERSION_CHECK)
269
#undef HEDLEY_TI_VERSION_CHECK
270
#endif
271
#if defined(HEDLEY_TI_VERSION)
272
#define HEDLEY_TI_VERSION_CHECK(major, minor, patch) (HEDLEY_TI_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
273
#else
274
#define HEDLEY_TI_VERSION_CHECK(major, minor, patch) (0)
275
#endif
276
277
#if defined(HEDLEY_TI_CL2000_VERSION)
278
#undef HEDLEY_TI_CL2000_VERSION
279
#endif
280
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
281
#define HEDLEY_TI_CL2000_VERSION \
282
HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
283
(__TI_COMPILER_VERSION__ % 1000))
284
#endif
285
286
#if defined(HEDLEY_TI_CL2000_VERSION_CHECK)
287
#undef HEDLEY_TI_CL2000_VERSION_CHECK
288
#endif
289
#if defined(HEDLEY_TI_CL2000_VERSION)
290
#define HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) \
291
(HEDLEY_TI_CL2000_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
292
#else
293
#define HEDLEY_TI_CL2000_VERSION_CHECK(major, minor, patch) (0)
294
#endif
295
296
#if defined(HEDLEY_TI_CL430_VERSION)
297
#undef HEDLEY_TI_CL430_VERSION
298
#endif
299
#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
300
#define HEDLEY_TI_CL430_VERSION \
301
HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
302
(__TI_COMPILER_VERSION__ % 1000))
303
#endif
304
305
#if defined(HEDLEY_TI_CL430_VERSION_CHECK)
306
#undef HEDLEY_TI_CL430_VERSION_CHECK
307
#endif
308
#if defined(HEDLEY_TI_CL430_VERSION)
309
#define HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) \
310
(HEDLEY_TI_CL430_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
311
#else
312
#define HEDLEY_TI_CL430_VERSION_CHECK(major, minor, patch) (0)
313
#endif
314
315
#if defined(HEDLEY_TI_ARMCL_VERSION)
316
#undef HEDLEY_TI_ARMCL_VERSION
317
#endif
318
#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
319
#define HEDLEY_TI_ARMCL_VERSION \
320
HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
321
(__TI_COMPILER_VERSION__ % 1000))
322
#endif
323
324
#if defined(HEDLEY_TI_ARMCL_VERSION_CHECK)
325
#undef HEDLEY_TI_ARMCL_VERSION_CHECK
326
#endif
327
#if defined(HEDLEY_TI_ARMCL_VERSION)
328
#define HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) \
329
(HEDLEY_TI_ARMCL_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
330
#else
331
#define HEDLEY_TI_ARMCL_VERSION_CHECK(major, minor, patch) (0)
332
#endif
333
334
#if defined(HEDLEY_TI_CL6X_VERSION)
335
#undef HEDLEY_TI_CL6X_VERSION
336
#endif
337
#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
338
#define HEDLEY_TI_CL6X_VERSION \
339
HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
340
(__TI_COMPILER_VERSION__ % 1000))
341
#endif
342
343
#if defined(HEDLEY_TI_CL6X_VERSION_CHECK)
344
#undef HEDLEY_TI_CL6X_VERSION_CHECK
345
#endif
346
#if defined(HEDLEY_TI_CL6X_VERSION)
347
#define HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) \
348
(HEDLEY_TI_CL6X_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
349
#else
350
#define HEDLEY_TI_CL6X_VERSION_CHECK(major, minor, patch) (0)
351
#endif
352
353
#if defined(HEDLEY_TI_CL7X_VERSION)
354
#undef HEDLEY_TI_CL7X_VERSION
355
#endif
356
#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
357
#define HEDLEY_TI_CL7X_VERSION \
358
HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
359
(__TI_COMPILER_VERSION__ % 1000))
360
#endif
361
362
#if defined(HEDLEY_TI_CL7X_VERSION_CHECK)
363
#undef HEDLEY_TI_CL7X_VERSION_CHECK
364
#endif
365
#if defined(HEDLEY_TI_CL7X_VERSION)
366
#define HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) \
367
(HEDLEY_TI_CL7X_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
368
#else
369
#define HEDLEY_TI_CL7X_VERSION_CHECK(major, minor, patch) (0)
370
#endif
371
372
#if defined(HEDLEY_TI_CLPRU_VERSION)
373
#undef HEDLEY_TI_CLPRU_VERSION
374
#endif
375
#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
376
#define HEDLEY_TI_CLPRU_VERSION \
377
HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, \
378
(__TI_COMPILER_VERSION__ % 1000))
379
#endif
380
381
#if defined(HEDLEY_TI_CLPRU_VERSION_CHECK)
382
#undef HEDLEY_TI_CLPRU_VERSION_CHECK
383
#endif
384
#if defined(HEDLEY_TI_CLPRU_VERSION)
385
#define HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) \
386
(HEDLEY_TI_CLPRU_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
387
#else
388
#define HEDLEY_TI_CLPRU_VERSION_CHECK(major, minor, patch) (0)
389
#endif
390
391
#if defined(HEDLEY_CRAY_VERSION)
392
#undef HEDLEY_CRAY_VERSION
393
#endif
394
#if defined(_CRAYC)
395
#if defined(_RELEASE_PATCHLEVEL)
396
#define HEDLEY_CRAY_VERSION HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
397
#else
398
#define HEDLEY_CRAY_VERSION HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
399
#endif
400
#endif
401
402
#if defined(HEDLEY_CRAY_VERSION_CHECK)
403
#undef HEDLEY_CRAY_VERSION_CHECK
404
#endif
405
#if defined(HEDLEY_CRAY_VERSION)
406
#define HEDLEY_CRAY_VERSION_CHECK(major, minor, patch) \
407
(HEDLEY_CRAY_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
408
#else
409
#define HEDLEY_CRAY_VERSION_CHECK(major, minor, patch) (0)
410
#endif
411
412
#if defined(HEDLEY_IAR_VERSION)
413
#undef HEDLEY_IAR_VERSION
414
#endif
415
#if defined(__IAR_SYSTEMS_ICC__)
416
#if __VER__ > 1000
417
#define HEDLEY_IAR_VERSION HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
418
#else
419
#define HEDLEY_IAR_VERSION HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
420
#endif
421
#endif
422
423
#if defined(HEDLEY_IAR_VERSION_CHECK)
424
#undef HEDLEY_IAR_VERSION_CHECK
425
#endif
426
#if defined(HEDLEY_IAR_VERSION)
427
#define HEDLEY_IAR_VERSION_CHECK(major, minor, patch) (HEDLEY_IAR_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
428
#else
429
#define HEDLEY_IAR_VERSION_CHECK(major, minor, patch) (0)
430
#endif
431
432
#if defined(HEDLEY_TINYC_VERSION)
433
#undef HEDLEY_TINYC_VERSION
434
#endif
435
#if defined(__TINYC__)
436
#define HEDLEY_TINYC_VERSION HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
437
#endif
438
439
#if defined(HEDLEY_TINYC_VERSION_CHECK)
440
#undef HEDLEY_TINYC_VERSION_CHECK
441
#endif
442
#if defined(HEDLEY_TINYC_VERSION)
443
#define HEDLEY_TINYC_VERSION_CHECK(major, minor, patch) \
444
(HEDLEY_TINYC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
445
#else
446
#define HEDLEY_TINYC_VERSION_CHECK(major, minor, patch) (0)
447
#endif
448
449
#if defined(HEDLEY_DMC_VERSION)
450
#undef HEDLEY_DMC_VERSION
451
#endif
452
#if defined(__DMC__)
453
#define HEDLEY_DMC_VERSION HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
454
#endif
455
456
#if defined(HEDLEY_DMC_VERSION_CHECK)
457
#undef HEDLEY_DMC_VERSION_CHECK
458
#endif
459
#if defined(HEDLEY_DMC_VERSION)
460
#define HEDLEY_DMC_VERSION_CHECK(major, minor, patch) (HEDLEY_DMC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
461
#else
462
#define HEDLEY_DMC_VERSION_CHECK(major, minor, patch) (0)
463
#endif
464
465
#if defined(HEDLEY_COMPCERT_VERSION)
466
#undef HEDLEY_COMPCERT_VERSION
467
#endif
468
#if defined(__COMPCERT_VERSION__)
469
#define HEDLEY_COMPCERT_VERSION \
470
HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
471
#endif
472
473
#if defined(HEDLEY_COMPCERT_VERSION_CHECK)
474
#undef HEDLEY_COMPCERT_VERSION_CHECK
475
#endif
476
#if defined(HEDLEY_COMPCERT_VERSION)
477
#define HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch) \
478
(HEDLEY_COMPCERT_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
479
#else
480
#define HEDLEY_COMPCERT_VERSION_CHECK(major, minor, patch) (0)
481
#endif
482
483
#if defined(HEDLEY_PELLES_VERSION)
484
#undef HEDLEY_PELLES_VERSION
485
#endif
486
#if defined(__POCC__)
487
#define HEDLEY_PELLES_VERSION HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
488
#endif
489
490
#if defined(HEDLEY_PELLES_VERSION_CHECK)
491
#undef HEDLEY_PELLES_VERSION_CHECK
492
#endif
493
#if defined(HEDLEY_PELLES_VERSION)
494
#define HEDLEY_PELLES_VERSION_CHECK(major, minor, patch) \
495
(HEDLEY_PELLES_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
496
#else
497
#define HEDLEY_PELLES_VERSION_CHECK(major, minor, patch) (0)
498
#endif
499
500
#if defined(HEDLEY_GCC_VERSION)
501
#undef HEDLEY_GCC_VERSION
502
#endif
503
#if defined(HEDLEY_GNUC_VERSION) && !defined(__clang__) && !defined(HEDLEY_INTEL_VERSION) && \
504
!defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_ARM_VERSION) && !defined(HEDLEY_TI_VERSION) && \
505
!defined(HEDLEY_TI_ARMCL_VERSION) && !defined(HEDLEY_TI_CL430_VERSION) && !defined(HEDLEY_TI_CL2000_VERSION) && \
506
!defined(HEDLEY_TI_CL6X_VERSION) && !defined(HEDLEY_TI_CL7X_VERSION) && !defined(HEDLEY_TI_CLPRU_VERSION) && \
507
!defined(__COMPCERT__)
508
#define HEDLEY_GCC_VERSION HEDLEY_GNUC_VERSION
509
#endif
510
511
#if defined(HEDLEY_GCC_VERSION_CHECK)
512
#undef HEDLEY_GCC_VERSION_CHECK
513
#endif
514
#if defined(HEDLEY_GCC_VERSION)
515
#define HEDLEY_GCC_VERSION_CHECK(major, minor, patch) (HEDLEY_GCC_VERSION >= HEDLEY_VERSION_ENCODE(major, minor, patch))
516
#else
517
#define HEDLEY_GCC_VERSION_CHECK(major, minor, patch) (0)
518
#endif
519
520
#if defined(HEDLEY_HAS_ATTRIBUTE)
521
#undef HEDLEY_HAS_ATTRIBUTE
522
#endif
523
#if defined(__has_attribute)
524
#define HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
525
#else
526
#define HEDLEY_HAS_ATTRIBUTE(attribute) (0)
527
#endif
528
529
#if defined(HEDLEY_GNUC_HAS_ATTRIBUTE)
530
#undef HEDLEY_GNUC_HAS_ATTRIBUTE
531
#endif
532
#if defined(__has_attribute)
533
#define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) __has_attribute(attribute)
534
#else
535
#define HEDLEY_GNUC_HAS_ATTRIBUTE(attribute, major, minor, patch) HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
536
#endif
537
538
#if defined(HEDLEY_GCC_HAS_ATTRIBUTE)
539
#undef HEDLEY_GCC_HAS_ATTRIBUTE
540
#endif
541
#if defined(__has_attribute)
542
#define HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch) __has_attribute(attribute)
543
#else
544
#define HEDLEY_GCC_HAS_ATTRIBUTE(attribute, major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
545
#endif
546
547
#if defined(HEDLEY_HAS_CPP_ATTRIBUTE)
548
#undef HEDLEY_HAS_CPP_ATTRIBUTE
549
#endif
550
#if defined(__has_cpp_attribute) && defined(__cplusplus) && \
551
(!defined(HEDLEY_SUNPRO_VERSION) || HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0))
552
#define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
553
#else
554
#define HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
555
#endif
556
557
#if defined(HEDLEY_HAS_CPP_ATTRIBUTE_NS)
558
#undef HEDLEY_HAS_CPP_ATTRIBUTE_NS
559
#endif
560
#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
561
#define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0)
562
#elif !defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_IAR_VERSION) && \
563
(!defined(HEDLEY_SUNPRO_VERSION) || HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0)) && \
564
(!defined(HEDLEY_MSVC_VERSION) || HEDLEY_MSVC_VERSION_CHECK(19, 20, 0))
565
#define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
566
#else
567
#define HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns, attribute) (0)
568
#endif
569
570
#if defined(HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
571
#undef HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
572
#endif
573
#if defined(__has_cpp_attribute) && defined(__cplusplus)
574
#define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) __has_cpp_attribute(attribute)
575
#else
576
#define HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
577
#endif
578
579
#if defined(HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
580
#undef HEDLEY_GCC_HAS_CPP_ATTRIBUTE
581
#endif
582
#if defined(__has_cpp_attribute) && defined(__cplusplus)
583
#define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) __has_cpp_attribute(attribute)
584
#else
585
#define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute, major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
586
#endif
587
588
#if defined(HEDLEY_HAS_BUILTIN)
589
#undef HEDLEY_HAS_BUILTIN
590
#endif
591
#if defined(__has_builtin)
592
#define HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
593
#else
594
#define HEDLEY_HAS_BUILTIN(builtin) (0)
595
#endif
596
597
#if defined(HEDLEY_GNUC_HAS_BUILTIN)
598
#undef HEDLEY_GNUC_HAS_BUILTIN
599
#endif
600
#if defined(__has_builtin)
601
#define HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch) __has_builtin(builtin)
602
#else
603
#define HEDLEY_GNUC_HAS_BUILTIN(builtin, major, minor, patch) HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
604
#endif
605
606
#if defined(HEDLEY_GCC_HAS_BUILTIN)
607
#undef HEDLEY_GCC_HAS_BUILTIN
608
#endif
609
#if defined(__has_builtin)
610
#define HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch) __has_builtin(builtin)
611
#else
612
#define HEDLEY_GCC_HAS_BUILTIN(builtin, major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
613
#endif
614
615
#if defined(HEDLEY_HAS_FEATURE)
616
#undef HEDLEY_HAS_FEATURE
617
#endif
618
#if defined(__has_feature)
619
#define HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
620
#else
621
#define HEDLEY_HAS_FEATURE(feature) (0)
622
#endif
623
624
#if defined(HEDLEY_GNUC_HAS_FEATURE)
625
#undef HEDLEY_GNUC_HAS_FEATURE
626
#endif
627
#if defined(__has_feature)
628
#define HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch) __has_feature(feature)
629
#else
630
#define HEDLEY_GNUC_HAS_FEATURE(feature, major, minor, patch) HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
631
#endif
632
633
#if defined(HEDLEY_GCC_HAS_FEATURE)
634
#undef HEDLEY_GCC_HAS_FEATURE
635
#endif
636
#if defined(__has_feature)
637
#define HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch) __has_feature(feature)
638
#else
639
#define HEDLEY_GCC_HAS_FEATURE(feature, major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
640
#endif
641
642
#if defined(HEDLEY_HAS_EXTENSION)
643
#undef HEDLEY_HAS_EXTENSION
644
#endif
645
#if defined(__has_extension)
646
#define HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
647
#else
648
#define HEDLEY_HAS_EXTENSION(extension) (0)
649
#endif
650
651
#if defined(HEDLEY_GNUC_HAS_EXTENSION)
652
#undef HEDLEY_GNUC_HAS_EXTENSION
653
#endif
654
#if defined(__has_extension)
655
#define HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch) __has_extension(extension)
656
#else
657
#define HEDLEY_GNUC_HAS_EXTENSION(extension, major, minor, patch) HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
658
#endif
659
660
#if defined(HEDLEY_GCC_HAS_EXTENSION)
661
#undef HEDLEY_GCC_HAS_EXTENSION
662
#endif
663
#if defined(__has_extension)
664
#define HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch) __has_extension(extension)
665
#else
666
#define HEDLEY_GCC_HAS_EXTENSION(extension, major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
667
#endif
668
669
#if defined(HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
670
#undef HEDLEY_HAS_DECLSPEC_ATTRIBUTE
671
#endif
672
#if defined(__has_declspec_attribute)
673
#define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
674
#else
675
#define HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
676
#endif
677
678
#if defined(HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
679
#undef HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
680
#endif
681
#if defined(__has_declspec_attribute)
682
#define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) __has_declspec_attribute(attribute)
683
#else
684
#define HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) \
685
HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
686
#endif
687
688
#if defined(HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
689
#undef HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
690
#endif
691
#if defined(__has_declspec_attribute)
692
#define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) __has_declspec_attribute(attribute)
693
#else
694
#define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute, major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
695
#endif
696
697
#if defined(HEDLEY_HAS_WARNING)
698
#undef HEDLEY_HAS_WARNING
699
#endif
700
#if defined(__has_warning)
701
#define HEDLEY_HAS_WARNING(warning) __has_warning(warning)
702
#else
703
#define HEDLEY_HAS_WARNING(warning) (0)
704
#endif
705
706
#if defined(HEDLEY_GNUC_HAS_WARNING)
707
#undef HEDLEY_GNUC_HAS_WARNING
708
#endif
709
#if defined(__has_warning)
710
#define HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch) __has_warning(warning)
711
#else
712
#define HEDLEY_GNUC_HAS_WARNING(warning, major, minor, patch) HEDLEY_GNUC_VERSION_CHECK(major, minor, patch)
713
#endif
714
715
#if defined(HEDLEY_GCC_HAS_WARNING)
716
#undef HEDLEY_GCC_HAS_WARNING
717
#endif
718
#if defined(__has_warning)
719
#define HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch) __has_warning(warning)
720
#else
721
#define HEDLEY_GCC_HAS_WARNING(warning, major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
722
#endif
723
724
#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || defined(__clang__) || \
725
HEDLEY_GCC_VERSION_CHECK(3, 0, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_IAR_VERSION_CHECK(8, 0, 0) || \
726
HEDLEY_PGI_VERSION_CHECK(18, 4, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
727
HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) || HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) || \
728
HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(7, 0, 0) || \
729
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || \
730
HEDLEY_CRAY_VERSION_CHECK(5, 0, 0) || HEDLEY_TINYC_VERSION_CHECK(0, 9, 17) || \
731
HEDLEY_SUNPRO_VERSION_CHECK(8, 0, 0) || (HEDLEY_IBM_VERSION_CHECK(10, 1, 0) && defined(__C99_PRAGMA_OPERATOR))
732
#define HEDLEY_PRAGMA(value) _Pragma(#value)
733
#elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
734
#define HEDLEY_PRAGMA(value) __pragma(value)
735
#else
736
#define HEDLEY_PRAGMA(value)
737
#endif
738
739
#if defined(HEDLEY_DIAGNOSTIC_PUSH)
740
#undef HEDLEY_DIAGNOSTIC_PUSH
741
#endif
742
#if defined(HEDLEY_DIAGNOSTIC_POP)
743
#undef HEDLEY_DIAGNOSTIC_POP
744
#endif
745
#if defined(__clang__)
746
#define HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
747
#define HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
748
#elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
749
#define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
750
#define HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
751
#elif HEDLEY_GCC_VERSION_CHECK(4, 6, 0)
752
#define HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
753
#define HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
754
#elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
755
#define HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
756
#define HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
757
#elif HEDLEY_ARM_VERSION_CHECK(5, 6, 0)
758
#define HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
759
#define HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
760
#elif HEDLEY_TI_VERSION_CHECK(15, 12, 0) || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
761
HEDLEY_TI_CL430_VERSION_CHECK(4, 4, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) || \
762
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
763
#define HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
764
#define HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
765
#elif HEDLEY_PELLES_VERSION_CHECK(2, 90, 0)
766
#define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
767
#define HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
768
#else
769
#define HEDLEY_DIAGNOSTIC_PUSH
770
#define HEDLEY_DIAGNOSTIC_POP
771
#endif
772
773
/* HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
774
HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
775
#if defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
776
#undef HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
777
#endif
778
#if defined(__cplusplus)
779
#if HEDLEY_HAS_WARNING("-Wc++98-compat")
780
#if HEDLEY_HAS_WARNING("-Wc++17-extensions")
781
#if HEDLEY_HAS_WARNING("-Wc++1z-extensions")
782
#define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
783
HEDLEY_DIAGNOSTIC_PUSH \
784
_Pragma("clang diagnostic ignored \"-Wc++98-compat\"") _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
785
_Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") xpr HEDLEY_DIAGNOSTIC_POP
786
#else
787
#define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
788
HEDLEY_DIAGNOSTIC_PUSH \
789
_Pragma("clang diagnostic ignored \"-Wc++98-compat\"") _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
790
xpr HEDLEY_DIAGNOSTIC_POP
791
#endif
792
#else
793
#define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
794
HEDLEY_DIAGNOSTIC_PUSH \
795
_Pragma("clang diagnostic ignored \"-Wc++98-compat\"") xpr HEDLEY_DIAGNOSTIC_POP
796
#endif
797
#endif
798
#endif
799
#if !defined(HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
800
#define HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
801
#endif
802
803
#if defined(HEDLEY_CONST_CAST)
804
#undef HEDLEY_CONST_CAST
805
#endif
806
#if defined(__cplusplus)
807
#define HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
808
#elif HEDLEY_HAS_WARNING("-Wcast-qual") || HEDLEY_GCC_VERSION_CHECK(4, 6, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
809
#define HEDLEY_CONST_CAST(T, expr) \
810
(__extension__({ \
811
HEDLEY_DIAGNOSTIC_PUSH \
812
HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL((T)(expr)); \
813
HEDLEY_DIAGNOSTIC_POP \
814
}))
815
#else
816
#define HEDLEY_CONST_CAST(T, expr) ((T)(expr))
817
#endif
818
819
#if defined(HEDLEY_REINTERPRET_CAST)
820
#undef HEDLEY_REINTERPRET_CAST
821
#endif
822
#if defined(__cplusplus)
823
#define HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
824
#else
825
#define HEDLEY_REINTERPRET_CAST(T, expr) ((T)(expr))
826
#endif
827
828
#if defined(HEDLEY_STATIC_CAST)
829
#undef HEDLEY_STATIC_CAST
830
#endif
831
#if defined(__cplusplus)
832
#define HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
833
#else
834
#define HEDLEY_STATIC_CAST(T, expr) ((T)(expr))
835
#endif
836
837
#if defined(HEDLEY_CPP_CAST)
838
#undef HEDLEY_CPP_CAST
839
#endif
840
#if defined(__cplusplus)
841
#if HEDLEY_HAS_WARNING("-Wold-style-cast")
842
#define HEDLEY_CPP_CAST(T, expr) \
843
HEDLEY_DIAGNOSTIC_PUSH \
844
_Pragma("clang diagnostic ignored \"-Wold-style-cast\"")((T)(expr)) HEDLEY_DIAGNOSTIC_POP
845
#elif HEDLEY_IAR_VERSION_CHECK(8, 3, 0)
846
#define HEDLEY_CPP_CAST(T, expr) \
847
HEDLEY_DIAGNOSTIC_PUSH \
848
_Pragma("diag_suppress=Pe137") HEDLEY_DIAGNOSTIC_POP
849
#else
850
#define HEDLEY_CPP_CAST(T, expr) ((T)(expr))
851
#endif
852
#else
853
#define HEDLEY_CPP_CAST(T, expr) (expr)
854
#endif
855
856
#if defined(HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
857
#undef HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
858
#endif
859
#if HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
860
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
861
#elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
862
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
863
#elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
864
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable : 1478 1786))
865
#elif HEDLEY_PGI_VERSION_CHECK(20, 7, 0)
866
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
867
#elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
868
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
869
#elif HEDLEY_GCC_VERSION_CHECK(4, 3, 0)
870
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
871
#elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
872
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable : 4996))
873
#elif HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
874
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
875
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
876
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
877
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
878
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
879
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
880
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
881
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
882
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
883
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
884
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && !defined(__cplusplus)
885
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
886
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) && defined(__cplusplus)
887
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
888
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
889
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
890
#elif HEDLEY_PELLES_VERSION_CHECK(2, 90, 0)
891
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
892
#else
893
#define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
894
#endif
895
896
#if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
897
#undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
898
#endif
899
#if HEDLEY_HAS_WARNING("-Wunknown-pragmas")
900
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
901
#elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
902
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
903
#elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
904
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable : 161))
905
#elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
906
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
907
#elif HEDLEY_GCC_VERSION_CHECK(4, 3, 0)
908
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
909
#elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0)
910
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable : 4068))
911
#elif HEDLEY_TI_VERSION_CHECK(16, 9, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) || \
912
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0)
913
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
914
#elif HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0)
915
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
916
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
917
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
918
#else
919
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
920
#endif
921
922
#if defined(HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
923
#undef HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
924
#endif
925
#if HEDLEY_HAS_WARNING("-Wunknown-attributes")
926
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
927
#elif HEDLEY_GCC_VERSION_CHECK(4, 6, 0)
928
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
929
#elif HEDLEY_INTEL_VERSION_CHECK(17, 0, 0)
930
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
931
#elif HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
932
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable : 1292))
933
#elif HEDLEY_MSVC_VERSION_CHECK(19, 0, 0)
934
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable : 5030))
935
#elif HEDLEY_PGI_VERSION_CHECK(20, 7, 0)
936
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
937
#elif HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
938
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
939
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)
940
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
941
#elif HEDLEY_TI_VERSION_CHECK(18, 1, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) || \
942
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0)
943
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
944
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
945
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
946
#else
947
#define HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
948
#endif
949
950
#if defined(HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
951
#undef HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
952
#endif
953
#if HEDLEY_HAS_WARNING("-Wcast-qual")
954
#define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
955
#elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
956
#define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
957
#elif HEDLEY_GCC_VERSION_CHECK(3, 0, 0)
958
#define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
959
#else
960
#define HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
961
#endif
962
963
#if defined(HEDLEY_DEPRECATED)
964
#undef HEDLEY_DEPRECATED
965
#endif
966
#if defined(HEDLEY_DEPRECATED_FOR)
967
#undef HEDLEY_DEPRECATED_FOR
968
#endif
969
#if HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
970
#define HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " #since))
971
#define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
972
#elif HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || HEDLEY_GCC_VERSION_CHECK(4, 5, 0) || \
973
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_ARM_VERSION_CHECK(5, 6, 0) || \
974
HEDLEY_SUNPRO_VERSION_CHECK(5, 13, 0) || HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || \
975
HEDLEY_TI_VERSION_CHECK(18, 1, 0) || HEDLEY_TI_ARMCL_VERSION_CHECK(18, 1, 0) || \
976
HEDLEY_TI_CL6X_VERSION_CHECK(8, 3, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
977
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 3, 0)
978
#define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
979
#define HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
980
#elif defined(__cplusplus) && (__cplusplus >= 201402L)
981
#define HEDLEY_DEPRECATED(since) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
982
#define HEDLEY_DEPRECATED_FOR(since, replacement) \
983
HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
984
#elif HEDLEY_HAS_ATTRIBUTE(deprecated) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \
985
HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
986
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
987
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
988
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
989
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
990
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
991
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
992
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
993
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
994
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
995
#define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
996
#define HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
997
#elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || HEDLEY_PELLES_VERSION_CHECK(6, 50, 0) || \
998
HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
999
#define HEDLEY_DEPRECATED(since) __declspec(deprecated)
1000
#define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1001
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
1002
#define HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1003
#define HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1004
#else
1005
#define HEDLEY_DEPRECATED(since)
1006
#define HEDLEY_DEPRECATED_FOR(since, replacement)
1007
#endif
1008
1009
#if defined(HEDLEY_UNAVAILABLE)
1010
#undef HEDLEY_UNAVAILABLE
1011
#endif
1012
#if HEDLEY_HAS_ATTRIBUTE(warning) || HEDLEY_GCC_VERSION_CHECK(4, 3, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
1013
#define HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1014
#else
1015
#define HEDLEY_UNAVAILABLE(available_since)
1016
#endif
1017
1018
#if defined(HEDLEY_WARN_UNUSED_RESULT)
1019
#undef HEDLEY_WARN_UNUSED_RESULT
1020
#endif
1021
#if defined(HEDLEY_WARN_UNUSED_RESULT_MSG)
1022
#undef HEDLEY_WARN_UNUSED_RESULT_MSG
1023
#endif
1024
#if HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || \
1025
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1026
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1027
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1028
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1029
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1030
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1031
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1032
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1033
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1034
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || (HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) || \
1035
HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
1036
#define HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1037
#define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1038
#elif (HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1039
#define HEDLEY_WARN_UNUSED_RESULT HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1040
#define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1041
#elif HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1042
#define HEDLEY_WARN_UNUSED_RESULT HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1043
#define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1044
#elif defined(_Check_return_)
/* SAL */
1045
#define HEDLEY_WARN_UNUSED_RESULT _Check_return_
1046
#define HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1047
#else
1048
#define HEDLEY_WARN_UNUSED_RESULT
1049
#define HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1050
#endif
1051
1052
#if defined(HEDLEY_SENTINEL)
1053
#undef HEDLEY_SENTINEL
1054
#endif
1055
#if HEDLEY_HAS_ATTRIBUTE(sentinel) || HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1056
HEDLEY_ARM_VERSION_CHECK(5, 4, 0)
1057
#define HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1058
#else
1059
#define HEDLEY_SENTINEL(position)
1060
#endif
1061
1062
#if defined(HEDLEY_NO_RETURN)
1063
#undef HEDLEY_NO_RETURN
1064
#endif
1065
#if HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
1066
#define HEDLEY_NO_RETURN __noreturn
1067
#elif HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
1068
#define HEDLEY_NO_RETURN __attribute__((__noreturn__))
1069
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1070
#define HEDLEY_NO_RETURN _Noreturn
1071
#elif defined(__cplusplus) && (__cplusplus >= 201103L)
1072
#define HEDLEY_NO_RETURN HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1073
#elif HEDLEY_HAS_ATTRIBUTE(noreturn) || HEDLEY_GCC_VERSION_CHECK(3, 2, 0) || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \
1074
HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1075
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1076
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1077
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1078
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1079
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1080
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1081
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1082
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1083
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
1084
#define HEDLEY_NO_RETURN __attribute__((__noreturn__))
1085
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
1086
#define HEDLEY_NO_RETURN _Pragma("does_not_return")
1087
#elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1088
#define HEDLEY_NO_RETURN __declspec(noreturn)
1089
#elif HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
1090
#define HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1091
#elif HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
1092
#define HEDLEY_NO_RETURN __attribute((noreturn))
1093
#elif HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
1094
#define HEDLEY_NO_RETURN __declspec(noreturn)
1095
#else
1096
#define HEDLEY_NO_RETURN
1097
#endif
1098
1099
#if defined(HEDLEY_NO_ESCAPE)
1100
#undef HEDLEY_NO_ESCAPE
1101
#endif
1102
#if HEDLEY_HAS_ATTRIBUTE(noescape)
1103
#define HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1104
#else
1105
#define HEDLEY_NO_ESCAPE
1106
#endif
1107
1108
#if defined(HEDLEY_UNREACHABLE)
1109
#undef HEDLEY_UNREACHABLE
1110
#endif
1111
#if defined(HEDLEY_UNREACHABLE_RETURN)
1112
#undef HEDLEY_UNREACHABLE_RETURN
1113
#endif
1114
#if defined(HEDLEY_ASSUME)
1115
#undef HEDLEY_ASSUME
1116
#endif
1117
#if HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1118
HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1119
#define HEDLEY_ASSUME(expr) __assume(expr)
1120
#elif HEDLEY_HAS_BUILTIN(__builtin_assume)
1121
#define HEDLEY_ASSUME(expr) __builtin_assume(expr)
1122
#elif HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
1123
#if defined(__cplusplus)
1124
#define HEDLEY_ASSUME(expr) std::_nassert(expr)
1125
#else
1126
#define HEDLEY_ASSUME(expr) _nassert(expr)
1127
#endif
1128
#endif
1129
#if (HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(HEDLEY_ARM_VERSION))) || \
1130
HEDLEY_GCC_VERSION_CHECK(4, 5, 0) || HEDLEY_PGI_VERSION_CHECK(18, 10, 0) || \
1131
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_IBM_VERSION_CHECK(13, 1, 5)
1132
#define HEDLEY_UNREACHABLE() __builtin_unreachable()
1133
#elif defined(HEDLEY_ASSUME)
1134
#define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0)
1135
#endif
1136
#if !defined(HEDLEY_ASSUME)
1137
#if defined(HEDLEY_UNREACHABLE)
1138
#define HEDLEY_ASSUME(expr) HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (HEDLEY_UNREACHABLE(), 1)))
1139
#else
1140
#define HEDLEY_ASSUME(expr) HEDLEY_STATIC_CAST(void, expr)
1141
#endif
1142
#endif
1143
#if defined(HEDLEY_UNREACHABLE)
1144
#if HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0)
1145
#define HEDLEY_UNREACHABLE_RETURN(value) return (HEDLEY_STATIC_CAST(void, HEDLEY_ASSUME(0)), (value))
1146
#else
1147
#define HEDLEY_UNREACHABLE_RETURN(value) HEDLEY_UNREACHABLE()
1148
#endif
1149
#else
1150
#define HEDLEY_UNREACHABLE_RETURN(value) return (value)
1151
#endif
1152
#if !defined(HEDLEY_UNREACHABLE)
1153
#define HEDLEY_UNREACHABLE() HEDLEY_ASSUME(0)
1154
#endif
1155
1156
HEDLEY_DIAGNOSTIC_PUSH
1157
#if HEDLEY_HAS_WARNING("-Wpedantic")
1158
#pragma clang diagnostic ignored "-Wpedantic"
1159
#endif
1160
#if HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1161
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1162
#endif
1163
#if HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros", 4, 0, 0)
1164
#if defined(__clang__)
1165
#pragma clang diagnostic ignored "-Wvariadic-macros"
1166
#elif defined(HEDLEY_GCC_VERSION)
1167
#pragma GCC diagnostic ignored "-Wvariadic-macros"
1168
#endif
1169
#endif
1170
#if defined(HEDLEY_NON_NULL)
1171
#undef HEDLEY_NON_NULL
1172
#endif
1173
#if HEDLEY_HAS_ATTRIBUTE(nonnull) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1174
HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
1175
#define HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1176
#else
1177
#define HEDLEY_NON_NULL(...)
1178
#endif
1179
HEDLEY_DIAGNOSTIC_POP
1180
1181
#if defined(HEDLEY_PRINTF_FORMAT)
1182
#undef HEDLEY_PRINTF_FORMAT
1183
#endif
1184
#if defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) && !defined(__USE_MINGW_ANSI_STDIO)
1185
#define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \
1186
__attribute__((__format__(ms_printf, string_idx, first_to_check)))
1187
#elif defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format, 4, 4, 0) && defined(__USE_MINGW_ANSI_STDIO)
1188
#define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \
1189
__attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1190
#elif HEDLEY_HAS_ATTRIBUTE(format) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1191
HEDLEY_ARM_VERSION_CHECK(5, 6, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1192
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1193
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1194
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1195
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1196
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1197
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1198
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1199
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1200
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
1201
#define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) \
1202
__attribute__((__format__(__printf__, string_idx, first_to_check)))
1203
#elif HEDLEY_PELLES_VERSION_CHECK(6, 0, 0)
1204
#define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check) __declspec(vaformat(printf, string_idx, first_to_check))
1205
#else
1206
#define HEDLEY_PRINTF_FORMAT(string_idx, first_to_check)
1207
#endif
1208
1209
#if defined(HEDLEY_CONSTEXPR)
1210
#undef HEDLEY_CONSTEXPR
1211
#endif
1212
#if defined(__cplusplus)
1213
#if __cplusplus >= 201103L
1214
#define HEDLEY_CONSTEXPR HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1215
#endif
1216
#endif
1217
#if !defined(HEDLEY_CONSTEXPR)
1218
#define HEDLEY_CONSTEXPR
1219
#endif
1220
1221
#if defined(HEDLEY_PREDICT)
1222
#undef HEDLEY_PREDICT
1223
#endif
1224
#if defined(HEDLEY_LIKELY)
1225
#undef HEDLEY_LIKELY
1226
#endif
1227
#if defined(HEDLEY_UNLIKELY)
1228
#undef HEDLEY_UNLIKELY
1229
#endif
1230
#if defined(HEDLEY_UNPREDICTABLE)
1231
#undef HEDLEY_UNPREDICTABLE
1232
#endif
1233
#if HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1234
#define HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1235
#endif
1236
#if (HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(HEDLEY_PGI_VERSION)) || \
1237
HEDLEY_GCC_VERSION_CHECK(9, 0, 0)
1238
#define HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability((expr), (value), (probability))
1239
#define HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1, (probability))
1240
#define HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0, (probability))
1241
#define HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1242
#define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1243
#elif (HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(HEDLEY_INTEL_CL_VERSION)) || \
1244
HEDLEY_GCC_VERSION_CHECK(3, 0, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1245
(HEDLEY_SUNPRO_VERSION_CHECK(5, 15, 0) && defined(__cplusplus)) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \
1246
HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1247
HEDLEY_TI_ARMCL_VERSION_CHECK(4, 7, 0) || HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) || \
1248
HEDLEY_TI_CL2000_VERSION_CHECK(6, 1, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || \
1249
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || \
1250
HEDLEY_TINYC_VERSION_CHECK(0, 9, 27) || HEDLEY_CRAY_VERSION_CHECK(8, 1, 0)
1251
#define HEDLEY_PREDICT(expr, expected, probability) \
1252
(((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (HEDLEY_STATIC_CAST(void, expected), (expr)))
1253
#define HEDLEY_PREDICT_TRUE(expr, probability) \
1254
(__extension__({ \
1255
double hedley_probability_ = (probability); \
1256
((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) \
1257
: ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1258
}))
1259
#define HEDLEY_PREDICT_FALSE(expr, probability) \
1260
(__extension__({ \
1261
double hedley_probability_ = (probability); \
1262
((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) \
1263
: ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1264
}))
1265
#define HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1266
#define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1267
#else
1268
#define HEDLEY_PREDICT(expr, expected, probability) (HEDLEY_STATIC_CAST(void, expected), (expr))
1269
#define HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1270
#define HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1271
#define HEDLEY_LIKELY(expr) (!!(expr))
1272
#define HEDLEY_UNLIKELY(expr) (!!(expr))
1273
#endif
1274
#if !defined(HEDLEY_UNPREDICTABLE)
1275
#define HEDLEY_UNPREDICTABLE(expr) HEDLEY_PREDICT(expr, 1, 0.5)
1276
#endif
1277
1278
#if defined(HEDLEY_MALLOC)
1279
#undef HEDLEY_MALLOC
1280
#endif
1281
#if HEDLEY_HAS_ATTRIBUTE(malloc) || HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1282
HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \
1283
HEDLEY_IBM_VERSION_CHECK(12, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1284
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1285
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1286
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1287
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1288
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1289
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1290
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1291
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1292
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
1293
#define HEDLEY_MALLOC __attribute__((__malloc__))
1294
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
1295
#define HEDLEY_MALLOC _Pragma("returns_new_memory")
1296
#elif HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1297
#define HEDLEY_MALLOC __declspec(restrict)
1298
#else
1299
#define HEDLEY_MALLOC
1300
#endif
1301
1302
#if defined(HEDLEY_PURE)
1303
#undef HEDLEY_PURE
1304
#endif
1305
#if HEDLEY_HAS_ATTRIBUTE(pure) || HEDLEY_GCC_VERSION_CHECK(2, 96, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1306
HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \
1307
HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1308
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1309
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1310
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1311
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1312
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1313
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1314
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1315
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1316
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
1317
#define HEDLEY_PURE __attribute__((__pure__))
1318
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
1319
#define HEDLEY_PURE _Pragma("does_not_write_global_data")
1320
#elif defined(__cplusplus) && (HEDLEY_TI_CL430_VERSION_CHECK(2, 0, 1) || HEDLEY_TI_CL6X_VERSION_CHECK(4, 0, 0) || \
1321
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0))
1322
#define HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1323
#else
1324
#define HEDLEY_PURE
1325
#endif
1326
1327
#if defined(HEDLEY_CONST)
1328
#undef HEDLEY_CONST
1329
#endif
1330
#if HEDLEY_HAS_ATTRIBUTE(const) || HEDLEY_GCC_VERSION_CHECK(2, 5, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1331
HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \
1332
HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1333
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1334
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1335
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1336
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1337
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1338
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1339
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1340
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1341
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0) || HEDLEY_PGI_VERSION_CHECK(17, 10, 0)
1342
#define HEDLEY_CONST __attribute__((__const__))
1343
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0)
1344
#define HEDLEY_CONST _Pragma("no_side_effect")
1345
#else
1346
#define HEDLEY_CONST HEDLEY_PURE
1347
#endif
1348
1349
#if defined(HEDLEY_RESTRICT)
1350
#undef HEDLEY_RESTRICT
1351
#endif
1352
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1353
#define HEDLEY_RESTRICT restrict
1354
#elif HEDLEY_GCC_VERSION_CHECK(3, 1, 0) || HEDLEY_MSVC_VERSION_CHECK(14, 0, 0) || \
1355
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || \
1356
HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_PGI_VERSION_CHECK(17, 10, 0) || \
1357
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 4) || \
1358
HEDLEY_TI_CL6X_VERSION_CHECK(8, 1, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1359
(HEDLEY_SUNPRO_VERSION_CHECK(5, 14, 0) && defined(__cplusplus)) || HEDLEY_IAR_VERSION_CHECK(8, 0, 0) || \
1360
defined(__clang__)
1361
#define HEDLEY_RESTRICT __restrict
1362
#elif HEDLEY_SUNPRO_VERSION_CHECK(5, 3, 0) && !defined(__cplusplus)
1363
#define HEDLEY_RESTRICT _Restrict
1364
#else
1365
#define HEDLEY_RESTRICT
1366
#endif
1367
1368
#if defined(HEDLEY_INLINE)
1369
#undef HEDLEY_INLINE
1370
#endif
1371
#if (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || (defined(__cplusplus) && (__cplusplus >= 199711L))
1372
#define HEDLEY_INLINE inline
1373
#elif defined(HEDLEY_GCC_VERSION) || HEDLEY_ARM_VERSION_CHECK(6, 2, 0)
1374
#define HEDLEY_INLINE __inline__
1375
#elif HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || \
1376
HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_TI_ARMCL_VERSION_CHECK(5, 1, 0) || \
1377
HEDLEY_TI_CL430_VERSION_CHECK(3, 1, 0) || HEDLEY_TI_CL2000_VERSION_CHECK(6, 2, 0) || \
1378
HEDLEY_TI_CL6X_VERSION_CHECK(8, 0, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1379
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
1380
#define HEDLEY_INLINE __inline
1381
#else
1382
#define HEDLEY_INLINE
1383
#endif
1384
1385
#if defined(HEDLEY_ALWAYS_INLINE)
1386
#undef HEDLEY_ALWAYS_INLINE
1387
#endif
1388
#if HEDLEY_HAS_ATTRIBUTE(always_inline) || HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || \
1389
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \
1390
HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1391
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1392
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1393
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1394
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1395
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1396
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1397
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1398
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1399
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
1400
#define HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) HEDLEY_INLINE
1401
#elif HEDLEY_MSVC_VERSION_CHECK(12, 0, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1402
#define HEDLEY_ALWAYS_INLINE __forceinline
1403
#elif defined(__cplusplus) && (HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1404
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || \
1405
HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0))
1406
#define HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1407
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
1408
#define HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1409
#else
1410
#define HEDLEY_ALWAYS_INLINE HEDLEY_INLINE
1411
#endif
1412
1413
#if defined(HEDLEY_NEVER_INLINE)
1414
#undef HEDLEY_NEVER_INLINE
1415
#endif
1416
#if HEDLEY_HAS_ATTRIBUTE(noinline) || HEDLEY_GCC_VERSION_CHECK(4, 0, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || \
1417
HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || \
1418
HEDLEY_IBM_VERSION_CHECK(10, 1, 0) || HEDLEY_TI_VERSION_CHECK(15, 12, 0) || \
1419
(HEDLEY_TI_ARMCL_VERSION_CHECK(4, 8, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1420
HEDLEY_TI_ARMCL_VERSION_CHECK(5, 2, 0) || \
1421
(HEDLEY_TI_CL2000_VERSION_CHECK(6, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1422
HEDLEY_TI_CL2000_VERSION_CHECK(6, 4, 0) || \
1423
(HEDLEY_TI_CL430_VERSION_CHECK(4, 0, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1424
HEDLEY_TI_CL430_VERSION_CHECK(4, 3, 0) || \
1425
(HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1426
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0) || HEDLEY_TI_CL7X_VERSION_CHECK(1, 2, 0) || \
1427
HEDLEY_TI_CLPRU_VERSION_CHECK(2, 1, 0)
1428
#define HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1429
#elif HEDLEY_MSVC_VERSION_CHECK(13, 10, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1430
#define HEDLEY_NEVER_INLINE __declspec(noinline)
1431
#elif HEDLEY_PGI_VERSION_CHECK(10, 2, 0)
1432
#define HEDLEY_NEVER_INLINE _Pragma("noinline")
1433
#elif HEDLEY_TI_CL6X_VERSION_CHECK(6, 0, 0) && defined(__cplusplus)
1434
#define HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1435
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
1436
#define HEDLEY_NEVER_INLINE _Pragma("inline=never")
1437
#elif HEDLEY_COMPCERT_VERSION_CHECK(3, 2, 0)
1438
#define HEDLEY_NEVER_INLINE __attribute((noinline))
1439
#elif HEDLEY_PELLES_VERSION_CHECK(9, 0, 0)
1440
#define HEDLEY_NEVER_INLINE __declspec(noinline)
1441
#else
1442
#define HEDLEY_NEVER_INLINE
1443
#endif
1444
1445
#if defined(HEDLEY_PRIVATE)
1446
#undef HEDLEY_PRIVATE
1447
#endif
1448
#if defined(HEDLEY_PUBLIC)
1449
#undef HEDLEY_PUBLIC
1450
#endif
1451
#if defined(HEDLEY_IMPORT)
1452
#undef HEDLEY_IMPORT
1453
#endif
1454
#if defined(_WIN32) || defined(__CYGWIN__)
1455
#define HEDLEY_PRIVATE
1456
#define HEDLEY_PUBLIC __declspec(dllexport)
1457
#define HEDLEY_IMPORT __declspec(dllimport)
1458
#else
1459
#if HEDLEY_HAS_ATTRIBUTE(visibility) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || HEDLEY_SUNPRO_VERSION_CHECK(5, 11, 0) || \
1460
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(13, 1, 0) || \
1461
(defined(__TI_EABI__) && ((HEDLEY_TI_CL6X_VERSION_CHECK(7, 2, 0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1462
HEDLEY_TI_CL6X_VERSION_CHECK(7, 5, 0)))
1463
#define HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1464
#define HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1465
#else
1466
#define HEDLEY_PRIVATE
1467
#define HEDLEY_PUBLIC
1468
#endif
1469
#define HEDLEY_IMPORT extern
1470
#endif
1471
1472
#if defined(HEDLEY_NO_THROW)
1473
#undef HEDLEY_NO_THROW
1474
#endif
1475
#if HEDLEY_HAS_ATTRIBUTE(nothrow) || HEDLEY_GCC_VERSION_CHECK(3, 3, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
1476
#define HEDLEY_NO_THROW __attribute__((__nothrow__))
1477
#elif HEDLEY_MSVC_VERSION_CHECK(13, 1, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0) || \
1478
HEDLEY_ARM_VERSION_CHECK(4, 1, 0)
1479
#define HEDLEY_NO_THROW __declspec(nothrow)
1480
#else
1481
#define HEDLEY_NO_THROW
1482
#endif
1483
1484
#if defined(HEDLEY_FALL_THROUGH)
1485
#undef HEDLEY_FALL_THROUGH
1486
#endif
1487
#if HEDLEY_HAS_ATTRIBUTE(fallthrough) || HEDLEY_GCC_VERSION_CHECK(7, 0, 0)
1488
#define HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1489
#elif HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang, fallthrough)
1490
#define HEDLEY_FALL_THROUGH HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1491
#elif HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1492
#define HEDLEY_FALL_THROUGH HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1493
#elif defined(__fallthrough)
/* SAL */
1494
#define HEDLEY_FALL_THROUGH __fallthrough
1495
#else
1496
#define HEDLEY_FALL_THROUGH
1497
#endif
1498
1499
#if defined(HEDLEY_RETURNS_NON_NULL)
1500
#undef HEDLEY_RETURNS_NON_NULL
1501
#endif
1502
#if HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || HEDLEY_GCC_VERSION_CHECK(4, 9, 0)
1503
#define HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1504
#elif defined(_Ret_notnull_)
/* SAL */
1505
#define HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1506
#else
1507
#define HEDLEY_RETURNS_NON_NULL
1508
#endif
1509
1510
#if defined(HEDLEY_ARRAY_PARAM)
1511
#undef HEDLEY_ARRAY_PARAM
1512
#endif
1513
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__STDC_NO_VLA__) && \
1514
!defined(__cplusplus) && !defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_TINYC_VERSION)
1515
#define HEDLEY_ARRAY_PARAM(name) (name)
1516
#else
1517
#define HEDLEY_ARRAY_PARAM(name)
1518
#endif
1519
1520
#if defined(HEDLEY_IS_CONSTANT)
1521
#undef HEDLEY_IS_CONSTANT
1522
#endif
1523
#if defined(HEDLEY_REQUIRE_CONSTEXPR)
1524
#undef HEDLEY_REQUIRE_CONSTEXPR
1525
#endif
1526
/* HEDLEY_IS_CONSTEXPR_ is for
1527
HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
1528
#if defined(HEDLEY_IS_CONSTEXPR_)
1529
#undef HEDLEY_IS_CONSTEXPR_
1530
#endif
1531
#if HEDLEY_HAS_BUILTIN(__builtin_constant_p) || HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || \
1532
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_TINYC_VERSION_CHECK(0, 9, 19) || \
1533
HEDLEY_ARM_VERSION_CHECK(4, 1, 0) || HEDLEY_IBM_VERSION_CHECK(13, 1, 0) || \
1534
HEDLEY_TI_CL6X_VERSION_CHECK(6, 1, 0) || (HEDLEY_SUNPRO_VERSION_CHECK(5, 10, 0) && !defined(__cplusplus)) || \
1535
HEDLEY_CRAY_VERSION_CHECK(8, 1, 0)
1536
#define HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1537
#endif
1538
#if !defined(__cplusplus)
1539
#if HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || HEDLEY_GCC_VERSION_CHECK(3, 4, 0) || \
1540
HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || HEDLEY_IBM_VERSION_CHECK(13, 1, 0) || \
1541
HEDLEY_CRAY_VERSION_CHECK(8, 1, 0) || HEDLEY_ARM_VERSION_CHECK(5, 4, 0) || HEDLEY_TINYC_VERSION_CHECK(0, 9, 24)
1542
#if defined(__INTPTR_TYPE__)
1543
#define HEDLEY_IS_CONSTEXPR_(expr) \
1544
__builtin_types_compatible_p(__typeof__((1 ? (void *)((__INTPTR_TYPE__)((expr)*0)) : (int *)0)), int *)
1545
#else
1546
#include <stdint.h>
1547
#define HEDLEY_IS_CONSTEXPR_(expr) \
1548
__builtin_types_compatible_p(__typeof__((1 ? (void *)((intptr_t)((expr)*0)) : (int *)0)), int *)
1549
#endif
1550
#elif (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(HEDLEY_SUNPRO_VERSION) && \
1551
!defined(HEDLEY_PGI_VERSION) && !defined(HEDLEY_IAR_VERSION)) || \
1552
HEDLEY_HAS_EXTENSION(c_generic_selections) || HEDLEY_GCC_VERSION_CHECK(4, 9, 0) || \
1553
HEDLEY_INTEL_VERSION_CHECK(17, 0, 0) || HEDLEY_IBM_VERSION_CHECK(12, 1, 0) || HEDLEY_ARM_VERSION_CHECK(5, 3, 0)
1554
#if defined(__INTPTR_TYPE__)
1555
#define HEDLEY_IS_CONSTEXPR_(expr) \
1556
_Generic((1 ? (void *)((__INTPTR_TYPE__)((expr)*0)) : (int *)0), int * : 1, void * : 0)
1557
#else
1558
#include <stdint.h>
1559
#define HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void *)((intptr_t)*0) : (int *)0), int * : 1, void * : 0)
1560
#endif
1561
#elif defined(HEDLEY_GCC_VERSION) || defined(HEDLEY_INTEL_VERSION) || defined(HEDLEY_TINYC_VERSION) || \
1562
defined(HEDLEY_TI_ARMCL_VERSION) || HEDLEY_TI_CL430_VERSION_CHECK(18, 12, 0) || \
1563
defined(HEDLEY_TI_CL2000_VERSION) || defined(HEDLEY_TI_CL6X_VERSION) || defined(HEDLEY_TI_CL7X_VERSION) || \
1564
defined(HEDLEY_TI_CLPRU_VERSION) || defined(__clang__)
1565
#define HEDLEY_IS_CONSTEXPR_(expr) \
1566
(sizeof(void) != sizeof(*(1 ? ((void *)((expr)*0L)) : ((struct { char v[sizeof(void) * 2]; } *)1))))
1567
#endif
1568
#endif
1569
#if defined(HEDLEY_IS_CONSTEXPR_)
1570
#if !defined(HEDLEY_IS_CONSTANT)
1571
#define HEDLEY_IS_CONSTANT(expr) HEDLEY_IS_CONSTEXPR_(expr)
1572
#endif
1573
#define HEDLEY_REQUIRE_CONSTEXPR(expr) (HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1574
#else
1575
#if !defined(HEDLEY_IS_CONSTANT)
1576
#define HEDLEY_IS_CONSTANT(expr) (0)
1577
#endif
1578
#define HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1579
#endif
1580
1581
#if defined(HEDLEY_BEGIN_C_DECLS)
1582
#undef HEDLEY_BEGIN_C_DECLS
1583
#endif
1584
#if defined(HEDLEY_END_C_DECLS)
1585
#undef HEDLEY_END_C_DECLS
1586
#endif
1587
#if defined(HEDLEY_C_DECL)
1588
#undef HEDLEY_C_DECL
1589
#endif
1590
#if defined(__cplusplus)
1591
#define HEDLEY_BEGIN_C_DECLS extern "C" {
1592
#define HEDLEY_END_C_DECLS }
1593
#define HEDLEY_C_DECL extern "C"
1594
#else
1595
#define HEDLEY_BEGIN_C_DECLS
1596
#define HEDLEY_END_C_DECLS
1597
#define HEDLEY_C_DECL
1598
#endif
1599
1600
#if defined(HEDLEY_STATIC_ASSERT)
1601
#undef HEDLEY_STATIC_ASSERT
1602
#endif
1603
#if !defined(__cplusplus) && \
1604
((defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1605
(HEDLEY_HAS_FEATURE(c_static_assert) && !defined(HEDLEY_INTEL_CL_VERSION)) || \
1606
HEDLEY_GCC_VERSION_CHECK(6, 0, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0) || defined(_Static_assert))
1607
#define HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1608
#elif (defined(__cplusplus) && (__cplusplus >= 201103L)) || HEDLEY_MSVC_VERSION_CHECK(16, 0, 0) || \
1609
HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1610
#define HEDLEY_STATIC_ASSERT(expr, message) HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1611
#else
1612
#define HEDLEY_STATIC_ASSERT(expr, message)
1613
#endif
1614
1615
#if defined(HEDLEY_NULL)
1616
#undef HEDLEY_NULL
1617
#endif
1618
#if defined(__cplusplus)
1619
#if __cplusplus >= 201103L
1620
#define HEDLEY_NULL HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1621
#elif defined(NULL)
1622
#define HEDLEY_NULL NULL
1623
#else
1624
#define HEDLEY_NULL HEDLEY_STATIC_CAST(void *, 0)
1625
#endif
1626
#elif defined(NULL)
1627
#define HEDLEY_NULL NULL
1628
#else
1629
#define HEDLEY_NULL ((void *)0)
1630
#endif
1631
1632
#if defined(HEDLEY_MESSAGE)
1633
#undef HEDLEY_MESSAGE
1634
#endif
1635
#if HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1636
#define HEDLEY_MESSAGE(msg) \
1637
HEDLEY_DIAGNOSTIC_PUSH \
1638
HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1639
HEDLEY_PRAGMA(message msg) \
1640
HEDLEY_DIAGNOSTIC_POP
1641
#elif HEDLEY_GCC_VERSION_CHECK(4, 4, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
1642
#define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message msg)
1643
#elif HEDLEY_CRAY_VERSION_CHECK(5, 0, 0)
1644
#define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(_CRI message msg)
1645
#elif HEDLEY_IAR_VERSION_CHECK(8, 0, 0)
1646
#define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg))
1647
#elif HEDLEY_PELLES_VERSION_CHECK(2, 0, 0)
1648
#define HEDLEY_MESSAGE(msg) HEDLEY_PRAGMA(message(msg))
1649
#else
1650
#define HEDLEY_MESSAGE(msg)
1651
#endif
1652
1653
#if defined(HEDLEY_WARNING)
1654
#undef HEDLEY_WARNING
1655
#endif
1656
#if HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1657
#define HEDLEY_WARNING(msg) \
1658
HEDLEY_DIAGNOSTIC_PUSH \
1659
HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1660
HEDLEY_PRAGMA(clang warning msg) \
1661
HEDLEY_DIAGNOSTIC_POP
1662
#elif HEDLEY_GCC_VERSION_CHECK(4, 8, 0) || HEDLEY_PGI_VERSION_CHECK(18, 4, 0) || HEDLEY_INTEL_VERSION_CHECK(13, 0, 0)
1663
#define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(GCC warning msg)
1664
#elif HEDLEY_MSVC_VERSION_CHECK(15, 0, 0) || HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1665
#define HEDLEY_WARNING(msg) HEDLEY_PRAGMA(message(msg))
1666
#else
1667
#define HEDLEY_WARNING(msg) HEDLEY_MESSAGE(msg)
1668
#endif
1669
1670
#if defined(HEDLEY_REQUIRE)
1671
#undef HEDLEY_REQUIRE
1672
#endif
1673
#if defined(HEDLEY_REQUIRE_MSG)
1674
#undef HEDLEY_REQUIRE_MSG
1675
#endif
1676
#if HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1677
#if HEDLEY_HAS_WARNING("-Wgcc-compat")
1678
#define HEDLEY_REQUIRE(expr) \
1679
HEDLEY_DIAGNOSTIC_PUSH \
1680
_Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1681
HEDLEY_DIAGNOSTIC_POP
1682
#define HEDLEY_REQUIRE_MSG(expr, msg) \
1683
HEDLEY_DIAGNOSTIC_PUSH \
1684
_Pragma("clang diagnostic ignored \"-Wgcc-compat\"") __attribute__((diagnose_if(!(expr), msg, "error"))) \
1685
HEDLEY_DIAGNOSTIC_POP
1686
#else
1687
#define HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1688
#define HEDLEY_REQUIRE_MSG(expr, msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1689
#endif
1690
#else
1691
#define HEDLEY_REQUIRE(expr)
1692
#define HEDLEY_REQUIRE_MSG(expr, msg)
1693
#endif
1694
1695
#if defined(HEDLEY_FLAGS)
1696
#undef HEDLEY_FLAGS
1697
#endif
1698
#if HEDLEY_HAS_ATTRIBUTE(flag_enum)
1699
#define HEDLEY_FLAGS __attribute__((__flag_enum__))
1700
#else
1701
#define HEDLEY_FLAGS
1702
#endif
1703
1704
#if defined(HEDLEY_FLAGS_CAST)
1705
#undef HEDLEY_FLAGS_CAST
1706
#endif
1707
#if HEDLEY_INTEL_VERSION_CHECK(19, 0, 0)
1708
#define HEDLEY_FLAGS_CAST(T, expr) \
1709
(__extension__({ \
1710
HEDLEY_DIAGNOSTIC_PUSH \
1711
_Pragma("warning(disable:188)")((T)(expr)); \
1712
HEDLEY_DIAGNOSTIC_POP \
1713
}))
1714
#else
1715
#define HEDLEY_FLAGS_CAST(T, expr) HEDLEY_STATIC_CAST(T, expr)
1716
#endif
1717
1718
#if defined(HEDLEY_EMPTY_BASES)
1719
#undef HEDLEY_EMPTY_BASES
1720
#endif
1721
#if (HEDLEY_MSVC_VERSION_CHECK(19, 0, 23918) && !HEDLEY_MSVC_VERSION_CHECK(20, 0, 0)) || \
1722
HEDLEY_INTEL_CL_VERSION_CHECK(2021, 1, 0)
1723
#define HEDLEY_EMPTY_BASES __declspec(empty_bases)
1724
#else
1725
#define HEDLEY_EMPTY_BASES
1726
#endif
1727
1728
/* Remaining macros are deprecated. */
1729
1730
#if defined(HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1731
#undef HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1732
#endif
1733
#if defined(__clang__)
1734
#define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) (0)
1735
#else
1736
#define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major, minor, patch) HEDLEY_GCC_VERSION_CHECK(major, minor, patch)
1737
#endif
1738
1739
#if defined(HEDLEY_CLANG_HAS_ATTRIBUTE)
1740
#undef HEDLEY_CLANG_HAS_ATTRIBUTE
1741
#endif
1742
#define HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) HEDLEY_HAS_ATTRIBUTE(attribute)
1743
1744
#if defined(HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1745
#undef HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1746
#endif
1747
#define HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1748
1749
#if defined(HEDLEY_CLANG_HAS_BUILTIN)
1750
#undef HEDLEY_CLANG_HAS_BUILTIN
1751
#endif
1752
#define HEDLEY_CLANG_HAS_BUILTIN(builtin) HEDLEY_HAS_BUILTIN(builtin)
1753
1754
#if defined(HEDLEY_CLANG_HAS_FEATURE)
1755
#undef HEDLEY_CLANG_HAS_FEATURE
1756
#endif
1757
#define HEDLEY_CLANG_HAS_FEATURE(feature) HEDLEY_HAS_FEATURE(feature)
1758
1759
#if defined(HEDLEY_CLANG_HAS_EXTENSION)
1760
#undef HEDLEY_CLANG_HAS_EXTENSION
1761
#endif
1762
#define HEDLEY_CLANG_HAS_EXTENSION(extension) HEDLEY_HAS_EXTENSION(extension)
1763
1764
#if defined(HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
1765
#undef HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
1766
#endif
1767
#define HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
1768
1769
#if defined(HEDLEY_CLANG_HAS_WARNING)
1770
#undef HEDLEY_CLANG_HAS_WARNING
1771
#endif
1772
#define HEDLEY_CLANG_HAS_WARNING(warning) HEDLEY_HAS_WARNING(warning)
1773
1774
#endif
/* !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < X) */
nuitka
build
include
nuitka
hedley.h
Generated by
1.9.8
1.9.8