Using a Delphi DLL in C++ - How to properly call functions?

Question

At work one brand of battery cyclers we are using has a proprietarily encodd data format which I would like to directly read in my scripts instead of the much larger ASCII version of the data. The manufacturer provided a DLL (no library or header) along with some Delphi example code of its use, very little documentation and an example executable (which fails to run with error 0xc000007b). Following this tutorial I managed to create a .lib and link my VS2018 project to the DLL.

With the following code I can call one of the desired functions from the DLL:

#pragma comment(lib, "MacReadDataFileLIB.lib")

#include <string>

extern "C" int OpenDataFile(const char*);

int main()
{
    std::string path = "K:\\Testfile.036";
    auto test = OpenDataFile(path.c_str());
}

When I step through the code, the function returns -1001 i. e. fails and an exception is thrown.

Run-Time Check Failure #0 - The value of ESP was not properly saved across a function call. This is usually a result of calling a function declared with one calling convention with a function pointer declared with a different calling convention.

From the documentation I know that stdcall is used.

Other relevant information from the documentation:

function OpenDataFile(FileName: PChar): int32; function LoadAndGetNextTimeData(Handle: int32; PTimeData: pointer): int32; procedure CloseDataFile(Handle: int32);

Open the Maccor data file with OpenDataFile and get a handle returned. If the handle is equal to or larger than 0, the file is successfully open. (...) Since it is common to read the entire data file, there is a dual purpose function, LoadAndGetNextTimeData, to load the time data and get/return the most common data. All functions takes at minimum the handle returned by OpenDataFile. (...) To read the data, keep calling LoadAndGetNextTimeData as long as it returns 0. Finally, the file must be closed with CloseDataFile to free up allocated memory.

When I change the function declaration to

extern "C" int __stdcall OpenDataFile(const char*);

It fails to compile with 2 error codes:

LNK1120 1 unresolved externals

LNK2019 unresolved external symbol _OpenDataFile@4 referenced in function _main

I understand that this is due to C++ name mangling, but at this point I am stuck.

Have you checked the answer to [Member function pointer runtime error - The value of ESP was not properly saved across a function call](https://stackoverflow.com/a/8678663/7582247)? — Ted Lyngmo, Jan 06 '23 at 11:41
How big is the API to that DLL (in terms of the number of symbols it exports)? If it's relatively small, `GetProcAddress` is also an option. — Paul Sanders, Jan 06 '23 at 11:44
Theoretically, you should be able to use delphi dll in c++, because symbols are resolved by operating system. Looks like problem is in your function declaration. `OpenDataFile(const char*)` is valid C++ code, but at the same time means that you don't need any parameters to that function and compiler will probably throw your `const char*`, and it will look like `OpenDataFile()` — Bolderaysky, Jan 06 '23 at 12:10
@TedLyngmo Unfortunately I don't understand the thread. The solution of adding /vmg to compiler options doesn't change anything for me. — JustSomeChemist, Jan 06 '23 at 12:45
@PaulSanders: Not sure what you mean. It has 26 implemented functions. I'm a novice, sorry — JustSomeChemist, Jan 06 '23 at 12:48
@Bolderaysky: When I try without argument, the behavior is exactly the same. Both with the exception as well as with '__stdcall' (except it's _OpenDataFile@0 in that case) — JustSomeChemist, Jan 06 '23 at 12:50
I mean, that `OpenDataFile()` and `OpenDataFile(const char*)` are identical. You have to add some name to your parameter, for example, `OpenDataFile(const char* filename)`. In this case, function will have parameter, and compiler will not throw that parameter from declaration, because it has name and can be set in the symbol which will be later resolved by linker. — Bolderaysky, Jan 06 '23 at 12:58
@Bolderaysky: I see. I tried it, but nothing changed. Same errors. — JustSomeChemist, Jan 06 '23 at 13:12
@JustSomeChemist Just Google `GetProcAddress` (and `LoadLibrary`). This will tell you how you can get the address of a function in a DLL independent of its call signature. You can then call it through a suitably declared function pointer, and in that manner you should be able to get it to work. — Paul Sanders, Jan 06 '23 at 14:34
@PaulSanders: That indeed seems to do the trick. In the meantime I stumbled upon this [Delphi-unrelated question](https://stackoverflow.com/questions/31282683/dll-call-with-stdcall-getprocaddress-in-vs2013?rq=1) and the code from the question actually already works for me. Please put your suggestion as an answer so I can acknowledge you. — JustSomeChemist, Jan 06 '23 at 14:44
Don't worry about that, I'd have to write some real code! I'm just glad that you're up and running now. — Paul Sanders, Jan 06 '23 at 15:33
@JustSomeChemist you can [post your own answer](https://stackoverflow.com/help/self-answer). Your edit should be moved into an answer. — Remy Lebeau, Jan 06 '23 at 17:22

Remy Lebeau · Answer 1 · 2023-01-07T00:22:06.900

When I change the function declaration to
extern "C" int __stdcall OpenDataFile(const char*);
It fails to compile with 2 error codes:
LNK1120 1 unresolved externals

LNK2019 unresolved external symbol _OpenDataFile@4 referenced in function _main

Adding __stdcall is the correct thing to do.

To solve the linker error, you can create an import .lib file using Visual Studio's lib.exe tool with the /DEF option to specify a .def file that maps the compiler's decorated symbol _OpenDataFile@4 to the undecorated symbol OpenDataFile that the DLL actually exports. See How To Create 32-bit Import Libraries Without .OBJs or Source

Alternatively, you can use MSVC's delay-loaded DLL feature instead. Continue using the .lib file you already have, and just mark the DLL as delay-loaded in your project settings. Then, in your code, you can use a delay-loaded notification hook to make the DLL function be imported using the undecorated symbol rather than the decorated symbol during the dliNotePreGetProcAddress stage.

#include <string>
#include <cstring>
#include <delayimp.h>
#pragma comment(lib, "MacReadDataFileLIB.lib")

ExternC int __stdcall OpenDataFile(const char*);

FARPROC WINAPI myDelayLoadHook(unsigned dliNotify, PDelayLoadInfo pdli)
{
    if ((dliNotify == dliNotePreGetProcAddress) &&
        (std::strcmp(pdli->szDll, "MacReadDataFileLIB.dll") == 0) &&
        pdli->dlp.fImportByName &&
        (std::strcmp(pdli->dlp.szProcName, "_OpenDataFile@4") == 0))
    {
        return (FARPROC) GetProcAddress(pdli->hmodCur, "OpenDataFile");
    }
    return NULL;
}

extern "C" const PfnDliHook __pfnDliNotifyHook2 = myDelayLoadHook;

int main()
{
    std::string path = "K:\\Testfile.036";
    auto test = OpenDataFile(path.c_str());
}

score 1 · Answer 2 · answered Jan 10 '23 at 09:39

I found a piece of code in a not directly related question that works out of the box:

typedef int(__stdcall* tMyFunction)(const char* filename);

int main(int argc, char* argv[]) {

    std::string path = "K:\\Testfile.036";

    HINSTANCE m_dllHandle = LoadLibrary("MacReadDataFileLIB.dll");
    tMyFunction function = (tMyFunction)GetProcAddress(m_dllHandle, "OpenDataFileASCII");
    int value = function(path.c_str());

    FreeLibrary(m_dllHandle);
    m_dllHandle = NULL;

    return 0;
}

Using a Delphi DLL in C++ - How to properly call functions?

2 Answers2