lix/src/fix-ng/primops.cc
Eelco Dolstra fa18f1f184 * Assertions.
* Logical operators (!, &&, ||, ->).
2003-11-05 16:27:40 +00:00

241 lines
6.8 KiB
C++

#include "primops.hh"
#include "normalise.hh"
#include "globals.hh"
Expr primImport(EvalState & state, Expr arg)
{
char * path;
if (!ATmatch(arg, "Path(<str>)", &path))
throw badTerm("path expected", arg);
return evalFile(state, path);
}
static PathSet nixExprRootsCached(EvalState & state, const Path & nePath)
{
DrvPaths::iterator i = state.drvPaths.find(nePath);
if (i != state.drvPaths.end())
return i->second;
else {
PathSet paths = nixExprRoots(nePath);
state.drvPaths[nePath] = paths;
return paths;
}
}
static Hash hashDerivation(EvalState & state, NixExpr ne)
{
if (ne.type == NixExpr::neDerivation) {
PathSet inputs2;
for (PathSet::iterator i = ne.derivation.inputs.begin();
i != ne.derivation.inputs.end(); i++)
{
DrvHashes::iterator j = state.drvHashes.find(*i);
if (j == state.drvHashes.end())
throw Error(format("don't know expression `%1%'") % (string) *i);
inputs2.insert(j->second);
}
ne.derivation.inputs = inputs2;
}
return hashTerm(unparseNixExpr(ne));
}
static Path copyAtom(EvalState & state, const Path & srcPath)
{
/* !!! should be cached */
Path dstPath(addToStore(srcPath));
ClosureElem elem;
NixExpr ne;
ne.type = NixExpr::neClosure;
ne.closure.roots.insert(dstPath);
ne.closure.elems[dstPath] = elem;
Hash drvHash = hashDerivation(state, ne);
Path drvPath = writeTerm(unparseNixExpr(ne), "");
state.drvHashes[drvPath] = drvHash;
msg(lvlChatty, format("copied `%1%' -> closure `%2%'")
% srcPath % drvPath);
return drvPath;
}
static string addInput(EvalState & state,
Path & nePath, NixExpr & ne)
{
PathSet paths = nixExprRootsCached(state, nePath);
if (paths.size() != 1) abort();
Path path = *(paths.begin());
ne.derivation.inputs.insert(nePath);
return path;
}
static string processBinding(EvalState & state, Expr e, NixExpr & ne)
{
e = evalExpr(state, e);
char * s;
ATermList es;
if (ATmatch(e, "Str(<str>)", &s)) return s;
if (ATmatch(e, "Uri(<str>)", &s)) return s;
if (ATmatch(e, "Bool(True)")) return "1";
if (ATmatch(e, "Bool(False)")) return "";
if (ATmatch(e, "Attrs([<list>])", &es)) {
Expr a = queryAttr(e, "type");
if (a && evalString(state, a) == "derivation") {
a = queryAttr(e, "drvPath");
if (a) {
Path drvPath = evalPath(state, a);
return addInput(state, drvPath, ne);
}
}
}
if (ATmatch(e, "Path(<str>)", &s)) {
Path drvPath = copyAtom(state, s);
return addInput(state, drvPath, ne);
}
if (ATmatch(e, "List([<list>])", &es)) {
string s;
bool first = true;
while (!ATisEmpty(es)) {
Nest nest(lvlVomit, format("processing list element"));
if (!first) s = s + " "; else first = false;
s += processBinding(state, evalExpr(state, ATgetFirst(es)), ne);
es = ATgetNext(es);
}
return s;
}
throw badTerm("invalid derivation binding", e);
}
Expr primDerivation(EvalState & state, Expr args)
{
Nest nest(lvlVomit, "evaluating derivation");
ATermMap attrs;
args = evalExpr(state, args);
queryAllAttrs(args, attrs);
/* Build the derivation expression by processing the attributes. */
NixExpr ne;
ne.type = NixExpr::neDerivation;
string drvName;
Path outPath;
Hash outHash;
bool outHashGiven = false;
for (ATermList keys = attrs.keys(); !ATisEmpty(keys);
keys = ATgetNext(keys))
{
string key = aterm2String(ATgetFirst(keys));
Expr value = attrs.get(key);
Nest nest(lvlVomit, format("processing attribute `%1%'") % key);
/* The `args' attribute is special: it supplies the
command-line arguments to the builder. */
if (key == "args") {
ATermList args;
if (!ATmatch(value, "[<list>]", &args))
throw badTerm("list expected", value);
while (!ATisEmpty(args)) {
Expr arg = evalExpr(state, ATgetFirst(args));
ne.derivation.args.push_back(processBinding(state, arg, ne));
args = ATgetNext(args);
}
}
/* All other attributes are passed to the builder through the
environment. */
else {
string s = processBinding(state, value, ne);
ne.derivation.env[key] = s;
if (key == "builder") ne.derivation.builder = s;
else if (key == "system") ne.derivation.platform = s;
else if (key == "name") drvName = s;
else if (key == "outPath") outPath = s;
else if (key == "id") {
outHash = parseHash(s);
outHashGiven = true;
}
}
}
/* Do we have all required attributes? */
if (ne.derivation.builder == "")
throw badTerm("required attribute `builder' missing", args);
if (ne.derivation.platform == "")
throw badTerm("required attribute `system' missing", args);
if (drvName == "")
throw badTerm("required attribute `name' missing", args);
/* Determine the output path. */
if (!outHashGiven) outHash = hashDerivation(state, ne);
if (outPath == "")
/* Hash the Nix expression with no outputs to produce a
unique but deterministic path name for this derivation. */
outPath = canonPath(nixStore + "/" +
((string) outHash).c_str() + "-" + drvName);
ne.derivation.env["out"] = outPath;
ne.derivation.outputs.insert(outPath);
/* Write the resulting term into the Nix store directory. */
Hash drvHash = outHashGiven
? hashString((string) outHash + outPath)
: hashDerivation(state, ne);
Path drvPath = writeTerm(unparseNixExpr(ne), "-d-" + drvName);
state.drvHashes[drvPath] = drvHash;
msg(lvlChatty, format("instantiated `%1%' -> `%2%'")
% drvName % drvPath);
attrs.set("outPath", ATmake("Path(<str>)", outPath.c_str()));
attrs.set("drvPath", ATmake("Path(<str>)", drvPath.c_str()));
attrs.set("type", ATmake("Str(\"derivation\")"));
return makeAttrs(attrs);
}
Expr primBaseNameOf(EvalState & state, Expr arg)
{
string s = evalString(state, arg);
return ATmake("Str(<str>)", baseNameOf(s).c_str());
}
Expr primToString(EvalState & state, Expr arg)
{
arg = evalExpr(state, arg);
char * s;
if (ATmatch(arg, "Str(<str>)", &s) ||
ATmatch(arg, "Path(<str>)", &s) ||
ATmatch(arg, "Uri(<str>)", &s))
return ATmake("Str(<str>)", s);
else throw badTerm("cannot coerce to string", arg);
}
Expr primNull(EvalState & state, Expr arg)
{
return ATmake("Null");
}
Expr primIsNull(EvalState & state, Expr arg)
{
arg = evalExpr(state, arg);
return makeBool(ATmatch(arg, "Null"));
}