www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - D: How would one make a shared dynamically linked D library?

reply BoQsc <vaidas.boqsc gmail.com> writes:
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.
Nov 08 2023
next sibling parent "Richard (Rikki) Andrew Cattermole" <richard cattermole.co.nz> writes:
Currently stick to ldc.

Dub's defaults will "just work" except:

- On *nix where you have to either set/patch the ``RPATH`` or set 
``LD_LIBRARY_PATH``.
- For executables on Windows in which you need to set the dflag 
``-dllimport=all``.


 From a README of mine (for Posix):


To get the loading of sidero shared libraries you will need to set the 
LD path before execution.

E.g. export 
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:~/projects/ProjectSidero/eventloop/examples/networking

or you can patch the binary:

patchelf --force-rpath --set-rpath 
~/projects/ProjectSidero/eventloop/examples/networking ./example_networking
Nov 08 2023
prev sibling next sibling parent Hipreme <msnmancini hotmail.com> writes:
On Wednesday, 8 November 2023 at 11:48:58 UTC, BoQsc wrote:

 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.


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:
```d
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:

```d
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
Nov 08 2023
prev sibling parent IchorDev <zxinsworld gmail.com> writes:
On Wednesday, 8 November 2023 at 11:48:58 UTC, BoQsc wrote:

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

 Is it possible to do that in D Language


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:
```d
//regular function:
int add(int x, int y) nothrow{
   x += y;
   return x;
}

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


 what are limitations?


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


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


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