672 lines
23 KiB
D
Executable file
672 lines
23 KiB
D
Executable file
#!/usr/bin/rdmd
|
|
|
|
/**
|
|
* License: Boost 1.0
|
|
*
|
|
* Copyright (c) 2009-2010 Eric Poggel, Changes 2011 Ferdinand Majerech
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*
|
|
* Description:
|
|
*
|
|
* This is a D programming language build script (and library) that can be used
|
|
* to compile D (version 1) source code. Unlike Bud, DSSS/Rebuild, Jake, and
|
|
* similar tools, CDC is contained within a single file that can easily be
|
|
* distributed with projects. This simplifies the build process since no other
|
|
* tools are required. The main() function can be utilized to turn
|
|
* CDC into a custom build script for your project.
|
|
*
|
|
* CDC's only requirement is a D compiler. It is/will be supported on any
|
|
* operating system supported by the language. It works with dmd, ldc (soon),
|
|
* and gdc.
|
|
*
|
|
* CDC can be used just like dmd, except for the following improvements.
|
|
* <ul>
|
|
* <li>CDC can accept paths as as well as individual source files for compilation.
|
|
* Each path is recursively searched for source, library, object, and ddoc files.</li>
|
|
* <li>CDC automatically creates a modules.ddoc file for use with CandyDoc and
|
|
* similar documentation utilities.</li>
|
|
* <li>CDC defaults to use the compiler that was used to build itself. Compiler
|
|
* flags are passed straight through to that compiler.</li>
|
|
* <li>The -op flag is always used, to prevent name conflicts in object and doc files.</li>
|
|
* <li>Documentation files are all placed in the same folder with their full package
|
|
* names. This makes relative links between documents easier.</li>
|
|
* </ul>
|
|
|
|
* These DMD/LDC options are automatically translated to the correct GDC
|
|
* options, or handled manually:
|
|
* <dl>
|
|
* <dt>-c</dt> <dd>do not link</dd>
|
|
* <dt>-D</dt> <dd>generate documentation</dd>
|
|
* <dt>-Dddocdir</dt> <dd>write fully-qualified documentation files to docdir directory</dd>
|
|
* <dt>-Dfdocfile</dt> <dd>write fully-qualified documentation files to docfile file</dd>
|
|
* <dt>-lib</dt> <dd>Generate library rather than object files</dd>
|
|
* <dt>-Ipath</dt> <dd>where to look for imports</dd>
|
|
* <dt>-o-</dt> <dd>do not write object file.</dd>
|
|
* <dt>-offilename</dt><dd>name output file to filename</dd>
|
|
* <dt>-odobjdir</dt> <dd>write object & library files to directory objdir</dd>
|
|
* </dl>
|
|
*
|
|
* In addition, these optional flags have been added.
|
|
* <dl>
|
|
* <dt>--dmd</dt> <dd>Use dmd to compile</dd>
|
|
* <dt>--gdc</dt> <dd>Use gdc to compile</dd>
|
|
* <dt>--ldc</dt> <dd>Use ldc to compile</dd>
|
|
* </dl>
|
|
*
|
|
* Bugs:
|
|
* <ul>
|
|
* <li>Doesn't yet work with LDC. See dsource.org/projects/ldc/ticket/323</li>
|
|
* <li>Dmd writes out object files as foo/bar.o, while gdc writes foo.bar.o</li>
|
|
* <li>Dmd fails to write object files when -od is an absolute path.</li>
|
|
* </ul>
|
|
*
|
|
* TODO:
|
|
* <ul>
|
|
* <li>Add support for a --script argument to accept another .d file that calls cdc's functions.</li>
|
|
* <li>-Df option</li>
|
|
* <li>GDC - Remove dependancy on "ar" on windows? </li>
|
|
* <li>LDC - Scanning a folder for files is broken. </li>
|
|
* <li>Unittests</li>
|
|
* <li>More testing on paths with spaces. </li>
|
|
* </ul>
|
|
*
|
|
* API:
|
|
* Use any of these functions in your own build script.
|
|
*/
|
|
|
|
|
|
import std.algorithm;
|
|
import std.array;
|
|
import std.exception;
|
|
import std.conv;
|
|
import std.file;
|
|
import std.path;
|
|
import std.process;
|
|
import std.range;
|
|
import std.string;
|
|
import std.stdio : writeln;
|
|
|
|
|
|
///Name of the default compiler, which is the compiler used to build cdc.
|
|
version(DigitalMars){string compiler = "dmd";}
|
|
version(GNU){string compiler = "gdmd";}
|
|
version(LDC){string compiler = "ldmd";}
|
|
|
|
version(Windows)
|
|
{
|
|
///Valid object file extensions.
|
|
const string[] obj_ext = ["obj", "o"];
|
|
///Library extension.
|
|
const string lib_ext = "lib";
|
|
///Binary executable extension.
|
|
const string bin_ext = "exe";
|
|
///Path separator character.
|
|
char file_separator ='\\';
|
|
}
|
|
else
|
|
{
|
|
///Valid object file extensions.
|
|
const string[] obj_ext = ["o"];
|
|
///Library extension.
|
|
const string lib_ext = "a";
|
|
///Binary executable extension.
|
|
const string bin_ext = "";
|
|
///Path separator character.
|
|
char file_separator ='/';
|
|
}
|
|
|
|
void main(string[] args)
|
|
{
|
|
string target = "release";
|
|
|
|
scope(failure){help(); core.stdc.stdlib.exit(-1);}
|
|
|
|
string[] extra_args = ["-w", "-wi"];
|
|
|
|
args = args[1 .. $];
|
|
foreach(arg; args)
|
|
{
|
|
if(arg[0] == '-') switch(arg)
|
|
{
|
|
case "--help", "-h": help(); return;
|
|
case "--dmd": compiler = "dmd"; break;
|
|
case "--gdc": compiler = "gdmd"; break;
|
|
case "--ldc": compiler = "ldmd"; break;
|
|
default: extra_args ~= arg;
|
|
}
|
|
}
|
|
if(args.length > 0 && args[$ - 1][0] != '-'){target = args[$ - 1];}
|
|
|
|
string[] dbg = ["-gc", "-debug"];
|
|
string[] optimize = ["-O", "-inline", "-release"];
|
|
string[] lib_src = ["dyaml/", "yaml.d"];
|
|
|
|
void compile_(string[] args, string[] files){compile(files, args ~ extra_args);}
|
|
|
|
void build_unittest()
|
|
{
|
|
writeln("building unittests");
|
|
compile_(dbg ~ ["-unittest", "-ofunittest"], lib_src ~ "unittest.d" ~ "test/src");
|
|
}
|
|
|
|
void build_debug()
|
|
{
|
|
writeln("building debug target");
|
|
compile_(dbg ~ ["-oflibdyaml-debug", "-lib"], lib_src);
|
|
}
|
|
|
|
void build_release()
|
|
{
|
|
writeln("building release target");
|
|
compile_(optimize ~ ["-oflibdyaml", "-lib"], lib_src);
|
|
}
|
|
|
|
void build_tar_gz()
|
|
{
|
|
if(system("git archive HEAD | gzip -9v > dyaml.tar.gz") != 0)
|
|
{
|
|
writeln("Error creating a tar.gz package.");
|
|
}
|
|
}
|
|
|
|
void build_tar_xz()
|
|
{
|
|
if(system("git archive HEAD | xz -9ev > dyaml.tar.xz ") != 0)
|
|
{
|
|
writeln("Error creating a tar.xz package.");
|
|
}
|
|
}
|
|
|
|
void build_zip()
|
|
{
|
|
if(system("git archive -odyaml.zip -9 HEAD") != 0)
|
|
{
|
|
writeln("Error creating a zip package");
|
|
}
|
|
}
|
|
|
|
void build(string[] targets ...)
|
|
{
|
|
foreach(target; targets)
|
|
{
|
|
switch(target)
|
|
{
|
|
//case "examples": build_examples(); break;
|
|
case "debug": build_debug(); break;
|
|
case "release": build_release(); break;
|
|
case "unittest": build_unittest(); break;
|
|
case "tar.gz": build_tar_gz(); break;
|
|
case "tar.xz": build_tar_xz(); break;
|
|
case "zip": build_zip(); break;
|
|
case "all": build("debug", "release", "unittest"); break;
|
|
default:
|
|
writeln("unknown build target: ", target);
|
|
writeln("available targets: 'debug', 'release', 'all'");
|
|
}
|
|
}
|
|
}
|
|
|
|
try{build(target);}
|
|
catch(CompileException e){writeln("Could not compile: " ~ e.msg);}
|
|
catch(ProcessException e){writeln("Compilation failed: " ~ e.msg);}
|
|
}
|
|
|
|
///Print help information.
|
|
void help()
|
|
{
|
|
string help =
|
|
"D:YAML build script\n"
|
|
"Changes Copyright (C) 2011 Ferdinand Majerech\n"
|
|
"Based on CDC script Copyright (C) 2009-2010 Eric Poggel\n"
|
|
"Usage: cdc [OPTION ...] [EXTRA COMPILER OPTION ...] [TARGET]\n"
|
|
"By default, cdc uses the compiler it was built with to compile the project.\n"
|
|
"\n"
|
|
"Any options starting with '-' not parsed by the script will be\n"
|
|
"passed to the compiler used.\n"
|
|
"\n"
|
|
"Optionally, build target can be specified, 'debug' is default.\n"
|
|
"Available build targets:\n"
|
|
" unittest Build unit tests.\n"
|
|
" debug Debug information, unittests, contracts built in.\n"
|
|
" No optimizations. Target binary name: 'pong-debug'\n"
|
|
" release Debug information, no unittests, contracts.\n"
|
|
" Optimizations, inlining enabled.\n"
|
|
" Target binary name: 'pong-release'\n"
|
|
" all All of the above.\n"
|
|
" tar.gz Needs git, gzip: Create a tar.gz package.\n"
|
|
" tar.xz Needs git, xz: Create a tar.xz package.\n"
|
|
" zip Needs zip: Create a zip package.\n"
|
|
"\n"
|
|
"Available options:\n"
|
|
" -h --help Show this help information.\n"
|
|
" --gdc Use GDC for compilation.\n"
|
|
" --dmd Use DMD for compilation.\n"
|
|
" --ldc Use LDC for compilation. (not tested)\n"
|
|
;
|
|
writeln(help);
|
|
}
|
|
|
|
/**
|
|
* Compile D code using the current compiler.
|
|
*
|
|
* Params: paths = Source and library files/directories. Directories are recursively searched.
|
|
* options = Compiler options.
|
|
*
|
|
* Example:
|
|
* --------
|
|
* //Compile all source files in src/core along with src/main.d,
|
|
* //link with all library files in the libs folder
|
|
* //and generate documentation in the docs folder.
|
|
* compile(["src/core", "src/main.d", "libs"], ["-D", "-Dddocs"]);
|
|
* --------
|
|
*
|
|
* TODO Add a dry run option to just return an array of commands to execute.
|
|
*/
|
|
static void compile(string[] paths, string[] options = null)
|
|
{
|
|
//Convert src and lib paths to files
|
|
string[] sources, libs, ddocs;
|
|
foreach(src; paths)
|
|
{
|
|
enforceEx!CompileException(exists(src),
|
|
"Source file/folder \"" ~ src ~ "\" does not exist.");
|
|
//Directory of source or lib files
|
|
if(isDir(src))
|
|
{
|
|
sources ~= scan(src, ".d");
|
|
ddocs ~= scan(src, ".ddoc");
|
|
libs ~= scan(src, lib_ext);
|
|
}
|
|
//File
|
|
else if(isFile(src))
|
|
{
|
|
string ext = src.extension();
|
|
if(ext == ".d"){sources ~= src;}
|
|
else if(ext == lib_ext){libs ~= src;}
|
|
}
|
|
}
|
|
|
|
//Add dl.a for dynamic linking on linux
|
|
version(linux){libs ~= ["-L-ldl"];}
|
|
|
|
//Combine all options, sources, ddocs, and libs
|
|
CompileOptions co = CompileOptions(options, sources);
|
|
options = co.get_options(compiler);
|
|
|
|
if(compiler == "gdc")
|
|
{
|
|
foreach(ref d; ddocs){d = "-fdoc-inc=" ~ d;}
|
|
//or should this only be version(Windows) ?
|
|
//TODO: Check in dmd and gdc
|
|
foreach(ref l; libs){l = "-L" ~ l;}
|
|
}
|
|
|
|
//Create modules.ddoc and add it to array of ddocs
|
|
if(co.generate_doc)
|
|
{
|
|
string modules = "MODULES = \r\n";
|
|
sources.sort;
|
|
foreach(src; sources)
|
|
{
|
|
//get filename
|
|
src = split(src, "\\.")[0];
|
|
src = replace(replace(src, "/", "."), "\\", ".");
|
|
modules ~= "\t$(MODULE " ~ src ~ ")\r\n";
|
|
}
|
|
scope(failure){remove("modules.ddoc");}
|
|
write("modules.ddoc", modules);
|
|
ddocs ~= "modules.ddoc";
|
|
}
|
|
|
|
string[] arguments = options ~ sources ~ ddocs ~ libs;
|
|
|
|
//Compile
|
|
if(compiler == "gdc")
|
|
{
|
|
//Add support for building libraries to gdc.
|
|
//GDC must build incrementally if creating documentation or a lib.
|
|
if(co.generate_lib || co.generate_doc || co.no_linking)
|
|
{
|
|
//Remove options we don't want to pass to gdc when building incrementally.
|
|
string[] incremental_options;
|
|
foreach(option; options)
|
|
{
|
|
if(option != "-lib" && !startsWith(option, "-o"))
|
|
{
|
|
incremental_options ~= option;
|
|
}
|
|
}
|
|
|
|
//Compile files individually, outputting full path names
|
|
string[] obj_files;
|
|
foreach(source; sources)
|
|
{
|
|
string obj = replace(source, "/", ".")[0 .. $ - 2] ~ ".o";
|
|
string ddoc = obj[0 .. $ - 2];
|
|
if(co.obj_directory !is null)
|
|
{
|
|
obj = co.obj_directory ~ file_separator ~ obj;
|
|
}
|
|
obj_files ~= obj;
|
|
string[] exec = incremental_options ~ ["-o" ~ obj, "-c"] ~ [source];
|
|
//ensure doc files are always fully qualified.
|
|
if(co.generate_doc){exec ~= ddocs ~ ["-fdoc-file=" ~ ddoc ~ ".html"];}
|
|
//throws ProcessException on compile failure
|
|
execute(compiler, exec);
|
|
}
|
|
|
|
//use ar to join the .o files into a lib and cleanup obj files
|
|
//TODO: how to join on GDC windows?
|
|
if(co.generate_lib)
|
|
{
|
|
//since ar refuses to overwrite it.
|
|
remove(co.out_file);
|
|
execute("ar", "cq " ~ co.out_file ~ obj_files);
|
|
}
|
|
|
|
//Remove obj files if -c or -od not were supplied.
|
|
if(!co.obj_directory && !co.no_linking)
|
|
{
|
|
foreach (o; obj_files){remove(o);}
|
|
}
|
|
}
|
|
|
|
if (!co.generate_lib && !co.no_linking)
|
|
{
|
|
//Remove documentation arguments since they were handled above
|
|
string[] nondoc_args;
|
|
foreach(arg; arguments)
|
|
{
|
|
if(!startsWith(arg, "-fdoc", "-od")){nondoc_args ~= arg;}
|
|
}
|
|
|
|
execute_compiler(compiler, nondoc_args);
|
|
}
|
|
}
|
|
//Compilers other than gdc
|
|
else
|
|
{
|
|
execute_compiler(compiler, arguments);
|
|
//Move all html files in doc_path to the doc output folder
|
|
//and rename them with the "package.module" naming convention.
|
|
if(co.generate_doc)
|
|
{
|
|
foreach(src; sources)
|
|
{
|
|
if(src.extension != ".d"){continue;}
|
|
|
|
string html = src[0 .. $ - 2] ~ ".html";
|
|
string dest = replace(replace(html, "/", "."), "\\", ".");
|
|
if(co.doc_directory.length > 0)
|
|
{
|
|
dest = co.doc_directory ~ file_separator ~ dest;
|
|
html = co.doc_directory ~ file_separator ~ html;
|
|
}
|
|
//TODO: Delete remaining folders where source files were placed.
|
|
if(html != dest)
|
|
{
|
|
copy(html, dest);
|
|
remove(html);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Remove extra files
|
|
string basename = split(co.out_file, "/")[$ - 1];
|
|
|
|
if(co.generate_doc){remove("modules.ddoc");}
|
|
if(co.out_file && !(co.no_linking || co.obj_directory))
|
|
{
|
|
foreach(ext; obj_ext)
|
|
{
|
|
//Delete object files with same name as output file that dmd sometimes leaves.
|
|
try{remove(co.out_file.setExtension(ext));}
|
|
catch(FileException e){continue;}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stores compiler options and translates them between compilers.
|
|
*
|
|
* Also enables -of and -op for easier handling.
|
|
*/
|
|
struct CompileOptions
|
|
{
|
|
public:
|
|
///Do not link.
|
|
bool no_linking;
|
|
///Generate documentation.
|
|
bool generate_doc;
|
|
///Write documentation to this directory.
|
|
string doc_directory;
|
|
///Write documentation to this file.
|
|
string doc_file;
|
|
///Generate library rather than object files.
|
|
bool generate_lib;
|
|
///Do not write object files.
|
|
bool no_objects;
|
|
///write object, library files to this directory.
|
|
string obj_directory;
|
|
///Name of output file.
|
|
string out_file;
|
|
|
|
private:
|
|
///Compiler options.
|
|
string[] options_;
|
|
|
|
public:
|
|
/**
|
|
* Construct CompileOptions from command line options.
|
|
*
|
|
* Params: options = Compiler command line options.
|
|
* sources = Source files to compile.
|
|
*/
|
|
this(string[] options, in string[] sources)
|
|
{
|
|
foreach (i, option; options)
|
|
{
|
|
if(option == "-c"){no_linking = true;}
|
|
else if(option == "-D" || option == "-fdoc"){generate_doc = true;}
|
|
else if(startsWith(option, "-Dd")){doc_directory = option[3..$];}
|
|
else if(startsWith(option, "-fdoc-dir=")){doc_directory = option[10..$];}
|
|
else if(startsWith(option, "-Df")){doc_file = option[3..$];}
|
|
else if(startsWith(option, "-fdoc-file=")){doc_file = option[11..$];}
|
|
else if(option == "-lib"){generate_lib = true;}
|
|
else if(option == "-o-" || option=="-fsyntax-only"){no_objects = true;}
|
|
else if(startsWith(option, "-of")){out_file = option[3..$];}
|
|
else if(startsWith(option, "-od")){obj_directory = option[3..$];}
|
|
else if(startsWith(option, "-o") && option != "-op"){out_file = option[2..$];}
|
|
options_ ~= option;
|
|
}
|
|
|
|
//Set the -o (output filename) flag to the first source file if not already set.
|
|
//This matches the default behavior of dmd.
|
|
string ext = generate_lib ? lib_ext : bin_ext;
|
|
if(out_file.length == 0 && !no_linking && !no_objects && sources.length > 0)
|
|
{
|
|
out_file = split(split(sources[0], "/")[$ - 1], "\\.")[0] ~ ext;
|
|
options_ ~= ("-of" ~ out_file);
|
|
}
|
|
version (Windows)
|
|
{
|
|
//TODO needs testing
|
|
//{ if (find(this.out_file, ".") <= rfind(this.out_file, "/"))
|
|
if(find(out_file, '.') <= retro(find(retro(out_file), '/')))
|
|
{
|
|
out_file ~= bin_ext;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Translate DMD compiler options to options of the target compiler.
|
|
*
|
|
* This function is incomplete. (what about -L? )
|
|
*
|
|
* Params: compiler = Compiler to translate to.
|
|
*
|
|
* Returns: Translated options.
|
|
*/
|
|
string[] get_options(in string compiler)
|
|
{
|
|
string[] result = options_.dup;
|
|
|
|
if(compiler != "gdc")
|
|
{
|
|
version(Windows)
|
|
{
|
|
foreach(ref option; result)
|
|
{
|
|
option = startsWith(option, "-of") ? replace(option, "/", "\\") : option;
|
|
}
|
|
}
|
|
|
|
//ensure ddocs don't overwrite one another.
|
|
return canFind(result, "-op") ? result : result ~ "-op";
|
|
}
|
|
|
|
//is gdc
|
|
string[string] translate;
|
|
translate["-Dd"] = "-fdoc-dir=";
|
|
translate["-Df"] = "-fdoc-file=";
|
|
translate["-debug="] = "-fdebug=";
|
|
translate["-debug"] = "-fdebug"; // will this still get selected?
|
|
translate["-inline"] = "-finline-functions";
|
|
translate["-L"] = "-Wl";
|
|
translate["-lib"] = "";
|
|
translate["-O"] = "-O3";
|
|
translate["-o-"] = "-fsyntax-only";
|
|
translate["-of"] = "-o ";
|
|
translate["-unittest"] = "-funittest";
|
|
translate["-version"] = "-fversion=";
|
|
translate["-version="] = "-fversion=";
|
|
translate["-wi"] = "-Wextra";
|
|
translate["-w"] = "-Wall";
|
|
translate["-gc"] = "-g";
|
|
|
|
//Perform option translation
|
|
foreach(ref option; result)
|
|
{
|
|
//remove unsupported -od
|
|
if(startsWith(option, "-od")){option = "";}
|
|
if(option =="-D"){option = "-fdoc";}
|
|
else
|
|
{
|
|
//Options with a direct translation
|
|
foreach(before, after; translate)
|
|
{
|
|
if(startsWith(option, before))
|
|
{
|
|
option = after ~ option[before.length..$];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
unittest
|
|
{
|
|
auto sources = ["foo.d"];
|
|
auto options = ["-D", "-inline", "-offoo"];
|
|
auto result = CompileOptions(options, sources).get_options("gdc");
|
|
assert(result[0 .. 3] == ["-fdoc", "-finline-functions", "-o foo"]);
|
|
}
|
|
}
|
|
|
|
///Thrown at errors in execution of other processes (e.g. compiler commands).
|
|
class CompileException : Exception
|
|
{
|
|
this(in string message, in string file, in size_t line){super(message, file, line);}
|
|
};
|
|
|
|
/**
|
|
* Wrapper around execute to write compile options to a file to get around max arg lenghts on Windows.
|
|
*
|
|
* Params: compiler = Compiler to execute.
|
|
* arguments = Compiler arguments.
|
|
*/
|
|
void execute_compiler(in string compiler, string[] arguments)
|
|
{
|
|
try
|
|
{
|
|
version(Windows)
|
|
{
|
|
write("compile", join(arguments, " "));
|
|
scope(exit){remove("compile");}
|
|
execute(compiler ~ " ", ["@compile"]);
|
|
}
|
|
else{execute(compiler, arguments);}
|
|
}
|
|
catch(ProcessException e)
|
|
{
|
|
writeln("Compiler failed: " ~ e.msg);
|
|
}
|
|
}
|
|
|
|
///Thrown at errors in execution of other processes (e.g. compiler commands).
|
|
class ProcessException : Exception {this(in string message){super(message);}};
|
|
|
|
/**
|
|
* Execute a command-line program and print its output.
|
|
*
|
|
* Params: command = The command to execute, e.g. "dmd".
|
|
* args = Arguments to pass to the command.
|
|
*
|
|
* Throws: ProcessException on failure or status code 1.
|
|
*/
|
|
void execute(string command, string[] args)
|
|
{
|
|
version(Windows)
|
|
{
|
|
if(startsWith(command, "./")){command = command[2 .. $];}
|
|
}
|
|
|
|
string full = command ~ " " ~ join(args, " ");
|
|
writeln("CDC: " ~ full);
|
|
if(int status = system(full) != 0)
|
|
{
|
|
throw new ProcessException("Process " ~ command ~ " exited with status " ~
|
|
to!string(status));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Recursively get all files with specified extensions in directory and subdirectories.
|
|
*
|
|
* Params: directory = Absolute or relative path to the current directory.
|
|
* extensions = Extensions to match.
|
|
*
|
|
* Returns: An array of paths (including filename) relative to directory.
|
|
*
|
|
* Bugs: LDC fails to return any results.
|
|
*/
|
|
string[] scan(in string directory, string extensions ...)
|
|
{
|
|
string[] result;
|
|
foreach(string name; dirEntries(directory, SpanMode.depth))
|
|
{
|
|
if(isFile(name) && endsWith(name, extensions)){result ~= name;}
|
|
}
|
|
return result;
|
|
}
|