tl;dr I'd like to learn a compact, cross-compiler way of selectively suppressing compiler warnings.

Consider the case where you really mean to make an exact floating-point comparison using ==, or the case where you capture a return value that you don't use in production but want to assert on in debug.

If you are running your compiler with a highly level of feedback you're going to get a warnings from the first all the time and from the second when performing a release build.

Now, most compilers have a way to annotate a symbol to let the compiler know you're aware of the situation (for instance __attribute__((unused)) in gcc), and various pre-processor pragmas to adjust the compilation envrionment. But we have three compilers to worry about (gcc and msvc for actually building the code on different target platforms and clang as a linter on both).

In some places we actually have painfully heavy and intrusive pre-processor constructs like:

#if defined(_MSC_VER)
#pragma warnings(push)
#pramga warnings(disable : 123456)
#elif defined(__clang__)
#pragma clang diagnostic push
#pramga clang diagnostic ignored "-Wluggage-combination"
#elif defined(__GNUC__)
#pragma GCC diagnostic push
#pramga GCC diagnostic ignored "-Wcode-for-my-luggage"
#endif

    // Offending line(s) of code

#if defined(_MSC_VER)
#pragma warnings(pop)
#elif defined(__clang__)
#pragma clang diagnostic pop
#elif defined(__GNUC__)
#pragma GCC diagnostic pop
#endif

Which, though ugly as sin, works and doesn't cause too much nausea if it occurs once in a low-level module that you don't touch often.

But I feel that it should be easier and neater.

Anyone have a working solution?

posted almost 4 years ago

CC BY-SA 4.0

4y ago by Alexei‭

dmckee‭

673 reputation 5 9 80 17