How to write a logging function or macro that can append caller's name to the logging output in C

Question

I need a logging function or macro in C language, which should works in Linux, that can accept a format string and a list of arguments, and can append the caller's function name to the output string.

Here is an example. Suppose the logging function (macro) is called smart_log. It looks like:

smart_log(const char *fmt, ...)

The first argument fmt is a format string, just like the format string in printf. Following fmt is a list of additional arguments to feed fmt.

Suppose a function called example_function calls smart_log in this way:

void example_function() {
    smart_log("try to output number %d\n", 1);
}

Then the logging string looks like:

[example_function]: try to output number 1

So the key point is that smart_log append the caller's function to the format string.

I am not sure how to achieve this in C. I think it may be possible to use macro to achieve this.

Answer 1

There is no portable way for a function to know its caller in C. But you’re right, a macro works:

#define smart_log(...) ( printf("[%s]: ", __func__) , printf(__VA_ARGS__) )

__func__ is defined (C99/C11 6.4.2.2 p.1)

as if, immediately following the opening brace of each function definition, the declaration

static const char __func__[] = "function-name";

appeared, where function-name is the name of the lexically-enclosing function.

---

Thanks to Hagen von Eitzen for improving my original attempt!

Answer 2

This is very system/compiler dependent as the exact incantation to get the function name depends very much on the compiler. For Visual C++, you'd use the macro __FUNCTION__ to get the current function name at compile time.

In order to make sure you get the correct function name logged without putting the macro into every invocation of smart_log, you can invoke your logging function via a macro so the macro that gets you the function name is evaluated in the correct context - if you simple add the macro to the function name, you'll always get the name of your logging function...

So instead of calling this:

smart_log("log message");

You call:

SMART_LOG("log message");

Which in turn is defined to:

#define SMART_LOG(message) smart_log(__FUNCTION__, message)

This is under the assumption that your log function takes the function name as the first parameter, so tweak to suit.

Answer 3

If you don't want to use macros you can use the stack for that. The smart_log function will be just on top of the function that called it.

See How can one grab a stack trace in C?

Answer 4

Define a macro - SMART_LOG - which passes __FILE__, __FUNCTION__, and __LINE__ to smart_log as arguments. Then whenever you use SMART_LOG, it automatically provides smart_log with the code location of the caller. Note however that __FUNCTION__ is non-standard, but is available in GCC (and Visual C so I'm lead to believe) see: https://stackoverflow.com/a/597081/191492 ).