• Introduction
• Lexical
• Interpolation Expression Sequence
• Grammar
• Modules
• Declarations
• Types
• Properties
• Attributes
• Pragmas
• Expressions
• Statements
• Arrays
• Associative Arrays
• Structs and Unions
• Classes
• Interfaces
• Enums
• Type Qualifiers
• Functions
• Operator Overloading
• Templates
• Template Mixins
• Contract Programming
• Conditional Compilation
• Traits
• Error Handling
• Unit Tests
• Garbage Collection
• Floating Point
• D x86 Inline Assembler
• Embedded Documentation
• Interfacing to C
• Interfacing to C++
• Interfacing to Objective-C
• Portability Guide
• Named Character Entities
• Memory Safety
• Application Binary Interface
• Vector Extensions
• Better C
• ImportC
• Live Functions
• Windows Programming
• Glossary
• Legacy Code

Conditional Compilation

Conditional compilation is the process of selecting which code to compile and which code to not compile.

ConditionalDeclaration:ConditionDeclarationBlockConditionDeclarationBlockelseDeclarationBlockCondition:DeclDefsoptConditionDeclarationBlockelse:DeclDefsopt
ConditionalStatement:ConditionNoScopeNonEmptyStatementConditionNoScopeNonEmptyStatementelseNoScopeNonEmptyStatement

If theCondition is satisfied, then the followingDeclarationBlock orStatement is compiled in. If it is not satisfied, theDeclarationBlock orStatement after the optionalelse is compiled in.

AnyDeclarationBlock orStatement that is not compiled in still must be syntactically correct.

No new scope is introduced, even if theDeclarationBlock orStatement is enclosed by{ }.

ConditionalDeclarations andConditionalStatements can be nested.

TheStaticAssert can be used to issue errors at compilation time for branches of the conditional compilation that are errors.

Condition comes in the following forms:

Condition:VersionConditionDebugConditionStaticIfCondition

Version Condition

VersionCondition:version (Identifier)version (unittest)version (assert)

Versions enable multiple versions of a module to be implemented with a single source file.

TheVersionCondition is satisfied ifIdentifier matches aversion identifier.

Theversion identifier can be set on the command line by the-version switch or in the module itself with aVersionSpecification, or they can be predefined by the compiler.

Version identifiers are in their own unique name space, they do not conflict with debug identifiers or other symbols in the module. Version identifiers defined in one module have no influence over other imported modules.

int k;version (Demo)// compile in this code block for the demo version{int i;int k;// error, k already defined    i = 3;}x = i;// uses the i declared above

version (X86){    ...// implement custom inline assembler version}else{    ...// use default, but slow, version}

Theversion(unittest) is satisfied if and only if the code is compiled with unit tests enabled (the-unittest option ondmd).

Version Specification

VersionSpecification:version =Identifier;

The version specification makes it straightforward to group a set of features under one major version, for example:

version (ProfessionalEdition){version = FeatureA;version = FeatureB;version = FeatureC;}version (HomeEdition){version = FeatureA;}...version (FeatureB){    ... implement Feature B ...}

Version identifiers or levels may not be forward referenced:

version (Foo){int x;}version = Foo;// error, Foo already used

VersionSpecifications may only appear at module scope.

While the debug and version conditions superficially behave the same, they are intended for very different purposes. Debug statements are for adding debug code that is removed for the release version. Version statements are to aid in portability and multiple release versions.

Here's an example of afull version as opposed to ademo version:

class Foo{int a, b;version(full)    {int extrafunctionality()        {            ...return 1;// extra functionality is supported        }    }else// demo    {int extrafunctionality()        {return 0;// extra functionality is not supported        }    }}

Various different version builds can be built with a parameter to version:

version(identifier)// add in version code if version// keyword is identifier{    ...version code ...}

This is presumably set by the command line as-version=identifier.

Predefined Versions

Several environmental version identifiers and identifier name spaces are predefined for consistent usage. Version identifiers do not conflict with other identifiers in the code, they are in a separate name space. Predefined version identifiers are global, i.e. they apply to all modules being compiled and imported.

The following identifiers are defined, but are deprecated:

Others will be added as they make sense and new implementations appear.

To allow for future growth of the language, the version identifier namespace beginning with "D_" is reserved for identifiers indicating D language specification or new feature conformance. Further, all identifiers derived from the ones listed above by appending any character(s) are reserved. This means that e.g.ARM_foo andWindows_bar are reserved whilefoo_ARM andbar_Windows are not.

Predefined version identifiers from this list cannot be set from the command line or from version statements. (This prevents things like bothWindows andlinux being simultaneously set.)

Compiler vendor specific versions can be predefined if the trademarked vendor identifier prefixes it, as in:

version(DigitalMars_funky_extension){    ...}

It is important to use the right version identifier for the right purpose. For example, use the vendor identifier when using a vendor specific feature. Use the operating system identifier when using an operating system specific feature, etc.

Debug Condition

DebugCondition:debugdebug (Identifier)

Two versions of programs are commonly built, a release build and a debug build. The debug build includes extra error checking code, test harnesses, pretty-printing code, etc. The debug statement conditionally compiles in its statement body. It is D's way of what in C is done with#ifdef DEBUG /#endif pairs.

Thedebug condition is satisfied when the-debug switch is passed to the compiler.

Thedebug (Identifier) condition is satisfied when the debug identifier matchesIdentifier.

class Foo{int a, b;debug:int flag;}

Debug Statement

AConditionalStatement that has aDebugCondition is called aDebugStatement.DebugStatements have relaxed semantic checks in thatpure,@nogc,nothrow and@safe checks are not done. Neither doDebugStatements influence the inference ofpure,@nogc,nothrow and@safe attributes.

Debug Specification

DebugSpecification:debug =Identifier;

Debug identifiers are set either by the command line switch-debug or by aDebugSpecification.

Debug specifications only affect the module they appear in, they do not affect any imported modules. Debug identifiers are in their own namespace, independent from version identifiers and other symbols.

It is illegal to forward reference a debug specification:

debug(foo) writeln("Foo");debug = foo;// error, foo used before set

DebugSpecifications may only appear at module scope.

Various different debug builds can be built with a parameter to debug:

debug(identifier) { }// add in debug code if debug keyword is identifier

These are presumably set by the command line as and-debug=identifier.

Static If Condition

StaticIfCondition:static if (AssignExpression)

AssignExpression is implicitly converted to a boolean type, and is evaluated at compile time. The condition is satisfied if it evaluates totrue. It is not satisfied if it evaluates tofalse.

It is an error ifAssignExpression cannot be implicitly converted to a boolean type or if it cannot be evaluated at compile time.

StaticIfConditions can appear in module, class, template, struct, union, or function scope. In function scope, the symbols referred to in theAssignExpression can be any that can normally be referenced by an expression at that point.

constint i = 3;int j = 4;staticif (i == 3)// ok, at module scopeint x;class C{constint k = 5;staticif (i == 3)// okint x;elselong x;staticif (j == 3)// error, j is not a constantint y;staticif (k == 5)// ok, k is in current scopeint z;}

template Int(int i){staticif (i == 32)alias Int =int;elsestaticif (i == 16)alias Int =short;elsestaticassert(0);// not supported}Int!(32) a;// a is an intInt!(16) b;// b is a shortInt!(17) c;// error, static assert trips

AStaticIfCondition differs from anIfStatement in the following ways:

1. It can be used to conditionally compile declarations, not just statements.
2. It does not introduce a new scope even if{ } are used for conditionally compiled statements.
3. For unsatisfied conditions, the conditionally compiled code need only be syntactically correct. It does not have to be semantically correct.
4. It must be evaluatable at compile time.

Static Foreach

StaticForeachDeclaration:StaticForeachDeclarationBlockStaticForeach:DeclDefsopt
StaticForeachStatement:StaticForeachNoScopeNonEmptyStatement
StaticForeach:staticAggregateForeachstaticRangeForeach

static foreach expands itsDeclarationBlock orDeclDefs into a series of declarations, each of which may reference anyForeachType symbols declared.

• The aggregate/range bounds are evaluated at compile time and turned into a sequence of compile-time entities by evaluating corresponding code with aForeachStatement/ForeachRangeStatement at compile time.
• The body of thestatic foreach is then copied a number of times that corresponds to the number of elements of the sequence.
• Within the i-th copy, the name of thestatic foreach element 'variable' is bound to the i-th entry of the sequence, either as anenum variable declaration (for constants) or analias declaration (for symbols). (In particular,static foreach variables are never runtime variables.)

staticforeach (i; [0, 1, 2, 3]){pragma(msg, i);}

static foreach supports multipleForeachType variables in cases where the correspondingforeach statement supports them. (In this case,static foreach generates a compile-time sequence of tuples, and the tuples are subsequently unpacked during iteration).

staticforeach (i, v; ['a', 'b', 'c', 'd']){staticassert(i + 'a' == v);}

Like bodies ofConditionalDeclarations, astatic foreach body does not introduce a new scope. Therefore, it can be used to add declarations to an existing scope:

import std.range : iota;staticforeach (i; iota(0, 3)){mixin(`enum x`, i,` = i;`);}pragma(msg, x0," ", x1," ", x2);// 0 1 2

Inside a function, if a new scope is desired for each expansion, use another set of braces:

void fun(){staticforeach (s; ["hi","hey","hello"])    {{enum len = s.length;// local to each iterationstaticassert(len <= 5);    }}staticassert(!is(typeof(len)));}

static foreach supports sequence expansionlikeforeach.

break andcontinue

Asstatic foreach is a code generation construct and not a loop,break andcontinue cannot be used to change control flow within it. Instead of breaking or continuing a suitable enclosing statement, such an usage yields an error (this is to prevent misunderstandings).

int test(int x){int r = -1;switch(x)    {staticforeach (i; 0 .. 5)        {case i:                r = i;break;// error        }default:break;    }return r;}staticforeach (i; 0 .. 10){staticassert(test(i) == (i < 5 ? i : -1));}

An explicitbreak/continue label can be used to avoid this limitation. (Note thatstatic foreach itself cannot be broken nor continued even if it is explicitly labeled.)

int test(int x){int r = -1;    Lswitch:switch(x)    {staticforeach (i; 0 .. 5)        {case i:                r = i;break Lswitch;        }default:break;    }return r;}staticforeach (i; 0 .. 10){staticassert(test(i) == (i < 5 ? i : -1));}

Static Assert

StaticAssert:static assert (ArgumentList) ;

The firstAssignExpression is evaluated at compile time, and converted to a boolean value. If the value is true, the static assert is ignored. If the value is false, an error diagnostic is issued and the compile fails.

On failure, any subsequentAssignExpressions will each be converted to string and then concatenated. The resulting string will be printed out along with the error diagnostic.

UnlikeAssertExpressions,StaticAsserts are always checked and evaluated by the compiler unless they appear in an unsatisfied conditional.

void foo(){if (0)    {assert(0);// never tripsstaticassert(0);// always trips    }version (BAR)    {    }else    {staticassert(0);// trips when version BAR is not defined    }}

StaticAssert is useful tool for drawing attention to conditional configurations not supported in the code.