/**
* Stores command line options and contains other miscellaneous declarations.
*
* Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/globals.d, _globals.d)
* Documentation: https://dlang.org/phobos/dmd_globals.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/globals.d
*/
module dmd.globals;
import core.stdc.stdint;
import dmd.root.array;
import dmd.root.filename;
import dmd.common.outbuffer;
import dmd.errorsink;
import dmd.errors;
import dmd.file_manager;
import dmd.identifier;
import dmd.location;
/// Defines a setting for how compiler warnings and deprecations are handled
enum DiagnosticReporting : ubyte
{
error, /// generate an error
inform, /// generate a warning
off, /// disable diagnostic
}
/// In which context checks for assertions, contracts, bounds checks etc. are enabled
enum CHECKENABLE : ubyte
{
_default, /// initial value
off, /// never do checking
on, /// always do checking
safeonly, /// do checking only in @safe functions
}
/// What should happend when an assertion fails
enum CHECKACTION : ubyte
{
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
}
/**
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 JsonFieldFlags : uint
{
none = 0,
compilerInfo = (1 << 0),
buildInfo = (1 << 1),
modules = (1 << 2),
semantics = (1 << 3),
}
/// Version of C++ standard to support
enum CppStdRevision : uint
{
cpp98 = 1997_11,
cpp11 = 2011_03,
cpp14 = 2014_02,
cpp17 = 2017_03,
cpp20 = 2020_02,
}
/// Trivalent boolean to represent the state of a `revert`able change
enum FeatureState : byte
{
default_ = -1, /// Not specified by the user
disabled = 0, /// Specified as `-revert=`
enabled = 1 /// Specified as `-preview=`
}
extern(C++) struct Output
{
bool doOutput; // Output is enabled
bool fullOutput; // Generate comments for hidden declarations (for -HC),
// and don't strip the bodies of plain (non-template) functions (for -H)
const(char)[] dir; // write to directory 'dir'
const(char)[] name; // write to file 'name'
Array!(const(char)*) files; // Other files associated with this output,
// e.g. macro include files for Ddoc, dependencies for makedeps
OutBuffer* buffer; // if this output is buffered, this is the buffer
int bufferLines; // number of lines written to the buffer
}
/// Put command line switches in here
extern (C++) struct Param
{
bool obj = true; // write object file
bool multiobj; // break one object file into multiple ones
bool trace; // insert profiling hooks
bool tracegc; // instrument calls to 'new'
bool verbose; // verbose compile
bool vcg_ast; // write-out codegen-ast
bool showColumns; // print character (column) numbers in diagnostics
bool vtls; // identify thread local variables
bool vtemplates; // collect and list statistics on template instantiations
bool vtemplatesListInstances; // collect and list statistics on template instantiations origins. TODO: make this an enum when we want to list other kinds of instances
bool vgc; // identify gc usage
bool vfield; // identify non-mutable field variables
bool vcomplex = true; // identify complex/imaginary type usage
bool vin; // identify 'in' parameters
DiagnosticReporting useDeprecated = DiagnosticReporting.inform; // how use of deprecated features are handled
bool useUnitTests; // generate unittest code
bool useInline = false; // inline expand functions
bool release; // build release version
bool preservePaths; // true means don't strip path from source file
DiagnosticReporting warnings = DiagnosticReporting.off; // how compiler warnings are handled
bool color; // use ANSI colors in console output
bool cov; // generate code coverage data
ubyte covPercent; // 0..100 code coverage percentage required
bool ctfe_cov = false; // generate coverage data for ctfe
bool ignoreUnsupportedPragmas; // rather than error on them
bool useModuleInfo = true; // generate runtime module information
bool useTypeInfo = true; // generate runtime type information
bool useExceptions = true; // support exception handling
bool betterC; // be a "better C" compiler; no dependency on D runtime
bool addMain; // add a default main() function
bool allInst; // generate code for all template instantiations
bool bitfields; // support C style bit fields
CppStdRevision cplusplus = CppStdRevision.cpp11; // version of C++ standard to support
bool showGaggedErrors; // print gagged errors anyway
bool printErrorContext; // print errors with the error context (the error line in the source file)
bool manual; // open browser on compiler manual
bool usage; // print usage and exit
bool mcpuUsage; // print help on -mcpu switch
bool transitionUsage; // print help on -transition switch
bool checkUsage; // print help on -check switch
bool checkActionUsage; // print help on -checkaction switch
bool revertUsage; // print help on -revert switch
bool previewUsage; // print help on -preview switch
bool externStdUsage; // print help on -extern-std switch
bool hcUsage; // print help on -HC switch
bool logo; // print compiler logo
// Options for `-preview=/-revert=`
FeatureState useDIP25 = FeatureState.enabled; // implement https://wiki.dlang.org/DIP25
FeatureState useDIP1000; // implement https://dlang.org/spec/memory-safe-d.html#scope-return-params
bool ehnogc; // use @nogc exception handling
bool useDIP1021; // implement https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1021.md
bool fieldwise; // do struct equality testing field-wise rather than by memcmp()
bool fixAliasThis; // if the current scope has an alias this, check it before searching upper scopes
FeatureState rvalueRefParam; // allow rvalues to be arguments to ref parameters
// https://dconf.org/2019/talks/alexandrescu.html
// https://gist.github.com/andralex/e5405a5d773f07f73196c05f8339435a
// https://digitalmars.com/d/archives/digitalmars/D/Binding_rvalues_to_ref_parameters_redux_325087.html
// Implementation: https://github.com/dlang/dmd/pull/9817
FeatureState noSharedAccess; // read/write access to shared memory objects
bool previewIn; // `in` means `[ref] scope const`, accepts rvalues
bool inclusiveInContracts; // 'in' contracts of overridden methods must be a superset of parent contract
bool shortenedMethods = true; // allow => in normal function declarations
bool fixImmutableConv; // error on unsound immutable conversion - https://github.com/dlang/dmd/pull/14070
bool fix16997 = true; // fix integral promotions for unary + - ~ operators
// https://issues.dlang.org/show_bug.cgi?id=16997
FeatureState dtorFields; // destruct fields of partially constructed objects
// https://issues.dlang.org/show_bug.cgi?id=14246
FeatureState systemVariables; // limit access to variables marked @system from @safe code
CHECKENABLE useInvariants = CHECKENABLE._default; // generate class invariant checks
CHECKENABLE useIn = CHECKENABLE._default; // generate precondition checks
CHECKENABLE useOut = CHECKENABLE._default; // generate postcondition checks
CHECKENABLE useArrayBounds = CHECKENABLE._default; // when to generate code for array bounds checks
CHECKENABLE useAssert = CHECKENABLE._default; // when to generate code for assert()'s
CHECKENABLE useSwitchError = CHECKENABLE._default; // check for switches without a default
CHECKENABLE boundscheck = CHECKENABLE._default; // state of -boundscheck switch
CHECKACTION checkAction = CHECKACTION.D; // action to take when bounds, asserts or switch defaults are violated
uint errorLimit = 20;
uint errorSupplementLimit = 6; // Limit the number of supplemental messages for each error (0 means unlimited)
const(char)[] argv0; // program name
Array!(const(char)*) modFileAliasStrings; // array of char*'s of -I module filename alias strings
Array!(const(char)*)* imppath; // array of char*'s of where to look for import modules
Array!(const(char)*)* fileImppath; // array of char*'s of where to look for file import modules
const(char)[] objdir; // .obj/.lib file output directory
const(char)[] objname; // .obj file output name
const(char)[] libname; // .lib file output name
Output ddoc; // Generate embedded documentation comments
Output dihdr; // Generate `.di` 'header' files
Output cxxhdr; // Generate 'Cxx header' file
Output json; // Generate JSON file
JsonFieldFlags jsonFieldFlags; // JSON field flags to include
Output makeDeps; // Generate make file dependencies
Output mixinOut; // write expanded mixins for debugging
Output moduleDeps; // Generate `.deps` module dependencies
uint debuglevel; // debug level
Array!(const(char)*)* debugids; // debug identifiers
uint versionlevel; // version level
Array!(const(char)*)* versionids; // version identifiers
MessageStyle messageStyle = MessageStyle.digitalmars; // style of file/line annotations on messages
bool run; // run resulting executable
Strings runargs; // arguments for executable
Array!(const(char)*) cppswitches; // C preprocessor switches
// Linker stuff
Array!(const(char)*) objfiles;
Array!(const(char)*) linkswitches;
Array!bool linkswitchIsForCC;
Array!(const(char)*) libfiles;
Array!(const(char)*) dllfiles;
const(char)[] deffile;
const(char)[] resfile;
const(char)[] exefile;
const(char)[] mapfile;
}
extern (C++) struct structalign_t
{
private:
ushort value = 0; // unknown
enum STRUCTALIGN_DEFAULT = 1234; // default = match whatever the corresponding C compiler does
bool pack; // use #pragma pack semantics
public:
pure @safe @nogc nothrow:
bool isDefault() const { return value == STRUCTALIGN_DEFAULT; }
void setDefault() { value = STRUCTALIGN_DEFAULT; }
bool isUnknown() const { return value == 0; } // value is not set
void setUnknown() { value = 0; }
void set(uint value) { this.value = cast(ushort)value; }
uint get() const { return value; }
bool isPack() const { return pack; }
void setPack(bool pack) { this.pack = pack; }
}
//alias structalign_t = uint;
// magic value means "match whatever the underlying C compiler does"
// other values are all powers of 2
//enum STRUCTALIGN_DEFAULT = (cast(structalign_t)~0);
enum mars_ext = "d"; // for D source files
enum doc_ext = "html"; // for Ddoc generated files
enum ddoc_ext = "ddoc"; // for Ddoc macro include files
enum dd_ext = "dd"; // for Ddoc source files
enum hdr_ext = "di"; // for D 'header' import files
enum json_ext = "json"; // for JSON files
enum map_ext = "map"; // for .map files
enum c_ext = "c"; // for C source files
enum i_ext = "i"; // for preprocessed C source file
/**
* Collection of global compiler settings and global state used by the frontend
*/
extern (C++) struct Global
{
const(char)[] inifilename; /// filename of configuration file as given by `-conf=`, or default value
string copyright = "Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved";
string written = "written by Walter Bright";
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
private enum string _version = import("VERSION");
private enum uint _versionNumber = parseVersionNumber(_version);
const(char)[] vendor; /// Compiler backend name
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 = 1; /// Relative lifetime of `VarDeclaration` within a function, used for `scope` checks
/// Cache files read from disk
FileManager fileManager;
enum recursionLimit = 500; /// number of recursive template expansions before abort
ErrorSink errorSink; /// where the error messages go
extern (C++) FileName function(FileName, ref const Loc, out bool, OutBuffer*) preprocess;
nothrow:
/**
* 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`
*/
extern (C++) uint startGagging()
{
++gag;
gaggedWarnings = 0;
return gaggedErrors;
}
/**
* Stop gagging, restoring the old gagged state before the most recent call to `startGagging`.
*
* Params:
* oldGagged = the previous number of errors, as returned by `startGagging`
* Returns: true if errors occurred while gagged.
*/
extern (C++) bool endGagging(uint oldGagged)
{
bool anyErrs = (gaggedErrors != oldGagged);
--gag;
// Restore the original state of gagged errors; set total errors
// to be original errors + new ungagged errors.
errors -= (gaggedErrors - oldGagged);
gaggedErrors = oldGagged;
return anyErrs;
}
/**
* 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.
*/
extern (C++) void increaseErrorCount()
{
if (gag)
++gaggedErrors;
++errors;
}
extern (C++) void _init()
{
global.errorSink = new ErrorSinkCompiler;
this.fileManager = new FileManager();
version (MARS)
{
vendor = "Digital Mars D";
// -color=auto is the default value
import dmd.console : detectTerminal;
params.color = detectTerminal();
}
else version (IN_GCC)
{
vendor = "GNU D";
}
}
/**
* Deinitializes the global state of the compiler.
*
* This can be used to restore the state set by `_init` to its original
* state.
*/
extern (D) void deinitialize()
{
this = this.init;
}
/**
* Computes the version number __VERSION__ from the compiler version string.
*/
extern (D) private static uint parseVersionNumber(string version_)
{
//
// parse _version
//
uint major = 0;
uint minor = 0;
bool point = false;
// skip initial 'v'
foreach (const c; version_[1..$])
{
if ('0' <= c && c <= '9') // isdigit
{
minor = minor * 10 + c - '0';
}
else if (c == '.')
{
if (point)
break; // ignore everything after second '.'
point = true;
major = minor;
minor = 0;
}
else
break;
}
return major * 1000 + minor;
}
/**
Returns: the version as the number that would be returned for __VERSION__
*/
extern(C++) uint versionNumber()
{
return _versionNumber;
}
/**
Returns: compiler version string.
*/
extern(D) string versionString()
{
return _version;
}
/**
Returns: compiler version as char string.
*/
extern(C++) const(char*) versionChars()
{
return _version.ptr;
}
}
// Because int64_t and friends may be any integral type of the
// correct size, we have to explicitly ask for the correct
// integer type to get the correct mangling with dmd
// Be careful not to care about sign when using dinteger_t
// use this instead of integer_t to
// avoid conflicts with system #include's
alias dinteger_t = ulong;
// Signed and unsigned variants
alias sinteger_t = long;
alias uinteger_t = ulong;
/// Collection of global state
extern (C++) __gshared Global global;