Calling conventions and language bindings

Question

I am a little confused about how to best handle calling convention differences in a public API and keep it in sync with its bindings. Let's say I am writing a C API, made available through a shared object library or a DLL. Now assume I have been told I should not use the default calling convention on Windows - that is, on Linux and other Unixes I should use the standard calling convention used by the compiler (probably cdecl) but that on Windows I should force the use of stdcall. So I have some #ifdef logic in the headers that sets the right calling convention as needed. The C headers of the library necessarily take care of that, so the C public API is usable.

Now suppose I want to write bindings for my library in another language. That means I have to rewrite the calling convention logic (depending on the current system) in that language too, for the bindings to correctly map to the library. And so on for all bindings. Some languages may not have good (or any) support for this.

Is there a more elegant way to do this? Should I just use the default calling convention everywhere, and assume that other languages will pick the right one for external/imported functions? Do I even need to worry about this stuff (I think so)? Thanks.

Answer 1

Many languages use a built-in or third party library for simplifying calls to shared libraries. These libraries often include support for both calling conventions. One example of this is JNA for invoking native shared libraries from java. Now that being said, if you don't want to rely on other languages using a single calling convention, you can implement the shared library with both types of functions included and have initializers which return the appropriate bindings for each type. For instance, if your library has 2 functions named function1 and function2 you could implement it like this:

typedef struct
{
    int (*function1)(int a, int b);
    char* (*function2)(void);
}API;

//stdcall implementation
//these functions compiled to use stdcalling convention
int stdcall_function1(int a, int b)
{
    /*...*/
}

char* stdcall_function2(void)
{
    /*...*/
}

API getSTDCallInstance()
{
    API api;
    api.function1 = &stdcall_function1;
    api.function2 = &stdcall_function2;
    return api;
}

//cdecl implementation
//these functions compiled to use cdecl convention

int cdecl_function1(int a, int b)
{
    /*...*/
}

char* cdecl_function2()
{
    /*...*/
}

API getCDECLInstance()
{
    API api;
    api.function1 = &cdecl_function1;
    api.function2 = &cdecl_function2;
    return api;
}

If you implement your library in this manner, then the loading language can use the appropriate initializer to get a handle to the struct containing the correct implementation for them.