Linux .so test

app.d

module app;

import std.stdio : writeln, writefln;
import std.string : toStringz;
import imodule;

version (Posix)
{
	pragma(lib, "dl");
	version (Linux) 
	{
		private import std.c.linux.linux;
	}
	else
	{
		extern( C ) nothrow
		{
			const int RTLD_NOW = 2;

			void *dlopen( const( char )* file, int mode );
			int dlclose( void* handle );
			void *dlsym( void* handle, const( char* ) name );
			const( char )* dlerror();
		}
	}

	alias void* SharedLibHandle;

	private
	{
		SharedLibHandle LoadSharedLib( string libName )
		{
			return dlopen( libName.toStringz(), RTLD_NOW );
		}

		void UnloadSharedLib( SharedLibHandle hlib )
		{
			dlclose( hlib );
		}

		void* GetSymbol( SharedLibHandle hlib, string symbolName )
		{
			return dlsym( hlib, symbolName.toStringz() );
		}

		string GetErrorStr()
		{
			import std.conv : to;
			auto err = dlerror();
			if( err is null )
				return "Uknown Error";

			return to!string( err );
		}
	}
}

IModule loadSharedModule(string file)
{
	import core.runtime;

	void* handle = Runtime.loadLibrary(file);

	if (handle is null)
	{
		writeln("Error loading ", file);
		GetErrorStr().writeln;
		return null;
	}

	void* farproc = GetSymbol(handle, "getModuleInstance");

	if (farproc is null)
	{
		writeln("Error loading symbol getModuleInstance()");
		GetErrorStr().writeln;

		return null;
	}

	alias ModuleFactory = IModule function();

	return (*cast(ModuleFactory)farproc)();
}

void main()
{
	IModule mod = loadSharedModule("./dll.so");
	writeln(mod);
	mod.name().writeln;
	writeln("done");
}

app.sh

dmd -c -ofapp.o app.d imodule.d -debug -g
dmd app.o -L-ldl -defaultlib=libphobos2.so
rm app.o

dll.d

module dll;

import imodule;

class Dll : IModule
{
	override string name()
	{
		return "Dll";
	}
}

export extern(C) IModule getModuleInstance()
{
	return new Dll;
}

dll.sh

dmd -c -ofdll.o dll.d -fPIC -g -debug
dmd -ofdll.so dll.o -shared -defaultlib=libphobos2.so
rm dll.o

imodule.d

module imodule;

interface IModule
{
	string name();
}