Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Post History
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 ==, o...
#2: Post edited
by
Alexei
·
2021-01-22T07:33:22Z (almost 4 years ago)
added relevant tags
**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:
- ```c++
- #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?
- []()**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:
- ```c++
- #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?
#1: Initial revision
by
dmckee
·
2021-01-20T20:19:44Z (almost 4 years ago)
Scheme for cross-platform warning control?
**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:
```c++
#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?