Macro to allocate struct on stack with pre-computed member lengths - c

Question

I have a struct of the form:
typedef struct node {
unsigned int * keys;
unsigned int * branches;
} NODE;
The number of keys and branches is determined at runtime, but is known. It is derived from another struct:
typedef struct tree {
unsigned int num_keys_per_node;
} TREE;
In order to allocate a NODE for this TREE, the manual steps would be:
NODE node;
unsigned int keys[tree->num_keys_per_node];
unsigned int branches[tree->num_keys_per_node + 1];
node.keys = keys;
node.branches = branches;
I need to allocate a lot of these nodes inside tight loops, only temporarily as I traverse a data structure, discarding them quickly as the node traversal continues. I could write a function that returns a pointer and malloc() the keys and branches on the heap and free() them manually, but I'd prefer to use the stack if possible.
Since this initialization logic is going to be repeated in a number of places, how can I define a macro, so that I can effectively do something like:
NODE node = CREATE_NODE_FOR_TREE(tree);
I'm having difficultly seeing a way to do this which will result in the preprocessor giving a valid syntax.
Happy to hear other approaches to dynamic struct allocation on stack memory too.
EDIT | I should never need more than one node in memory at the same time, so I can re-use the one struct repeatedly too.

Answer 1

Try to pass node as argument to the macro like so:
#define CREATE_NODE_FOR_TREE( \
node, \
tree) \
\
unsigned int keys[tree->num_keys_per_node]; \
unsigned int branches[tree->num_keys_per_node + 1]; \
\
node.keys = keys; \
node.branches = branches;
...
NODE node = {0};
CREATE_NODE_FOR_TREE(node, tree);
...
This solution assumes at least c99.

Answer 2

Compound literals can't be VLA and your size parameter is dynamic, so there is no possibility to do that directly with the syntax that you propose. I'd do the following:
#define NODE_ON_STACK(NAME, TREE) \
NODE NAME = { 0 }; \
register size_t NAME ## keys = (TREE)->num_keys_per_node; \
auto unsigned int NAME ## keys[NAME ## keys]; \
auto unsigned int NAME ## branches[NAME ## keys + 1]; \
node.keys = NAME ## keys; \
node.branches = NAME ## branches
This works at any place in function scope where several declarations can be placed. register and auto ensure that it is never used in file scope. The NAME ## keys variable ensures that the TREE argument is only evaluated once. You also could mangle the names of the identifiers that are generated a bit more to avoid conflicts, if you like.
Nitpicks:
always initialize struct variables
your TREE thing got somehow wrong in the question
the & operator in your question was wrong
int as an integer type is almost certainly wrong, things that are counting stuff should be unsigned
unsigned int is also wrong, size_t is usually best for everything
that is supposed to count objects or parts of it.
Ah and the usual warning tag: VLA as auto variables are to be taken carefully because of stackoverflow. But you knew that already, I suppose.

Answer 3

I think that something like the following might work, though I'm not sure if it's the best way to do this:
#define PASTE2(x,y) x##y
#define PASTE(x,y) PASTE2(x,y)
#define CREATE_NODE_FOR_TREE( n, tree) \
NODE n; \
unsigned int PASTE(n,_keys)[(tree)->num_keys_per_node]; \
unsigned int PASTE(n,_branches)[(tree)->num_keys_per_node + 1]; \
n.keys = &PASTE(n,_keys); \
n.branches = &PASTE(n,_branches);
The token pasting is there so that if at some point you needed to use more than one NODE at a time, the 'hidden' keys and branches locals would have their names 'scoped' to the NODE name to avoid a conflict.
To use it, instead of
NODE node = CREATE_NODE_FOR_TREE(tree);
You'd declare and initialize node like so:
CREATE_NODE_FOR_TREE(node, tree);