libcutils

libcutils/include/cutils/hedley.h
hedley.h
⎇
Raw
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 */
11
12#if !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < 3)
13#if defined(HEDLEY_VERSION)
14# undef HEDLEY_VERSION
15#endif
16#define HEDLEY_VERSION 3
17
18#if defined(HEDLEY_VERSION_ENCODE)
19# undef HEDLEY_VERSION_ENCODE
20#endif
21#define HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
22
23#if defined(HEDLEY_VERSION_DECODE_MAJOR)
24# undef HEDLEY_VERSION_DECODE_MAJOR
25#endif
26#define HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
27
28#if defined(HEDLEY_VERSION_DECODE_MINOR)
29# undef HEDLEY_VERSION_DECODE_MINOR
30#endif
31#define HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
32
33#if defined(HEDLEY_VERSION_DECODE_REVISION)
34# undef HEDLEY_VERSION_DECODE_REVISION
35#endif
36#define HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
37
38#if defined(HEDLEY_GCC_VERSION_CHECK)
39# undef HEDLEY_GCC_VERSION_CHECK
40#endif
41#if !defined(__GNUC__) || defined(__INTEL_COMPILER)
42# define HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
43#else
44# if defined(__GNUC_PATCHLEVEL__)
45# define HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) >= HEDLEY_VERSION_ENCODE(major,minor,patch))
46# else
47# define HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) >= HEDLEY_VERSION_ENCODE(major,minor,patch))
48# endif
49#endif
50
51#if defined(HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
52# undef HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
53#endif
54#if defined(__clang__)
55# define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
56#else
57# define HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
58#endif
59
60#if defined(HEDLEY_MSVC_VERSION_CHECK)
61# undef HEDLEY_GCC_VERSION_CHECK
62#endif
63#if !defined(_MSC_VER)
64# define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
65#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
66# define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
67#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
68# define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 100000) + (minor * 1000) + (patch)))
69#else
70# define HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
71#endif
72
73#if defined(HEDLEY_INTEL_VERSION_CHECK)
74# undef HEDLEY_INTEL_VERSION_CHECK
75#endif
76#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
77# define HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) ((__INTEL_COMPILER + __INTEL_COMPILER_UPDATE) >= (((major) * 100) + (minor)))
78#elif defined(__INTEL_COMPILER)
79# define HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (__INTEL_COMPILER >= (((major) * 100) + (minor)))
80#else
81# define HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
82#endif
83
84#if defined(HEDLEY_PGI_VERSION_CHECK)
85# undef HEDLEY_PGI_VERSION_CHECK
86#endif
87#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
88# define HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) >= HEDLEY_VERSION_ENCODE(major,minor,patch))
89#else
90# define HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
91#endif
92
93#if defined(HEDLEY_SUNPRO_VERSION_CHECK)
94# undef HEDLEY_SUNPRO_VERSION_CHECK
95#endif
96#if defined(__SUNPRO_C)
97# define HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) \
98 (__SUNPRO_C >= ((((major) > 5) || (((major) == 5) && ((minor) > 9))) ? \
99 (((major) * 0x1000) + (((minor + (6 * (minor / 10)))) * 0x10) + (revision)) : \
100 (((major) * 0x100) + ((minor) * 0x10) + (revision))))
101#elif defined(__SUNPRO_CC)
102# define HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) \
103 (__SUNPRO_CC >= ((((major) > 5) || (((major) == 5) && ((minor) > 9))) ? \
104 (((major) * 0x1000) + (((minor + (6 * (minor / 10)))) * 0x10) + (revision)) : \
105 (((major) * 0x100) + ((minor) * 0x10) + (revision))))
106#else
107# define HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
108#endif
109
110#if defined(HEDLEY_EMSCRIPTEN_VERSION_CHECK)
111# undef HEDLEY_EMSCRIPTEN_VERSION_CHECK
112#endif
113#if defined(__EMSCRIPTEN__)
114# define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) \
115 (HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) >= HEDLEY_VERSION_ENCODE(major, minor, patch))
116#else
117# define HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
118#endif
119
120#if defined(HEDLEY_ARM_VERSION_CHECK)
121# undef HEDLEY_ARM_VERSION_CHECK
122#endif
123#if defined(__ARMCOMPILER_VERSION)
124# define HEDLEY_ARM_VERSION_CHECK(major,minor,patch) ((__ARMCOMPILER_VERSION) >= ((major * 1000000) + (minor * 10000) + (patch * 100)))
125#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
126# define HEDLEY_ARM_VERSION_CHECK(major,minor,patch) ((__ARMCC_VERSION) >= ((major * 1000000) + (minor * 10000) + (patch)))
127#else
128# define HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
129#endif
130
131#if defined(HEDLEY_IBM_VERSION_CHECK)
132# undef HEDLEY_IBM_VERSION_CHECK
133#endif
134#if defined(__IBMC__)
135# define HEDLEY_IBM_VERSION_CHECK(major,minor,patch) ((((major) * 100) + ((minor) * 10) + (patch)) >= (__IBMC__))
136#elif defined(__IBMCPP__)
137# define HEDLEY_IBM_VERSION_CHECK(major,minor,patch) ((((major) * 100) + ((minor) * 10) + (patch)) >= (__IBMCPP__))
138#else
139# define HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
140#endif
141
142#if \
143 (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
144 HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
145 (HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
146# define HEDLEY_PRAGMA(value) _Pragma(#value)
147#elif HEDLEY_MSVC_VERSION_CHECK(15,0,0)
148# define HEDLEY_PRAGMA(value) __pragma(value)
149#else
150# define HEDLEY_PRAGMA(value)
151#endif
152
153#if defined(HEDLEY_CLANG_HAS_ATTRIBUTE)
154# undef HEDLEY_CLANG_HAS_ATTRIBUTE
155#endif
156#if defined(HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
157# undef HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
158#endif
159#if defined(HEDLEY_CLANG_HAS_BUILTIN)
160# undef HEDLEY_CLANG_HAS_BUILTIN
161#endif
162#if defined(HEDLEY_CLANG_HAS_FEATURE)
163# undef HEDLEY_CLANG_HAS_FEATURE
164#endif
165#if defined(HEDLEY_CLANG_HAS_EXTENSION)
166# undef HEDLEY_CLANG_HAS_EXTENSION
167#endif
168#if defined(HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE)
169# undef HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE
170#endif
171#if defined(HEDLEY_CLANG_HAS_WARNING)
172# undef HEDLEY_CLANG_HAS_WARNING
173#endif
174#if defined(__has_attribute)
175# define HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
176#else
177# define HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) (0)
178#endif
179#if defined(__has_cpp_attribute) && defined(__cplusplus)
180# define HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
181#else
182# define HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) (0)
183#endif
184#if defined(__has_builtin)
185# define HEDLEY_CLANG_HAS_BUILTIN(builtin) __has_builtin(builtin)
186#else
187# define HEDLEY_CLANG_HAS_BUILTIN(builtin) (0)
188#endif
189#if defined(__has_feature)
190# define HEDLEY_CLANG_HAS_FEATURE(feature) __has_feature(feature)
191#else
192# define HEDLEY_CLANG_HAS_FEATURE(feature) (0)
193#endif
194#if defined(__has_extension)
195# define HEDLEY_CLANG_HAS_EXTENSION(extension) __has_extension(extension)
196#else
197# define HEDLEY_CLANG_HAS_EXTENSION(extension) (0)
198#endif
199#if defined(__has_declspec_attribute)
200# define HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
201#else
202# define HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
203#endif
204#if defined(__has_warning)
205# define HEDLEY_CLANG_HAS_WARNING(warning) __has_warning(warning)
206#else
207# define HEDLEY_CLANG_HAS_WARNING(warning) (0)
208#endif
209
210#if defined(HEDLEY_GCC_HAS_ATTRIBUTE)
211# undef HEDLEY_GCC_HAS_ATTRIBUTE
212#endif
213#if defined(__has_attribute)
214# define HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
215#else
216# define HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
217#endif
218
219#if defined(HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
220# undef HEDLEY_GCC_HAS_CPP_ATTRIBUTE
221#endif
222#if defined(__has_cpp_attribute) && defined(__cplusplus)
223# define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(cpp_attribute,major,minor,patch) __has_cpp_attribute(cpp_attribute)
224#else
225# define HEDLEY_GCC_HAS_CPP_ATTRIBUTE(cpp_attribute,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
226#endif
227
228#if defined(HEDLEY_GCC_HAS_BUILTIN)
229# undef HEDLEY_GCC_HAS_BUILTIN
230#endif
231#if defined(__has_builtin)
232# define HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
233#else
234# define HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
235#endif
236
237#if defined(HEDLEY_GCC_HAS_FEATURE)
238# undef HEDLEY_GCC_HAS_FEATURE
239#endif
240#if defined(__has_feature)
241# define HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
242#else
243# define HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
244#endif
245
246#if defined(HEDLEY_GCC_HAS_EXTENSION)
247# undef HEDLEY_GCC_HAS_EXTENSION
248#endif
249#if defined(__has_extension)
250# define HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
251#else
252# define HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
253#endif
254
255#if defined(HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
256# undef HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
257#endif
258#if defined(__has_declspec_attribute)
259# define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(declspec_attribute,major,minor,patch) __has_declspec_attribute(declspec_attribute)
260#else
261# define HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(declspec_attribute,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
262#endif
263
264#if defined(HEDLEY_GCC_HAS_WARNING)
265# undef HEDLEY_GCC_HAS_WARNING
266#endif
267#if defined(__has_warning)
268# define HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
269#else
270# define HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
271#endif
272
273#if defined(HEDLEY_DIAGNOSTIC_PUSH)
274# undef HEDLEY_DIAGNOSTIC_PUSH
275#endif
276#if defined(HEDLEY_DIAGNOSTIC_POP)
277# undef HEDLEY_DIAGNOSTIC_POP
278#endif
279#if defined(__clang__)
280# define HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
281# define HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
282#elif HEDLEY_INTEL_VERSION_CHECK(16,0,0)
283# define HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
284# define HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
285#elif HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(4,6,0)
286# define HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
287# define HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
288#elif HEDLEY_MSVC_VERSION_CHECK(15,0,0)
289# define HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
290# define HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
291#else
292# define HEDLEY_DIAGNOSTIC_PUSH
293# define HEDLEY_DIAGNOSTIC_POP
294#endif
295
296#if defined(HEDLEY_DEPRECATED)
297# undef HEDLEY_DEPRECATED
298#endif
299#if defined(HEDLEY_DEPRECATED_FOR)
300# undef HEDLEY_DEPRECATED_FOR
301#endif
302#if defined(__cplusplus) && (__cplusplus >= 201402L)
303# define HEDLEY_DEPRECATED(since) [[deprecated("Since " #since)]]
304# define HEDLEY_DEPRECATED_FOR(since, replacement) [[deprecated("Since " #since "; use " #replacement)]]
305#elif \
306 HEDLEY_GCC_HAS_EXTENSION(attribute_deprecated_with_message,4,5,0) || \
307 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
308 HEDLEY_ARM_VERSION_CHECK(5,6,0)
309# define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
310# define HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
311#elif \
312 HEDLEY_GCC_HAS_ATTRIBUTE(deprcated,4,0,0) || \
313 HEDLEY_ARM_VERSION_CHECK(4,1,0)
314# define HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
315# define HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
316#elif HEDLEY_MSVC_VERSION_CHECK(14,0,0)
317# define HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
318# define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
319#elif HEDLEY_MSVC_VERSION_CHECK(13,10,0)
320# define HEDLEY_DEPRECATED(since) _declspec(deprecated)
321# define HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
322#else
323# define HEDLEY_DEPRECATED(since)
324# define HEDLEY_DEPRECATED_FOR(since, replacement)
325#endif
326
327#if defined(HEDLEY_UNAVAILABLE)
328# undef HEDLEY_UNAVAILABLE
329#endif
330#if \
331 HEDLEY_GCC_HAS_ATTRIBUTE(warning,4,3,0) || \
332 HEDLEY_INTEL_VERSION_CHECK(16,0,0)
333# define HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
334#else
335# define HEDLEY_UNAVAILABLE(available_since)
336#endif
337
338#if defined(HEDLEY_WARN_UNUSED_RESULT)
339# undef HEDLEY_WARN_UNUSED_RESULT
340#endif
341#if defined(__cplusplus) && (__cplusplus >= 201703L)
342# define HEDLEY_WARN_UNUSED_RESULT [[nodiscard]]
343#elif HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)
344# define HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
345#elif \
346 HEDLEY_GCC_HAS_ATTRIBUTE(warn_unused_result,3,4,0) || \
347 HEDLEY_INTEL_VERSION_CHECK(16,0,0)
348# define HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
349#elif defined(_Check_return_) /* SAL */
350# define HEDLEY_WARN_UNUSED_RESULT _Check_return_
351#else
352# define HEDLEY_WARN_UNUSED_RESULT
353#endif
354
355#if defined(HEDLEY_SENTINEL)
356# undef HEDLEY_SENTINEL
357#endif
358#if \
359 HEDLEY_GCC_HAS_ATTRIBUTE(sentinel,4,0,0) || \
360 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
361 HEDLEY_ARM_VERSION_CHECK(5,4,0)
362# define HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
363#else
364# define HEDLEY_SENTINEL(position)
365#endif
366
367#if defined(HEDLEY_NO_RETURN)
368# undef HEDLEY_NO_RETURN
369#endif
370#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
371# define HEDLEY_NO_RETURN _Noreturn
372#elif defined(__cplusplus) && (__cplusplus >= 201103L)
373# define HEDLEY_NO_RETURN [[noreturn]]
374#elif \
375 HEDLEY_GCC_HAS_ATTRIBUTE(noreturn,3,2,0) || \
376 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
377 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
378 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
379 HEDLEY_IBM_VERSION_CHECK(10,1,0)
380# define HEDLEY_NO_RETURN __attribute__((__noreturn__))
381#elif HEDLEY_MSVC_VERSION_CHECK(13,10,0)
382# define HEDLEY_NO_RETURN __declspec(noreturn)
383#else
384# define HEDLEY_NO_RETURN
385#endif
386
387#if defined(HEDLEY_UNREACHABLE)
388# undef HEDLEY_UNREACHABLE
389#endif
390#if (HEDLEY_GCC_HAS_BUILTIN(__builtin_unreachable,4,5,0) && !defined(__CC_ARM)) || HEDLEY_INTEL_VERSION_CHECK(16,0,0)
391# define HEDLEY_UNREACHABLE() __builtin_unreachable()
392#elif HEDLEY_MSVC_VERSION_CHECK(13,10,0)
393# define HEDLEY_UNREACHABLE() __assume(0)
394#elif defined(EXIT_FAILURE)
395# define HEDLEY_UNREACHABLE() abort()
396#else
397# define HEDLEY_UNREACHABLE()
398#endif
399
400HEDLEY_DIAGNOSTIC_PUSH
401#if HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
402# if defined(__clang__)
403# pragma clang diagnostic ignored "-Wvariadic-macros"
404# elif defined(__GNUC__)
405# pragma GCC diagnostic ignored "-Wvariadic-macros"
406# endif
407#endif
408#if defined(HEDLEY_NON_NULL)
409# undef HEDLEY_NON_NULL
410#endif
411#if HEDLEY_GCC_HAS_ATTRIBUTE(nonnull,3,3,0) || HEDLEY_INTEL_VERSION_CHECK(16,0,0) || HEDLEY_ARM_VERSION_CHECK(4,1,0)
412# define HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
413#else
414# define HEDLEY_NON_NULL(...)
415#endif
416HEDLEY_DIAGNOSTIC_POP
417
418#if defined(HEDLEY_PRINTF_FORMAT)
419# undef HEDLEY_PRINTF_FORMAT
420#endif
421#if defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
422# define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
423#elif defined(__MINGW32__) && HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
424# define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
425#elif \
426 HEDLEY_GCC_HAS_ATTRIBUTE(format,3,1,0) || \
427 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
428 HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
429 HEDLEY_IBM_VERSION_CHECK(10,1,0)
430# define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
431#else
432# define HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
433#endif
434
435#if defined(HEDLEY_LIKELY)
436# undef HEDLEY_LIKELY
437#endif
438#if defined(HEDLEY_UNLIKELY)
439# undef HEDLEY_UNLIKELY
440#endif
441#if \
442 HEDLEY_GCC_HAS_BUILTIN(__builtin_expect,3,0,0) || \
443 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
444 HEDLEY_SUNPRO_VERSION_CHECK(5,12,0) || \
445 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
446 HEDLEY_IBM_VERSION_CHECK(10,1,0)
447# define HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
448# define HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
449#else
450# define HEDLEY_LIKELY(expr) (!!(expr))
451# define HEDLEY_UNLIKELY(expr) (!!(expr))
452#endif
453
454#if defined(HEDLEY_MALLOC)
455# undef HEDLEY_MALLOC
456#endif
457#if \
458 HEDLEY_GCC_HAS_ATTRIBUTE(malloc, 3, 1, 0) || \
459 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
460 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
461 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
462 HEDLEY_IBM_VERSION_CHECK(12,1,0)
463# define HEDLEY_MALLOC __attribute__((__malloc__))
464#elif HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
465# define HEDLEY_MALLOC __declspec(restrict)
466#else
467# define HEDLEY_MALLOC
468#endif
469
470#if defined(HEDLEY_PURE)
471# undef HEDLEY_PURE
472#endif
473#if \
474 HEDLEY_GCC_HAS_ATTRIBUTE(pure, 2, 96, 0) || \
475 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
476 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
477 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
478 HEDLEY_IBM_VERSION_CHECK(10,1,0)
479# define HEDLEY_PURE __attribute__((__pure__))
480#elif HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
481# define HEDLEY_PURE __declspec(noalias)
482#else
483# define HEDLEY_PURE
484#endif
485
486#if defined(HEDLEY_CONST)
487# undef HEDLEY_CONST
488#endif
489#if HEDLEY_GCC_HAS_ATTRIBUTE(const, 2, 5, 0) || \
490 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
491 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
492 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
493 HEDLEY_IBM_VERSION_CHECK(10,1,0)
494# define HEDLEY_CONST __attribute__((__const__))
495#else
496# define HEDLEY_CONST HEDLEY_PURE
497#endif
498
499#if defined(HEDLEY_RESTRICT)
500# undef HEDLEY_RESTRICT
501#endif
502#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
503# define HEDLEY_RESTRICT restrict
504#elif \
505 HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
506 HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
507 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
508 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
509 HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
510 HEDLEY_PGI_VERSION_CHECK(17,10,0)
511# define HEDLEY_RESTRICT __restrict
512#elif HEDLEY_SUNPRO_VERSION_CHECK(5,8,0)
513# define HEDLEY_RESTRICT _Restrict
514#endif
515
516#if defined(HEDLEY_INLINE)
517# undef HEDLEY_INLINE
518#endif
519#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
520# define HEDLEY_INLINE inline
521#elif defined(__GNUC_STDC_INLINE__) || HEDLEY_ARM_VERSION_CHECK(6,2,0)
522# define HEDLEY_INLINE __inline__
523#elif HEDLEY_MSVC_VERSION_CHECK(12,0,0) || HEDLEY_ARM_VERSION_CHECK(4,1,0)
524# define HEDLEY_INLINE __inline
525#else
526# define HEDLEY_INLINE
527#endif
528
529#if defined(HEDLEY_ALWAYS_INLINE)
530# undef HEDLEY_ALWAYS_INLINE
531#endif
532#if \
533 HEDLEY_GCC_HAS_ATTRIBUTE(always_inline,4,0,0) || \
534 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
535 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
536 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
537 HEDLEY_IBM_VERSION_CHECK(10,1,0)
538# define HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__))
539#elif HEDLEY_MSVC_VERSION_CHECK(12,0,0)
540# define HEDLEY_ALWAYS_INLINE __forceinline
541#else
542# define HEDLEY_ALWAYS_INLINE HEDLEY_INLINE
543#endif
544
545#if defined(HEDLEY_NEVER_INLINE)
546# undef HEDLEY_NEVER_INLINE
547#endif
548#if \
549 HEDLEY_GCC_HAS_ATTRIBUTE(never_inline,4,0,0) || \
550 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
551 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
552 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
553 HEDLEY_IBM_VERSION_CHECK(10,1,0)
554# define HEDLEY_NEVER_INLINE __attribute__((__noinline__))
555#elif HEDLEY_MSVC_VERSION_CHECK(13,10,0)
556# define HEDLEY_NEVER_INLINE __declspec(noinline)
557#else
558# define HEDLEY_NEVER_INLINE HEDLEY_INLINE
559#endif
560
561#if defined(HEDLEY_PRIVATE)
562# undef HEDLEY_PRIVATE
563#endif
564#if defined(HEDLEY_PUBLIC)
565# undef HEDLEY_PUBLIC
566#endif
567#if defined(HEDLEY_IMPORT)
568# undef HEDLEY_IMPORT
569#endif
570#if defined(_WIN32) || defined(__CYGWIN__)
571# if \
572 HEDLEY_GCC_VERSION_CHECK(4,2,0) || \
573 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
574 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
575 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
576 HEDLEY_IBM_VERSION_CHECK(13,1,0)
577# define HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
578# else
579# define HEDLEY_PRIVATE
580# endif
581# define HEDLEY_PUBLIC __declspec(dllexport)
582# define HEDLEY_IMPORT __declspec(dllimport)
583#else
584# if \
585 HEDLEY_GCC_VERSION_CHECK(4,2,0) || \
586 HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
587 HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
588 HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
589 HEDLEY_IBM_VERSION_CHECK(13,1,0)
590# define HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
591# define HEDLEY_PUBLIC __attribute__((__visibility__("default")))
592# else
593# define HEDLEY_PRIVATE
594# define HEDLEY_PUBLIC
595# endif
596# define HEDLEY_IMPORT extern
597#endif
598
599#if defined(HEDLEY_NO_THROW)
600# undef HEDLEY_NO_THROW
601#endif
602#if \
603 HEDLEY_GCC_HAS_ATTRIBUTE(nothrow,3,3,0) || \
604 HEDLEY_INTEL_VERSION_CHECK(16,0,0)
605# define HEDLEY_NO_THROW __attribute__((__nothrow__))
606#elif \
607 HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
608 HEDLEY_ARM_VERSION_CHECK(4,1,0)
609# define HEDLEY_NO_THROW __declspec(nothrow)
610#else
611# define HEDLEY_NO_THROW
612#endif
613
614#if defined(HEDLEY_FALL_THROUGH)
615# undef HEDLEY_FALL_THROUGH
616#endif
617#if defined(__cplusplus) && (__cplusplus >= 201703L)
618# define HEDLEY_FALL_THROUGH [[fallthrough]]
619#elif defined(__cplusplus) && (__cplusplus >= 201103L) && HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(clang::fallthrough)
620# define HEDLEY_FALL_THROUGH [[clang::fallthrough]]
621#elif defined(__cplusplus) && (__cplusplus >= 201103L) && HEDLEY_GCC_HAS_CPP_ATTRIBUTE(gnu::fallthrough,7,0,0)
622# define HEDLEY_FALL_THROUGH [[gnu::fallthrough]]
623#elif HEDLEY_GCC_HAS_ATTRIBUTE(fallthrough,7,0,0)
624# define HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
625#elif defined(__fallthrough) /* SAL */
626# define HEDLEY_FALL_THROUGH __fallthrough
627#else
628# define HEDLEY_FALL_THROUGH
629#endif
630
631#if defined(HEDLEY_RETURNS_NON_NULL)
632# undef HEDLEY_RETURNS_NON_NULL
633#endif
634#if \
635 HEDLEY_GCC_HAS_ATTRIBUTE(returns_nonnull,4,9,0) || \
636 HEDLEY_INTEL_VERSION_CHECK(16,0,0)
637# define HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
638#elif defined(_Ret_notnull_) /* SAL */
639# define HEDLEY_RETURNS_NON_NULL _Ret_notnull_
640#else
641# define HEDLEY_RETURNS_NON_NULL
642#endif
643
644#if defined(HEDLEY_ARRAY_PARAM)
645# undef HEDLEY_ARRAY_PARAM
646#endif
647#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) && !defined(__PGI)
648# define HEDLEY_ARRAY_PARAM(name) (name)
649#else
650# define HEDLEY_ARRAY_PARAM(name)
651#endif
652
653#if defined(HEDLEY_BEGIN_C_DECLS)
654# undef HEDLEY_BEGIN_C_DECLS
655#endif
656#if defined(HEDLEY_END_C_DECLS)
657# undef HEDLEY_END_C_DECLS
658#endif
659#if defined(HEDLEY_C_DECL)
660# undef HEDLEY_C_DECL
661#endif
662#if defined(__cplusplus)
663# define HEDLEY_BEGIN_C_DECLS extern "C" {
664# define HEDLEY_END_C_DECLS }
665# define HEDLEY_C_DECL extern "C"
666#else
667# define HEDLEY_BEGIN_C_DECLS
668# define HEDLEY_END_C_DECLS
669# define HEDLEY_C_DECL
670#endif
671
672#if defined(HEDLEY_STATIC_ASSERT)
673# undef HEDLEY_STATIC_ASSERT
674#endif
675#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
676# define HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
677#elif defined(__cplusplus) && __cplusplus >= 201103L
678# define HEDLEY_STATIC_ASSERT(expr, message) static_assert(expr, message)
679#elif \
680 HEDLEY_GCC_HAS_FEATURE(c_static_assert,4,6,0) || \
681 HEDLEY_INTEL_VERSION_CHECK(16,0,0)
682# define HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
683#elif HEDLEY_MSVC_VERSION_CHECK(16,0,0)
684# define HEDLEY_STATIC_ASSERT(expr, message) static_assert(expr, message)
685#else
686# define HEDLEY_STATIC_ASSERT(expr, message)
687#endif
688
689#if defined(HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
690# undef HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
691#endif
692#if HEDLEY_CLANG_HAS_WARNING("-Wdeprecated")
693# define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated\"")
694#elif HEDLEY_INTEL_VERSION_CHECK(16,0,0)
695# define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478)")
696#elif HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(4,3,0)
697# define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated\"")
698#elif HEDLEY_MSVC_VERSION_CHECK(15,0,0)
699# define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
700#else
701# define HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
702#endif
703
704#endif /* !defined(HEDLEY_VERSION) || (HEDLEY_VERSION < X) */
705