X-Git-Url: https://git.distorted.org.uk/~mdw/mLib/blobdiff_plain/3832000d8a0d417dbfda0ca2d26bc7d66f7f4741..b64eb60f6c1fdb12f3922e04913e137199838807:/utils/macros.h diff --git a/utils/macros.h b/utils/macros.h index b960475..954ed0c 100644 --- a/utils/macros.h +++ b/utils/macros.h @@ -32,9 +32,17 @@ extern "C" { #endif +/*----- Header files ------------------------------------------------------*/ + +#include + +#ifndef MLIB_COMPILER_H +# include "compiler.h" +#endif + /*----- Miscellaneous utility macros --------------------------------------*/ -#define N(v) (sizeof(v)/sizeof(*v)) +#define N(v) (sizeof(v)/sizeof(*(v))) #define MLIB__STR(x) #x #define STR(x) MLIB__STR(x) @@ -42,96 +50,147 @@ #define MLIB__GLUE(x, y) x##y #define GLUE(x, y) MLIB__GLUE(x, y) +#ifdef static_assert +# define STATIC_ASSERT(cond, msg) static_assert(!!(cond), msg) +#else +# define STATIC_ASSERT(cond, msg) \ + IGNORABLE extern char static_assert_failed[2*!!(cond) - 1] +#endif + +#define COMMA , + +/*----- String and character hacks ----------------------------------------*/ + +#define CTYPE_HACK(func, ch) (func((unsigned char)(ch))) + +#define ISALNUM(ch) CTYPE_HACK(isalnum, ch) +#define ISALPHA(ch) CTYPE_HACK(isalpha, ch) +#define ISASCII(ch) CTYPE_HACK(isascii, ch) +#define ISBLANK(ch) CTYPE_HACK(isblank, ch) +#define ISCNTRL(ch) CTYPE_HACK(iscntrl, ch) +#define ISDIGIT(ch) CTYPE_HACK(isdigit, ch) +#define ISGRAPH(ch) CTYPE_HACK(isgraph, ch) +#define ISLOWER(ch) CTYPE_HACK(islower, ch) +#define ISPRINT(ch) CTYPE_HACK(isprint, ch) +#define ISPUNCT(ch) CTYPE_HACK(ispunct, ch) +#define ISSPACE(ch) CTYPE_HACK(isspace, ch) +#define ISUPPER(ch) CTYPE_HACK(isupper, ch) +#define ISXDIGIT(ch) CTYPE_HACK(isxdigit, ch) + +#define TOASCII(ch) CTYPE_HACK(toascii, ch) +#define TOLOWER(ch) CTYPE_HACK(tolower, ch) +#define TOUPPER(ch) CTYPE_HACK(toupper, ch) + +#define MEMCMP(x, op, y, n) (memcmp((x), (y), (n)) op 0) +#define STRCMP(x, op, y) (strcmp((x), (y)) op 0) +#define STRNCMP(x, op, y, n) (strncmp((x), (y), (n)) op 0) + /*----- Compiler diagnostics ----------------------------------------------*/ /* --- Compiler-specific definitions --- */ -#if defined(__GNUC__) - -# define GCC_VERSION_P(maj, min) \ - (__GNUC__ > (maj) || (__GNUC__ == (maj) && __GNUC_MINOR__ >= (min))) - -# if GCC_VERSION_P(2, 5) -# define NORETURN __attribute__((noreturn)) -# define PRINTF_LIKE(fix, aix) __attribute__((format(printf, fix, aix))) -# define SCANF_LIKE(fix, aix) __attribute__((format(scanf, fix, aix))) -# define IGNORABLE __attribute__((unused)) -# endif - -# if GCC_VERSION_P(4, 5) -# define DEPRECATED(msg) __attribute__((deprecated(msg))) -# elif GCC_VERSION_P(3, 1) -# define DEPRECATED(msg) __attribute__((deprecated)) -# endif - -# if GCC_VERSION_P(4, 0) -# define EXECL_LIKE(ntrail) __attribute__((sentinel(ntrail))) -# endif - -# if GCC_VERSION_P(4, 6) - - /* --- Diagnostic suppression in GCC: a tale of woe --- * - * - * This is extremely unpleasant, largely as a result of bugs in the GCC - * preprocessor's handling of @_Pragma@. The fundamental problem is - * that it's the preprocessor, and not the compiler proper, which - * detects @_Pragma@, emitting @#pragma@ lines into its output; and it - * does it during macro expansion, even if the macro is being expanded - * during argument collection. Since arguments are expanded before - * replacing the macro's invocation with its body, a pragma in an - * argument will be emitted %%\emph{before}%% any pragmata in the body, - * even if they appear before the argument in the body -- and even if - * the argument doesn't actually appear anywhere at all in the body. - * - * Another, rather less significant, problem is that @_Pragma@'s - * argument is a single string literal, recognized in translation phase - * 4, before string-literal concatenation in phase 6, so we must build - * pragma bodies as token lists and then stringify them. - * - * As a result, we need some subterfuge here. The @MLIB__PRAGMA_HACK@ - * macro issues a @_Pragma@ on its argument token list, which it - * stringifies; this deals with the second problem. The first is - * trickier: we must delay expansion of @MLIB__PRAGMA_HACK@ from the - * argument collection phase to the body rescanning phase, and we do - * this by splitting the invocations between @GCC_WARNING@ macro calls: - * the name is left hanging from the previous call (or from - * @MLIB__MUFFLE_WARNINGS@, in the first case) and the body is supplied - * by @GCC_WARNING@, which also supplies the next @MLIB__PRAGMA_HACK@. - * The remaining problem is to make sure we can dispose of the final - * trailing @MLIB__PRAGMA_HACK@ harmlessly, which we do by introducing - * an extra argument @emitp@, which may be either @t@ or @nil@; this - * dispatches to an appropriate helper macro by means of token-pasting. - * - * I'm so sorry. - */ - -# define MLIB__PRAGMA_HACK_t(x) _Pragma(#x) -# define MLIB__PRAGMA_HACK_nil(x) -# define MLIB__PRAGMA_HACK(emitp, x) MLIB__PRAGMA_HACK_##emitp(x) -# define MLIB__MUFFLE_WARNINGS(warns, body) \ +#if GCC_VERSION_P(2, 5) || CLANG_VERSION_P(3, 3) +# define NORETURN __attribute__((__noreturn__)) +# define PRINTF_LIKE(fix, aix) __attribute__((__format__(printf, fix, aix))) +# define SCANF_LIKE(fix, aix) __attribute__((__format__(scanf, fix, aix))) +# define IGNORABLE __attribute__((__unused__)) +#endif + +#if GCC_VERSION_P(3, 4) || CLANG_VERSION_P(3, 3) +# define MUST_CHECK __attribute__((__warn_unused_result__)) +#endif + +#if GCC_VERSION_P(4, 5) || CLANG_VERSION_P(3, 3) +# define DEPRECATED(msg) __attribute__((__deprecated__(msg))) +#elif GCC_VERSION_P(3, 1) +# define DEPRECATED(msg) __attribute__((__deprecated__)) +#endif + +#if GCC_VERSION_P(4, 0) || CLANG_VERSION_P(3, 3) +# define EXECL_LIKE(ntrail) __attribute__((__sentinel__(ntrail))) +#endif + +#if GCC_VERSION_P(2, 7) +# define LAUNDER(x) \ + ({ __typeof__(x) _y; __asm__("" : "=g"(_y) : "0"(x)); _y; }) +# define RELAX do __asm__ __volatile__("" ::: "memory"); while (0) +#endif + +#if CLANG_VERSION_P(3, 3) + +# define MLIB__PRAGMA_HACK(x) _Pragma(#x) +# define MLIB__MUFFLE_WARNINGS(warns, body) \ + _Pragma("clang diagnostic push") \ + warns \ + body \ + _Pragma("clang diagnostic pop") +# define CLANG_WARNING(warn) \ + MLIB__PRAGMA_HACK(clang diagnostic ignored warn) +# define MUFFLE_WARNINGS_DECL(warns, body) \ + MLIB__MUFFLE_WARNINGS(warns, body) +# define MUFFLE_WARNINGS_EXPR(warns, body) \ + __extension__ ({ MLIB__MUFFLE_WARNINGS(warns, (body);) }) +# define MUFFLE_WARNINGS_STMT(warns, body) \ + do { MLIB__MUFFLE_WARNINGS(warns, body) } while (0) + +#elif GCC_VERSION_P(4, 6) + + /* --- Diagnostic suppression in GCC: a tale of woe --- * + * + * This is extremely unpleasant, largely as a result of bugs in the GCC + * preprocessor's handling of @_Pragma@. The fundamental problem is + * that it's the preprocessor, and not the compiler proper, which + * detects @_Pragma@, emitting @#pragma@ lines into its output; and it + * does it during macro expansion, even if the macro is being expanded + * during argument collection. Since arguments are expanded before + * replacing the macro's invocation with its body, a pragma in an + * argument will be emitted %%\emph{before}%% any pragmata in the body, + * even if they appear before the argument in the body -- and even if + * the argument doesn't actually appear anywhere at all in the body. + * + * Another, rather less significant, problem is that @_Pragma@'s + * argument is a single string literal, recognized in translation phase + * 4, before string-literal concatenation in phase 6, so we must build + * pragma bodies as token lists and then stringify them. + * + * As a result, we need some subterfuge here. The @MLIB__PRAGMA_HACK@ + * macro issues a @_Pragma@ on its argument token list, which it + * stringifies; this deals with the second problem. The first is + * trickier: we must delay expansion of @MLIB__PRAGMA_HACK@ from the + * argument collection phase to the body rescanning phase, and we do + * this by splitting the invocations between @GCC_WARNING@ macro calls: + * the name is left hanging from the previous call (or from + * @MLIB__MUFFLE_WARNINGS@, in the first case) and the body is supplied + * by @GCC_WARNING@, which also supplies the next @MLIB__PRAGMA_HACK@. + * The remaining problem is to make sure we can dispose of the final + * trailing @MLIB__PRAGMA_HACK@ harmlessly, which we do by introducing + * an extra argument @emitp@, which may be either @t@ or @nil@; this + * dispatches to an appropriate helper macro by means of token-pasting. + * + * I'm so sorry. + */ + +# define MLIB__PRAGMA_HACK_t(x) _Pragma(#x) +# define MLIB__PRAGMA_HACK_nil(x) +# define MLIB__PRAGMA_HACK(emitp, x) MLIB__PRAGMA_HACK_##emitp(x) +# define MLIB__MUFFLE_WARNINGS(warns, body) \ _Pragma("GCC diagnostic push") MLIB__PRAGMA_HACK \ warns \ (nil, nil) \ body \ _Pragma("GCC diagnostic pop") -# define GCC_WARNING(warn) \ +# define GCC_WARNING(warn) \ (t, GCC diagnostic ignored warn) MLIB__PRAGMA_HACK -# define MUFFLE_WARNINGS_DECL(warns, body) \ +# define MUFFLE_WARNINGS_DECL(warns, body) \ MLIB__MUFFLE_WARNINGS(warns, body) -# define MUFFLE_WARNINGS_EXPR(warns, body) \ +# define MUFFLE_WARNINGS_EXPR(warns, body) \ __extension__ ({ MLIB__MUFFLE_WARNINGS(warns, (body);) }) -# define MUFFLE_WARNINGS_STMT(warns, body) \ +# define MUFFLE_WARNINGS_STMT(warns, body) \ do { MLIB__MUFFLE_WARNINGS(warns, body) } while (0) -# endif - #endif /* --- Fallback definitions, mostly trivial --- */ -#ifndef GCC_VERSION_P -# define GCC_VERSION_P(maj, min) 0 -#endif - #ifndef DEPRECATED # define DEPRECATED(msg) #endif @@ -168,14 +227,34 @@ # define SCANF_LIKE(fmtix, argix) #endif +#ifndef NORETURN +# define NORETURN +#endif + #ifndef IGNORABLE # define IGNORABLE #endif +#ifndef MUST_CHECK +# define MUST_CHECK +#endif + +#ifndef LAUNDER +# define LAUNDER +#endif + +#ifndef RELAX +# define RELAX +#endif + #ifndef GCC_WARNING # define GCC_WARNING(warn) #endif +#ifndef CLANG_WARNING +# define CLANG_WARNING(warn) +#endif + /*----- That's all, folks -------------------------------------------------*/ #ifdef __cplusplus