Is it possible to tell when a C++ file is a primary source file?

Question

Is it possible to determine whether a source file is being preprocessed due to an #include statement vs. being preprocessed due to it being a primary source file passed to the compiler?

Basically, I want to be able to write something like the following:

// foo.x:
#if COMPILING_FOO_MODULE
/* FOO code that's only visible when compiling foo.x module */
#endif
/* FOO code that's visible when compiling foo.x module or included in other modules */

// bar.cpp:
#include "foo.x"
...

When preprocessing foo.x, I want both sections of code to be passed on to the compiler, but when preprocessing bar.cpp, I only want the second section to be used:

// foo.x.preprocessed:
/* FOO code that's only visible when compiling foo.x module */
/* FOO code that's visible when compiling foo.x module or included in other modules */

// bar.cpp.preprocessed:
/* FOO code that's visible when compiling foo.x module or included in other modules */
...

I realize I could easily accomplish this by adding #define COMPILING_FOO_MODULE 0 just before the #include, but my goal is to avoid requiring any other code besides the #include to be added to the bar.cpp file.

Including both c and c++ since I assume the answer is the same for both.

EDIT:

To be clear, I understand that having a separate .h and .cpp file exactly solves this problem, and in almost all cases that's the right thing to do. But for various reasons I only want one source file that can be used as both the main module source file and the header file for other modules.

Answer 1

The way this is traditionally done is to split foo.x into two files: foo.h and foo.c (or foo.cpp).

foo.h contains "FOO code that's visible when compiling foo.x module or included in other modules" and foo.c / foo.cpp contains "FOO code that's only visible when compiling foo.x module".

Inside foo.c / foo.cpp you #include "foo.h" so that it has both sets of code, and bar.cpp also has #include "foo.h".

Answer 2

Instead of

#define COMPILING_FOO_MODULE 0

in the files which aren't foo.cpp, use

#define COMPILING_FOO_MODULE 1

in foo.cpp and nothing in other compilation units.

#if works fine with undefined macros, and treats them as zero.

Answer 3

There is a way to do exactly what you want. Try this out:

foo.c

#if __INCLUDE_LEVEL__ == 0
/* FOO code that's only visible when compiling foo.x module */
#endif
/* FOO code that's visible when compiling foo.x module or included in other modules */

bar.c

#include <foo.c>
//other lines of code

Note that the macro __INCLUDE_LEVEL__ is predefined. It represents the depth of nesting in the include files.

I hope this helps.

Source: https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html