How can I keep doxygen from documenting #defines in a C file?

There is no need to use the \cond and \endcond commands. You can hide the initializer by simply using the \hideinitializer command:

#define SOME_CONSTANT 1234 /**< An explanation @hideinitializer */

Regarding the first question, you may set HIDE_UNDOC_MEMBERS = YES and only the macros having a Doxygen documentation block will be shown in the output.

You can set MAX_INITIALIZER_LINES = 0 in your doxyfile to hide the values of your defines.

You only want to document what is declared in the .h files. I'm assuming you declare all static functions and variables as static in your .c files. All the remaining are declared in .h corresponding files also. These are your "public" members.

What I like to do in this case, and I believe doxygen was more designed to be used this way is:

• in your Doxyfile, set EXTRACT_ALL = NO and add the directory where your .h files are to INPUT
• add /** \file */ to all your .h files (but not your .c files).

This will index only what is contained in your .h files. You can still add the directory containing your .c files to INPUT at your Doxyfile, and they will be scanned for additional documentation for your "public" members...

It will no doubt still seem noisy and unnatural, but to address your other question, try:

/** An explanation */
#define SOME_CONSTANT /** @cond */ 1234 /** @endcond */

I solved this problem by moving my documentation from the .c file to the .h file. Then run doxygen only on the .h file.

Then the items that I want to document (the 'public' items) are intrinsically what doxygen picks up.

Because I have been previously careful to put 'public' items in the .h file and 'private' items in the .c file this works very well.

This technique came to mind when I noticed that doxygen was pulling in the includes. It struck me that if I were to also move the subset of includes that the calling module would need to use my module, then that list would be documented as well.

This technique has an additional benefit: I can put the documentation in one terminal window and the source in a different terminal window while updating the documentation.

Sometimes you may have a define which you want to document, but want doxygen to treat it differently (or even ignore it completely to avoid parsing errors). For this you can define the #define in doxygen differently than in your sourcecode.

Example: Some compilers allow variable linkage to specific segments, i.e.:

const int myvar @ "segment_of_myvar_in_memory"=123;

=> doxygen would parse the "segment_of_myvar_in_memory" part as variable name which is not desired. We could use a define for it:

#define __link_to_segment(name) @ name
const int myvar __link_to_segment("segment_of_myvar_in_memory")=123;

If Preprocessing is active, Doxygen interprets our variable now as a function because of the function-like define using brackets.. But if we redefine our define within the Doxyfile, behaviour changes:

PREDEFINED = __link_to_segment(a)=

now the variable is parsed correctly as variable - also all types or keywords in front are correctly shown as keywords.

A nice side effekt: In case you use 2 different IDEs with your code (one IDE for compiling&debugging, one for editing), you will also discover that some IDEs (i.e. Eclipse) have problems parsing variables with @"segment name". Using the approach above, you can redefine the __link_to_segment(name) there too:

#define __link_to_segment(name)

i.e. Eclipse will then show and parse the variable correctly, whereas the "compiling&debugging" IDE can still link the variable to its segment name.