title: D short-description: Compiling D sources ...

Compiling D applications

Meson has support for compiling D programs. A minimal meson.build file for D looks like this:

project('myapp', 'd')

executable('myapp', 'app.d')

Conditional compilation

If you are using the version() feature for conditional compilation, you can use it using the d_module_versions target property:

project('myapp', 'd')
executable('myapp', 'app.d', d_module_versions: ['Demo', 'FeatureA'])

For debugging, debug() conditions are compiled automatically in debug builds, and extra identifiers can be added with the d_debug argument:

project('myapp', 'd')
executable('myapp', 'app.d', d_debug: [3, 'DebugFeatureA'])

In `declare_dependency`

Since 0.62.0, when declaring your own dependency using declare_dependency, it is possible to add parameters for D specific features, e.g. to propagate conditional compilation versions:

my_dep = declare_dependency(
    # ...
    d_module_versions: ['LUA_53'],
    d_import_dirs: include_directories('my_lua_folder'),
)

Accepted D specific parameters are d_module_versions and d_import_dirs (DMD -J switch).

Using embedded unittests

If you are using embedded unittest functions, your source code needs to be compiled twice, once in regular mode, and once with unittests active. This is done by setting the d_unittest target property to true. Meson will only ever pass the respective compiler's -unittest flag, and never have the compiler generate an empty main function. If you need that feature in a portable way, create an empty main() function for unittests yourself, since the GNU D compiler does not have this feature.

This is an example for using D unittests with Meson:

project('myapp_tested', 'd')

myapp_src = ['app.d', 'alpha.d', 'beta.d']
executable('myapp', myapp_src)

test_exe = executable('myapp_test', myapp_src, d_unittest: true)
test('myapptest', test_exe)

Compiling D libraries and installing them

Building D libraries is a straightforward process, not different from how C libraries are built in Meson. You should generate a pkg-config file and install it, in order to make other software on the system find the dependency once it is installed.

This is an example on how to build a D shared library:

project('mylib', 'd', version: '1.2.0')

project_soversion = 0
glib_dep = dependency('glib-2.0')

my_lib = library('mylib',
    ['src/mylib/libfunctions.d'],
    dependencies: [glib_dep],
    install: true,
    version: meson.project_version(),
    soversion: project_soversion,
    d_module_versions: ['FeatureA', 'featureB', 1]
)

pkgc = import('pkgconfig')
pkgc.generate(name: 'mylib',
              libraries: my_lib,
              subdirs: 'd/mylib',
              version: meson.project_version(),
              description: 'A simple example D library.',
              d_module_versions: ['FeatureA', 1]
)
install_subdir('src/mylib/', install_dir: 'include/d/mylib/')

It is important to make the D sources install in a subdirectory in the include path, in this case /usr/include/d/mylib/mylib. All D compilers include the /usr/include/d directory by default, and if your library would be installed into /usr/include/d/mylib, there is a high chance that, when you compile your project again on a machine where you installed it, the compiler will prefer the old installed include over the new version in the source tree, leading to very confusing errors.

This is an example of how to use the D library we just built and installed in an application:

project('myapp', 'd')

mylib_dep = dependency('mylib', version: '>= 1.2.0')
myapp_src = ['app.d', 'alpha.d', 'beta.d']
executable('myapp', myapp_src, dependencies: [mylib_dep])

Please keep in mind that the library and executable would both need to be built with the exact same D compiler and D compiler version. The D ABI is not stable across compilers and their versions, and mixing compilers will lead to problems.

Integrating with DUB