Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
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 a local clone.

dmd.mars

This modules defines related utilities needed for arguments parsing, path manipulation, etc... This file is not shared with other compilers which use the DMD front-end.
Authors:

Source mars.d

void logo();
Print DMD's logo on stdout
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
void usage();
Print DMD's usage message on stdout
bool generateJson(ref Modules modules, ErrorSink eSink);
Generate JSON file.
Parameters:
Modules modules Modules
ErrorSink eSink error message sink
Returns:
true on error
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, -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", or "64" if the "-m32", "-m64" 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
pure @safe void setDefaultLibraries(const ref Target target, ref const(char)[] defaultlibname, ref const(char)[] debuglibname);
Set the default and debug libraries to link against, if not already set
Must be called after argument parsing is done, as it won't override any value. Note that if -defaultlib= or -debuglib= was used, we don't override that either.
Parameters:
Target target parameters set by user
const(char)[] defaultlibname set based on target
const(char)[] debuglibname set based on target
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(const ref Strings arguments, const size_t argc, ref Param params, ref Strings files, ref Target target, ref DMDparams driverParams, ErrorSink eSink);
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
Target target more things set to result of parsing arguments
DMDparams driverParams even more things to set
ErrorSink eSink error sink
Returns:
true if errors in command line
bool createModules(ref Strings files, ref Strings libmodules, const ref Target target, ErrorSink eSink, ref Modules modules);
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
Target target target system
ErrorSink eSink error message sink
Modules modules empty array of modules to be filled in
Returns:
true on error
Module moduleWithEmptyMain();
Returns:
a compiled module (semantic3) containing an empty main() function, for the -main flag