root/buildHelper.d

// Written in The D Programming Language
/// Script to build DDMD
import std.file;
import std.getopt;
import std.path;
import std.process;
import std.stdio;
import std.string: replace, format;
import std.zip;

enum dmdVersionDefault = "2.040";
enum dmdArchiveBaseURL = "http://ftp.digitalmars.com/";
enum dmd = "dmd";

version(Windows)
{
    enum scriptName = "build.bat";
    enum osSubDir   = "windows";
    enum configFile = "sc.ini";
    enum execExt    = ".exe";
    enum dmdLib = "dmd.lib";
}
else
{
    version (OSX)
        enum osSubDir   = "osx";

    else version (linux)
        enum osSubDir   = "linux";

    enum scriptName = "./build.sh";
    enum configFile = "dmd.conf";
    enum execExt    = "";
    enum dmdLib = "libdmd.a";
}

string dmdVersion;
string dmdPackage;
string dmdArchive;
string dmBase="";
bool shouldDownload;

void doCopy(string from, string to)
{
    from = normFilePath(from);
    to   = normFilePath(to);
    
    writefln(`copy "%s" "%s"`, from, to);
    copy(from, to);
}

void doChDir(string dir)
{
    dir = normDirPath(dir);
    
    writefln(`chdir "%s"`, dir);
    chdir(dir);
}

int doSystem(string cmd)
{
    writeln(cmd);
    stdout.flush();
    return system(cmd);
}

void copyRecurse(string from, string to)
{
    from = normDirPath(from)[0..$-1];
    to   = normDirPath(to)[0..$-1];
    version(Windows)
        doSystem(`xcopy "%s" "%s" /E /I /Y /Q`.format(from, to));
    else
        doSystem(`cp '%s' '%s' -r`.format(from, to));
}

void copyAndPatch(string from, string to, void delegate(ref string) patcher)
{
    auto data = cast(string)read(from);
    patcher(data);
    std.file.write(to, data);
}

/// makePath("C:\foo\bar\dir") will create "C:\foo\bar\dir" if it doesn't already exist.
/// makePath("C:\foo\bar\dir\") will create "C:\foo\bar\dir" if it doesn't already exist.
void makePath(string dir)
{
    dir = normDirPath(dir)[0..$-1];
    if(!exists(dir))
        mkdirRecurse(dir);
}

/// makePathTo("C:\foo\bar\file.txt") will create "C:\foo\bar\" if it doesn't already exist.
/// makePathTo("C:\foo\bar\dir\") will create "C:\foo\bar\" if it doesn't already exist.
void makePathTo(string file)
{
    file = normFilePath(file);
    auto dir = dirname(file);
    makePath(dir);
}

/// Ensure trailing slash and OS-correct path separators
string normDirPath(string str)
{
    str = normPathSep(str);
    if(str.length > 0 && str[$-1] != sep[0])
        str ~= sep;
    
    return str;
}

/// Ensure no trailing slash and OS-correct path separators
string normFilePath(string str)
{
    str = normPathSep(str);
    if(str.length > 0 && str[$-1] == sep[0])
        str = str[0..$-1];
    
    return str;
}

/// Ensure OS-correct path separators
string normPathSep(string str)
{
    version(Windows)
        str = str.replace("/", "\\");
    else
        str = str.replace("\\", "/");
    
    return str;
}

unittest
{
    version(Windows)
    {
        assert(normDirPath ("C:\\a/b\\c/d"  ) == "C:\\a\\b\\c\\d\\");
        assert(normDirPath ("C:\\a/b\\c/d\\") == "C:\\a\\b\\c\\d\\");
        assert(normDirPath ("C:\\a/b\\c/d/" ) == "C:\\a\\b\\c\\d\\");
        assert(normFilePath("C:\\a/b\\c/d"  ) == "C:\\a\\b\\c\\d"  );
        assert(normFilePath("C:\\a/b\\c/d\\") == "C:\\a\\b\\c\\d"  );
    }
    else
    {
        assert(normDirPath ("\\a/b\\c/d"  ) == "/a/b/c/d/");
        assert(normDirPath ("\\a/b\\c/d\\") == "/a/b/c/d/");
        assert(normDirPath ("\\a/b\\c/d/" ) == "/a/b/c/d/");
        assert(normFilePath("\\a/b\\c/d"  ) == "/a/b/c/d" );
        assert(normFilePath("\\a/b\\c/d\\") == "/a/b/c/d" );
    }
}

bool initialSetup()
{
    writeln("Running initial setup...");
    
    makePath("bin");
    
    // Download dmd zip
    if(!exists(dmdArchive) && shouldDownload)
        doSystem("wget "~dmdArchiveBaseURL~dmdArchive);

    // Extract dmd zip
    writeln("Extracting dmd archive...");
    if(exists("dmd2"))
        rmdirRecurse("dmd2");
    auto zip = new ZipArchive(std.file.read(dmdArchive));
    foreach(member; zip.directory)
    {
        makePathTo(member.name);
        std.file.write(member.name, zip.expand(member));
    }
    
    // Make mars2.c with 'main' hidden
    doChDir("dmd2/src/dmd");
    copyAndPatch("mars.c", "mars2.c", (ref string data) {
        data = data.replace("int main(int argc, char *argv[])", "int HIDE_main(int argc, char *argv[])");
    });
    
    copyAndPatch("util.c", "util.c", (ref string data) {
        data = data.replace("void util_assert(char *file,int line)", "void HIDE_util_assert(char *file,int line)");
    });

    // Apply patch
    doChDir("../../..");
    doChDir("dmd2");
    doSystem("patch -p1 --binary < " ~ normFilePath("../dmdpatch.patch"));
    
    // Setup makefile for dmd.lib
    doChDir("..");
    doChDir("dmd2/src/dmd");
    version(Windows)
        enum makefile = "win32.mak";
    else
    {
        version (linux)
            enum makefile = "linux_lib.mak";

        else version (OSX)
            enum makefile = "osx_lib.mak";

        doCopy("../../../"~makefile, makefile);
    }

    version(Windows)
    copyAndPatch(makefile, makefile, (ref string data) {
        if(dmBase == "")
        {
            data = data.replace("\nCC=$(SCROOT)\\bin\\dmc", "\nCC=dmc");
            data = data.replace("\nLIB=$(SCROOT)\\bin\\lib", "\nLIB=lib");
        }
        else
            data = data.replace("\nD=", "\nD="~dmBase);
    });

    
    // Build dmd.lib
    version(Windows)
        doSystem("make deblib -f"~makefile);
    else
        doSystem("make -f"~makefile);
    doCopy(dmdLib, "../../../" ~ dmdLib);
    
    // Copy and patch config file
    doChDir("../../..");
    copyAndPatch(
        normFilePath("dmd2/"~osSubDir~"/bin/"~configFile),
        normFilePath("bin/"~configFile),
        (ref string data) {
            data = data.replace(normDirPath("../.."), normDirPath("../dmd2"));
            data = data.replace(normDirPath("../lib")[0 .. $ - 1], normDirPath("../dmd2/"~osSubDir~"/lib")[0 .. $ - 1]);
        }
    );

    // Copy linker
    version (Windows)
        doCopy("dmd2/"~osSubDir~"/bin/link"~execExt, "bin/link"~execExt);

    return true;
}

int main(string[] args)
{
    endOfOptions = "";
    bool help;
    bool shouldSetup;
    bool debugOnly;
    bool releaseOnly;
    dmdVersion = dmdVersionDefault;
    getopt(
        args,
        std.getopt.config.caseSensitive,
        "setup",      &shouldSetup,
        "debug|d",    &debugOnly,
        "release|r",  &releaseOnly,
        "ver",        &dmdVersion,
        "download",   &shouldDownload,
        "dmbase",     &dmBase,
        "help|h|H|?", &help
    );
    
    dmdPackage = "dmd."~dmdVersion;
    dmdArchive = dmdPackage~".zip";

    auto helpMsg = 
`This script will compile DDMD

Note that this script must be run from the main DDMD directory.

Also, make sure you have GNU patch installed and current versions
of DMC and DMD (D2) on the PATH. (DMC is only needed on Windows.)

Usage:
    `~scriptName~` [options...]
    
    --help,-h,-H,-?  Display this help message
    --debug,-d       Only build debug version
    --release,-r     Only build release version
    --ver={ver}      Base DDMD off specific DMD version (default: `~dmdVersionDefault~`)
    --setup          Run initial setup
    --download       If running initial setup and the dmd zip doesn't exist,
                     use wget to download it
    --dmbase={path}  Path to directory containing 'dm' for building dmd.lib
                     (Optional if --setup is used, otherwise ignored)
`;

    // Assume the user meant they wanted both.
    if(debugOnly && releaseOnly)
    {
        debugOnly = releaseOnly = false;
    }
    
    if(
        help ||
        ( shouldSetup && !exists(dmdArchive) && !shouldDownload    ) ||
        ( shouldSetup && exists(dmdArchive) && !isFile(dmdArchive) )
    )
    {
        write(helpMsg);
        return 1;
    }
    
    if( !shouldSetup && (!exists(dmdLib) || !isFile(dmdLib)) )
    {
        auto needSetupMsg = 
`'`~dmdLib~`' has not been built so you need to run the initial setup:

If you have GNU wget installed, just run:
  `~scriptName~` --setup --download

If you don't have wget, download a copy of `~dmdArchive~` to this
directory. It can be obtained from:
  `~dmdArchiveBaseURL~dmdArchive~`
Then run:
  `~scriptName~` --setup

For a full list of options, run:
  `~scriptName~` --help
`;

        write(needSetupMsg);
        return 1;
    }

    if(shouldSetup)
    {
        if(!initialSetup())
            return 1;
    }
    
    int ret=0;
    version(Windows)
    {
        system("cls");
        if(ret == 0) ret = doSystem(r"dmc.exe bridge\bridge.cpp -c");
        if(!releaseOnly) if(ret == 0) ret = doSystem(dmd ~ r" -debug -g @commands.txt");
        if(!debugOnly)   if(ret == 0) ret = doSystem(dmd ~ r" -release -O -inline @commands.txt");
    }
    else
    {
        version (linux)
            auto commands = "@commands.linux.txt";

        else version (OSX)
            auto commands = "@commands.osx.txt";

        if(ret == 0) ret = doSystem("g++ -m32 -c bridge/bridge.cpp -obridge.o");
        if(!releaseOnly) if(ret == 0) ret = doSystem(dmd ~ " -debug -gc " ~ commands);
        if(!debugOnly)   if(ret == 0) ret = doSystem(dmd ~ " -release -O -inline " ~ commands);
    }
    
    return ret;
}