root/trunk/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 std.ctype;
import std.file;
import std.process;
import std.stdio;
import std.stream;
import std.string;

import std.c.stdlib;

import sss.clean;
import sss.platform;
import sss.system;

import hcf.env;
import hcf.path;
import hcf.process;

import util.booltype;
import util.fdt;
import util.str;

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

alias std.process.system system;
alias std.string.find find;
alias std.string.iswhite iswhite;

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;

/** Should we be verbose? */
bool verboseMode = 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)) {
        writefln("Failed to determine DSSS' installed prefix.");
        exit(1);
    }
    
    installPrefix = canonPath(installPrefix);
    
    // get some default usedirs
    useDirs ~= canonPath(installPrefix ~ std.path.sep ~ "..");
    version (Posix) {
        char[] home = getEnvVar("HOME");
        if (home != "") {
            useDirs ~= canonPath(home ~ std.path.sep ~ "d");
        }
    }
    
    // set the prefix to actually install things to
    
    // using this directory, find include and library directories
    if (exists(installPrefix ~ std.path.sep ~ "sss" ~ std.path.sep ~ "main.d")) {
        // this is probably the build prefix
        inSourceDir = true;
        
        if (forcePrefix == "") {
            forcePrefix = installPrefix ~ std.path.sep ~ "inst";
        } else {
            forcePrefix = canonPath(forcePrefix);
        }
        
        char[] sssBaseLoc = installPrefix ~ std.path.sep ~ "sss" ~ std.path.sep;
        stubDLoc = sssBaseLoc ~ "stub.d";
        dsssDllLoc = sssBaseLoc ~ "dssdll.d";
        
        // get rebuild environment variable
        version (Posix) {
            dsss_build = installPrefix ~
                std.path.sep ~ "rebuild" ~
                std.path.sep ~ "rebuild";
        } else version (Windows) {
            dsss_build = installPrefix ~
                std.path.sep ~ "rebuild" ~
                std.path.sep ~ "rebuild.exe";
        } else {
            static assert(0);
        }
        
        setEnvVar("DSSS_BUILD", dsss_build);
        
        if (!candyDocPrefix.length)
            candyDocPrefix = canonPath(
                installPrefix ~ std.path.sep ~
                "candydoc.tar.gz");
        if (!dsssLibTestDPrefix.length)
            dsssLibTestDPrefix = canonPath(
                installPrefix ~ std.path.sep ~
                "sss" ~ std.path.sep ~
                "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");
                        writefln("Default prefix %s is unwritable, using %s instead.",
                                 forcePrefix, newPrefix);
                        forcePrefix = newPrefix;
                    }
                }
            }
            
        } else {
            forcePrefix = canonPath(forcePrefix);
        }
        
        char[] sssBaseLoc = forcePrefix ~ std.path.sep ~
            "include" ~ std.path.sep ~
            "d" ~ std.path.sep ~
            "sss" ~ std.path.sep;
        stubDLoc = sssBaseLoc ~ "stub.d";
        dsssDllLoc = sssBaseLoc ~ "dsssdll.d";
        
        // set build environment variable
        version (Posix) {
            dsss_build = installPrefix ~
                 std.path.sep ~ "rebuild";
        } else version (Windows) {
            dsss_build = installPrefix ~
                std.path.sep ~ "rebuild.exe";
        } else {
            static assert(0);
        }
        
        // if we don't have rebuild next to us, try to use it without a path
        if (!std.file.exists(dsss_build)) {
            version (Posix) {
                dsss_build = "rebuild";
            } else version (Windows) {
                dsss_build = "rebuild.exe";
            } else {
                static assert(0);
            }
        }
        
        setEnvVar("DSSS_BUILD", dsss_build);
        
        if (!candyDocPrefix.length)
            candyDocPrefix = canonPath(
                installPrefix ~ std.path.sep ~
                ".." ~ std.path.sep ~
                "share" ~ std.path.sep ~
                "dsss" ~ std.path.sep ~
                "candydoc.tar.gz");
        if (!dsssLibTestDPrefix.length)
            dsssLibTestDPrefix = canonPath(
                installPrefix ~ std.path.sep ~
                ".." ~ std.path.sep ~
                "share" ~ std.path.sep ~
                "dsss" ~ std.path.sep ~
                "dsss_lib_test.d");
    }
    
    if (!binPrefix.length)
        binPrefix = forcePrefix ~ std.path.sep ~ "bin";
    if (!libPrefix.length)
        libPrefix = forcePrefix ~ std.path.sep ~ "lib";
    if (!includePrefix.length)
        includePrefix = forcePrefix ~ std.path.sep ~
             "include" ~ std.path.sep ~
             "d";
    if (!docPrefix.length)
        docPrefix = forcePrefix ~ std.path.sep ~
            "share" ~ std.path.sep ~
            "doc";
    if (!manifestPrefix.length)
        manifestPrefix = forcePrefix ~ std.path.sep ~
            "share" ~ std.path.sep ~
            "dsss" ~ std.path.sep ~
            "manifest";
    if (!etcPrefix.length) {
        if (forcePrefix == "/usr") {
            // in the case of /usr, use /etc instead of /usr/etc
            etcPrefix = "/etc";
        } else {
            etcPrefix = forcePrefix ~ std.path.sep ~
                "etc";
        }
    }
    if (!srcListPrefix.length)
        srcListPrefix = canonPath(
            forcePrefix ~ std.path.sep ~
            "share" ~ std.path.sep ~
            "dsss" ~ std.path.sep ~
            "sources");
    
    // set the scratch prefix and some some environment variables
    version (Posix) {
        scratchPrefix = "/tmp";
        
        setEnvVar("DSSS", installPrefix ~ std.path.sep ~ bname);
        setEnvVar("PREFIX", forcePrefix);
        setEnvVar("BIN_PREFIX", binPrefix);
        setEnvVar("LIB_PREFIX", libPrefix);
        setEnvVar("INCLUDE_PREFIX", includePrefix);
        setEnvVar("DOC_PREFIX", docPrefix);
        setEnvVar("ETC_PREFIX", etcPrefix);
        setEnvVar("EXE_EXT", "");
        
        // make sure components run with libraries, etc
        setEnvVar("PATH", binPrefix ~ ":" ~ getEnvVar("PATH"));
        char[] ldlibp = getEnvVar("LD_LIBRARY_PATH");
        if (ldlibp == "") {
            ldlibp = libPrefix;
        } else {
            ldlibp = libPrefix ~ ":" ~ ldlibp;
        }
        setEnvVar("LD_LIBRARY_PATH", ldlibp);
    } else version (Windows) {
        scratchPrefix = canonPath(installPrefix ~ std.path.sep ~
                                  ".." ~ std.path.sep ~
                                  "tmp");
        
        setEnvVar("DSSS", installPrefix ~ std.path.sep ~ bname);
        setEnvVar("PREFIX", forcePrefix);
        setEnvVar("BIN_PREFIX", binPrefix);
        setEnvVar("LIB_PREFIX", libPrefix);
        setEnvVar("INCLUDE_PREFIX", includePrefix);
        setEnvVar("DOC_PREFIX", docPrefix);
        setEnvVar("ETC_PREFIX", etcPrefix);
        setEnvVar("EXE_EXT", ".exe");
        
        // path for both bin and lib
        setEnvVar("PATH", binPrefix ~ ";" ~ libPrefix ~ ";" ~ getEnvVar("PATH"));
    } else {
        static assert(0);
    }
    
    dsss_build ~= " " ~ dsss_buildOptions ~
        " -Idsss_imports" ~ std.path.sep ~
        " -I. -S." ~ std.path.sep ~
        " -I" ~ includePrefix ~ " -S" ~ libPrefix ~ std.path.sep ~ " ";
}

/** 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 (iswhite(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 && iswhite(tok[0])) tok = tok[1..$];
                while (tok.length && iswhite(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 (exists(configFName)) {
        if (genconfig) {
            // this makes no sense
            writefln("Will not generate a config file when a config file already exists.");
            exit(1);
        }
        
        // before reading the config, distclean if it's changed
        if (configF == configFName) {
            if (exists(configLBName)) {
                if (fileNewer(configFName, configLBName)) {
                    // our config has changed
                    distclean(readConfig(null, false, configLBName));
                }
            }
        
            // copy in our new dsss.lastbuild
            std.file.copy(configFName, configLBName);
        }
        
        // Read the config file
        confFile = cast(char[]) std.file.read(configFName);
    } else {
        if (!genconfig && buildElems.length == 0) {
            // this makes no sense
            writefln("No config file found and no targets explicitly specified.");
            exit(1);
        }

        // Generate the config file
        if (buildElems.length == 0) {
            // from nothing - just make every directory into a library
            char[][] dires = listdir(".");
            foreach (dire; dires) {
                if (isdir(dire) &&
                    dire[0] != '.') {
                    confFile ~= "[" ~ dire ~ "]\n";
                }
            }
            
        } else {
            // from a list
            foreach (build; buildElems) {
                if (!exists(build)) {
                    writefln("File %s not found!", build);
                } else {
                    confFile ~= "[" ~ build ~ "]\n";
                }
            }
        }
        
        if (genconfig) {
            // write it
            std.file.write(configFName, confFile);
        }
        
    }
    
    
    // Normalize it
    confFile = replace(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"] = getBaseName(getcwd());
    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] = std.string.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!
            writefln("DSSS config error: unclosed scope.");
            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 = std.string.join(tokens[1 .. ($ - 1)], "");
            // allow \'s for badly-written conf files
            path = std.string.replace(path, "\\", "/");
            
            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 (find(section, '+') != -1) {
                int ploc = find(section, '+'); // FIXME
                // auxiliary section
                conf.sections ~= section;
                conf.settings[section]["type"] = "binary";
                conf.settings[section]["target"] = section[1..$];