Thread: Validating variadic arguments

There's no way to do it in general in the function itself. The only possibility is to write your own preprocessor that checks the function usage before compilation. gcc gives warnings if the argument types of printf don't match the format string, but it's only able to do that because it has knowledge of the printf standard library function.

Playing with variadics a little, I discovered something interesting about how they are implemented in gcc.

Although the following produces warnings about the formats not matching up, it prints the three ints first and then the three doubles. This is because the values are passed in registers and when you ask for an int you get the one in the first int register; when you ask for a double, you get the one in the first double register.

Code:

#include <stdio.h>
int main() {
    printf("%d %d %d %.1f %.1f %.1f\n",
           1.1, 1, 2.2, 2, 3.3, 3);
    return 0;
}

/* Output:
1 2 3 1.1 2.2 3.3
*/

Even our own variadic functions work that way. If you ask for an int, you will get the first int that was passed in. You need to overload (in the sense of overburden) the registers to screw it up.

Code:

#include <stdio.h>
int main() {
    printf("%d %d %d %.1f %.1f %.1f\n"
           "%d %d %d %.1f %.1f %.1f\n"
           "%d %d %d %.1f %.1f %.1f\n"
           "%d %d %d %.1f %.1f %.1f\n"
           "%d %d %d %.1f %.1f %.1f\n",
           1.1, 11, 2.1, 21, 3.1, 31,
           1.2, 12, 2.2, 22, 3.2, 32,
           1.3, 13, 2.3, 23, 3.3, 33,
           1.4, 14, 2.4, 24, 3.4, 34,
           1.5, 15, 2.5, 25, 3.5, 35);
    return 0;
}

/* Output:
11 21 31 1.1 2.1 3.1
12 22 32 1.2 2.2 3.2
13 23 1717986918 1.3 2.3 0.0
1717986918 14 858993459 0.0 3.4 0.0
0 15 0 0.0 3.5 0.0
*/

I'm detecting the type internally, by parsing a string which is supposed to contain characters that identify the type of each argument, e.g 'i' or 'd' for integers, 'u' for unsigned ' f' for float, etc.

If GCC is your compiler of choice (or Clang), then make your format strings the same as printf.
Using the GNU Compiler Collection (GCC): Common Function Attributes

You get this for free at that point.

Originally Posted by GCC Manual

format (archetype, string-index, first-to-check)

The format attribute specifies that a function takes printf, scanf, strftime or strfmon style arguments that should be type-checked against a format string. For example, the declaration:

extern int
my_printf (void *my_object, const char *my_format, ...)
__attribute__ ((format (printf, 2, 3)));

causes the compiler to check the arguments in calls to my_printf for consistency with the printf style format string argument my_format.

Originally Posted by Dren

John, that is pretty interesting! it doesn't offer complete fool protection -like I ask for an int but there are no ints for instance- but it is certainly better than nothing. I will definitely be using this if can't circumvent the school bot.

I didn't mean it as a solution to your problem. It isn't. It's just interesting.

Originally Posted by Dren

I'm not certain I'll be able to use it, as our school projects have to pass through a bot that checks the code meets certain style and syntax guidelines as well as other school rules.And sadly, the stupid bot doesn't recognize compiler attributes, so it thinks the project will not compile. Let's see how I manage to work around that.

You can always do this, so you only get the format checking in an environment you control.

Code:

extern int
my_printf (void *my_object, const char *my_format, ...)
#ifdef COMPILE_LOCALLY_WITH_CHECKS
__attribute__ ((format (printf, 2, 3)))
#endif
;

You will have fixed all the issues it would ever detect by the time you get to submission time.

Once more Salem to the rescue They ought to change the name of these forums to "Ask Salem" lol.
I don't even know how you knew the bot would ignore the preprocessor directives, but that works like a charm.

Thank you thank you thank you!