Quick way to determine the C preprocessor branches

Question

When the code is burden with a lot of #if, #ifdef. Like the case below

#ifdef CASE1                       
#ifdef CASE1_1
#define VALUE X
#else
#define VALUE Y
#endif
#else
#define VALUE Z
#endif

Is there a way to quickly determine which branch the code will get compiled. Any suggestions are appreciated. Thanks and Best Regards

I never understood why nobody indents #ifdef and stuff like they would normal ifs in code. This is made worse by the fact that IDEs like to automatically totally unindent lines that begin with #. — Seth Carnegie
– Seth Carnegie, Commented Mar 1, 2012 at 3:30
@SethCarnegie I've read that older pre-processors didn't allow whitespace before the #, so that's why the old habit of not indenting it comes from. — Some programmer dude
– Some programmer dude, Commented Mar 1, 2012 at 3:38
Some people do ident #ifdef and I find it the best way to keep them readable. — Correa
– Correa, Commented Mar 1, 2012 at 3:43
agree with you @SethCarnegie, it is hard to read codes which are not indented. — Dien Nguyen
– Dien Nguyen, Commented Mar 1, 2012 at 4:19

Andrew Edgecombe · Accepted Answer · 2012-03-01 04:27:54Z

2

Reading nested preprocessor macros can be made easier by indenting. Most preprocessors allow:


#ifdef foo
    #define bar (1)
#endif

But the following form should be universally allowed:


#ifdef foo
#    define bar (1)
#endif

While that helps follow the nest, it doesn't guarantee that you'll be able to spot which path is active, particularly if you are doing definitions by passing options to your compiler via -D

One solution is to run the preprocessor over your source files and inspect the output. You can either do that by running the preprocessor executable manually (eg. cpp), or by telling your compiler to stop after running the preprocessor (eg. gcc -E)

That is guaranteed to show you what values have been substituted for your preprocessor macros. But the output from the preprocessor can be hard to follow.

If you're just trying to trace a small section of code (as in your example) you can do it manually by liberally inserting #error (or #warning if your preprocessor supports it), and looking at the errors dumped from your compiler. This is typically the simplest option as you don't have to make changes to your build system to get the visibility that you're after.

Another option, depending on the complexity of your preprocessor macros, is to run another preprocessor tool over your source files that will generate friendlier output than the preprocessor. I've had success with filepp in the past.

edited Mar 1, 2012 at 4:27

answered Mar 1, 2012 at 4:21

Andrew Edgecombe

40.5k3 gold badges39 silver badges63 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Dien Nguyen Over a year ago

Thank everyone for your suggestions! I found that "#error" is the easiest way, just put it in each code branch and the compiler will report an error

Correa · Accepted Answer · 2012-03-01 03:48:09Z

1

You could ident it as

#ifdef CASE1                       
#  ifdef CASE1_1
#    define VALUE X
#  else
#    define VALUE Y
#  endif
#else
#  define VALUE Z
#endif

The compiler won't complain and the same identation style is currently used in qglobal.h from Qt which has to support a quite a number of compilers on many platforms.

answered Mar 1, 2012 at 3:48

Correa

4232 silver badges11 bronze badges

Comments

Ernest Friedman-Hill · Accepted Answer · 2012-03-01 03:30:42Z

0

Some IDEs will highlight the "good parts" or grey out the "bad parts"; Visual Studio does this (only if it understands the #defines, though!)

And of course, you can run the preprocessor over your source and look at the output -- for example, with the -E switch to g++.

answered Mar 1, 2012 at 3:30

Ernest Friedman-Hill

81.9k11 gold badges158 silver badges192 bronze badges

Comments

Carl · Accepted Answer · 2012-03-01 03:38:01Z

0

Don't trust Visual Studio. It grays out code that executes. Lots of times, especially when you mix preprocessor macros in the project settings with those defined in your header files.

Simple approach?

#ifdef CASE1                       
#ifdef CASE1_1
#define VALUE X
const int branch = 1;
#else
#define VALUE Y
const int branch = 2;
#endif
#else
#define VALUE Z
const int branch = 3;
#endif

At the end, you have a variable whose value will tell you which branch got compiled in. Not very elegant, but it does do what you asked and I'm guessing you need this for debugging purposes anyway :)

answered Mar 1, 2012 at 3:38

Carl

44.8k10 gold badges84 silver badges110 bronze badges

Collectives™ on Stack Overflow

Quick way to determine the C preprocessor branches

4 Answers 4

1 Comment

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related