C: how can I fail to compile when -Wswitch is off?

Question

If I want my switch(an_enum) statement to be reported when it misses an enum case, I can turn on the -Wswitch compiler flag (on gcc).

enum E { e1, e2, e3 };

...
switch(e) {
  case e1: ...
  case e2: ...
  // NO default: checked by -Wswitch and -Werror
}

It works nicely: "error: enumeration value ‘e3’ not handled in switch [-Werror=switch]"

But now the correctness of my code depends on the compiler flags in use, which is kind of brittle.

Something like this:

switch(e) __attribute__((exhaustive))
{
  ...
}

Is there a way I can have that piece of code fail if the -Wswitch flag is off? Or temporarily switch it on within the code?

The reliable and portable solution is to add a default. It can do `assert(0); abort();` so that it fails even if assertions are inhibited — or you can do something more sensible if you prefer. — Jonathan Leffler, Aug 21 '19 at 06:57
There are pragmas you can use to enable or disable warnings from within source files. As the flags it should be noted that these pragmas are compiler-dependent and non-portable. See [the diagnostic pragmas section](https://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Pragmas.html) of the documentation for details. — Some programmer dude, Aug 21 '19 at 06:57
Are the enums always adjacent values like in your example? If so, there's much better solutions to the problem than gcc extensions. — Lundin, Aug 21 '19 at 07:40

Jonathan Leffler · Accepted Answer · 2019-08-21T07:15:23.217

The reliable and portable solution is to add a default label to your switch statement. It can do:

default:
    assert(0);
    abort();

so that it fails even if assertions are inhibited — or you can do something more sensible if you prefer.

If you're using GCC, you can use diagnostic pragmas to get the required result of turning on -Wswitch for a short scope.

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic error "-Wswitch"
#endif /* __GNUC__ */

switch (e)
{
…
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif /* __GNUC__ */

This pushes the diagnostic state, changes it to add errors as if -Wswitch is specified on the command line, compiles the switch statement, and then pops (restores) the saved diagnostic state.

If you never use a compiler other than GCC (or perhaps Clang), you can omit the __GNUC__ tests. However, compilers on other platforms (e.g. IBM XLC 13.1.3 on AIX 7.2) complain about the GCC-specific pragmas, even though the C standard says it shouldn't. You pays your money and takes your pick.

You can use ignore or warning instead of error to achieve other effects if you prefer.

You might also note that the -Wswitch option is one of the warnings enabled by -Wall — and if you're compiling with GCC, you should always be using -Wall (and -Wextra and -Werror), so you should never run into problems.

Also, the correctness of your program depends on how you wrote it (or modified it), not on the compiler options. What does depend on the compiler options is whether or not the mitsakes you've made are spotted by the compiler.

score 0 · Answer 2 · answered Aug 21 '19 at 07:54

Assuming that the enum only contains adjacent numbers like in your example, then you can "unroll" the switch statement by replacing it with a table of function pointers, which is fairly common practice. A function pointer table would be pure standard C. Example:

typedef enum 
{ 
  e1, 
  e2, 
  e3,
  eN  // enum counter
} e_t;

typedef void e_func_t (void);

e_func_t* const do_stuff [] =   // array of functions of type void f(void);
{
  e1_stuff, 
  e2_stuff,
  e3_stuff,
};

// force compilation error if missing a "case statement":
_Static_assert(sizeof(do_stuff)/sizeof(*do_stuff) == eN, 
               "Function pointer table incomplete.");

Then you can replace the whole switch with this:

if(e < e1 || e >= eN)
{  
  /* handle errors or "default" here */ 
}
else
{
  do_stuff[e]();
}

C: how can I fail to compile when -Wswitch is off?

2 Answers2