{"id":442,"date":"2009-10-16T00:04:09","date_gmt":"2009-10-16T05:04:09","guid":{"rendered":"http:\/\/vgable.com\/blog\/?p=442"},"modified":"2009-10-16T12:42:10","modified_gmt":"2009-10-16T17:42:10","slug":"hack-counting-varadic-arguments-in-c","status":"publish","type":"post","link":"https:\/\/vgable.com\/blog\/2009\/10\/16\/hack-counting-varadic-arguments-in-c\/","title":{"rendered":"Hack: Counting Variadic Arguments in C"},"content":{"rendered":"

This isn’t practical, but I think it’s neat that it’s doable in C99. The implementation I present here is incomplete and for illustrative purposes only<\/strong>.<\/p>\n

Background<\/h3>\n

C’s implementation of variadic functions<\/a> (functions that take a variable-number of arguments) is characteristically bare-bones. Even though the compiler knows the number, and type, of all arguments passed to variadic functions; there isn’t a mechanism for the function to get this information from the compiler. Instead, programmers need to pass an extra argument, like the printf<\/code> format-string<\/a>, to tell the function “these are the arguments I gave you”. This has worked for over 37 years. But it’s clunky — you have to write the same information twice, once for the compiler and again to tell the function what you told the compiler.<\/p>\n

Inspecting Arguments in C<\/h3>\n

Argument Type<\/h4>\n

I don’t know of a way to find the type of the Nth argument to a varadic function, called with heterogeneous types.<\/strong> If you can figure out a way, I’d love to know. The typeof<\/code><\/a> extension is often sufficient to write generic code that works when every argument has the same type.<\/strong> (C++ templates<\/a> also solve this problem if we step outside of C-proper.)<\/p>\n

Argument Count (The Good Stuff Starts Here)<\/h4>\n

By using variadic macros<\/a>, and stringification (#<\/code>)<\/a>, we can actually pass a function the literal string of its argument list from the source code — which it can parse to determine how many arguments it was given.
\n<\/strong><\/p>\n

For example, say f()<\/code> is a variadic function. We create a variadic wrapper macro, F()<\/code> and call it like so in our source code,<\/p>\n

x = F(a,b,c);<\/pre>\n
The preprocessor expands this to,<\/p>\n
x = f(\"a,b,c\",a,b,c)<\/pre>\n
Or perhaps,<\/p>\n
x = f(count_arguments(\"a,b,c\"),a,b,c)<\/pre>\n
where count_arguments(char *s)<\/code> returns the number of arguments in the string source-code string s<\/code>. (Technically s<\/code> would be an argument-expression-list).<\/p>\n
Example Code<\/h3>\n
Here’s an implementation for, iArray()<\/code>, an array-builder for int<\/code> values, very much like JavaScript<\/a>‘s Array()<\/code> constructor. Unlike the quirky JavaScript<\/a> Array()<\/code>, iArray(3)<\/code> returns an array containing just the element 3, [3]<\/code>, not an uninitilized array with 3 elements, [undefined, undefined, undefined]<\/code>. Another difference: iArray()<\/code>, invoked with no arguments, is invalid, and will not compile.<\/p>\n
\n#define iArray(...) alloc_ints(count_arguments(#__VA_ARGS__), __VA_ARGS__)\n<\/pre>\n
This macro is pretty straightforward. It’s given a variable number of arguments, represented by __VA_ARGS__<\/code> in the expansion. #__VA_ARGS__<\/code> turns the code into a string<\/a> so that count_arguments<\/code> can analyze it. (If you were doing this for real, you should use two levels of stringification<\/a> though, otherwise macros won’t be fully expanded. I choose to keep things “demo-simple” here.)<\/p>\n
\nunsigned count_arguments(char *s){\n\tunsigned i,argc = 1;\n\t\tfor(i = 0; s[i]; i++)\n\t\t\tif(s[i] == ',')\n\t\t\t\targc++;\n\treturn argc;\n}\n<\/pre>\n
This is a dangerously naive<\/strong> implementation and only works correctly when iArray()<\/code> is given a straightforward non-empty list of values or variables. Basically it’s the least code I could write to make a working demo.<\/p>\n
Since iArray<\/code> must have at least one argument to compile, we just count the commas in the argument-list to see how many other arguments were passed. Simple to code, but it fails for more complex expressions like f(a,g(b,c))<\/code>.<\/p>\n
\nint *alloc_ints(unsigned count, ...){\n\tunsigned i = 0;\n\tint *ints = malloc(sizeof(int) * count);\n\tva_list args;\n    va_start(args, count);\n\tfor(i = 0; i < count; i++)\n\t\tints[i] = va_arg(args,int);\n\tva_end(args);\n\treturn ints;\n}\n<\/pre>\n
Just as you'd expect, this code allocates enough memory to hold count<\/code> int<\/code>s, and fills it with the remaining count<\/code> arguments. Bad things happen if < count<\/code> arguments are passed, or they are the wrong type.<\/p>\n
Parsing is Hard<\/a>, Let's Go Shopping<\/h3>\n
I didn't even try to correctly parse any<\/em> valid argument-expression-list in count_arguments<\/code>. It's non trivial. I'd rather deal with choosing the correct MAX3<\/code> or MAX4<\/code> macro in a few places than maintain such a code base.<\/p>\n
So this kind of introspection isn't really practical in C. But it's neat that it can be done, without any tinkering with the compiler or language.<\/p>\n","protected":false},"excerpt":{"rendered":"
This isn’t practical, but I think it’s neat that it’s doable in C99. The implementation I present here is incomplete and for illustrative purposes only. Background C’s implementation of variadic functions (functions that take a variable-number of arguments) is characteristically bare-bones. Even though the compiler knows the number, and type, of all arguments passed to […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[12,4,11,13,8],"tags":[613,504,505,417,503,502],"class_list":["post-442","post","type-post","status-publish","format-standard","hentry","category-design","category-programming","category-research","category-sample-code","category-usability","tag-c","tag-introspection","tag-parsing","tag-programming-language-design","tag-variadic-functions","tag-variadic-macros"],"_links":{"self":[{"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/posts\/442","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/comments?post=442"}],"version-history":[{"count":9,"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/posts\/442\/revisions"}],"predecessor-version":[{"id":455,"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/posts\/442\/revisions\/455"}],"wp:attachment":[{"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/media?parent=442"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/categories?post=442"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vgable.com\/blog\/wp-json\/wp\/v2\/tags?post=442"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Download the code<\/a>, if you like.<\/p>\n