Convert a macro into a function call - c

Question

I have a created a macro which will print the timestamp with all the prints.
void timestamp()
{
struct timeval tv;
gettimeofday(&tv,NULL);
printf("%d",tv.tv_sec );
}
#define printf_all(format, ...) { \
static const char format_string[] = format; \
printf(format_string, ##__VA_ARGS__); \
timestamp(); \
}
int main()
{
printf_all("%d\n",10);
return 0;
}
I want to convert this macro into a function. But I am facing problems while passing in the arguments.
void printf_timestamp(static const char format_string[]) {
static const char format_string[] = format;
printf(format_string, ##__VA_ARGS__);
timestamp();
}

Answer 1

You can use vprintf:
int printf_timestamp(const char* fmt, ...) {
va_list args;
int result;
va_start(args, fmt);
result = vprintf(fmt, args);
va_end(args);
timestamp();
return result;
}

Answer 2

This is usually done using the vprintf() function, as orlp explained. However, that alone leaves you with a format that cannot be typechecked: Usually, your compiler interpretes the format string literal in every printf() call that it sees to determine whether the corresponding arguments have the right types.
Some compilers allow you to add support for this kind of type checking, here is the __attribute__(()) that is needed for gcc:
//within header
void printfTimestamp(const char* format, ...)
__attribute__((format(printf, 1, 2)));
//within implementation file
void printfTimestamp(const char* format, ...) {
va_list args;
va_start(args, format);
int result = vfprintf(stderr, format, args);
va_end(args);
timestamp();
return result;
}
The arguments to the attribute are the argument number with the format string (1) and the first variable argument position (2). As such, if you were to add an additional parameter to your function, you would declare it like this:
void myPimpedPrintf(int foo, const char* format, ...)
__attribute__((format(printf, 2, 3)));

Answer 3

For just adding a timestamp, I agree that vprintf() as proposed by orlp is the way to go. However, I think there is a valid argument in favor of macros, and that's the use of other compiler built-in macros like __LINE__, __FILE__, and __func__, which I personally find very useful for logging.
I generally use something like this with gcc and anything else that does comma swallowing.
#define log_debug(M, ...) do{ \
struct timespec _ts; \
double _ts_sec; \
clock_gettime(CLOCK_MONOTONIC, &_ts);\
_ts_sec = _ts.tv_nsec * 1e-9 + _ts.tv_sec; \
fprintf(stderr, "%.3f [DEBUG] (%s:%d) " M, _ts_sec, \
__func__, __LINE__, ##__VA_ARGS__); \
}while(0)
// usage:
log_debug("x=%d\n", x);
There are a couple "tricks" going on here you might not be familiar with.
The first of which is the do{}while() loop. This is a fairly common and largely portable C idiom for writing multi-statement macros. It lets you use the macro terminating it in a ; and allows declaration of scoped variables. However, is a statement, not an expression, so there's no "return value". Usually doesn't matter for printf() like macros, but be aware, this can bite you in other uses when trying to make function-like macros.
The other "trick" is the use of comma swallowing with the '##' operator. Read more here: https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html
Also, this takes advantage of the fact that back-to-back string literals are concatenated in C to form a single string literal. The downside is that this technique ONLY works with string literals, i.e. your format string cannot be in a variable.