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.utils

This module defines some utility functions for DMD.
Authors:

Source utils.d

nothrow const(char)* toWinPath(const(char)* src);
Normalize path by turning forward slashes into backslashes
Parameters:
const(char)* src Source path, using unix-style ('/') path separators
Returns:
A newly-allocated string with '/' turned into backslashes
nothrow bool readFile(Loc loc, const(char)[] filename, ref OutBuffer buf);
Reads a file, terminate the program on error
Parameters:
Loc loc The line number information from where the call originates
const(char)[] filename Path to file
OutBuffer buf append contents of file to
Returns:
true on failure
nothrow bool writeFile(Loc loc, const(char)[] filename, const void[] data);
Writes a file, terminate the program on error
Parameters:
Loc loc The line number information from where the call originates
const(char)[] filename Path to file
void[] data Full content of the file to be written
Returns:
false on error
nothrow bool ensurePathToNameExists(Loc loc, const(char)[] name);
Ensure the root path (the path minus the name) of the provided path exists, and terminate the process if it doesn't.
Parameters:
Loc loc The line number information from where the call originates
const(char)[] name a path to check (the name is stripped)
Returns:
false on error
nothrow void escapePath(OutBuffer* buf, const(char)* fname);
Takes a path, and escapes '(', ')' and backslashes
Parameters:
OutBuffer* buf Buffer to write the escaped path to
const(char)* fname Path to escape
nothrow void writeEscapedMakePath(ref OutBuffer buf, const(char)* fname);
Takes a path, and make it compatible with GNU Makefile format.
GNU make uses a weird quoting scheme for white space. A space or tab preceded by 2N+1 backslashes represents N backslashes followed by space; a space or tab preceded by 2N backslashes represents N backslashes at the end of a file name; and backslashes in other contexts should not be doubled.
Parameters:
OutBuffer buf Buffer to write the escaped path to
const(char)* fname Path to escape
Examples:
version (Windows)
{
    enum input = `C:\My Project\file#4$.ext`;
    enum expected = `C:\My\ Project\file\#4$$.ext`;
}
else
{
    enum input = `/foo\bar/weird$.:name#\ with spaces.ext`;
    enum expected = `/foo\bar/weird$$.\:name\#\\\ with\ spaces.ext`;
}

OutBuffer buf;
buf.writeEscapedMakePath(input);
assert(buf[] == expected);
pure nothrow @nogc @safe bool parseDigits(T)(ref T val, const(char)[] p, const T max = T.max);
Convert string to integer.
Parameters:
T Type of integer to parse
T val Variable to store the result in
const(char)[] p slice to start of string digits
T max max allowable value (inclusive), defaults to T.max
Returns:
false on error, true on success
Examples:
byte b;
ubyte ub;
short s;
ushort us;
int i;
uint ui;
long l;
ulong ul;

assert(b.parseDigits("42") && b  == 42);
assert(ub.parseDigits("42") && ub == 42);

assert(s.parseDigits("420") && s  == 420);
assert(us.parseDigits("42000") && us == 42_000);

assert(i.parseDigits("420000") && i  == 420_000);
assert(ui.parseDigits("420000") && ui == 420_000);

assert(l.parseDigits("42000000000") && l  == 42_000_000_000);
assert(ul.parseDigits("82000000000") && ul == 82_000_000_000);

assert(!b.parseDigits(ubyte.max.stringof));
assert(!b.parseDigits("WYSIWYG"));
assert(!b.parseDigits("-42"));
assert(!b.parseDigits("200"));
assert(ub.parseDigits("200") && ub == 200);
assert(i.parseDigits(int.max.stringof) && i == int.max);
assert(i.parseDigits("420", 500) && i == 420);
assert(!i.parseDigits("420", 400));
nothrow ubyte[] arrayCastBigEndian(const ubyte[] data, size_t size);
Cast a ubyte[] to an array of larger integers as if we are on a big endian architecture
Parameters:
ubyte[] data array with big endian data
size_t size 1 for ubyte[], 2 for ushort[], 4 for uint[], 8 for ulong[]
Returns:
copy of data, with bytes shuffled if compiled for version(LittleEndian)