Question

I know how to disable all unknown #pragma warnings. The answer was given, for example, in How can I disable #pragma warnings?.

Is there a way to disable an ‘unknown pragma’ warning for one particular pragma? For example, if I disable warning for #pragma ugubugu the following code:

#pragma ugubugu
#pragma untiunti

int main() {return 0;}

when compiled with either:

g++ pragma.cpp -Wall
clang++ pragma.cpp -Wall

should produce a single warning:

warning: ignoring #pragma untiunti

Maybe, for example, is there a simple way to register a custom pragma which would do nothing?

It would be great to know if there is such an option is Visual Studio too, but that is less important.

---

"But why ultimately is he playing with custom pragmas?"

My source code is parsed by two compilers. In one of those, there is a special #pragma that is unknown to the other. Of course, I could probably put #ifdef COMPILER_IDENTIFICATION_MACRO ... #endif around every instance of the #pragma, but that would be cumbersome.

Answer 1

I’m reasonably sure that there isn’t any way to do this.

Both GCC and Clang do have internal interfaces which allow the language frontend to register #pragma handlers with the preprocessor – see GCC’s libcpp/directives.c and Clang’s lib/Lex/Pragma.cpp – but, as far as I can see, there is nothing which lets you modify which handlers are registered (beyond what is implied by the language variant you’re compiling for) based on command line options.

I know how to disable all unknown #pragma warnings. The answer was given, for example, here: SO: How to disable #pragma warnings?

Note that the highest voted answer is better than the accepted one there. -Wno-unknown-pragmas can simply be added on the command line after anything (like -Wall) which turns the warning on.

My source is parsed by two compilers. In one of those, there is a special #pragma, that is unknown to the other. Of course, I could probably put #ifdef COMPILER_IDENTIFICATION_MACRO ... #endif around every instance of the #pragma but that would be cumbersome.

From a more philisophical viewpoint, I think this is really the right solution, cumbersome though it may be!

It seems correct to me to hide any #pragma from a compiler which is not expected to understand it in the way that you intend, given that the whole point of #pragma is to provide a mechanism for invoking implementation-defined behaviour in the compiler.

(If you do end up doing this, note that Clang defines __clang__, but both GCC and Clang define __GNUC__.)