lix/src/eval.cc

487 lines
13 KiB
C++
Raw Normal View History

#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>
#include "eval.hh"
#include "globals.hh"
#include "values.hh"
#include "db.hh"
/* A Unix environment is a mapping from strings to strings. */
typedef map<string, string> Environment;
/* Return true iff the given path exists. */
bool pathExists(string path)
{
int res;
struct stat st;
res = stat(path.c_str(), &st);
if (!res) return true;
if (errno != ENOENT)
throw SysError("getting status of " + path);
return false;
}
/* Compute a derived value by running a program. */
static Hash computeDerived(Hash sourceHash, string targetName,
string platform, Hash prog, Environment env)
{
string targetPath = nixValues + "/" +
(string) sourceHash + "-nf";
/* Check whether the target already exists. */
if (pathExists(targetPath))
throw Error("derived value in " + targetPath + " already exists");
/* Find the program corresponding to the hash `prog'. */
string progPath = queryValuePath(prog);
/* Finalize the environment. */
env["out"] = targetPath;
/* Create a log file. */
string logFileName =
nixLogDir + "/" + baseNameOf(targetPath) + ".log";
/* !!! auto-pclose on exit */
FILE * logFile = popen(("tee " + logFileName + " >&2").c_str(), "w"); /* !!! escaping */
if (!logFile)
throw SysError("unable to create log file " + logFileName);
try {
/* Fork a child to build the package. */
pid_t pid;
switch (pid = fork()) {
case -1:
throw SysError("unable to fork");
case 0:
try { /* child */
#if 0
/* Try to use a prebuilt. */
string prebuiltHashS, prebuiltFile;
if (queryDB(nixDB, dbPrebuilts, hash, prebuiltHashS)) {
try {
prebuiltFile = getFile(parseHash(prebuiltHashS));
} catch (Error e) {
cerr << "cannot obtain prebuilt (ignoring): " << e.what() << endl;
goto build;
}
cerr << "substituting prebuilt " << prebuiltFile << endl;
int res = system(("tar xfj " + prebuiltFile + " 1>&2").c_str()); // !!! escaping
if (WEXITSTATUS(res) != 0)
/* This is a fatal error, because path may now
have clobbered. */
throw Error("cannot unpack " + prebuiltFile);
_exit(0);
}
#endif
2003-06-27 09:55:31 +00:00
// build:
/* 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 Error("cannot pipe standard error into log file: " + string(strerror(errno)));
/* Dup stderr to stdin. */
if (dup2(STDERR_FILENO, STDOUT_FILENO) == -1)
throw Error("cannot dup stderr into stdout");
/* Make the program executable. !!! hack. */
if (chmod(progPath.c_str(), 0755))
throw Error("cannot make program executable");
/* Execute the program. This should not return. */
execle(progPath.c_str(), baseNameOf(progPath).c_str(), 0, env2);
throw Error("unable to execute builder: " +
string(strerror(errno)));
} catch (exception & e) {
cerr << "build error: " << e.what() << endl;
}
_exit(1);
}
/* parent */
/* 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");
/* Check whether the result was created. */
if (!pathExists(targetPath))
throw Error("program " + progPath +
" failed to create a result in " + targetPath);
2003-06-16 15:59:23 +00:00
#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);
2003-06-16 15:59:23 +00:00
#endif
} catch (exception &) {
// system(("rm -rf " + targetPath).c_str());
throw;
}
/* Hash the result. */
2003-06-16 15:59:23 +00:00
Hash targetHash = hashPath(targetPath);
/* Register targetHash -> targetPath. !!! this should be in
values.cc. */
2003-06-16 21:01:18 +00:00
setDB(nixDB, dbRefs, targetHash, targetName);
/* Register that targetHash was produced by evaluating
sourceHash; i.e., that targetHash is a normal form of
sourceHash. !!! this shouldn't be here */
setDB(nixDB, dbNFs, sourceHash, targetHash);
return targetHash;
}
/* Throw an exception if the given platform string is not supported by
the platform we are executing on. */
static void checkPlatform(string platform)
{
if (platform != thisSystem)
throw Error("a `" + platform +
"' is required, but I am a `" + thisSystem + "'");
}
2003-06-17 13:37:44 +00:00
string printExpr(Expr e)
{
char * s = ATwriteToString(e);
return s;
}
/* Throw an exception with an error message containing the given
aterm. */
static Error badTerm(const string & msg, Expr e)
{
2003-06-17 13:37:44 +00:00
return Error(msg + ", in `" + printExpr(e) + "'");
}
2003-06-17 13:37:44 +00:00
Hash hashExpr(Expr e)
{
2003-06-17 13:37:44 +00:00
return hashString(printExpr(e));
}
/* Evaluate an expression; the result must be a string. */
static string evalString(Expr e)
{
2003-06-27 09:55:31 +00:00
e = whNormalise(e);
char * s;
if (ATmatch(e, "Str(<str>)", &s)) return s;
else throw badTerm("string value expected", e);
}
2003-06-27 09:55:31 +00:00
#if 0
2003-06-17 15:45:43 +00:00
/* Evaluate an expression; the result must be a value reference. */
static Hash evalHash(Expr e)
{
2003-06-17 13:37:44 +00:00
e = evalValue(e);
char * s;
2003-06-17 15:45:43 +00:00
if (ATmatch(e, "Hash(<str>)", &s)) return parseHash(s);
else throw badTerm("value reference expected", e);
}
2003-06-27 09:55:31 +00:00
#endif
2003-06-27 09:55:31 +00:00
#if 0
2003-06-16 21:01:18 +00:00
/* Evaluate a list of arguments into normal form. */
void evalArgs(ATermList args, ATermList & argsNF, Environment & env)
{
argsNF = ATempty;
while (!ATisEmpty(args)) {
ATerm eName, eVal, arg = ATgetFirst(args);
if (!ATmatch(arg, "Tup(<term>, <term>)", &eName, &eVal))
throw badTerm("invalid argument", arg);
string name = evalString(eName);
2003-06-17 13:37:44 +00:00
eVal = evalValue(eVal);
2003-06-16 21:01:18 +00:00
char * s;
if (ATmatch(eVal, "Str(<str>)", &s)) {
env[name] = s;
2003-06-17 15:45:43 +00:00
} else if (ATmatch(eVal, "Hash(<str>)", &s)) {
2003-06-16 21:01:18 +00:00
env[name] = queryValuePath(parseHash(s));
} else throw badTerm("invalid argument value", eVal);
argsNF = ATinsert(argsNF,
2003-06-16 21:01:18 +00:00
ATmake("Tup(Str(<str>), <term>)", name.c_str(), eVal));
args = ATgetNext(args);
}
argsNF = ATreverse(argsNF);
}
2003-06-27 09:55:31 +00:00
#endif
Expr substExpr(string x, Expr rep, Expr e)
{
char * s;
Expr e2;
if (ATmatch(e, "Var(<str>)", &s))
if (x == s)
return rep;
else
return e;
if (ATmatch(e, "Lam(<str>, <term>)", &s, &e2))
if (x == s)
return e;
/* !!! unfair substitutions */
/* Generically substitute in subterms. */
if (ATgetType(e) == AT_APPL) {
AFun fun = ATgetAFun(e);
int arity = ATgetArity(fun);
ATermList args = ATempty;
for (int i = arity - 1; i >= 0; i--)
args = ATinsert(args, substExpr(x, rep, ATgetArgument(e, i)));
return (ATerm) ATmakeApplList(fun, args);
}
if (ATgetType(e) == AT_LIST) {
ATermList in = (ATermList) e;
ATermList out = ATempty;
while (!ATisEmpty(in)) {
out = ATinsert(out, substExpr(x, rep, ATgetFirst(in)));
in = ATgetNext(in);
}
return (ATerm) ATreverse(out);
}
throw badTerm("do not know how to substitute", e);
2003-06-16 21:01:18 +00:00
}
2003-06-27 09:55:31 +00:00
#if 0
2003-06-17 13:37:44 +00:00
Expr evalValue(Expr e)
{
char * s;
Expr eBuildPlatform, eProg, e2, e3, e4;
ATermList args;
2003-06-17 15:45:43 +00:00
/* Value references. */
if (ATmatch(e, "Hash(<str>)", &s)) {
2003-06-17 13:37:44 +00:00
parseHash(s); /* i.e., throw exception if not valid */
return e;
}
2003-06-17 15:45:43 +00:00
/* External expression. */
if (ATmatch(e, "Deref(<term>)", &e2)) {
string fn = queryValuePath(evalHash(e2));
ATerm e3 = ATreadFromNamedFile(fn.c_str());
if (!e3) throw Error("reading aterm from " + fn);
return evalValue(e3);
2003-06-17 15:45:43 +00:00
}
/* Execution primitive. */
2003-06-17 13:37:44 +00:00
if (ATmatch(e, "Exec(<term>, <term>, [<list>])",
&eBuildPlatform, &eProg, &args))
{
string buildPlatform = evalString(eBuildPlatform);
checkPlatform(buildPlatform);
2003-06-17 15:45:43 +00:00
Hash prog = evalHash(eProg);
Environment env;
2003-06-16 21:01:18 +00:00
ATermList argsNF;
evalArgs(args, argsNF, env);
Hash sourceHash = hashExpr(
ATmake("Exec(Str(<str>), Hash(<str>), <term>)",
buildPlatform.c_str(), ((string) prog).c_str(), argsNF));
/* Do we know a normal form for sourceHash? */
Hash targetHash;
string targetHashS;
if (queryDB(nixDB, dbNFs, sourceHash, targetHashS)) {
/* Yes. */
targetHash = parseHash(targetHashS);
debug("already built: " + (string) sourceHash
+ " -> " + (string) targetHash);
} else {
/* No, so we compute one. */
targetHash = computeDerived(sourceHash,
(string) sourceHash + "-nf", buildPlatform, prog, env);
}
2003-06-17 15:45:43 +00:00
return ATmake("Hash(<str>)", ((string) targetHash).c_str());
}
/* Barf. */
2003-06-17 13:37:44 +00:00
throw badTerm("invalid expression", e);
}
2003-06-27 09:55:31 +00:00
#endif
Expr whNormalise(Expr e)
{
char * s;
Expr e2, e3, e4, e5;
/* Normal forms. */
if (ATmatch(e, "Str(<str>)", &s) ||
ATmatch(e, "Bool(True)") ||
ATmatch(e, "Bool(False)") ||
ATmatch(e, "Lam(<str>, <term>)", &s, &e2) ||
ATmatch(e, "File(<str>, <term>, <term>)", &s, &e2, &e3) ||
ATmatch(e, "Derive(<term>, <term>, <term>, <term>)", &e2, &e3, &e4, &e5))
return e;
/* Application. */
if (ATmatch(e, "App(<term>, <term>)", &e2, &e3)) {
e2 = whNormalise(e2);
if (!ATmatch(e2, "Lam(<str>, <term>)", &s, &e4))
throw badTerm("expecting lambda", e2);
return whNormalise(substExpr(s, e3, e4));
}
throw badTerm("invalid expression", e);
}
Expr dNormalise(Expr e)
{
e = whNormalise(e);
/* !!! todo */
return e;
}
Expr fNormalise(Expr e)
{
e = dNormalise(e);
char * s;
Expr e2, e3;
if (ATmatch(e, "File(<str>, <term>, [<list>])", &s, &e2, &e3)) {
ATermList refs = (ATermList) e3, refs2 = ATempty;
while (!ATisEmpty(refs)) {
ATerm ref = ATgetFirst(refs);
refs2 = ATinsert(refs2, fNormalise(ref));
refs = ATgetNext(refs);
}
refs2 = ATreverse(refs2);
return ATmake("File(<str>, <term>, <term>)", s, e2, refs2);
}
else return e;
}
void writeContent(string path, Content content)
{
char * s;
if (ATmatch(content, "Regular(<str>)", &s)) {
int fd; /* !!! close on exception */
fd = open(path.c_str(), O_CREAT | O_EXCL | O_WRONLY, 0666);
if (fd == -1)
throw SysError("creating file " + path);
int len = strlen(s);
if (write(fd, s, len) != len)
throw SysError("writing file " + path);
close(fd);
}
else throw badTerm("ill-formed content", content);
}
struct RStatus
{
/* !!! the comparator of this hash should match the semantics of
the file system */
map<string, Hash> paths;
};
static void realise2(RStatus & status, Expr e)
{
char * s;
Content content;
ATermList refs;
if (!ATmatch(e, "File(<str>, <term>, [<list>])", &s, &content, &refs))
throw badTerm("not f-normalised", e);
string path(s);
while (!ATisEmpty(refs)) {
realise2(status, ATgetFirst(refs));
refs = ATgetNext(refs);
}
writeContent(path, content);
}
void realise(Expr e)
{
RStatus status;
realise2(status, e);
}