It appears this can be done. I'm unable to determine the version of GCC that it was added, but it was sometime before June 2010.

Here's an example:

#pragma GCC diagnostic error "-Wuninitialized"    foo(a);         /* error is given for this one */#pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wuninitialized"    foo(b);         /* no diagnostic for this one */#pragma GCC diagnostic pop    foo(c);         /* error is given for this one */#pragma GCC diagnostic pop    foo(d);         /* depends on command line options */

To net everything out, this is an example of temporarily disabling a warning:

#pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wunused-result"    write(foo, bar, baz);#pragma GCC diagnostic pop

You can check the GCC documentation on diagnostic pragmas for more details.

TL;DR: If it works, avoid, or use specifiers like __attribute__, otherwise _Pragma.

This is a short version of my blog article Suppressing Warnings in GCC and Clang.

Consider the following Makefile

CPPFLAGS:=-std=c11 -W -Wall -pedantic -Werror.PHONY: allall: puts

for building the following puts.c source code

#include <stdio.h>int main(int argc, const char *argv[]){    while (*++argv) puts(*argv);    return 0;}

It will not compile because argc is unused, and the settings are hardcore (-W -Wall -pedantic -Werror).

There are 5 things you could do:

• Improve the source code, if possible
• Use a declaration specifier, like __attribute__
• Use _Pragma
• Use #pragma
• Use a command line option.

Improving the source

The first attempt should be checking if the source code can be improved to get rid of the warning. In this case we don't want to change the algorithm just because of that, as argc is redundant with !*argv (NULL after last element).

Using a declaration specifier, like __attribute__

#include <stdio.h>int main(__attribute__((unused)) int argc, const char *argv[]){    while (*++argv) puts(*argv);    return 0;}

If you're lucky, the standard provides a specifier for your situation, like _Noreturn.

__attribute__ is proprietary GCC extension (supported by Clang and some other compilers like armcc as well) and will not be understood by many other compilers. Put __attribute__((unused)) inside a macro if you want portable code.

_Pragma operator

_Pragma can be used as an alternative to #pragma.

#include <stdio.h>_Pragma("GCC diagnostic push")_Pragma("GCC diagnostic ignored \"-Wunused-parameter\"")int main(int argc, const char *argv[]){    while (*++argv) puts(*argv);    return 0;}_Pragma("GCC diagnostic pop")

The main advantage of the _Pragma operator is that you could put it inside macros, which is not possible with the #pragma directive.

Downside: It's almost a tactical nuke, as it works line-based instead of declaration-based.

The _Pragma operator was introduced in C99.

#pragma directive.

We could change the source code to suppress the warning for a region of code, typically an entire function:

#include <stdio.h>#pragma GCC diagnostic push#pragma GCC diagnostic ignored "-Wunused-parameter"int main(int argc, const char *argv[]){    while (*++argc) puts(*argv);    return 0;}#pragma GCC diagnostic pop

Downside: It's almost a tactical nuke, as it works line-based instead of declaration-based.

Note that a similar syntax exists in clang.

Suppressing the warning on the command line for a single file

We could add the following line to the Makefile to suppress the warning specifically for puts:

CPPFLAGS:=-std=c11 -W -Wall -pedantic -Werror.PHONY: allall: putsputs.o: CPPFLAGS+=-Wno-unused-parameter

This is probably not want you want in your particular case, but it may help other reads who are in similar situations.