W3cubDocs

/D

dmd.mars

Compiler implementation of the D programming language. Entry point for DMD.

This modules defines the entry point (main) for DMD, as well as related utilities needed for arguments parsing, path manipulation, etc... This file is not shared with other compilers which use the DMD front-end.

Authors:
Walter Bright
License:
Boost License 1.0
Source
mars.d
Documentation
https://dlang.org/phobos/dmd_mars.html
Coverage
https://codecov.io/gh/dlang/dmd/src/master/src/dmd/mars.d
void printInternalFailure(FILE* stream);

Print DMD's logo with more debug information and error-reporting pointers.

Parameters:
FILE* stream output stream to print the information on
int main(int argc, char** argv);

DMD's entry point, C main.

Without -lowmem, we need to switch to the bump-pointer allocation scheme right from the start, before any module ctors are run, so we need this hook before druntime is initialized and _Dmain is called.

Returns:
Return code of the application
int _Dmain(char[][]);

Manual D main (for druntime initialization), which forwards to tryMain.

Returns:
Return code of the application
void getenv_setargv(const(char)* envvalue, Strings* args);

Parses an environment variable containing command-line flags and append them to args.

This function is used to read the content of DFLAGS. Flags are separated based on spaces and tabs.

Parameters:
const(char)* envvalue The content of an environment variable
Strings* args Array to append the flags to, if any.
const(char)* parse_arch_arg(Strings* args, const(char)* arch);

Parse command line arguments for the last instance of -m32, -m64 or -m32mscoff to detect the desired architecture.

Parameters:
Strings* args Command line arguments
const(char)* arch Default value to use for architecture. Should be "32" or "64"
Returns:
"32", "64" or "32mscoff" if the "-m32", "-m64", "-m32mscoff" flags were passed, respectively. If they weren't, return arch.
const(char)[] parse_conf_arg(Strings* args);

Parse command line arguments for the last instance of -conf=path.

Parameters:
Strings* args Command line arguments
Returns:
The 'path' in -conf=path, which is the path to the config file to use
void setTarget(ref Param params);

Set the is target fields of params according to the TARGET value.

Parameters:
Param params where the is fields are
void addDefaultVersionIdentifiers(ref const Param params);

Add default version identifier for dmd, and set the target platform in params. https://dlang.org/spec/version.html#predefined-versions

Needs to be run after all arguments parsing (command line, DFLAGS environment variable and config file) in order to add final flags (such as X86_64 or the CRuntime used).

Parameters:
Param params which target to compile for (set by setTarget())
void flushMixins();

we want to write the mixin expansion file also on error, but there are too many ways to terminate dmd (e.g. fatal() which calls exit(EXIT_FAILURE)), so we can't rely on scope(exit) ... in tryMain() actually being executed so we add atexit(&flushMixins); for those fatal exits (with the GC still valid)

bool parseCommandLine(ref const Strings arguments, const size_t argc, ref Param params, ref Strings files);

Parse command line arguments.

Prints message(s) if there are errors.

Parameters:
Strings arguments command line arguments
size_t argc argument count
Param params set to result of parsing arguments
Strings files set to files pulled from arguments
Returns:
true if errors in command line
Modules createModules(ref Strings files, ref Strings libmodules);

Creates the list of modules based on the files provided

Files are dispatched in the various arrays (global.params.{ddocfiles,dllfiles,jsonfiles,etc...}) according to their extension. Binary files are added to libmodules.

Parameters:
Strings files File names to dispatch
Strings libmodules Array to which binaries (shared/static libs and object files) will be appended
Returns:
An array of path to D modules

© 1999–2019 The D Language Foundation
Licensed under the Boost License 1.0.
https://dlang.org/phobos/dmd_mars.html