root/branches/tango/sss/conf.d

/**
 * DSSS configuration stuff
 * 
 * Authors:
 *  Gregor Richards
 * 
 * License:
 *  Copyright (c) 2006, 2007  Gregor Richards
 *  
 *  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.
 */

module sss.conf;

import tango.io.Console;
import tango.io.File;
import tango.io.FileConst;
import tango.io.FilePath;
import tango.io.FileSystem;
import tango.io.Stdout;
import tango.io.protocol.Reader;

import tango.sys.Environment;
import tango.sys.Process;

import tango.text.Ascii;
import tango.text.Util;

import tango.stdc.ctype;
import tango.stdc.stdlib;

import sss.clean;

import hcf.path;
import hcf.process;

version (Windows) {
    import bcd.windows.windows;
}

extern (C) int access(char*, int);
enum accessRights : int {
        F_OK = 0,
        X_OK,
        W_OK,
        R_OK
};

/** The default config file name */
const char[] configFName = "dsss.conf";

/** The lastbuild config file name */
const char[] configLBName = "dsss.last";

/** The dsss_build line */
char[] dsss_build;

/** Options added to dsss_build */
char[] dsss_buildOptions;

/** Is DSSS installed, or is it being run out of the source directory? */
bool inSourceDir;

/** The prefix to which DSSS was installed */
char[] installPrefix;

/** The provided prefix */
char[] forcePrefix;

/** The prefix to which other binaries should be installed */
char[] binPrefix;

/** The prefix to which libraries are installed */
char[] libPrefix;

/** The prefix to which includes are installed */
char[] includePrefix;

/** The prefix to which documentation is installed */
char[] docPrefix;

/** The prefix to which manifests are installed */
char[] manifestPrefix;

/** The prefix to which configuration files are installed */
char[] etcPrefix;

/** The prefix to which the source list is downloaded */
char[] srcListPrefix;

/** The location of candydoc.tar.gz */
char[] candyDocPrefix;

/** The location of dsss_lib_test.d */
char[] dsssLibTestDPrefix;

/** Are we doing documentation? */
bool doDocs = false;

/** Are we doing documentation for binaries? */
bool doDocBinaries = false;

/** Should we delete response files? */
bool deleteRFiles = true;

/** Should we generate test binaries? */
bool testLibs = false;

/** Should we build debug versions? */
bool buildDebug = false;

/** The prefix for scratch work */
char[] scratchPrefix;

/** The location of stub.d (used to make stub D libraries) */
char[] stubDLoc;

/** The location of dsssdll.d (used to make DLLs from any library) */
char[] dsssDllLoc;

/** Usedirs (dirs to import both includes and libs from */
char[][] useDirs;

/** Tested versions (for the target) */
bool[char[]] versions;
    
/* It's often useful to know whether we're using GNU and/or Posix, as GNU on
 * Windows tends to do some things Posixly. */
version (build) {
    version (GNU) {
        pragma(export_version, "GNU_or_Posix");
    } else version (Posix) {
        pragma(export_version, "GNU_or_Posix");
    }
}

/** Set prefixes automatically, given argv[0] */
void getPrefix(char[] argvz)
{
    char[] bname;
    if (!whereAmI(argvz, installPrefix, bname)) {
        Cout("Failed to determine DSSS' installed prefix.").newline;
        exit(1);
    }
    
    installPrefix = canonPath(installPrefix);
    
    // get some default usedirs
    useDirs ~= canonPath(installPrefix ~ FileConst.PathSeparatorChar ~ "..");
    version (Posix) {
        char[] home = Environment.get("HOME");
        if (home != "") {
            useDirs ~= canonPath(home ~ FileConst.PathSeparatorChar ~ "d");
        }
    }
    
    // set the prefix to actually install things to
    
    // using this directory, find include and library directories
    if ((new FilePath(installPrefix ~ FileConst.PathSeparatorChar ~ "sss" ~
                  FileConst.PathSeparatorChar ~ "main.d")).exists()) {
        // this is probably the build prefix
        inSourceDir = true;
        
        if (forcePrefix == "") {
            forcePrefix = installPrefix ~ FileConst.PathSeparatorChar ~ "inst";
        } else {
            forcePrefix = canonPath(forcePrefix);
        }
        
        char[] sssBaseLoc = installPrefix ~ FileConst.PathSeparatorChar ~ "sss" ~ FileConst.PathSeparatorChar;
        stubDLoc = sssBaseLoc ~ "stub.d";
        dsssDllLoc = sssBaseLoc ~ "dssdll.d";
        
        // get rebuild environment variable
        version (Posix) {
            dsss_build = installPrefix ~
                FileConst.PathSeparatorChar ~ "rebuild" ~
                FileConst.PathSeparatorChar ~ "rebuild";
        } else version (Windows) {
            dsss_build = installPrefix ~
                FileConst.PathSeparatorChar ~ "rebuild" ~
                FileConst.PathSeparatorChar ~ "rebuild.exe";
        } else {
            static assert(0);
        }
        
        Environment.set("DSSS_BUILD", dsss_build);
        
        if (!candyDocPrefix.length)
            candyDocPrefix = canonPath(
                installPrefix ~ FileConst.PathSeparatorChar ~
                "candydoc.tar.gz");
        if (!dsssLibTestDPrefix.length)
            dsssLibTestDPrefix = canonPath(
                installPrefix ~ FileConst.PathSeparatorChar ~
                "sss" ~ FileConst.PathSeparatorChar ~
                "dsss_lib_test.d");
    } else {
        inSourceDir = false;
        
        // slightly more complicated for a real install
        if (forcePrefix == "") {
            forcePrefix = getDirName(installPrefix);
            
            // if this is inaccessible, we need to make a better decision
            version (Posix) {
                if (access((forcePrefix ~ '\0').ptr, accessRights.W_OK) != 0) {
                    // choose $HOME/d
                    if (home != "") {
                        char[] newPrefix = canonPath(home ~ "/d");
                        Cout("Default prefix ")
                            (forcePrefix)
                            (" is unwritable, using ")
                            (newPrefix)
                            (" instead.").newline;
                        forcePrefix = newPrefix;
                    }
                }
            }
            
        } else {
            forcePrefix = canonPath(forcePrefix);
        }
        
        char[] sssBaseLoc = forcePrefix ~ FileConst.PathSeparatorChar ~
            "include" ~ FileConst.PathSeparatorChar ~
            "d" ~ FileConst.PathSeparatorChar ~
            "sss" ~ FileConst.PathSeparatorChar;
        stubDLoc = sssBaseLoc ~ "stub.d";
        dsssDllLoc = sssBaseLoc ~ "dsssdll.d";
        
        // set build environment variable
        version (Posix) {
            dsss_build = installPrefix ~
                 FileConst.PathSeparatorChar ~ "rebuild";
        } else version (Windows) {
            dsss_build = installPrefix ~
                FileConst.PathSeparatorChar ~ "rebuild.exe";
        } else {
            static assert(0);
        }
        
        // if we don't have rebuild next to us, try to use it without a path
        if (!(new FilePath(dsss_build)).exists()) {
            version (Posix) {
                dsss_build = "rebuild";
            } else version (Windows) {
                dsss_build = "rebuild.exe";
            } else {
                static assert(0);
            }
        }
        
        Environment.set("DSSS_BUILD", dsss_build);
        
        if (!candyDocPrefix.length)
            candyDocPrefix = canonPath(
                installPrefix ~ FileConst.PathSeparatorChar ~
                ".." ~ FileConst.PathSeparatorChar ~
                "share" ~ FileConst.PathSeparatorChar ~
                "dsss" ~ FileConst.PathSeparatorChar ~
                "candydoc.tar.gz");
        if (!dsssLibTestDPrefix.length)
            dsssLibTestDPrefix = canonPath(
                installPrefix ~ FileConst.PathSeparatorChar ~
                ".." ~ FileConst.PathSeparatorChar ~
                "share" ~ FileConst.PathSeparatorChar ~
                "dsss" ~ FileConst.PathSeparatorChar ~
                "dsss_lib_test.d");
    }
    
    if (!binPrefix.length)
        binPrefix = forcePrefix ~ FileConst.PathSeparatorChar ~ "bin";
    if (!libPrefix.length)
        libPrefix = forcePrefix ~ FileConst.PathSeparatorChar ~ "lib";
    if (!includePrefix.length)
        includePrefix = forcePrefix ~ FileConst.PathSeparatorChar ~
             "include" ~ FileConst.PathSeparatorChar ~
             "d";
    if (!docPrefix.length)
        docPrefix = forcePrefix ~ FileConst.PathSeparatorChar ~
            "share" ~ FileConst.PathSeparatorChar ~
            "doc";
    if (!manifestPrefix.length)
        manifestPrefix = forcePrefix ~ FileConst.PathSeparatorChar ~
            "share" ~ FileConst.PathSeparatorChar ~
            "dsss" ~ FileConst.PathSeparatorChar ~
            "manifest";
    if (!etcPrefix.length) {
        if (forcePrefix == "/usr") {
            // in the case of /usr, use /etc instead of /usr/etc
            etcPrefix = "/etc";
        } else {
            etcPrefix = forcePrefix ~ FileConst.PathSeparatorChar ~
                "etc";
        }
    }
    if (!srcListPrefix.length)
        srcListPrefix = canonPath(
            forcePrefix ~ FileConst.PathSeparatorChar ~
            "share" ~ FileConst.PathSeparatorChar ~
            "dsss" ~ FileConst.PathSeparatorChar ~
            "sources");
    
    // set the scratch prefix and some some environment variables
    version (Posix) {
        scratchPrefix = "/tmp";
        
        Environment.set("DSSS", installPrefix ~ FileConst.PathSeparatorChar ~ bname);
        Environment.set("PREFIX", forcePrefix);
        Environment.set("BIN_PREFIX", binPrefix);
        Environment.set("LIB_PREFIX", libPrefix);
        Environment.set("INCLUDE_PREFIX", includePrefix);
        Environment.set("DOC_PREFIX", docPrefix);
        Environment.set("ETC_PREFIX", etcPrefix);
        Environment.set("EXE_EXT", "");
        
        // make sure components run with libraries, etc
        Environment.set("PATH", binPrefix ~ ":" ~ Environment.get("PATH"));
        char[] ldlibp = Environment.get("LD_LIBRARY_PATH");
        if (ldlibp == "") {
            ldlibp = libPrefix;
        } else {
            ldlibp = libPrefix ~ ":" ~ ldlibp;
        }
        Environment.set("LD_LIBRARY_PATH", ldlibp);
    } else version (Windows) {
        scratchPrefix = canonPath(installPrefix ~ FileConst.PathSeparatorChar ~
                                  ".." ~ FileConst.PathSeparatorChar ~
                                  "tmp");
        
        Environment.set("DSSS", installPrefix ~ FileConst.PathSeparatorChar ~ bname);
        Environment.set("PREFIX", forcePrefix);
        Environment.set("BIN_PREFIX", binPrefix);
        Environment.set("LIB_PREFIX", libPrefix);
        Environment.set("INCLUDE_PREFIX", includePrefix);
        Environment.set("DOC_PREFIX", docPrefix);
        Environment.set("ETC_PREFIX", etcPrefix);
        Environment.set("EXE_EXT", ".exe");
        
        // path for both bin and lib
        Environment.set("PATH", binPrefix ~ ";" ~ libPrefix ~ ";" ~ Environment.get("PATH"));
    } else {
        static assert(0);
    }
    
    dsss_build ~= " -Idsss_imports" ~ FileConst.PathSeparatorChar ~
        " -I. -S." ~ FileConst.PathSeparatorChar ~
        " -I" ~ includePrefix ~ " -S" ~ libPrefix ~ FileConst.PathSeparatorChar ~ " " ~
        dsss_buildOptions ~ " ";
}

/** DSSS configuration information - simply a list of sections, then an array
 * of settings for those sections */
class DSSSConf {
    /// Configurable sections
    char[][] sections;
    
    /// Settings per section
    char[][char[]][char[]] settings;
}

/** Generate a DSSSConf from dsss.conf, or generate a dsss.conf from buildElems */
DSSSConf readConfig(char[][] buildElems, bool genconfig = false, char[] configF = configFName)
{
    /* config file format: every line is precisely one section, setting, block
     * opener or block closer. The only valid block opener is 'version' */
    
    /** A function to tokenize a single config file line */
    char[][] tokLine(char[] line)
    {
        /** All tokens read thusfar */
        char[][] tokens;
        
        /** Current token */
        char[] tok;
        
        /** Add the current token */
        void addToken()
        {
            if (tok != "") {
                tokens ~= tok;
                tok = "";
            }
        }
        
        for (int i = 0; i < line.length; i++) {
            if (isalnum(line[i]) ||
                line[i] == '_') {
                tok ~= line[i..i+1];
            } else if (isSpace(line[i])) {
                addToken();
            } else if (line[i] == '=' ||
                       line[i] == ':') {
                // the rest is all one token
                addToken();
                tok ~= line[i];
                addToken();
                
                tok ~= line[(i + 1) .. $];
                
                // trim whitespace of the setting
                while (tok.length && isSpace(tok[0])) tok = tok[1..$];
                while (tok.length && isSpace(tok[$-1])) tok = tok[0..($-1)];
                
                if (tok.length) addToken();
                break;
            } else {
                addToken();
                tok ~= line[i..i+1];
                addToken();
            }
        }
        addToken();
        
        return tokens;
    }
    
    /// The actual configuration store
    DSSSConf conf = new DSSSConf();
    
    /// The data from the config file
    char[] confFile;
    
    if ((new FilePath(configFName)).exists()) {
        if (genconfig) {
            // this makes no sense
            Cout("Will not generate a config file when a config file already exists.").newline;
            exit(1);
        }
        
        // before reading the config, distclean if it's changed
        if (configF == configFName) {
            if ((new FilePath(configLBName)).exists()) {
                if (fileNewer(configFName, configLBName)) {
                    // our config has changed
                    distclean(readConfig(null, false, configLBName));
                }
            }
        
            // copy in our new dsss.lastbuild
            (new FilePath(configLBName)).copy(configFName);
        }
        
        // Read the config file
        confFile = cast(char[]) (new File(configFName)).read();
    } else {
        // Generate the config file
        if (buildElems.length == 0) {
            // from nothing - just make every directory into a library
            auto dires = (new FilePath(".")).toList((FilePath path, bool isDirectory) { return true; });
            foreach (dire; dires) {
                if (dire.isFolder() &&
                    dire.name[0] != '.') {
                    confFile ~= "[" ~ dire.name ~ "]\n";
                }
            }
            
        } else {
            // from a list
            foreach (build; buildElems) {
                if (!(new FilePath(build)).exists()) {
                    Cout("File ")(build)(" not found!").newline;
                } else {
                    confFile ~= "[" ~ build ~ "]\n";
                }
            }
        }
        
        if (genconfig) {
            // write it
            (new File(configFName)).write(confFile);
        }
        
    }
    
    
    // Normalize it
    confFile = substitute(confFile, "\r", "");
    
    // Split it by lines
    char[][] lines = split(confFile, "\n");
    
    /// Current section
    char[] section;
    
    // set up the defaults for the top-level section
    conf.settings[""] = null;
    conf.settings[""]["name"] = (new FilePath(FileSystem.getDirectory())).file();
    conf.settings[""]["version"] = "latest";
    
    // parse line-by-line
    for (int i = 0; i < lines.length; i++) {
        char[] line = lines[i];
            
        /** A function to close the current scope */
        void closeScope(bool ignoreElse = false)
        {
            int depth = 1;
            for (i++; i < lines.length; i++) {
                char[][] ntokens = tokLine(lines[i]);
                if (ntokens.length == 0) continue;
                    
                // possibly change the depth
                if (ntokens[0] == "}") {
                    // check for else
                    if (ntokens.length >= 3 &&
                        ntokens[1] == "else") {
                        if (!ignoreElse) {
                            // rewrite this line for later parsing
                            lines[i] = tango.text.Util.join(ntokens[2 .. $], " ");
                            depth--;
                            i--;
                        } else if (ntokens[$ - 1] != "{") {
                            // drop the depth even though we won't reparse it
                            depth--;
                        }
                        
                    } else {
                        depth--;
                    }
                    
                    if (depth == 0) {
                        return; // done! :)
                    }
                } else if (ntokens[$ - 1] == "{") {
                    depth++;
                }
            }
            // didn't close!
            Cout("DSSS config error: unclosed scope.").newline;
            exit(1);
        }
        
        // combine lines
        while (i < lines.length - 1 &&
               line.length &&
               line[$ - 1] == '\\') {
            i++;
            line = line[0 .. ($ - 1)] ~ lines[i];
        }
        
        // then parse it
        char[][] tokens = tokLine(line);
        if (tokens.length == 0) continue;
        
        // then do something with it
        if (tokens[0] == "[" &&
            tokens[$ - 1] == "]") {
            // a section header
            char[] path = tango.text.Util.join(tokens[1 .. ($ - 1)], "");
            // allow \'s for badly-written conf files
            path = tango.text.Util.replace(path.dup, '\\', '/');
            
            section = canonPath(path);
            conf.settings[section] = null;
                
            // need to have some default settings: target and type
            if (section == "*") {
                // "global" section, no target/type
            } else if (section == "") {
                // top-level section
            } else if (section.length > 0 &&
                       section[0] == '+') {
                // special section
                conf.sections ~= section;
                conf.settings[section]["type"] = "special";
                conf.settings[section]["target"] = section[1..$];
                
            } else if (!(new FilePath(section)).exists()) {
                Cout("WARNING: Section for nonexistant file ")(section)(".").newline;
            } else {
                conf.sections ~= section;
                
                if ((new FilePath(section)