dmd.utils

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)