Question

I am working on a C math library, and it is using macros do to the most of it’s work, I am now facing a problem.

This is what the macro looks like:

the_macro(a, b, c)

and the macro itself does something like:
(a - b > 0) ? error_function : 1

the error_function is used to stop the user at complie time, so if (a - b > 0) is true, then the macro will expand as a function which does not have a definition. So this will cause a linkage error.

Everthing seems good, but today my boss told me we need to do some unit-test, so I wrote a function which wraps the macro:

int my_func(int a, int b, int c)
{
    return the_macro(a, b, c);
}

here comes the problem, the code can’t pass linkage, because if I use a var instead of a constant to call the_macro, these error_functions will be in the .o file, because the int a, int b, int c are all known at runtime, so I can only call the macro function with constants: the_macro(2, 3, 4) is there any way to avoid this? or is there a better solution to do unit-test on this macro?

EDIT:

The code I’m working on is confidential… but I made an example which demonstrates the problem:

#include <stdio.h>

#define the_macro(a, b)\
    (a > b)?error_function():1

// Comment out my_func(), then the program will run normaly
// But if you don't comment it out, the linkage error will come out.
void my_func(int a, int b)
{
    the_macro(a, b);
}

int main()
{
    printf("%d\n", the_macro(1, 10));
    return 0;
}

I’m using gcc-4

Answer 1

Regardless of where you use the macro, if error_function is not declared, you should get a compiler error. If it is declared but not defined, you have undefined behavior. Whether the arguments to the macro are constants or not changes nothing in this respect. (It may affect what the actual behavior is in the case of undefined behavior.)