dmd.globals

enum DiagnosticReporting: ubyte;

Defines a setting for how compiler warnings and deprecations are handled

error

generate an error

inform

generate a warning

off

disable diagnostic

enum CHECKENABLE: ubyte;

In which context checks for assertions, contracts, bounds checks etc. are enabled

_default

initial value

off

never do checking

on

always do checking

safeonly

do checking only in @safe functions

enum CHECKACTION: ubyte;

What should happend when an assertion fails

D

call D assert on failure

C

call C assert on failure

halt

cause program halt on failure

context

call D assert with the error context on failure

enum JsonFieldFlags: uint;

Each flag represents a field that can be included in the JSON output.

NOTE set type to uint so its size matches C++ unsigned type

enum CppStdRevision: uint;

Version of C++ standard to support

enum FeatureState: ubyte;

Trivalent boolean to represent the state of a revertable change

default_

Not specified by the user

disabled

Specified as -revert=

enabled

Specified as -preview=

struct Help;

Command line state related to printing usage about other switches

struct Param;

Put command line switches in here

bool parsingUnittestsRequired();

struct Global;

Collection of global compiler settings and global state used by the frontend

const(char)[] inifilename;

filename of configuration file as given by -conf=, or default value

Array!(const(char)*)* path;

Array of char*'s which form the import lookup path

Array!(const(char)*)* filePath;

Array of char*'s which form the file import lookup path

char[26] datetime;

string returned by ctime()

Param params;

command line parameters

uint errors;

number of errors reported so far

uint warnings;

number of warnings reported so far

uint gag;

!=0 means gag reporting of errors & warnings

uint gaggedErrors;

number of errors reported while gagged

uint gaggedWarnings;

number of warnings reported while gagged

void* console;

opaque pointer to console for controlling text attributes

Array!Identifier* versionids;

command line versions and predefined versions

Array!Identifier* debugids;

command line debug versions and predefined versions

bool hasMainFunction;

Whether a main function has already been compiled in (for -main switch)

uint varSequenceNumber;

Relative lifetime of VarDeclaration within a function, used for scope checks

FileManager fileManager;

Cache files read from disk

enum int recursionLimit;

number of recursive template expansions before abort

ErrorSink errorSink;

where the error messages go

ErrorSink errorSinkNull;

where the error messages are ignored

nothrow @safe uint startGagging();

Start ignoring compile errors instead of reporting them.

Used for speculative compilation like __traits(compiles, XXX), but also internally to e.g. try out an alias this rewrite without comitting to it.

Works like a stack, so N calls to startGagging should be paired with N calls to endGagging.

Returns:

the current number of gagged errors, which should later be passed to endGagging

nothrow @safe bool endGagging(uint oldGagged);

Stop gagging, restoring the old gagged state before the most recent call to startGagging.

Parameters:

uint oldGagged

the previous number of errors, as returned by startGagging

Returns:

true if errors occurred while gagged.

nothrow @safe void increaseErrorCount();

Increment the error count to record that an error has occurred in the current context.

An error message may or may not have been printed.

nothrow void deinitialize();

Deinitializes the global state of the compiler.

This can be used to restore the state set by _init to its original state.

nothrow @safe uint versionNumber();

Returns:

the version as the number that would be returned for __VERSION__

nothrow @safe string versionString();

Returns:

compiler version string.

nothrow const(char*) versionChars();

Returns:

compiler version as char string.

Global global;

Collection of global state