Displace function header with preprocessor directive - c

Question

For debugging reasons i created the following code example: There is a function a() which is called by the function b(). I want to know the name of the function which calls a(). So i created the code below which is working fine:
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
uint8_t a(uint8_t k)
{
printf("function: a\n");
return k;
}
uint8_t a_debug( uint8_t j, char const *caller_name)
{
uint8_t rtv;
printf("a was called by %s\n", caller_name);
rtv = a(j);
return rtv;
}
#define a(x) a_debug(x,__func__)
void b()
{
uint8_t asdf;
asdf = a(5);
printf("asdf = %u", asdf);
}
int main(int argc, char **argv)
{
b();
return 0;
}
In a bigger software project with several c- and h-files I pasted the code
uint8_t a_debug( uint8_t j, char const *caller_name)
{
uint8_t rtv;
printf("a was called by %s\n", caller_name);
rtv = a(j);
return rtv;
}
#define a(x) a_debug(x,__func__)
right below the function a() to debug the function a(). I can build and execute the software-project but the function a_debug() is never entered. Instead of the function a() is directly executed. In which file or exactly where do I have to define the preprocessor directive #define a(x) a_debug(x,__func__) so that the compiler will displace a() with a_debug() function?

Answer 1

Preprocessor directives operate only in the translation unit where they appear.
A translation unit is the source file being compiled, including all the files it includes. To use a preprocessor macro, it must be defined in the translation unit. The way this is usually done is that a source file containing some functions named foo or related to some category or idea foo are defined in a file named foo.c, and declarations for those functions are put in a file named foo.h. The header file foo.h should provide whatever preprocessor macros, declarations, and other things are needed to use the facilities provided by foo.c.
To start, you can put your new function a_debug in the source file that contains a. Also, you can simplify it; there is no need for the variable rtv:
uint8_t a_debug(uint8_t j, char const *caller_name)
{
printf("a was called by %s.\n", caller_name);
return a(j);
}
Then, in the header file that declares a, you need to add two things. First, a declaration for a_debug:
uint8_t a_debug(uint8_t, char const *);
Second, a definition for the macro a:
#define a(x) (a_debug((x), __func__))
However, this is going to cause a problem. The source file defining a should include its own header file. (One reason for this is to allow the compiler to check for errors such as function declarations not matching function definitions.) But when it includes the header file, that will define the a macro, and then, when the function a is defined, the definition will be altered by the macro replacement, and the compiler will complain. One way around this is to put #undef a in the source file that defines a, after it includes its header file.
Also, since a_debug is so simple, you can define it as a static inline function in the header. Instead of putting the definition shown above in the source file and its declaration in the header file, put this in the header file:
static inline uint8_t a_debug(uint8_t j, char const *caller_name)
{
printf("a was called by %s.\n", caller_name);
return a(j);
}