I would like to export some functionality as external shared dynamically linked D library.

Is it possible to do that in D Language and what are limitations?

A simple writeln example would be great.

What I expect is an executable that uses functions, variables, classes, modules from compiled external shared D dynamic library.

Example of shared dynamic libraries depending on other shared dynamic libraries would be great as well.

On Wednesday, 8 November 2023 at 11:48:58 UTC, BoQsc wrote:

For a complete reference, check: https://wiki.dlang.org/Win32_DLLs_in_D

Create a dub project.
Set its targetType to dynamicLibrary.

Now, create a function:

module dllmodule;

version(Windows)
{
    import core.sys.windows.dll;
    mixin SimpleDllMain;
}

export extern(C) void helloWorld()
{
    import std.stdio;
    writeln("DLL: Hello World");
}

Now, when you enter dub, you'll get a .dll on windows, and a .so on linux.
You can use any compiler of your preference.

Now, whenever you need to load this dll, you'll need to call:

module my_app;

extern(C) void function helloWorld();

void main()
{
    import core.runtime;
    void* dllmodule = Runtime.loadLibrary("dllmodule.dll");
    version(Windows)
    {
        import core.sys.windows.dll;
        helloWorld =  cast(typeof(helloWorld))GetProcAddress(dllmodule, "helloWorld");
    }
    else version(Posix)
    {
        import core.sys.posix.dlfcn;
        helloWorld = cast(typeof(helloWorld))dlsym(dllmodule, "helloWorld");
    }
    helloWorld();
}

With that, there it is.
You also may need to call core.runtime.rt_init() if you're not calling from D

On Wednesday, 8 November 2023 at 11:48:58 UTC, BoQsc wrote:

Yes, as long as the symbols you want to use externally are public, which is the default.
When it comes to linking, the main factor is usually matching symbol mangling. In C you would help users do this by distributing your header files. In D it's more common to distribute your source code, so if you want to distribute a "header" you'll need to remove your function bodies:

//regular function:
int add(int x, int y) nothrow{
  x += y;
  return x;
}

//for a D "header":
int add(int x) nothrow;

The desired template instantiations must be generated at compile time, not at link time. CTFE probably won't work.

There should be no material difference to using a shared library from an executable binary.