How to disable a particular unknown #pragma warning (GCC and/or Clang)

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.

score 23 · Accepted Answer · edited May 23 '17 at 11:46

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__.)

Given that no one comes with a better solution, I have to accept the one saying "there is now way to do it" - that is - yours. Also, the pointers to the compiler internals may be helpful if I decide to jump deeper into it. Thank you! — CygnusX1, Jul 11 '11 at 14:24
And nobody knows of a way to supress warnings in code? When I submit it goes up to an automated project generation that I have no control over. It gets built with full warnings. — Dan, Mar 20 '14 at 16:24
#pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunknown-pragmas" ... Code using Unknown pragmas ... #pragma GCC diagnostic push — Dan, Mar 20 '14 at 16:31
The note above from @Dan about using `#pragma GCC diagnostic push` `#pragma GCC diagnostic ignored "-Wunknown-pragmas"` is a workable solution if you are willing to surround your unknown `#pragmas` this way; just a note to close it out with a `#pragma GCC diagnostic pop` rather than a `#pragma GCC diagnostic push`. I am using `#pragma mark` statements in my code for the benefit of my IDE and GCC was emitting warnings due to this that I wanted to prevent. — bluebinary, Jun 04 '16 at 19:43

score 8 · Answer 2 · answered Sep 29 '17 at 03:19

I assume you want to disable the pragma warnings because it's something that is valid on one platform but not another. If that's the case, you can use macros to selectively enable the pragma, eliminating the need to suppress the warning.

For example, if you want the pragma on Visual C++ only, you can do:

#if defined(_MSC_VER)
#    define SAFE_PRAGMA_UGUBUGU __pragma(ugubugu)
#else
#    define SAFE_PRAGMA_UGUBUGU 
#endif

And then, you can write

SAFE_PRAGMA_UGUBUGU
#pragma untiunti   
int main() {return 0;}

score -6 · Answer 3 · edited Nov 14 '21 at 04:32

Compilers do not allow custom pragmas because pragmas are (mostly) compiler and/or linker controlling directives. Since this is very close to a particular compiler implementation and features, what would be the application of "defining new pragmas" for the user? In fact, what available pragma directives are implemented on a particular compiler is totally vendor independent (there is no C++ standardization rule).
May be you want to use pragmas for marking up special sections of your code (e.g., to feed your own preprocessor) since you are asking for no-op directives. This can be done using the preprocessor (#defines).
Another possibility for custom "markup" in C/C++ code, e.g., #MY_PRAGMA, is to use your own preprocessor before the C/C++ one.

An example of this type of processing is used for the Qt library, non-standard metaobject system which interacts with the Qt MOC compiler. This is used to expand some non-C++ constructs (for example, Q_OBJECT, Q_PROPERTY, etc.) that is later fed with a valid syntax to the C++ compiler.

I don't think he is looking to make a pragma that does nothing, but rather he thought that was a possible way quash the warning. `ugubugu` is an unknown pragma, so register it, but make it do nothing, so now it is a known pragma that won't generate a warning. — Dennis Zickefoose, Jul 03 '11 at 04:58
@Dennis Zickefoose, but why ultimately he's playing with custom pragmas? I suspect he's trying to use them as 'markup' in the code or something like that, which is perfectly valid but there are alternatives instead of using your own pragmas (which can collide with compiler vendor ones since there is no standarization for them) — Hernán, Jul 03 '11 at 05:09

How to disable a particular unknown #pragma warning (GCC and/or Clang)

3 Answers3