root/branches/bud/dsss_build/build.d

/* *******************************************************
   Build is a tool to assist building applications and libraries written
   using the D programming language.

 Copyright:
   (c) 2005 Derek Parnell
   (c) 2006 Gregor Richards
 Authors:
   Derek Parnell, Melbourne
   Gregor Richards
 Initial Creation: January 2005
 Version: 3.04+DSSS
 Date: October 2006
 License:
        This software is provided 'as-is', without any express or implied
        warranty. In no event will the authors be held liable for damages
        of any kind arising from the use of this software.
        Permission is hereby granted to anyone to use this software for any
        purpose, including commercial applications, and to alter it and/or
        redistribute it freely, subject to the following restrictions:$(NL)
        1. The origin of this software must not be misrepresented; you must
           not claim that you wrote the original software. If you use this
           software in a product, an acknowledgment within documentation of
           said product would be appreciated but is not required.$(NL)
        2. Altered source versions must be plainly marked as such, and must
           not be misrepresented as being the original software.$(NL)
        3. This notice may not be removed or altered from any distribution
           of the source.$(NL)
        4. Derivative works are permitted, but they must carry this notice
           in full and credit the original source.
******************************************************* */

module build;
private import build_bn;    // This module's build number

version(unix)   version = Unix;
version(Unix)   version = Posix;
version(linux)  version = Posix;
version(darwin) version = Posix;
version(DigitalMars) version(Windows) version = UseResponseFile;

version(build)
{
    version(Windows) {
        // OptLink Definition File
        pragma (build_def, "VERSION 3.04");
    }
}


private{
    alias char[] string;
    // --------- imports ----------------
    static import source;          // Source File class

    static import util.str;        // non-standard string routines.
    static import util.fdt;        // File Date-Time class
    static import util.pathex;     // Extended Path routines.
    static import util.fileex;     // Extended File routines.
    static import util.macro;      // Macro processing routines.
    static import util.booltype;   // definition of True and False
    alias util.booltype.True True;
    alias util.booltype.False False;
    alias util.booltype.Bool Bool;

    static import std.c.stdio;
    static import std.file;
    static import std.outbuffer;
    static import std.path;
    static import std.stdio;
    static import std.stream;
    static import std.string;

    version(Windows)
    {
        static import std.c.windows.windows;
    }

    else version(linux)
    {
        static import std.c.linux.linux;
    }

    else version(darwin)
    {
        static import std.c.darwin.darwin;
    }

    // --------- C externals ----------------
    extern (C)
    {
        int     system  (char *);
    }

    class BuildException : Error
    {
        this(string pMsg)
        {
            super (vAppName ~ ":" ~ pMsg);
        }
    }

    // --------- enums ----------------
    enum LibOpt {Implicit, Build, Shared, DontBuild}

    // --------- internal strings ----------------
    version(Windows) {
        string vExeExtension=`exe`;
        string vLibExtension=`lib`;
        string vObjExtension=`obj`;
        string vShrLibExtension=`dll`;
        string vLinkerStdOut = ">nul";
    }

    version(Posix) {
        string vExeExtension=``;
        string vLibExtension=`a`;
        string vObjExtension=`o`;
        string vShrLibExtension=`so`;
        string vLinkerStdOut = ">/dev/null";
    }
    string vSrcExtension=`d`;
    string vSrcDInterfaceExt = `di`;
    string vMacroExtension=`mac`;
    string vDdocExtension=`ddoc`;

    // ---------- Module scoped globals -----------
    version(DigitalMars) {
        version(Windows) {
            string vCompilerExe=`dmd.exe`;
            string vCompileOnly = `-c`;
            string vLinkerExe=`link.exe`;
            bool   vPostSwitches = true;
            bool   vAppendLinkSwitches = true;
            string vArgDelim = ",";
            string vArgFileDelim = "+";
            string vConfigFile=`sc.ini`;
            string vCompilerPath=``;
            string vLinkerPath=``;
            string vLinkerDefs=`/noi/map`;
            string vConfigPath=``;
            string vLibPaths = ``;
            string vConfigSep = ";";
            string vLibrarian = `lib.exe`;
            string vLibrarianOpts = `-c -p256`;
            string vPostLibrarian = ``;
            bool   vShLibraries = false;
            string vShLibrarian = "";
            string vShLibrarianOpts = "";
            string vShLibrarianOutFileSwitch = "";
            string vHomePathId = "HOME";
            string vEtcPath    = "";
            string vSymInfoSwitch = "/co";
            string vOutFileSwitch = "-of";
            string vLinkLibSwitch = "";
        }

        version(Posix) {
            string vCompilerExe=`dmd`;
            string vCompileOnly= `-c`;
            string vLinkerExe=`gcc`;
            bool   vPostSwitches = false;
            bool   vAppendLinkSwitches = false;
            string vArgDelim = " ";
            string vArgFileDelim = " ";
            string vConfigFile=`dmd.conf`;
            string vCompilerPath=``;
            string vLinkerPath=``;
            string vLinkerDefs=``;
            string vConfigPath=`/etc/`;
            string vLibPaths = ``;
            string vConfigSep = ":";
            string vLibrarian = `ar`;
            string vLibrarianOpts = `-r`;
            string vPostLibrarian = `ranlib`;
            bool   vShLibraries = false;
            string vShLibrarian = "";
            string vShLibrarianOpts = "";
            string vShLibrarianOutFileSwitch = "";
            string vHomePathId = "HOME";
            string vEtcPath    = "/etc/";
            string vSymInfoSwitch = "-g";
            string vOutFileSwitch = "-o ";
            string vLinkLibSwitch = "-l";
        }

        string     vVersionSwitch = "-version";
        string     vDebugSwitch = "-debug";
        string[]   vCompilerDefs;
        string     vImportPath = "-I";
        bool       vUseModBaseName = false;
        
        // circular dependency things
        bool       vCircularDepsOK = true;
        bool       vCircularLinkAll = false;
        string     vCircularOnlyFlag = "";
    }

    version(GNU) {
        version(Windows) {
            string vCompilerExe=`gdc.exe`;
            string vCompileOnly= `-c`;
            string vLinkerExe=`gdc.exe`;
            bool   vPostSwitches = false;
            bool   vAppendLinkSwitches = false;
            string vArgDelim = " ";
            string vArgFileDelim = " ";
            string vConfigFile=null;
            string vCompilerPath=``;
            string vLinkerPath=``;
            string vLinkerDefs=``;
            string vConfigPath=null;
            string vLibPaths = ``;
            string vConfigSep = ";";
            string vLibrarian = `ar.exe`;
            string vLibrarianOpts = `-c`;
            string vPostLibrarian = `ranlib.exe`;
            bool   vShLibraries = false;
            string vShLibrarian = "";
            string vShLibrarianOpts = "";
            string vShLibrarianOutFileSwitch = "";
            string vLinkLibSwitch = "-l";
            string vHomePathId = "HOME";
            string vEtcPath    = "";
        }

        version(Posix) {
            string vCompilerExe=`gdc`;
            string vCompileOnly= `-c`;
            string vLinkerExe=`gdc`;
            bool   vPostSwitches = false;
            bool   vAppendLinkSwitches = false;
            string vArgDelim = " ";
            string vArgFileDelim = " ";
            string vConfigFile=null;
            string vCompilerPath=``;
            string vLinkerPath=``;
            string vLinkerDefs=``;
            string vConfigPath=null;
            string vLibPaths = ``;
            string vConfigSep = ":";
            string vLibrarian = `ar`;
            string vLibrarianOpts = `-r`;
            string vPostLibrarian = `ranlib`;
            bool   vShLibraries = true;
            string vShLibrarian = `gcc`;
            string vShLibrarianOpts = `-shared`;
            string vShLibrarianOutFileSwitch = `-o `;
            string vLinkLibSwitch = "-l";
            string vHomePathId = "HOME";
            string vEtcPath    = "/etc/";
        }
        
        string     vOutFileSwitch = "-o ";
        string     vVersionSwitch = "-fversion";
        string     vDebugSwitch = "-fdebug";
        string[]   vCompilerDefs;
        string     vImportPath = "-I ";
        string     vSymInfoSwitch = "-g";
        /* GDC places object files in the directory from which it is called */
        bool       vUseModBaseName = true;
        
        // circular dependency things
        bool       vCircularDepsOK = false;
        bool       vCircularLinkAll = true;
        string     vCircularOnlyFlag = "-fonly=";
    }

    string       vCFGPath = ``;
    string       vOverrideConfigPath = "";
    string       vBuildImportPath = "-I";
    string       vImportPathDelim = ";";
    string       vOutputPath = "-od";
    string       vRunSwitch = "-exec";
    string       vLibrarianPath = "";
    string*      vDelayedValue = null;
    string       vTemporaryPath = "";
    string       vLibPathSwitch = "-L";
    string       vMapSwitch = "-M";
    string       vGenDebugInfo = "-g";
    string       vResponseExt = "brf";
    string       vDefResponseFile = "build.brf";
    string       vDefMacroDefFile = "build.mdf";
    string       vUtilsConfigFile = "build.cfg";
    string       vPathId = "PATH";   // Used to locate the environment symbol

    string       vModOutPrefix = "MODULES = \n";
    string       vModOutSuffix = "";
    string       vModOutBody   = "    $(MODULE {mod})\n";
    string       vModOutDelim  = "";
    string       vModOutFile   = "_modules.ddoc";

    string[]     vFinalProc;

    Bool         vTestRun;
    Bool         vExplicit;
    Bool         vScanImports;
    Bool         vNoLink;
    Bool         vForceCompile;
    Bool         vSilent;
    Bool         vSymbols;
    Bool         vCleanup;
    version(BuildVerbose) Bool         vVerbose;
    Bool         vMacroInput;
    Bool         vCollectUses;
    Bool         vNames;
    Bool         vAllObjects;
    Bool         vNoDef;
    Bool         vAutoImports;
    Bool         vExecuteProgram;
    Bool         vUseResponseFile;
    Bool         vConsoleApp;
    Bool         vUseFinal;
    Bool         vEmptyArgs;
    
    Bool         vCircularDeps;

    string       vUsesOutput;
    string       vSymbolOutName;
    string       vRunParms;
    string       vTargetExe;
    string[]     vImportRoots;
    string[]     vModulesToIgnore;
    string[]     vModulesToNotice;
    string[]     vBuildDef;
    string[]     vDefaultLibs;
    LibOpt       vLibraryAction = LibOpt.Implicit;
    string       vAppPath;
    string       vAppName;
    string       vAppVersion = "3.04";
    string       vTargetName;           // Output name from first file name.
    string       vPragmaTargetName;     // Output name from pragma.
    string       vCommandTargetName;    // Output name from switches.
    string[]     vCmdLineSourceFiles;   // List of source files from command line
    string[]     vLinkFiles;            // List of non-source files from command line
    string[]     vCombinedArgs;         // All the args are gathered here prior to processing.
    string[]     vBuildArgs;            // Arguments passed to build
    string[]     vCompilerArgs;         // Arguments passed to compiler
    string[]     vSourceScanList;       // The list of places to find source files.
    bool[string] vResourceFileTypes;
    string[]     vUDResTypes;


    version(Windows)
    {
        string       vWinVer = "";
        ubyte        vWinVerNum;
        bool         vAutoWinLibs = true;
    }

}

// Module constructor.
//-------------------------------------------------------
static this()
//-------------------------------------------------------
{
    // Force the 'build' version to be active.
    source.ActivateVersion("build");

    vSourceScanList ~= "." ~ std.path.sep;
    vNoLink = False;
    vTestRun = False;
    vExplicit = False;
    vScanImports = False;
    vUseFinal = True;
    vEmptyArgs = True;
    vForceCompile = False;
    vSilent = False;
    vCleanup = False;
    version(BuildVerbose) vVerbose = False;
    vMacroInput = True;
    vCollectUses = False;
    vNames = False;
    vAllObjects = False;
    vNoDef = False;
    vAutoImports = True;
    vExecuteProgram = False;
    vUseResponseFile = False;
    vSymbols = False;
    vConsoleApp = True;
    
    vCircularDeps = False;

    version(Posix)
    {
        vCompilerDefs ~= vVersionSwitch ~ "=Posix"; // Until such time as this is standard in dmd.
    }

    version(Windows) {
        vWinVerNum = cast(ubyte)(std.c.windows.windows.GetVersion() & 0xFF);
        vWinVer = std.string.format("%d.0", vWinVerNum);
     }

    vUseResponseFile = False;
    version(UseResponseFile) vUseResponseFile = True;

    util.str.SetEnv("@P", std.path.getDirName(vConfigPath));
    util.str.SetEnv("@D", std.path.getDirName(vCompilerPath));

    source.Source.UseModBaseName(vUseModBaseName);

}

//-------------------------------------------------------
void DisplayUsage(bool pFull = true)
//-------------------------------------------------------
{

    std.stdio.writefln(
        "Path and Version : %s v%s(%d)\n  built on %s"
            ,vAppPath, vAppVersion, build_bn.auto_build_number,
            __TIMESTAMP__);
    if (pFull == false)
        return;
    else {

    std.stdio.writefln(
        "Usage: %s sourcefile [options objectfiles libraries]"
            , vAppName);
    std.stdio.writefln("  sourcefile D source file");
    std.stdio.writefln("  -v         Verbose (passed through to D)");
    std.stdio.writefln("  -V         Verbose (NOT passed through)");
    std.stdio.writefln("  -names     Displays the names of the files used in building the target.");
    std.stdio.writefln("  -DCPATH<path> <path> is where the compiler has been installed.");
    std.stdio.writefln("             Only needed if the compiler is not in the system's");
    std.stdio.writefln("             PATH list. Used if you are testing an alternate");
    std.stdio.writefln("             version of the compiler.");
    std.stdio.writefln("  -CFPATH<path> <path> is where the D config file has been installed.");
    std.stdio.writefln("  -BCFPATH<path> <path> is where the Build config file has been installed.");
    std.stdio.writefln("  -full      Causes all source files, except ignored modules,");
    std.stdio.writefln("              to be compiled.");
    std.stdio.writefln("  -link      Forces the linker to be called instead of the librarian.");
    std.stdio.writefln("              (Only needed if the source files do not contain");
    std.stdio.writefln("               main/WinMain)");
    std.stdio.writefln("  -nolink    Ensures that the linker is not called.");
    std.stdio.writefln("              (Only needed if main/WinMain is found in the source");
    std.stdio.writefln("               files and you do NOT want an executable created.)");
    std.stdio.writefln("  -lib       Forces the object files to be placed in a library.");
    std.stdio.writefln("              (Only needed if main/WinMain is found in the source");
    std.stdio.writefln("               files AND you want it in a library instead of");
    std.stdio.writefln("               an executable.)");
    std.stdio.writefln("  -shlib     Forces the object files to be placed in a shared library.");
    std.stdio.writefln("  -shlib-support");
    std.stdio.writefln("             Output 'yes' and return a successful exit code if shared");
    std.stdio.writefln("             libraries are supported, otherwise output 'no' and return");
    std.stdio.writefln("             a failure exit code.");
    std.stdio.writefln("  -nolib     Ensures that the object files are not used to form");
    std.stdio.writefln("              a library.");
    std.stdio.writefln("              (Only needed if main/WinMain is not found in the source");
    std.stdio.writefln("               files and you do NOT want a library.");
    std.stdio.writefln("  -obj       This is the same as having both -nolib and -nolink switches.");
    std.stdio.writefln("  -allobj    Ensures that all object files are added to a");
    std.stdio.writefln("              library.");
    std.stdio.writefln("              (Normally only those in the same directory are added.)");
    std.stdio.writefln("  -cleanup   Ensures that all object files created during the run");
    std.stdio.writefln("              are removed at the end of the run, plus other work files.");
    std.stdio.writefln("  -clean     Same as -cleanup");
  version(Windows) {
    std.stdio.writefln("  -gui[:x.y] Forces a GUI application to be created. The optional");
    std.stdio.writefln("              :x.y can be used to build an application for a ");
    std.stdio.writefln("              specific version of Windows. eg. -gui:4.0");
    std.stdio.writefln("              (Only needed if WinMain is not found in the source files");
    std.stdio.writefln("               or if you wish to override the default Windows version)");
    std.stdio.writefln("  -dll       Forces a DLL library to be created.");
    std.stdio.writefln("              (Only needed if DllMain is not found in the source files.)");
   }

    std.stdio.writefln("  -explicit  Only compile files explicitly named on the command line.");
    std.stdio.writefln("             All other files, such as imported ones, are not compiled.");
    std.stdio.writefln("  -LIBOPT<opt> Allows you to pass <opt> to the librarian.");
    std.stdio.writefln("  -SHLIBOPT<opt> Allows you to pass <opt> to the shared-librarian.");
    std.stdio.writefln("  -LIBPATH=<pathlist> Used to add a semi-colon delimited list");
    std.stdio.writefln("                of search paths for library files.");
    std.stdio.writefln("  -MDF<path> Overrides the default Macro Definition File");
    std.stdio.writefln("  -test      Does everything as normal except it displays the commands");
    std.stdio.writefln("              instead of running them.");
    std.stdio.writefln("  -RDF<path> Overrides the default Rule Definition File");
    std.stdio.writefln("  -R=<Yes|No> Indicates whether to use a response file or command line");
    std.stdio.writefln("              arguments with the compiler tools.");
    std.stdio.writefln("               -R=Yes will cause a response to be used.");
    std.stdio.writefln("               -R=No will cause command line arguments to be used.");
    std.stdio.writefln("               -R will reverse the current usage.");
    std.stdio.writefln("  -PP<path>  Add a path to the Source Search List");
    std.stdio.writefln("  -usefinal=<Yes|No> Indicates whether to use any FINAL processes");
    std.stdio.writefln("              defined in the configuration file.");
    std.stdio.writefln("               -usefinal=Yes will cause the FINAL to be used. This is the default");
    std.stdio.writefln("               -usefinal=No will prevent the FINAL from being used.");

  version(UseResponseFile)
    std.stdio.writefln("               ** The default is to use a response file");
  else
    std.stdio.writefln("               ** The default is to use command line arguments");

    std.stdio.writefln("  -exec<param> If the link is successful, this will cause the");
    std.stdio.writefln("               executable just created to run. You can give it ");
    std.stdio.writefln("               run time parameters. Anything after the '-exec' will");
    std.stdio.writefln("               placed in the program's command line. You will need");
    std.stdio.writefln("               to quote any embedded spaces.");
    std.stdio.writefln("  -od<path>  Nominate the directory where temporary (work) files");
    std.stdio.writefln("             are to be created. By default they are created in");
    std.stdio.writefln("             the same directory as the target file.");
    std.stdio.writefln("  -X<module> Modules/Packages to ignore (eg. -Xmylib)");
    std.stdio.writefln("  -M<module> Modules/Packages to notice (eg. -Mphobos)");
    std.stdio.writefln("  -T<targetname> The name of the target file to create. Normally");
    std.stdio.writefln("              the target name istaken from the first or only name");
    std.stdio.writefln("              of the command line.");
    std.stdio.writefln("  -help     Displays the full 'usage' help text. ");
    std.stdio.writefln("  -h        Same as -help, displays the full 'usage' help text.");
    std.stdio.writefln("  -?        Same as -help, displays the full 'usage' help text.");
    std.stdio.writefln("  -silent   Avoids unnecessary messages being displayed.");
    std.stdio.writefln("  -noautoimport Turns off the automatic addition of source paths");
    std.stdio.writefln("              to the list of Import Roots.");
    std.stdio.writefln("  -info      Displays the version and path of the Build application.");
    std.stdio.writefln("  -nodef    Prevents a Module Definition File from being created.");
    std.stdio.writefln("  -UMB=<Yes/No> If 'Yes' this forces the utility to expect");
    std.stdio.writefln("            the object file to be created or residing in the current");
    std.stdio.writefln("            directory.");
    std.stdio.writefln("  -circular Allows circular dependencies to work on some compilers (namely GDC)");
    version(Windows)
    {
    std.stdio.writefln("  -AutoWinLibs=<Yes/No> If 'No' this prevents the tool from");
    std.stdio.writefln("              passing the standard set of Windows libraries");
    std.stdio.writefln("              to the linker for GUI applications. 'Yes' is");
    std.stdio.writefln("              is the default.");
    }
    std.stdio.writefln("  [...]      All other options, objectfiles and libraries are");
    std.stdio.writefln("              passed to the compiler");
    std.stdio.writefln("*Note, you can specify all or any command line value in a ");
    std.stdio.writefln("   response file. Each value appears in its own line in the");
    std.stdio.writefln(<