Improve this page Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone. Page wiki View or edit the community-maintained wiki page associated with this page.

DMD Compiler for Windows

Requirements and Downloads

  1. Download D Compiler
  2. 32 bit Windows (Win32) operating system, such as Windows XP
  3. Download dmc.zip (C and C++ compiler) for Win32 (not required, but it complements dmd for Windows)

Files

\dmd2\src\phobos\
D runtime library source
\dmd2\src\dmd\
D compiler front end source under dual (GPL and Artistic) license
\dmd2\html\d\
Documentation
\dmd2\samples\d\
Sample D programs
\dmd2\windows\bin\dmd.exe
D compiler executable
\dmd2\windows\bin\shell.exe
Simple command line shell
\dmd2\windows\bin\sc.ini
Global compiler settings
\dmd2\windows\lib\phobos.lib
D runtime library

Installation

Open a console window (for Windows XP this is done by clicking on [Start][Command Prompt]). All the tools are command line tools, which means they are run from a console window. Switch to the root directory. Unzip the files in the root directory. dmd.zip will create a \dmd2 directory with all the files in it. dmc.zip will create a \dm directory with all the files in it.

A typical session might look like:

C:\Documents and Settings\Your Name>cd \
C:\>unzip dmd.zip
C:\>unzip dmc.zip

Example

Run:

\dmd2\windows\bin\shell all.sh

in the \dmd2\samples\d directory for several small examples.

Compiler Arguments and Switches

dmd files... -switches...
files...
File Extensions
Extension File Type
none D source files
.d D source files
.dd Ddoc source files
.di D interface files
.obj Object files to link in
.lib Object code libraries to search
.exe Output executable file
.def module definition file
.res resource file
@cmdfile
If cmdfile is an environment variable, read the compiler arguments and switches from the value of that variable. Otherwise, read compiler arguments and switches from the text file cmdfile. The file may contain single-line comments starting with the hash symbol (#).
-c
compile only, do not link
-cov
instrument for code coverage analysis
-D
generate documentation from source
-Dddocdir
write documentation file to docdir directory. -op can be used if the original package hierarchy should be retained
-Dffilename
write documentation file to filename
-d
silently allow deprecated features
-dw
show deprecated features as warnings (this is the default)
-de
show deprecated features as errors
-debug
compile in debug code
-debug=level
compile in debug level <= level
-debug=ident
compile in debug identifier ident
-debuglib=libname
link in libname as the default library when compiling for symbolic debugging instead of phobos.lib
-defaultlib=libname
link in libname as the default library when not compiling for symbolic debugging instead of phobos.lib
-deps=filename
write module dependencies as text to filename
-g
add CodeView 4 symbolic debug info with D extensions for debuggers such as Ddbg
-gc
add CodeView 4 symbolic debug info in C format for debuggers such as \dmd2\bin\windbg
-gs
always generate standard stack frame
-H
generate D interface file
-Hddir
write D interface file to dir directory. -op can be used if the original package hierarchy should be retained
-Hffilename
write D interface file to filename
--help
print brief help to console
-Ipath
where to look for imports. path is a ; separated list of paths. Multiple -I's can be used, and the paths are searched in the same order.
-ignore
ignore unsupported pragmas
-inline
inline expand functions at the discretion of the compiler. This can improve performance, at the expense of making it more difficult to use a debugger on it.
-Jpath
where to look for files for ImportExpressions. This switch is required in order to use ImportExpressions. path is a ; separated list of paths. Multiple -J's can be used, and the paths are searched in the same order.
-Llinkerflag
pass linkerflag to the linker , for example, -L/ma/li
-lib
generate library file as output instead of object file(s). All compiled source files, as well as object files and library files specified on the command line, are inserted into the output library. Compiled source modules may be partitioned into several object modules to improve granularity. The name of the library is taken from the name of the first source module to be compiled. This can be overridden with the -of switch.
-man
open default browser on this page
-map
generate a .map file
-noboundscheck
turns off all array bounds checking, even for safe functions
-O
Optimize generated code. For fastest executables, compile with the -O -release -inline switches together.
-o-
Suppress generation of object file. Useful in conjuction with -D or -H flags.
-odobjdir
write object files relative to directory objdir instead of to the current directory. -op can be used if the original package hierarchy should be retained
-offilename
Set output file name to filename in the output directory. The output file can be an object file, executable file, or library file depending on the other switches.
-op
normally the path for .d source files is stripped off when generating an object, interface, or Ddoc file name. -op will leave it on.
-profile
profile the runtime performance of the generated code
-property
enforce use of @property on property functions
-quiet
suppress non-essential compiler messages
-release
compile release version, which means not generating code for contracts and asserts. Array bounds checking is not done for system and trusted functions.
-run srcfile args... compile
link, and run the program srcfile with the rest of the command line, args..., as the arguments to the program. No .obj or executable file is left behind.
-unittest
compile in unittest code, turns on asserts, and sets the unittest version identifier
-v
verbose
-version=level
compile in version level >= level
-version=ident
compile in version identifier ident
-vtls
print informational messages identifying variables defaulting to thread local storage. Handy for migrating to shared model.
-w
enable warnings
-wi
enable informational warnings (i.e. compilation still proceeds normally)
-X
generate JSON file
-Xffilename
write JSON file to filename

Empty switches, i.e. "", are ignored.

Linking

Linking is done directly by the dmd compiler after a successful compile. To prevent dmd from running the linker, use the -c switch.

The programs must be linked with the D runtime library phobos.lib, followed by the C runtime library snn.lib. This is done automatically as long as the directories for the libraries are on the LIB environment variable path. A typical way to set LIB would be:

set LIB=\dmd2\lib;\dm\lib

If the dmd command is used to both compile and link to an executable, it will make certain optimizations that are valid only for Windows executable files. Do not use the resulting .obj files in a DLL. To compile modules into .obj files that can be used in an exe or DLL, compile with -c.

Linking is done using the optlink linker.

Environment Variables

The D compiler dmd uses the following environment variables:

DFLAGS
The value of DFLAGS is treated as if it were appended to the command line to dmd.exe.
LIB
The linker uses LIB to search for library files. For D, it will normally be set to:
set LIB=\dmd2\lib;\dm\lib
LINKCMD
dmd normally runs the linker by looking for link.exe along the PATH. To use a specific linker instead, set the LINKCMD environment variable to it. For example:
set LINKCMD=\dmd\windows\bin\link
PATH
If the linker is not found in the same directory as dmd.exe is in, the PATH is searched for it. Note: other linkers named link.exe will likely not work. Make sure the Digital Mars link.exe is found first in the PATH before other link.exe's, or use LINKCMD to specifically identify which linker to use.

sc.ini Initialization File

dmd will look for the initialization file sc.ini in the following sequence of directories:

  1. current working directory
  2. directory specified by the HOME environment variable
  3. directory dmd.exe resides in

If found, environment variable settings in the file will override any existing settings. This is handy to make dmd independent of programs with conflicting use of environment variables.

Initialization File Format

Comments are lines that begin with ; and are ignored.

Environment variables follow the [Environment] section heading, in NAME=value pairs. The NAMEs are treated as upper case. Comments are lines that start with ;. For example:

; sc.ini file for dmd
; Names enclosed by %% are searched for in the existing environment
; and inserted. The special name %@P% is replaced with the path
; to this file.
[Environment]
LIB="%@P%\..\lib";\dm\lib

DFLAGS="-I%@P%\..\src\phobos" "-I%@P%\..\src\druntime\import"
LINKCMD="%@P%\..\..\dm\bin"
DDOCFILE=mysettings.ddoc

Location Independence of sc.ini

The %@P% is replaced with the path to sc.ini. Thus, if the fully qualified file name sc.ini is c:\dmd2\bin\sc.ini, then %@P% will be replaced with c:\dmd2\bin, and the above sc.ini will be interpreted as:

[Environment]
LIB="c:\dmd2\bin\..\lib";\dm\lib

DFLAGS="-Ic:\dmd2\bin\..\src\phobos" "-Ic:\dmd2\bin\..\src\druntime\import"
LINKCMD="c:\dmd2\bin\..\..\dm\bin"
DDOCFILE=mysettings.ddoc

This enables your dmd setup to be moved around without having to re-edit sc.ini.

Common Installation Problems


Differences between Windows and Linux versions


D Interface Files

When an import declaration is processed in a D source file, the compiler searches for the D source file corresponding to the import, and processes that source file to extract the information needed from it. Alternatively, the compiler can instead look for a corresponding D interface file. A D interface file contains only what an import of the module needs, rather than the whole implementation of that module.

The advantages of using a D interface file for imports rather than a D source file are:

D interface files can be created by the compiler from a D source file by using the -H switch to the compiler. D interface files have the .di file extension. When the compiler resolves an import declaration, it first looks for a .di D interface file, then it looks for a D source file.

D interface files bear some analogous similarities to C++ header files. But they are not required in the way that C++ header files are, and they are not part of the D language. They are a feature of the compiler, and serve only as an optimization of the build process.

Building Executables

dmd can build an executable much faster if as many of the source files as possible are put on the command line.

Another advantage to putting multiple source files on the same invocation of dmd is that dmd will be able to do some level of cross-module optimizations, such as function inlining across modules.

Building Libraries

There are three ways to build a library. For example, given foo.d and bar.d which are to be compiled, and existing object file bar.obj and existing library def.lib which are all to be combined into a library foo.lib:

  1. Compile modules separately and then run the librarian on them:
    dmd -c foo.d
    dmd -c bar.d
    lib -c -p32 foo.lib foo.obj bar.obj abc.obj def.lib
    del foo.obj bar.obj
    
    This option is typical when using a makefile to avoid compiling modules that have already been compiled.
  2. Compile modules together and then run the librarian on them:
    dmd -c foo.d bar.d
    lib -c -p32 foo.lib foo.obj bar.obj abc.obj def.lib
    del foo.obj bar.obj
    
  3. Use dmd to compile and build library in one operation:
    dmd -lib foo.d bar.d abc.obj def.lib
    
    No object files are written to disk, it's all done in memory. Using -lib also has the advantage that modules may be compiled into multiple object files rather than exactly one per module. This improves granularity of the library without having to break up the modules.

Compiling dmd

Complete source code is provided to build the compiler. Follow these steps:

cd \dmd2\src\dmd
make -f win32.mak

Compiling Phobos

Complete source code is provided to build Phobos, the D runtime library. Follow these steps:

cd \dmd2\src\druntime
make -f win32.mak DMD=\dmd2\windows\bin\dmd
cd ..\phobos
make -f win32.mak DMD=\dmd2\windows\bin\dmd
Forums | Comments | Search | Downloads | Home