2003-06-16 13:33:38 +00:00
|
|
|
#include <map>
|
|
|
|
#include <iostream>
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <unistd.h>
|
2003-06-27 09:55:31 +00:00
|
|
|
#include <fcntl.h>
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-07-07 07:43:58 +00:00
|
|
|
#include "fstate.hh"
|
2003-06-16 13:33:38 +00:00
|
|
|
#include "globals.hh"
|
2003-07-07 07:43:58 +00:00
|
|
|
#include "store.hh"
|
2003-06-16 13:33:38 +00:00
|
|
|
#include "db.hh"
|
2003-07-14 10:23:11 +00:00
|
|
|
#include "references.hh"
|
2003-06-16 13:33:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* A Unix environment is a mapping from strings to strings. */
|
|
|
|
typedef map<string, string> Environment;
|
|
|
|
|
|
|
|
|
2003-07-08 13:22:08 +00:00
|
|
|
class AutoDelete
|
2003-06-16 13:33:38 +00:00
|
|
|
{
|
2003-07-08 13:22:08 +00:00
|
|
|
string path;
|
|
|
|
public:
|
|
|
|
|
|
|
|
AutoDelete(const string & p) : path(p)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
~AutoDelete()
|
|
|
|
{
|
|
|
|
deletePath(path);
|
|
|
|
}
|
|
|
|
};
|
2003-06-16 13:33:38 +00:00
|
|
|
|
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Run a program. */
|
|
|
|
static void runProgram(const string & program, Environment env)
|
2003-06-16 13:33:38 +00:00
|
|
|
{
|
|
|
|
/* Create a log file. */
|
2003-06-27 14:56:12 +00:00
|
|
|
string logFileName = nixLogDir + "/run.log";
|
2003-06-16 13:33:38 +00:00
|
|
|
/* !!! auto-pclose on exit */
|
2003-07-08 13:22:08 +00:00
|
|
|
FILE * logFile = popen(("tee -a " + logFileName + " >&2").c_str(), "w"); /* !!! escaping */
|
2003-06-16 13:33:38 +00:00
|
|
|
if (!logFile)
|
2003-07-08 13:22:08 +00:00
|
|
|
throw SysError(format("creating log file `%1%'") % logFileName);
|
|
|
|
|
|
|
|
/* Create a temporary directory where the build will take
|
|
|
|
place. */
|
|
|
|
static int counter = 0;
|
|
|
|
string tmpDir = (format("/tmp/nix-%1%-%2%") % getpid() % counter++).str();
|
|
|
|
|
|
|
|
if (mkdir(tmpDir.c_str(), 0777) == -1)
|
|
|
|
throw SysError(format("creating directory `%1%'") % tmpDir);
|
|
|
|
|
|
|
|
AutoDelete delTmpDir(tmpDir);
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Fork a child to build the package. */
|
|
|
|
pid_t pid;
|
|
|
|
switch (pid = fork()) {
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
case -1:
|
|
|
|
throw SysError("unable to fork");
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
case 0:
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
try { /* child */
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-07-08 13:22:08 +00:00
|
|
|
if (chdir(tmpDir.c_str()) == -1)
|
|
|
|
throw SysError(format("changing into to `%1%'") % tmpDir);
|
2003-06-27 14:56:12 +00:00
|
|
|
|
|
|
|
/* Fill in the environment. We don't bother freeing
|
|
|
|
the strings, since we'll exec or die soon
|
|
|
|
anyway. */
|
|
|
|
const char * env2[env.size() + 1];
|
|
|
|
int i = 0;
|
|
|
|
for (Environment::iterator it = env.begin();
|
|
|
|
it != env.end(); it++, i++)
|
|
|
|
env2[i] = (new string(it->first + "=" + it->second))->c_str();
|
|
|
|
env2[i] = 0;
|
|
|
|
|
|
|
|
/* Dup the log handle into stderr. */
|
|
|
|
if (dup2(fileno(logFile), STDERR_FILENO) == -1)
|
|
|
|
throw SysError("cannot pipe standard error into log file");
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Dup stderr to stdin. */
|
|
|
|
if (dup2(STDERR_FILENO, STDOUT_FILENO) == -1)
|
|
|
|
throw SysError("cannot dup stderr into stdout");
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Make the program executable. !!! hack. */
|
|
|
|
if (chmod(program.c_str(), 0755))
|
|
|
|
throw SysError("cannot make program executable");
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Execute the program. This should not return. */
|
|
|
|
execle(program.c_str(), baseNameOf(program).c_str(), 0, env2);
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
throw SysError(format("unable to execute %1%") % program);
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
} catch (exception & e) {
|
2003-07-04 12:18:06 +00:00
|
|
|
cerr << format("build error: %1%\n") % e.what();
|
2003-07-04 15:42:03 +00:00
|
|
|
}
|
2003-06-27 14:56:12 +00:00
|
|
|
_exit(1);
|
2003-06-16 13:33:38 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* parent */
|
2003-06-16 13:33:38 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Close the logging pipe. Note that this should not cause
|
|
|
|
the logger to exit until builder exits (because the latter
|
|
|
|
has an open file handle to the former). */
|
|
|
|
pclose(logFile);
|
|
|
|
|
|
|
|
/* Wait for the child to finish. */
|
|
|
|
int status;
|
|
|
|
if (waitpid(pid, &status, 0) != pid)
|
|
|
|
throw Error("unable to wait for child");
|
|
|
|
|
|
|
|
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
|
|
|
|
throw Error("unable to build package");
|
2003-06-16 13:33:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Throw an exception if the given platform string is not supported by
|
|
|
|
the platform we are executing on. */
|
2003-06-27 14:56:12 +00:00
|
|
|
static void checkPlatform(const string & platform)
|
2003-06-16 13:33:38 +00:00
|
|
|
{
|
|
|
|
if (platform != thisSystem)
|
2003-06-27 13:55:12 +00:00
|
|
|
throw Error(format("a `%1%' is required, but I am a `%2%'")
|
|
|
|
% platform % thisSystem);
|
2003-06-16 13:33:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-06-27 13:55:12 +00:00
|
|
|
string printTerm(ATerm t)
|
2003-06-17 13:37:44 +00:00
|
|
|
{
|
2003-06-27 13:55:12 +00:00
|
|
|
char * s = ATwriteToString(t);
|
2003-06-17 13:37:44 +00:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-06 14:20:47 +00:00
|
|
|
Error badTerm(const format & f, ATerm t)
|
2003-06-16 13:33:38 +00:00
|
|
|
{
|
2003-06-27 13:55:12 +00:00
|
|
|
return Error(format("%1%, in `%2%'") % f.str() % printTerm(t));
|
2003-06-16 13:33:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-06-27 13:55:12 +00:00
|
|
|
Hash hashTerm(ATerm t)
|
2003-06-16 13:33:38 +00:00
|
|
|
{
|
2003-06-27 13:55:12 +00:00
|
|
|
return hashString(printTerm(t));
|
2003-06-16 13:33:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-10 15:11:48 +00:00
|
|
|
FState hash2fstate(Hash hash)
|
|
|
|
{
|
|
|
|
return ATmake("Include(<str>)", ((string) hash).c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-15 16:28:54 +00:00
|
|
|
ATerm termFromId(const FSId & id, string * p)
|
2003-07-04 12:18:06 +00:00
|
|
|
{
|
2003-07-15 16:28:54 +00:00
|
|
|
string path = expandId(id);
|
2003-07-09 15:02:03 +00:00
|
|
|
if (p) *p = path;
|
2003-07-04 12:18:06 +00:00
|
|
|
ATerm t = ATreadFromNamedFile(path.c_str());
|
2003-07-15 16:28:54 +00:00
|
|
|
if (!t) throw Error(format("cannot read aterm from `%1%'") % path);
|
2003-07-04 12:18:06 +00:00
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-15 16:28:54 +00:00
|
|
|
FSId writeTerm(ATerm t, const string & suffix, string * p)
|
2003-07-04 12:18:06 +00:00
|
|
|
{
|
2003-07-15 16:28:54 +00:00
|
|
|
FSId id = hashTerm(t);
|
|
|
|
|
|
|
|
string path = canonPath(nixStore + "/" +
|
|
|
|
(string) id + suffix + ".nix");
|
2003-07-04 12:18:06 +00:00
|
|
|
if (!ATwriteToNamedTextFile(t, path.c_str()))
|
|
|
|
throw Error(format("cannot write aterm %1%") % path);
|
2003-07-15 16:28:54 +00:00
|
|
|
|
|
|
|
registerPath(path, id);
|
|
|
|
if (p) *p = path;
|
|
|
|
|
|
|
|
return id;
|
2003-07-04 12:18:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-15 16:28:54 +00:00
|
|
|
void registerSuccessor(const FSId & id1, const FSId & id2)
|
2003-07-10 18:48:11 +00:00
|
|
|
{
|
2003-07-15 16:28:54 +00:00
|
|
|
setDB(nixDB, dbSuccessors, id1, id2);
|
2003-07-10 18:48:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-15 16:28:54 +00:00
|
|
|
static FSId storeSuccessor(const FSId & id1, FState sc)
|
2003-07-09 15:02:03 +00:00
|
|
|
{
|
2003-07-15 16:28:54 +00:00
|
|
|
FSId id2 = writeTerm(sc, "-s-" + (string) id1, 0);
|
|
|
|
registerSuccessor(id1, id2);
|
|
|
|
return id2;
|
2003-07-09 15:02:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-15 16:28:54 +00:00
|
|
|
#if 0
|
2003-07-09 15:02:03 +00:00
|
|
|
static FState realise(FState fs, StringSet & paths)
|
2003-06-27 09:55:31 +00:00
|
|
|
{
|
2003-06-27 14:56:12 +00:00
|
|
|
char * s1, * s2, * s3;
|
2003-06-27 13:55:12 +00:00
|
|
|
Content content;
|
2003-07-04 12:18:06 +00:00
|
|
|
ATermList refs, ins, bnds;
|
|
|
|
|
|
|
|
/* First repeatedly try to substitute $fs$ by any known successors
|
|
|
|
in order to speed up the rewrite process. */
|
|
|
|
{
|
|
|
|
string fsHash, scHash;
|
|
|
|
while (queryDB(nixDB, dbSuccessors, fsHash = hashTerm(fs), scHash)) {
|
|
|
|
debug(format("successor %1% -> %2%") % (string) fsHash % scHash);
|
2003-07-09 15:02:03 +00:00
|
|
|
string path;
|
|
|
|
FState fs2 = termFromHash(parseHash(scHash), &path);
|
|
|
|
paths.insert(path);
|
2003-07-04 12:18:06 +00:00
|
|
|
if (fs == fs2) {
|
|
|
|
debug(format("successor cycle detected in %1%") % printTerm(fs));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
fs = fs2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fall through. */
|
|
|
|
|
|
|
|
if (ATmatch(fs, "Include(<str>)", &s1)) {
|
2003-07-09 15:02:03 +00:00
|
|
|
string path;
|
|
|
|
fs = termFromHash(parseHash(s1), &path);
|
|
|
|
paths.insert(path);
|
|
|
|
return realise(fs, paths);
|
2003-07-04 12:18:06 +00:00
|
|
|
}
|
2003-06-27 13:55:12 +00:00
|
|
|
|
2003-07-06 14:20:47 +00:00
|
|
|
else if (ATmatch(fs, "Path(<str>, <term>, [<list>])", &s1, &content, &refs)) {
|
2003-06-27 14:56:12 +00:00
|
|
|
string path(s1);
|
2003-06-27 09:55:31 +00:00
|
|
|
|
2003-07-04 12:18:06 +00:00
|
|
|
msg(format("realising atomic path %1%") % path);
|
|
|
|
Nest nest(true);
|
|
|
|
|
2003-07-06 14:20:47 +00:00
|
|
|
if (path[0] != '/')
|
|
|
|
throw Error(format("path `%1% is not absolute") % path);
|
2003-06-27 09:55:31 +00:00
|
|
|
|
2003-06-27 13:55:12 +00:00
|
|
|
/* Realise referenced paths. */
|
2003-06-27 14:56:12 +00:00
|
|
|
ATermList refs2 = ATempty;
|
2003-06-27 09:55:31 +00:00
|
|
|
while (!ATisEmpty(refs)) {
|
2003-07-09 15:02:03 +00:00
|
|
|
refs2 = ATinsert(refs2, realise(ATgetFirst(refs), paths));
|
2003-06-27 09:55:31 +00:00
|
|
|
refs = ATgetNext(refs);
|
|
|
|
}
|
2003-06-27 14:56:12 +00:00
|
|
|
refs2 = ATreverse(refs2);
|
2003-06-27 09:55:31 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
if (!ATmatch(content, "Hash(<str>)", &s1))
|
2003-06-27 13:55:12 +00:00
|
|
|
throw badTerm("hash expected", content);
|
2003-06-27 14:56:12 +00:00
|
|
|
Hash hash = parseHash(s1);
|
|
|
|
|
|
|
|
/* Normal form. */
|
2003-07-06 14:20:47 +00:00
|
|
|
ATerm nf = ATmake("Path(<str>, <term>, <term>)",
|
2003-06-27 14:56:12 +00:00
|
|
|
path.c_str(), content, refs2);
|
2003-06-27 09:55:31 +00:00
|
|
|
|
2003-07-04 12:18:06 +00:00
|
|
|
/* Register the normal form. */
|
2003-07-09 15:02:03 +00:00
|
|
|
nf = storeSuccessor(fs, nf, paths);
|
|
|
|
|
2003-07-09 16:12:40 +00:00
|
|
|
/* Expand the hash into the target path. */
|
|
|
|
expandHash(hash, path);
|
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
return nf;
|
2003-06-27 09:55:31 +00:00
|
|
|
}
|
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
else if (ATmatch(fs, "Derive(<str>, <str>, [<list>], <str>, [<list>])",
|
|
|
|
&s1, &s2, &ins, &s3, &bnds))
|
|
|
|
{
|
|
|
|
string platform(s1), builder(s2), outPath(s3);
|
|
|
|
|
2003-07-04 12:18:06 +00:00
|
|
|
msg(format("realising derivate path %1%") % outPath);
|
|
|
|
Nest nest(true);
|
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
checkPlatform(platform);
|
2003-06-27 13:55:12 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Realise inputs. */
|
2003-07-14 10:23:11 +00:00
|
|
|
Strings inPaths;
|
2003-06-27 14:56:12 +00:00
|
|
|
ATermList ins2 = ATempty;
|
|
|
|
while (!ATisEmpty(ins)) {
|
2003-07-14 10:23:11 +00:00
|
|
|
FState in = realise(ATgetFirst(ins), paths);
|
|
|
|
inPaths.push_back(fstatePath(in));
|
|
|
|
ins2 = ATinsert(ins2, in);
|
2003-06-27 14:56:12 +00:00
|
|
|
ins = ATgetNext(ins);
|
|
|
|
}
|
2003-07-14 10:23:11 +00:00
|
|
|
ins = ATreverse(ins2);
|
2003-06-27 14:56:12 +00:00
|
|
|
|
|
|
|
/* Build the environment. */
|
|
|
|
Environment env;
|
|
|
|
while (!ATisEmpty(bnds)) {
|
|
|
|
ATerm bnd = ATgetFirst(bnds);
|
|
|
|
if (!ATmatch(bnd, "(<str>, <str>)", &s1, &s2))
|
2003-07-06 14:20:47 +00:00
|
|
|
throw badTerm("tuple of strings expected", bnd);
|
2003-06-27 14:56:12 +00:00
|
|
|
env[s1] = s2;
|
|
|
|
bnds = ATgetNext(bnds);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether the target already exists. */
|
|
|
|
if (pathExists(outPath))
|
|
|
|
deleteFromStore(outPath);
|
|
|
|
// throw Error(format("path %1% already exists") % outPath);
|
|
|
|
|
|
|
|
/* Run the builder. */
|
|
|
|
runProgram(builder, env);
|
2003-06-27 13:55:12 +00:00
|
|
|
|
2003-06-27 14:56:12 +00:00
|
|
|
/* Check whether the result was created. */
|
|
|
|
if (!pathExists(outPath))
|
|
|
|
throw Error(format("program %1% failed to create a result in %2%")
|
|
|
|
% builder % outPath);
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* Remove write permission from the value. */
|
|
|
|
int res = system(("chmod -R -w " + targetPath).c_str()); // !!! escaping
|
|
|
|
if (WEXITSTATUS(res) != 0)
|
|
|
|
throw Error("cannot remove write permission from " + targetPath);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Hash the result. */
|
|
|
|
Hash outHash = hashPath(outPath);
|
|
|
|
|
|
|
|
/* Register targetHash -> targetPath. !!! this should be in
|
|
|
|
values.cc. */
|
2003-07-07 09:25:26 +00:00
|
|
|
registerPath(outPath, outHash);
|
2003-06-27 14:56:12 +00:00
|
|
|
|
2003-07-14 10:23:11 +00:00
|
|
|
/* Filter out inputs that are not referenced in the output. */
|
|
|
|
for (Strings::iterator i = inPaths.begin();
|
|
|
|
i != inPaths.end(); i++)
|
|
|
|
debug(format("in: %1%") % *i);
|
|
|
|
|
|
|
|
Strings outPaths = filterReferences(outPath, inPaths);
|
|
|
|
|
|
|
|
for (Strings::iterator i = outPaths.begin();
|
|
|
|
i != outPaths.end(); i++)
|
|
|
|
debug(format("out: %1%") % *i);
|
|
|
|
|
|
|
|
ins2 = ATempty;
|
|
|
|
while (!ATisEmpty(ins)) {
|
|
|
|
FState in = ATgetFirst(ins);
|
|
|
|
string path = fstatePath(in);
|
|
|
|
for (Strings::iterator i = outPaths.begin();
|
|
|
|
i != outPaths.end(); i++)
|
|
|
|
if (path.find(*i) != string::npos) {
|
|
|
|
debug(format("out2: %1%") % path);
|
|
|
|
ins2 = ATinsert(ins2, in);
|
|
|
|
}
|
|
|
|
ins = ATgetNext(ins);
|
|
|
|
}
|
|
|
|
ins = ATreverse(ins2);
|
|
|
|
|
2003-07-04 12:18:06 +00:00
|
|
|
/* Register the normal form of fs. */
|
2003-07-06 14:20:47 +00:00
|
|
|
FState nf = ATmake("Path(<str>, Hash(<str>), <term>)",
|
2003-07-14 10:23:11 +00:00
|
|
|
outPath.c_str(), ((string) outHash).c_str(), ins);
|
2003-07-09 15:02:03 +00:00
|
|
|
nf = storeSuccessor(fs, nf, paths);
|
2003-07-04 12:18:06 +00:00
|
|
|
|
|
|
|
return nf;
|
2003-06-27 09:55:31 +00:00
|
|
|
}
|
2003-06-27 13:55:12 +00:00
|
|
|
|
2003-07-04 15:29:58 +00:00
|
|
|
throw badTerm("bad fstate expression", fs);
|
2003-06-27 09:55:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-09 15:02:03 +00:00
|
|
|
FState realiseFState(FState fs, StringSet & paths)
|
2003-06-27 09:55:31 +00:00
|
|
|
{
|
2003-07-09 15:02:03 +00:00
|
|
|
return realise(fs, paths);
|
2003-07-08 13:22:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
string fstatePath(FState fs)
|
|
|
|
{
|
|
|
|
char * s1, * s2, * s3;
|
|
|
|
FState e1, e2;
|
|
|
|
if (ATmatch(fs, "Path(<str>, <term>, [<list>])", &s1, &e1, &e2))
|
|
|
|
return s1;
|
|
|
|
else if (ATmatch(fs, "Derive(<str>, <str>, [<list>], <str>, [<list>])",
|
|
|
|
&s1, &s2, &e1, &s3, &e2))
|
|
|
|
return s3;
|
|
|
|
else if (ATmatch(fs, "Include(<str>)", &s1))
|
|
|
|
return fstatePath(termFromHash(parseHash(s1)));
|
|
|
|
else
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void fstateRefs2(FState fs, StringSet & paths)
|
|
|
|
{
|
|
|
|
char * s1, * s2, * s3;
|
|
|
|
FState e1, e2;
|
|
|
|
ATermList refs, ins;
|
|
|
|
|
|
|
|
if (ATmatch(fs, "Path(<str>, <term>, [<list>])", &s1, &e1, &refs)) {
|
|
|
|
paths.insert(s1);
|
|
|
|
|
|
|
|
while (!ATisEmpty(refs)) {
|
|
|
|
fstateRefs2(ATgetFirst(refs), paths);
|
|
|
|
refs = ATgetNext(refs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (ATmatch(fs, "Derive(<str>, <str>, [<list>], <str>, [<list>])",
|
|
|
|
&s1, &s2, &ins, &s3, &e2))
|
|
|
|
{
|
|
|
|
while (!ATisEmpty(ins)) {
|
|
|
|
fstateRefs2(ATgetFirst(ins), paths);
|
|
|
|
ins = ATgetNext(ins);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
else if (ATmatch(fs, "Include(<str>)", &s1))
|
|
|
|
fstateRefs2(termFromHash(parseHash(s1)), paths);
|
|
|
|
|
|
|
|
else throw badTerm("bad fstate expression", fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-07-09 15:02:03 +00:00
|
|
|
void fstateRefs(FState fs, StringSet & paths)
|
2003-07-08 13:22:08 +00:00
|
|
|
{
|
|
|
|
fstateRefs2(fs, paths);
|
2003-06-27 09:55:31 +00:00
|
|
|
}
|
2003-07-15 16:28:54 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
static void parseIds(ATermList ids, FSIds & out)
|
|
|
|
{
|
|
|
|
while (!ATisEmpty(ids)) {
|
|
|
|
char * s;
|
|
|
|
ATerm id = ATgetFirst(ids);
|
|
|
|
if (!ATmatch(id, "<str>", &s))
|
|
|
|
throw badTerm("not an id", id);
|
|
|
|
out.push_back(parseHash(s));
|
|
|
|
debug(s);
|
|
|
|
ids = ATgetNext(ids);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Parse a slice. */
|
|
|
|
static Slice parseSlice(FState fs)
|
|
|
|
{
|
|
|
|
Slice slice;
|
|
|
|
ATermList roots, elems;
|
|
|
|
|
|
|
|
if (!ATmatch(fs, "Slice([<list>], [<list>])", &roots, &elems))
|
|
|
|
throw badTerm("not a slice", fs);
|
|
|
|
|
|
|
|
parseIds(roots, slice.roots);
|
|
|
|
|
|
|
|
while (!ATisEmpty(elems)) {
|
|
|
|
char * s1, * s2;
|
|
|
|
ATermList refs;
|
|
|
|
ATerm t = ATgetFirst(elems);
|
|
|
|
if (!ATmatch(t, "(<str>, <str>, [<list>])", &s1, &s2, &refs))
|
|
|
|
throw badTerm("not a slice element", t);
|
|
|
|
SliceElem elem;
|
|
|
|
elem.path = s1;
|
|
|
|
elem.id = parseHash(s2);
|
|
|
|
parseIds(refs, elem.refs);
|
|
|
|
slice.elems.push_back(elem);
|
|
|
|
elems = ATgetNext(elems);
|
|
|
|
}
|
|
|
|
|
|
|
|
return slice;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Slice normaliseFState(FSId id)
|
|
|
|
{
|
|
|
|
debug(format("normalising fstate"));
|
|
|
|
Nest nest(true);
|
|
|
|
|
|
|
|
/* Try to substitute $id$ by any known successors in order to
|
|
|
|
speed up the rewrite process. */
|
|
|
|
string idSucc;
|
|
|
|
while (queryDB(nixDB, dbSuccessors, id, idSucc)) {
|
|
|
|
debug(format("successor %1% -> %2%") % (string) id % idSucc);
|
|
|
|
id = parseHash(idSucc);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get the fstate expression. */
|
|
|
|
FState fs = termFromId(id);
|
|
|
|
|
|
|
|
/* Already in normal form (i.e., a slice)? */
|
|
|
|
if (ATgetType(fs) == AT_APPL &&
|
|
|
|
(string) ATgetName(ATgetAFun(fs)) == "Slice")
|
|
|
|
return parseSlice(fs);
|
|
|
|
|
|
|
|
/* Then we it's a Derive node. */
|
|
|
|
ATermList outs, ins, bnds;
|
|
|
|
char * builder;
|
|
|
|
char * platform;
|
|
|
|
if (!ATmatch(fs, "Derive([<list>], [<list>], <str>, <str>, [<list>])",
|
|
|
|
&outs, &ins, &builder, &platform, &bnds))
|
|
|
|
throw badTerm("not a derive", fs);
|
|
|
|
|
|
|
|
/* Right platform? */
|
|
|
|
checkPlatform(platform);
|
|
|
|
|
|
|
|
/* Realise inputs (and remember all input paths). */
|
|
|
|
FSIds inIds;
|
|
|
|
parseIds(ins, inIds);
|
|
|
|
|
|
|
|
SliceElems inElems; /* !!! duplicates */
|
|
|
|
StringSet inPathsSet;
|
|
|
|
for (FSIds::iterator i = inIds.begin(); i != inIds.end(); i++) {
|
|
|
|
Slice slice = normaliseFState(*i);
|
|
|
|
realiseSlice(slice);
|
|
|
|
|
|
|
|
for (SliceElems::iterator j = slice.elems.begin();
|
|
|
|
j != slice.elems.end(); j++)
|
|
|
|
{
|
|
|
|
inElems.push_back(*j);
|
|
|
|
inPathsSet.insert(j->path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Strings inPaths;
|
|
|
|
copy(inPathsSet.begin(), inPathsSet.end(),
|
|
|
|
inserter(inPaths, inPaths.begin()));
|
|
|
|
|
|
|
|
/* Build the environment. */
|
|
|
|
Environment env;
|
|
|
|
while (!ATisEmpty(bnds)) {
|
|
|
|
char * s1, * s2;
|
|
|
|
ATerm bnd = ATgetFirst(bnds);
|
|
|
|
if (!ATmatch(bnd, "(<str>, <str>)", &s1, &s2))
|
|
|
|
throw badTerm("tuple of strings expected", bnd);
|
|
|
|
env[s1] = s2;
|
|
|
|
bnds = ATgetNext(bnds);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check that none of the output paths exist. */
|
|
|
|
typedef pair<string, FSId> OutPath;
|
|
|
|
list<OutPath> outPaths;
|
|
|
|
while (!ATisEmpty(outs)) {
|
|
|
|
ATerm t = ATgetFirst(outs);
|
|
|
|
char * s1, * s2;
|
|
|
|
if (!ATmatch(t, "(<str>, <str>)", &s1, &s2))
|
|
|
|
throw badTerm("string expected", t);
|
|
|
|
outPaths.push_back(OutPath(s1, parseHash(s2)));
|
|
|
|
outs = ATgetNext(outs);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (list<OutPath>::iterator i = outPaths.begin();
|
|
|
|
i != outPaths.end(); i++)
|
|
|
|
if (pathExists(i->first))
|
|
|
|
throw Error(format("path `%1%' exists") % i->first);
|
|
|
|
|
|
|
|
/* Run the builder. */
|
|
|
|
runProgram(builder, env);
|
|
|
|
|
|
|
|
Slice slice;
|
|
|
|
|
|
|
|
/* Check whether the output paths were created, and register each
|
|
|
|
one. */
|
|
|
|
for (list<OutPath>::iterator i = outPaths.begin();
|
|
|
|
i != outPaths.end(); i++)
|
|
|
|
{
|
|
|
|
string path = i->first;
|
|
|
|
if (!pathExists(path))
|
|
|
|
throw Error(format("path `%1%' does not exist") % path);
|
|
|
|
registerPath(path, i->second);
|
|
|
|
slice.roots.push_back(i->second);
|
|
|
|
|
|
|
|
Strings outPaths = filterReferences(path, inPaths);
|
|
|
|
}
|
|
|
|
|
|
|
|
return slice;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void realiseSlice(Slice slice)
|
|
|
|
{
|
|
|
|
debug(format("realising slice"));
|
|
|
|
Nest nest(true);
|
|
|
|
|
|
|
|
if (slice.elems.size() == 0)
|
|
|
|
throw Error("empty slice");
|
|
|
|
|
|
|
|
/* Perhaps all paths already contain the right id? */
|
|
|
|
|
|
|
|
bool missing = false;
|
|
|
|
for (SliceElems::iterator i = slice.elems.begin();
|
|
|
|
i != slice.elems.end(); i++)
|
|
|
|
{
|
|
|
|
SliceElem elem = *i;
|
|
|
|
string id;
|
|
|
|
if (!queryDB(nixDB, dbPath2Id, elem.path, id)) {
|
|
|
|
if (pathExists(elem.path))
|
|
|
|
throw Error(format("path `%1%' obstructed") % elem.path);
|
|
|
|
missing = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (parseHash(id) != elem.id)
|
|
|
|
throw Error(format("path `%1%' obstructed") % elem.path);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!missing) {
|
|
|
|
debug(format("already installed"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* For each element, expand its id at its path. */
|
|
|
|
for (SliceElems::iterator i = slice.elems.begin();
|
|
|
|
i != slice.elems.end(); i++)
|
|
|
|
{
|
|
|
|
SliceElem elem = *i;
|
|
|
|
expandId(elem.id, elem.path);
|
|
|
|
}
|
|
|
|
}
|