Thread: typesafe printf hackery

Hi,

I've occasionally wished for a typesafe version of pg_printf() and other
varargs functions. The compiler warnings are nice, but also far from
complete.

Here's a somewhat crazy hack/prototype for how printf could get actual
argument types.  I'm far from certain it's worth pursuing this
further... Nor the contrary.

Note that this requires removing the parentheses from VA_ARGS_NARGS_'s
result (i.e. (N) -> N). To me those parens don't make much sense, we're
pretty much guaranteed to only ever have a number there.

With the following example e.g.

    myprintf("boring fmt", 1, 0.1, (char)'c', (void*)0, "crazy stuff");
    myprintf("empty argument fmt");

yield

format string "boring fmt", 5 args
    arg number 0 is of type int: 1
    arg number 1 is of type double: 0.100000
    arg number 2 is of type bool: true
    arg number 3 is of type void*: (nil)
    arg number 4 is of type char*: crazy stuff
format string "empty argument fmt", 0 args


which'd obviously allow for error checking inside myprintf.


#include "c.h"

// hack pg version out of the way
#undef printf

// FIXME: This doesn't correctly work with zero arguments
#define VA_ARGS_EACH(wrap, ...) \
    VA_ARGS_EACH_EXPAND(VA_ARGS_NARGS(__VA_ARGS__)) (wrap, __VA_ARGS__)
#define VA_ARGS_EACH_EXPAND(count) VA_ARGS_EACH_EXPAND_REALLY(VA_ARGS_EACH_INT_, count)
#define VA_ARGS_EACH_EXPAND_REALLY(prefix, count) prefix##count

#define VA_ARGS_EACH_INT_1(wrap, el1) wrap(el1)
#define VA_ARGS_EACH_INT_2(wrap, el1, ...) wrap(el1), VA_ARGS_EACH_INT_1(wrap, __VA_ARGS__)
#define VA_ARGS_EACH_INT_3(wrap, el1, ...) wrap(el1), VA_ARGS_EACH_INT_2(wrap, __VA_ARGS__)
#define VA_ARGS_EACH_INT_4(wrap, el1, ...) wrap(el1), VA_ARGS_EACH_INT_3(wrap, __VA_ARGS__)
#define VA_ARGS_EACH_INT_5(wrap, el1, ...) wrap(el1), VA_ARGS_EACH_INT_4(wrap, __VA_ARGS__)
#define VA_ARGS_EACH_INT_6(wrap, el1, ...) wrap(el1), VA_ARGS_EACH_INT_5(wrap, __VA_ARGS__)
#define VA_ARGS_EACH_INT_7(wrap, el1, ...) wrap(el1), VA_ARGS_EACH_INT_6(wrap, __VA_ARGS__)


typedef enum printf_arg_type
{
    PRINTF_ARG_BOOL,
    PRINTF_ARG_CHAR,
    PRINTF_ARG_INT,
    PRINTF_ARG_DOUBLE,
    PRINTF_ARG_CHARP,
    PRINTF_ARG_VOIDP,
} printf_arg_type;

typedef struct arginfo
{
    printf_arg_type tp;
} arginfo;

// hackfix empty argument case
#define myprintf(...) myprintf_wrap(__VA_ARGS__, "dummy")
#define myprintf_wrap(fmt, ... ) \
    myprintf_impl(fmt, VA_ARGS_NARGS(__VA_ARGS__) - 1, ((arginfo[]){ VA_ARGS_EACH(blurttype, __VA_ARGS__) }),
__VA_ARGS__)

// FIXME: Obviously not enough types
#define blurttype(x) ((arginfo){_Generic(x, char: PRINTF_ARG_BOOL, int: PRINTF_ARG_INT, double: PRINTF_ARG_DOUBLE, char
*:PRINTF_ARG_CHARP, void *: PRINTF_ARG_VOIDP)})
 

static const char*
printf_arg_typename(printf_arg_type tp)
{
    switch (tp)
    {
        case PRINTF_ARG_BOOL:
            return "bool";
        case PRINTF_ARG_CHAR:
            return "char";
        case PRINTF_ARG_INT:
            return "int";
        case PRINTF_ARG_DOUBLE:
            return "double";
        case PRINTF_ARG_CHARP:
            return "char*";
        case PRINTF_ARG_VOIDP:
            return "void*";
    }

    return "";
}

static void
myprintf_impl(char *fmt, size_t nargs, arginfo arg[], ...)
{
    va_list args;
    va_start(args, arg);

    printf("format string \"%s\", %zu args\n", fmt, nargs);
    for (int argno = 0; argno < nargs; argno++)
    {
        printf("\targ number %d is of type %s: ",
               argno,
               printf_arg_typename(arg[argno].tp));

        switch (arg[argno].tp)
        {
            case PRINTF_ARG_BOOL:
                printf("%s", ((bool) va_arg(args, int)) ? "true" : "false");
                break;
            case PRINTF_ARG_CHAR:
                printf("%c", (char) va_arg(args, int));
                break;
            case PRINTF_ARG_INT:
                printf("%d", va_arg(args, int));
                break;
            case PRINTF_ARG_DOUBLE:
                printf("%f", va_arg(args, double));
                break;
            case PRINTF_ARG_CHARP:
                printf("%s", va_arg(args, char *));
                break;
            case PRINTF_ARG_VOIDP:
                printf("%p", va_arg(args, void *));
                break;
        }

        printf("\n");
    }
}

int main(int argc, char **argv)
{
    myprintf("boring fmt", 1, 0.1, (char)'c', (void*)0, "crazy stuff");
    myprintf("empty argument fmt");
}


Greetings,

Andres Freund