Definining a C macro that expands to a variable number of elements - c

Question

I'm writing USB report descriptors, which are a sequence of bytes: a tag byte (in which the lower bits tell how many data bytes follow) followed by 0, 1, 2 or 4 data bytes. e.g. to define the logical ranges of an input:
uint8_t report_descriptor[] = {
...
0x15, 0x00, // Logical Minimum (0)
0x26, 0xFF, 0x03, // Logical Maximum (1023)
...
};
Since 0 fits into one byte, we use tag type 0x15 (Logical Minimum with one data byte). But 1023 requires two bytes, so tag type 0x26 (Logical Maximum with two data bytes).
I had hoped to define some macros to make this more readable (and avoid having to comment every line):
uint8_t report_descriptor[] = {
...
LOGICAL_MINIMUM(0),
LOGICAL_MAXIMUM(1023),
...
};
However, I've hit a snag: that macro needs to expand to a different number of elements depending on the value. I don't see any easy way to achieve this. I've tried tricks like value > 255 ? (value & 0xFF, value >> 8) : value, but it always gets expanded to just one byte.
I think the spec allows to just always use the 4-byte tags, but that would be wasteful, so I'd rather not do that.
Is what I'm after possible with the preprocessor?

Answer 1

There is a dirty hack that will achieve the asked functionality. But being a dirty hack, it's unlikely to improve the readability. But it works. First lets define an include file helper.h like this:
#if PARAM > 255
0x26, (PARAM & 0xFF), (PARAM >> 8),
#else
0x15, (PARAM),
#endif
Then in our main we will do:
uint8_t report_descriptor[] = {
#define PARAM 0
#include "helper.h"
#undef PARAM
#define PARAM 1023
#include "helper.h"
#undef PARAM
};
To see it is working here is the test code:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
uint8_t report_descriptor[] = {
#define PARAM 0
#include "helper.h"
#undef PARAM
#define PARAM 1023
#include "helper.h"
#undef PARAM
};
int main(int argc, char** args) {
int i;
for (i=0; i < sizeof(report_descriptor); i++ )
printf("%x\n", report_descriptor[i]);
return 0;
}
and the output is:
15
0
26
ff
3

Answer 2

I don't think that the C preprocessor is powerful enough to do this in a clean way. If you are willing to resort to the M4 macro processor, it can be done fairly easily. M4 should be readily available on the vast majority of GNU/Linux systems and portable implementations should be available for most platforms.
Let's define the M4 macros in a separate file and name it macros.m4.
define(`EXTRACT_BYTE', `(($1 >> (8 * $2)) & 0xFF)')
dnl You probably don't want to define these as M4 macros but as C preprocessor
dnl macros in your header files.
define(`TAG_1_BYTES', `0x15')
define(`TAG_2_BYTES', `0x26')
define(`TAG_3_BYTES', `0x37')
define(`TAG_4_BYTES', `0x48')
define(`EXPAND_1_BYTES', `TAG_1_BYTES, EXTRACT_BYTE($1, 0)')
define(`EXPAND_2_BYTES', `TAG_2_BYTES, EXTRACT_BYTE($1, 1), EXTRACT_BYTE($1, 0)')
define(`EXPAND_3_BYTES', `TAG_3_BYTES, EXTRACT_BYTE($1, 2), EXTRACT_BYTE($1, 1), EXTRACT_BYTE($1, 0)')
define(`EXPAND_4_BYTES', `TAG_4_BYTES, EXTRACT_BYTE($1, 3), EXTRACT_BYTE($1, 2), EXTRACT_BYTE($1, 1), EXTRACT_BYTE($1, 0)')
define(`ENCODE',
`ifelse(eval($1 < 256), `1', `EXPAND_1_BYTES($1)',
`ifelse(eval($1 < 65536), `1', `EXPAND_2_BYTES($1)',
`ifelse(eval($1 < 16777216), `1', `EXPAND_3_BYTES($1)',
`EXPAND_4_BYTES($1)')')')')
Now, writing your C files is straight forward. Put the following code in a file test.c.m4:
include(`macros.m4')
`static unint8_t report_descriptor[] = {'
ENCODE(50),
ENCODE(5000),
ENCODE(500000),
ENCODE(50000000),
`};'
In your Makefile, add the following rule
test.c: test.c.m4 macros.m4
${M4} $< > $#
where M4 is set to the M4 processor (usually m4).
If M4 is run on test.c.m4, it will – omitting some excess white space – produce the following test.c file:
static unint8_t report_descriptor[] = {
0x15, ((50 >> (8 * 0)) & 0xFF),
0x26, ((5000 >> (8 * 1)) & 0xFF), ((5000 >> (8 * 0)) & 0xFF),
0x37, ((500000 >> (8 * 2)) & 0xFF), ((500000 >> (8 * 1)) & 0xFF), ((500000 >> (8 * 0)) & 0xFF),
0x48, ((50000000 >> (8 * 3)) & 0xFF), ((50000000 >> (8 * 2)) & 0xFF), ((50000000 >> (8 * 1)) & 0xFF), ((50000000 >> (8 * 0)) & 0xFF),
};
You'll probably find it more convenient to keep the test.c.m4 file as minimal as possible and #include it in an ordinary C file.
If you don't know M4, you can learn the basics rather quickly. If already using GNU Autoconf, you might find it convenient to use their M4sugar M4 macro library instead of the plain M4 I've used above.