Function visibility in C : make function visible and callable through macro only (MSVC compiler)

Question

I would like to make function to be callable (e.g. exposed) to the rest of the library through the macro only, to prevent accidental undesired side effects.

Why? This is because I have a variadic function, which could be called from another variadic function and that way I would like to add NULL sentinel to the call, using macro, thus making access to va_list much easier and prevent undefined behaviour. There are also other handy scenarios, where this could really be helplful.

An example :

test.h

void _func(char *dummy, ...);
//I would like to make sure that rest of the library
//only calls _func through this macro
#define func(dummy, ...) _func(dummy, __VA_ARGS__, NULL)

test.c

//Implementation of the _func function
static void _func(char *dummy, ...) {
     //body goes here...
}

main.c

int main(int argc, char *argv[]) {
    //This should not be allowed by compiler
    _func("dummy", "arg1");
    //This should be allowed by compiler, but since definition
    //of _func is static in test.c file, compiler is not happy anyway
    //LNK2001   unresolved external symbol __func
    func("dummy", "arg1");
    return 0;
}

I've already tried with #define and #undef compiler directives to somehow force this scenario, but no avail. Is this even possible in C?

Answer 1

You can shadow the function with a macro:

void _func(char *dummy, ...);
#define _func(...) error_use_the_macro_func_instead_of_calling__func_directly

// Always use the macro "func" instead of calling "_func" directly.
#define func(dummy, ...) (_func)(dummy, __VA_ARGS__, NULL)

Notice the parentheses around _func in the macro. This prevents the _func from being recognized as a function-like macro and gives the macro access to the function. If somebody tries to call _func directly, they get

error C2065: 'error_use_the_macro_func_instead_of_calling__func_directly': undeclared identifier

This "macro shadowing" technique has the advantage of being usable in expression contexts:

for (int i = 0; i < 5; func("incrementing i", ++i)) { ... }

or if we change the situation slightly and give _func a return value:

int _func(char *dummy, ...);
#define _func(...) error_use_the_macro_func_instead_of_calling__func_directly

// Always use the macro "func" instead of calling "_func" directly.
#define func(dummy, ...) (_func)(dummy, __VA_ARGS__, NULL)

then this allows you to do things like

int i = func("hello", 2) * func("there", 3);

Answer 2

Maybe you can scope the visibility of the private function? Here's a snippet to illustrate what I mean. Not pretty, but it may work for you(no MSVC to test with here)

#define func(a, b) do { \
    extern void private_func(int , int );\
    private_func(a, b);\
 } while (0)

void foo(void)
{
    func(1, 2);
    private_func(3, 4);
}

Answer 3

What @Bjorn A. has written in the post above, actually solves my problem as compiler gets angry with the message : '_func': redefinition; different basic types if I try to call _func directly.

Here is the adopted example :

test.h

#define func(dummy, ...) do { \
    extern void _func(char *, ...);\
    _func(dummy, __VA_ARGS__, NULL);\
 } while (0)

test.c

//Implementation of the _func function
//static has to be omitted here, but it doesn't matter
void _func(char *dummy, ...) {
     //body goes here...
}

main.c

int main(int argc, char *argv[]) {
    //'_func': redefinition; different basic types
    //if we try to call _func directly
    _func("dummy", "arg1");
    //this is ok
    func("dummy", "arg1");
    func("dummy2", "arg2");
    return 0;
}

EDIT : Actually, @Raymond Chen has proposed much better solution with function shadowing - idea is to enclose the function name with parentheses to stop preprocessor from expanding it. More info about that here.

Here is the final (hopefully) solution that works like a charm :

test.h

void _func(char *dummy, ...);
#define _func(...) error_use_the_macro_func_instead_of_calling__func_directly
#define func(dummy, ...) (_func)(dummy, __VA_ARGS__, NULL)

test.c

//Notice the _func is enclosed with parentheses here
void (_func)(char *dummy, ...) {
     //body goes here...
}

main.c

int main(int argc, char *argv[]) {
    //C2065 'error_use_the_macro_func_instead_of_calling__func_directly': undeclared identifier
    //if we try to call _func directly
    _func("dummy", "arg1");
    //this is ok
    func("dummy", "arg1");
    func("dummy2", "arg2");
    return 0;
}

Many thanks! Cheers!