Multiline macro function with "return" statement

Question

I'm currently working on a project, and a particular part needs a multi-line macro function (a regular function won't work here as far as I know).

The goal is to make a stack manipulation macro, that pulls data of an arbitrary type off the stack (being the internal stack from a function call, not a high-level "stack" data type). If it were a function, it'd look like this:

type MY_MACRO_FUNC(void *ptr, type);

Where type is the type of data being pulled from the stack.

I currently have a working implementation of this for my platform (AVR):

#define MY_MACRO_FUNC(ptr, type) (*(type*)ptr); \
    (ptr = /* Pointer arithmetic and other stuff here */)

This allows me to write something like:

int i = MY_MACRO_FUNC(ptr, int);

As you can see in the implementation, this works because the statement which assigns i is the first line in the macro: (*(type*)ptr).

However, what I'd really like is to be able to have a statement before this, to verify that ptr is a valid pointer before anything gets broken. But, this would cause the macro to be expanded with the int i = pointing to that pointer check. Is there any way to get around this issue in standard C? Thanks for any help!

Answer 1

As John Bollinger points out, macros expanding to multiple statements can have surprising results. A way to make several statements (and declarations!) a single statement is to wrap them into a block (surrounded by do … while(0), see for example here).

In this case, however, the macro should evaluate to something, so it must be an expression (and not a statement). Everything but declarations and iteration and jump statements (for, while, goto) can be transformed to an expression: Several expressions can be sequenced with the comma operator, if-else-clauses can be replaced by the conditional operator (?:).

Given that the original value of ptr can be recovered (I’ll assume "arithmetic and other stuff here" as adding 4 for the sake of having an example)

#define MY_MACRO_FUNC(ptr, type) \
    ( (ptr) && (uintptr_t)(ptr)%4 == 0 \
        ? (ptr) += 4 , *(type*)((ptr) - 4) \
        : (abort() , (type){ 0 }) )

Note, that I put parentheses around ptr and around the whole expression, see e.g. here for an explanation.

The second and third operand of ?: must be of the same type, so I included (type){0} after the abort call. This expression is never evaluated. You just need some valid dummy object; here, type cannot be a function type.

If you use C89 and can’t use compound literals, you can use (type)0, but that wouldn’t allow for structure or union types.

---

Just as a note, Gcc has an extension Statements and Declarations in Expressions.