root/trunk/buildme.d

/*
 * Copyright (c) 2004-2008 Derelict Developers
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the names 'Derelict' nor the names of its contributors
 *   may be used to endorse or promote products derived from this software
 *   without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
//==============================================================================
// Imports
//==============================================================================
module buildme;

version(Tango)
{
//    static assert(0, "Tango support for the build script is currently incomplete.");
    private
    {
        import tango.text.Ascii;
        import tango.text.Util;
        import tango.io.File;
        import tango.sys.Process;
        import tango.core.Version;
        import tango.stdc.stringz;
        import tango.stdc.stdio;
        import tango.io.FilePath;
        import tango.io.Stdout;
        import tango.sys.Environment;
    }
}
else
{
    private
    {
        import std.string;
        import std.path;
        import std.file;
        import std.c.process;
    }
}

//==============================================================================
// Constants
//==============================================================================
version(Windows)
{
    private static const char[] delCmd  = "cmd /c del ";
    private static const char[] pathSep     = "\\";
    private static const char[] libPre      = "";
    private static const char[] libExt      = ".lib";
}
else version(linux)
{
    version = NixConst;
}
else version(Unix)
{
    version = NixConst;
}

version(NixConst)
{
    private static const char[] delCmd      = "rm -f ";
    private static const char[] pathSep     = "/";
    private static const char[] libPre      = "lib";
    private static const char[] libExt      = ".a";
}

// this must be set in a static class constructor in the builder file
private Builder theBuilder = null;

//==============================================================================
// Options
//==============================================================================
// build configurations
enum Mode
{
    Debug,
    Release
}
private Mode mode = Mode.Release;

// option file types
enum OptsType
{
    Debug,
    Release,
    Common
}

// when true, do not delete the temporary Build Response File for Bud
private bool doNotDeleteBRF = false;

//==============================================================================
// Main
//==============================================================================
void main(char[][] args)
{
    // check if the first arg is the cleanlib argument
    if(args.length == 2 && (cmpStr(toLowerStr(args[1]), "cleanlib") == 0))
    {
        cleanLib();
        return;
    }

    // list of package names passed on the command line
    char[][] packageList;

    // parse the command line
    foreach(c; args)
    {
        char[] lower = toLowerStr(c);
        switch(lower)
        {
            case "bud":
                theBuilder = new BudBuilder();
                break;
            case "debug":
                mode = Mode.Debug;
                break;
            case "release":
                mode = Mode.Release;
                break;
            case "nodelbrf":
                doNotDeleteBRF = true;
                break;
            default:
                if(findStr(lower, "derelict") == 0)
                {
                    packageList ~= c;
                }
                break;
        }
    }

    theBuilder.build(packageList);
}

//==============================================================================
// CleanLib -- this is a special command that doesn't warrant a builder class
//==============================================================================
void cleanLib()
{
    printf("[BuildMe] Deleting all %s files from the lib subdirectory...\n", toCString(libExt));
    execute(delCmd ~ "lib" ~ pathSep ~ "*" ~ libExt);
    printf("[BuildMe] Finished!\n\n");
}

//==============================================================================
// Builder Class
//==============================================================================
class Builder
{
    abstract void buildPackage(char[] packageName);

private:
    void build(char[][] packageList)
    {
        // if no packages were passed in, scan for buildable packages
        if(packageList.length == 0 || packageList is null)
        {
            scanForPackages();
        }
        else
        {
            // iterate the package list and build each package
            foreach(s; packageList)
            {
                buildPackage(s);
            }
        }
    }

    void scanForPackages()
    {
        printf("\n[BuildMe] Scanning for buildable packages...\n\n");

        // cycle through every Derelict directory to find buildable packages
        version(Tango)
        {
            bool filter(FilePath p, bool isDir)
            {
                char[] name = p.name;
                if(isDir && name[0] != '.')
                    return true;
                return false;
            }
            scope dir = new FilePath(".");
            foreach(p; dir.toList(&filter))
            {
                processPackage(p.name);
            }
        }
        else
        {
            auto list = listdir(".");
            foreach(c; list)
            {
                // if this filename is a directory, process it for building
                if(isdir(c) && c[0] != '.')
                    processPackage(c);
            }
        }

        printf("[BuildMe] Finished!\n\n");
    }

    void processPackage(char[] packageName)
    {
        // test if the package is buildable
        if(findStr(packageName, "Derelict") != 0)
        {
            printf("[BuildMe] Nothing to do for directory \'%s\'\n", toCString(packageName));
        }
        else
        {
            buildPackage(packageName);
        }
    }
}

//==============================================================================
// BudBuilder -- for building with the Bud tool
//==============================================================================
class BudBuilder : Builder
{
    static this()
    {
        theBuilder = new BudBuilder();
    }

    //==========================================================================
    // Methods
    //==========================================================================
    override void buildPackage(char[] packageName)
    {
        // construct a path to the package's forbud file
        char[] path = packageName ~ pathSep ~ _forBudName;

        // create the temporary brf
        printf("[BuildMe] Preparing to build package %s in %s mode...\n", toCString(packageName), toCString(modeToString()));
        if(!createBRF(packageName, path))
            return false;

        // call out to build with the name of the temp brf as an arg
        printf("[BuildMe] Building %s...\n", toCString(packageName));
        if(execute(_name ~ " @" ~ _tempBRFName) != 0)
        {
            throw new Exception("Failed to build package " ~ packageName);
        }

        if(!doNotDeleteBRF)
        {
            // delete the temporary brf
            printf("[BuildMe] Deleting temporary Build Response File...\n\n");
            execute(delCmd ~ _tempBRFName);
        }
    }

private:
    this()
    {
        _name               = "bud";
        _tempBRFName        = "temp.brf";
        _forBudName         = "forbud.txt";
        _brfBuf             = "";

        _brfBuf = loadOpts(_name, OptsType.Common) ~ "\n";
        _brfBuf ~= loadOpts(_name, cast(OptsType)mode);
    }

    bool createBRF(char[] packageName, char[] path)
    {
        printf("[BuildMe] Reading build tool arguments...\n");

        char[] txt;         // holds the contents of the forbud file

        // read the forbud.txt in this package
        txt = readFile(path);

        // make sure the file was found
        if(txt is null)
        {
            printf("[BuildMe] Could not find %s\n", toCString(path));
            return false;
        }

        // this will store all of the text to be output to the temp brf
        char[] brf = "";

        // append the common brf buffer
        brf ~= _brfBuf;

        // the package directory myst be on the import path
        brf ~= "\n-I" ~ packageName;

        // if the current package is not DerelictUtil, then DerelictUtil must
        // be on the import path and excluded from compilation
        if(cmpStr(packageName, "DerelictUtil") != 0)
        {
            brf ~= "\n-IDerelictUtil\n-XDerelictUtil" ~ pathSep ~ "derelict" ~ pathSep ~ "util";
        }

        // append a switch to set the output path of the library and append the config file
        brf ~= "\n-Tlib" ~ pathSep ~ libPre ~ packageName ~ libExt ~ "\n" ~ txt;

        // write the temporary brf to disk
        printf("[BuildMe] Creating temporary Build Response File...\n");

        writeFile(_tempBRFName, brf);

        return true;
    }

    //==========================================================================
    // Members
    //==========================================================================
    char[] _name;
    char[] _tempBRFName;
    char[] _forBudName;
    char[] _brfBuf;
}

//==============================================================================
// Utility functions
//==============================================================================
char[] modeToString()
{
    return (mode == Mode.Debug) ? "Debug" : "Release";
}

char[] loadOpts(char[] prefix, OptsType type)
{
    char[] fileName = "buildopts" ~ pathSep ~ prefix ~ optsSuffix(type) ~ ".txt";
    char[] ret = readFile(fileName);
    if(ret is null)
    {
        throw new Exception(fileName ~ " is missing!");
    }
    return ret;
}

char[] optsSuffix(OptsType type)
{
    switch(type)
    {
        case OptsType.Common:
            return "_common";
        case OptsType.Release:
            return "_release";
        case OptsType.Debug:
            return "_debug";
        default:
            throw new Exception("Unknown OptsType");
    }
}

//==============================================================================
// Phobos/Tango Wrappers
//==============================================================================
char[] toLowerStr(char[] str)
{
    version(Tango)
    {
        return toLower(str.dup);
    }
    else
    {
        return tolower(str);
    }
}

int cmpStr(char[] a, char[] b)
{
    version(Tango)
    {
        return compare(a,b);
    }
    else
    {
        return cmp(a,b);
    }
}

int findStr(char[] str, char[] match)
{
    version(Tango)
    {
        int i = locatePattern(str, match);
        return (i == str.length) ? -1 : i;
    }
    else
    {
        return find(str, match);
    }
}

char[][] splitString(char[] str, char[] delim)
{
    return split(str, delim);
}

char *toCString(char[] str)
{
    version(Tango)
    {
        return toStringz(str);
    }
    else
    {
        return toStringz(str);
    }
}

int execute(char[] cmd)
{
    version(Tango)
    {
        auto p = new Process(cmd, Environment.get);
        p.execute();
//        Stdout.stream.copy(p.stdout);
        auto r = p.wait();
        return r.status;
    }
    else
    {
        return system(toStringz(cmd));
    }
}

char[] readFile(char[] name)
{
    version(Tango)
    {
        scope f = new File(name);
        return cast(char[])f.read();
    }
    else
    {
        if(exists(name))
            return cast(char[])read(name);
        else
            return null;
    }
}

void writeFile(char[] name, char[] contents)
{
    version(Tango)
    {
        scope f = new File(name);
        f.write(cast(void[])contents);
    }
    else
    {
        write(name, cast(void[])contents);
    }
}