2005-09-13 13:17:01 +00:00
|
|
|
#include <algorithm>
|
|
|
|
|
|
2005-01-19 16:39:47 +00:00
|
|
|
#include "build.hh"
|
2006-03-06 11:21:15 +00:00
|
|
|
#include "misc.hh"
|
2004-08-04 10:59:20 +00:00
|
|
|
#include "eval.hh"
|
2003-10-31 17:09:31 +00:00
|
|
|
#include "globals.hh"
|
2004-10-29 11:22:49 +00:00
|
|
|
#include "nixexpr-ast.hh"
|
2006-08-24 14:34:29 +00:00
|
|
|
#include "expr-to-xml.hh"
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
|
|
|
|
2006-08-23 14:39:11 +00:00
|
|
|
static Expr primBuiltins(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
|
|
|
|
/* Return an attribute set containing all primops. This allows
|
|
|
|
|
Nix expressions to test for new primops and take appropriate
|
|
|
|
|
action if they're not available. For instance, rather than
|
|
|
|
|
calling a primop `foo' directly, they could say `if builtins ?
|
|
|
|
|
foo then builtins.foo ... else ...'. */
|
|
|
|
|
|
|
|
|
|
ATermMap builtins(128);
|
|
|
|
|
|
|
|
|
|
for (ATermMap::const_iterator i = state.primOps.begin();
|
|
|
|
|
i != state.primOps.end(); ++i)
|
|
|
|
|
{
|
|
|
|
|
string name = aterm2String(i->key);
|
|
|
|
|
if (string(name, 0, 2) == "__")
|
|
|
|
|
name = string(name, 2);
|
|
|
|
|
/* !!! should use makePrimOp here, I guess. */
|
|
|
|
|
builtins.set(toATerm(name), makeAttrRHS(makeVar(i->key), makeNoPos()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return makeAttrs(builtins);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Load and evaluate an expression from path specified by the
|
|
|
|
|
argument. */
|
|
|
|
|
static Expr primImport(EvalState & state, const ATermVector & args)
|
2003-10-31 17:09:31 +00:00
|
|
|
{
|
2005-05-02 14:44:58 +00:00
|
|
|
ATermList es;
|
|
|
|
|
Path path;
|
|
|
|
|
|
|
|
|
|
Expr arg = evalExpr(state, args[0]), arg2;
|
|
|
|
|
|
|
|
|
|
if (matchPath(arg, arg2))
|
|
|
|
|
path = aterm2String(arg2);
|
|
|
|
|
|
|
|
|
|
else if (matchAttrs(arg, es)) {
|
|
|
|
|
Expr a = queryAttr(arg, "type");
|
|
|
|
|
|
|
|
|
|
/* If it is a derivation, we have to realise it and load the
|
|
|
|
|
Nix expression created at the derivation's output path. */
|
|
|
|
|
if (a && evalString(state, a) == "derivation") {
|
|
|
|
|
a = queryAttr(arg, "drvPath");
|
2006-07-19 15:36:15 +00:00
|
|
|
if (!a) throw EvalError("bad derivation in import");
|
2005-05-02 14:44:58 +00:00
|
|
|
Path drvPath = evalPath(state, a);
|
|
|
|
|
|
|
|
|
|
buildDerivations(singleton<PathSet>(drvPath));
|
|
|
|
|
|
|
|
|
|
a = queryAttr(arg, "outPath");
|
2006-07-19 15:36:15 +00:00
|
|
|
if (!a) throw EvalError("bad derivation in import");
|
2005-05-02 14:44:58 +00:00
|
|
|
path = evalPath(state, a);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (path == "")
|
2006-07-19 15:36:15 +00:00
|
|
|
throw TypeError("`import' requires a path or derivation as its argument");
|
2005-05-02 14:44:58 +00:00
|
|
|
|
|
|
|
|
return evalFile(state, path);
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
/* Returns the hash of a derivation modulo fixed-output
|
|
|
|
|
subderivations. A fixed-output derivation is a derivation with one
|
|
|
|
|
output (`out') for which an expected hash and hash algorithm are
|
|
|
|
|
specified (using the `outputHash' and `outputHashAlgo'
|
|
|
|
|
attributes). We don't want changes to such derivations to
|
|
|
|
|
propagate upwards through the dependency graph, changing output
|
|
|
|
|
paths everywhere.
|
|
|
|
|
|
|
|
|
|
For instance, if we change the url in a call to the `fetchurl'
|
|
|
|
|
function, we do not want to rebuild everything depending on it
|
|
|
|
|
(after all, (the hash of) the file being downloaded is unchanged).
|
|
|
|
|
So the *output paths* should not change. On the other hand, the
|
|
|
|
|
*derivation store expression paths* should change to reflect the
|
|
|
|
|
new dependency graph.
|
|
|
|
|
|
|
|
|
|
That's what this function does: it returns a hash which is just the
|
|
|
|
|
of the derivation ATerm, except that any input store expression
|
|
|
|
|
paths have been replaced by the result of a recursive call to this
|
|
|
|
|
function, and that for fixed-output derivations we return
|
|
|
|
|
(basically) its outputHash. */
|
2005-01-19 11:16:11 +00:00
|
|
|
static Hash hashDerivationModulo(EvalState & state, Derivation drv)
|
2003-10-31 17:09:31 +00:00
|
|
|
{
|
2005-01-19 11:16:11 +00:00
|
|
|
/* Return a fixed hash for fixed-output derivations. */
|
|
|
|
|
if (drv.outputs.size() == 1) {
|
|
|
|
|
DerivationOutputs::const_iterator i = drv.outputs.begin();
|
|
|
|
|
if (i->first == "out" &&
|
|
|
|
|
i->second.hash != "")
|
|
|
|
|
{
|
|
|
|
|
return hashString(htSHA256, "fixed:out:"
|
|
|
|
|
+ i->second.hashAlgo + ":"
|
|
|
|
|
+ i->second.hash + ":"
|
|
|
|
|
+ i->second.path);
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
}
|
2005-01-19 11:16:11 +00:00
|
|
|
}
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
|
2005-01-19 11:16:11 +00:00
|
|
|
/* For other derivations, replace the inputs paths with recursive
|
|
|
|
|
calls to this function.*/
|
2005-01-20 14:10:19 +00:00
|
|
|
DerivationInputs inputs2;
|
|
|
|
|
for (DerivationInputs::iterator i = drv.inputDrvs.begin();
|
2005-01-19 11:16:11 +00:00
|
|
|
i != drv.inputDrvs.end(); ++i)
|
|
|
|
|
{
|
2005-01-20 14:10:19 +00:00
|
|
|
Hash h = state.drvHashes[i->first];
|
2005-01-19 11:16:11 +00:00
|
|
|
if (h.type == htUnknown) {
|
2005-01-20 14:10:19 +00:00
|
|
|
Derivation drv2 = derivationFromPath(i->first);
|
2005-01-19 11:16:11 +00:00
|
|
|
h = hashDerivationModulo(state, drv2);
|
2005-01-20 14:10:19 +00:00
|
|
|
state.drvHashes[i->first] = h;
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
2005-01-20 14:10:19 +00:00
|
|
|
inputs2[printHash(h)] = i->second;
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
2005-01-19 11:16:11 +00:00
|
|
|
drv.inputDrvs = inputs2;
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
|
2005-01-19 11:16:11 +00:00
|
|
|
return hashTerm(unparseDerivation(drv));
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-01-19 11:16:11 +00:00
|
|
|
static void processBinding(EvalState & state, Expr e, Derivation & drv,
|
2004-03-28 20:34:22 +00:00
|
|
|
Strings & ss)
|
2003-10-31 17:09:31 +00:00
|
|
|
{
|
|
|
|
|
e = evalExpr(state, e);
|
|
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
ATerm s;
|
2003-10-31 17:09:31 +00:00
|
|
|
ATermList es;
|
2004-03-28 20:34:22 +00:00
|
|
|
int n;
|
2004-03-28 20:58:28 +00:00
|
|
|
Expr e1, e2;
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2006-05-01 09:56:56 +00:00
|
|
|
if (matchContext(e, es, e2)) {
|
|
|
|
|
e = e2;
|
|
|
|
|
for (ATermIterator i(es); i; ++i) {
|
|
|
|
|
Strings dummy;
|
|
|
|
|
processBinding(state, *i, drv, dummy);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
if (matchStr(e, s)) ss.push_back(aterm2String(s));
|
|
|
|
|
else if (matchUri(e, s)) ss.push_back(aterm2String(s));
|
|
|
|
|
else if (e == eTrue) ss.push_back("1");
|
|
|
|
|
else if (e == eFalse) ss.push_back("");
|
2006-08-26 16:48:01 +00:00
|
|
|
else if (matchInt(e, n)) ss.push_back(int2String(n));
|
2003-11-25 12:05:48 +00:00
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
else if (matchAttrs(e, es)) {
|
2003-10-31 17:09:31 +00:00
|
|
|
Expr a = queryAttr(e, "type");
|
2005-02-11 16:56:45 +00:00
|
|
|
|
2003-10-31 17:09:31 +00:00
|
|
|
if (a && evalString(state, a) == "derivation") {
|
|
|
|
|
a = queryAttr(e, "drvPath");
|
2006-07-19 15:36:15 +00:00
|
|
|
if (!a) throw EvalError("derivation name missing");
|
2003-11-21 14:23:18 +00:00
|
|
|
Path drvPath = evalPath(state, a);
|
|
|
|
|
|
2004-10-25 14:38:23 +00:00
|
|
|
a = queryAttr(e, "outPath");
|
2006-07-19 15:36:15 +00:00
|
|
|
if (!a) throw EvalError("output path missing");
|
2005-01-19 11:16:11 +00:00
|
|
|
/* !!! supports only single output path */
|
|
|
|
|
Path outPath = evalPath(state, a);
|
2004-10-25 14:38:23 +00:00
|
|
|
|
2005-02-11 16:56:45 +00:00
|
|
|
drv.inputDrvs[drvPath] = singleton<StringSet>("out");
|
2005-01-19 11:16:11 +00:00
|
|
|
ss.push_back(outPath);
|
2005-02-11 16:56:45 +00:00
|
|
|
}
|
|
|
|
|
|
2006-08-25 17:09:55 +00:00
|
|
|
else throw TypeError("attribute sets in derivations must be derivations");
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
else if (matchPath(e, s)) {
|
2005-01-20 15:25:01 +00:00
|
|
|
Path srcPath(canonPath(aterm2String(s)));
|
2005-04-07 14:35:01 +00:00
|
|
|
|
|
|
|
|
if (isStorePath(srcPath)) {
|
|
|
|
|
printMsg(lvlChatty, format("using store path `%1%' as source")
|
|
|
|
|
% srcPath);
|
|
|
|
|
drv.inputSrcs.insert(srcPath);
|
|
|
|
|
ss.push_back(srcPath);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else {
|
|
|
|
|
if (isDerivation(srcPath))
|
2006-07-19 15:36:15 +00:00
|
|
|
throw EvalError(format("file names are not allowed to end in `%1%'")
|
2005-04-07 14:35:01 +00:00
|
|
|
% drvExtension);
|
2006-03-09 15:09:18 +00:00
|
|
|
Path dstPath;
|
|
|
|
|
if (state.srcToStore[srcPath] != "")
|
|
|
|
|
dstPath = state.srcToStore[srcPath];
|
|
|
|
|
else {
|
|
|
|
|
dstPath = addToStore(srcPath);
|
|
|
|
|
state.srcToStore[srcPath] = dstPath;
|
|
|
|
|
printMsg(lvlChatty, format("copied source `%1%' -> `%2%'")
|
|
|
|
|
% srcPath % dstPath);
|
|
|
|
|
}
|
2005-04-07 14:35:01 +00:00
|
|
|
drv.inputSrcs.insert(dstPath);
|
|
|
|
|
ss.push_back(dstPath);
|
|
|
|
|
}
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
else if (matchList(e, es)) {
|
2003-11-16 18:31:29 +00:00
|
|
|
for (ATermIterator i(es); i; ++i) {
|
2003-11-09 10:35:45 +00:00
|
|
|
startNest(nest, lvlVomit, format("processing list element"));
|
2005-01-19 11:16:11 +00:00
|
|
|
processBinding(state, evalExpr(state, *i), drv, ss);
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
}
|
2003-11-06 15:24:31 +00:00
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
else if (matchNull(e)) ss.push_back("");
|
2004-03-28 20:58:28 +00:00
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
else if (matchSubPath(e, e1, e2)) {
|
2006-08-09 15:08:47 +00:00
|
|
|
static bool warn = false;
|
|
|
|
|
if (!warn) {
|
|
|
|
|
printMsg(lvlError, "warning: the subpath operator (~) is deprecated, use string concatenation (+) instead");
|
|
|
|
|
warn = true;
|
|
|
|
|
}
|
2004-03-28 20:58:28 +00:00
|
|
|
Strings ss2;
|
2005-01-19 11:16:11 +00:00
|
|
|
processBinding(state, evalExpr(state, e1), drv, ss2);
|
2004-03-28 20:58:28 +00:00
|
|
|
if (ss2.size() != 1)
|
2006-07-19 15:36:15 +00:00
|
|
|
throw TypeError("left-hand side of `~' operator cannot be a list");
|
2004-03-28 20:58:28 +00:00
|
|
|
e2 = evalExpr(state, e2);
|
2004-10-26 22:54:26 +00:00
|
|
|
if (!(matchStr(e2, s) || matchPath(e2, s)))
|
2006-07-19 15:36:15 +00:00
|
|
|
throw TypeError("right-hand side of `~' operator must be a path or string");
|
2004-10-26 22:54:26 +00:00
|
|
|
ss.push_back(canonPath(ss2.front() + "/" + aterm2String(s)));
|
2004-03-28 20:58:28 +00:00
|
|
|
}
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2006-07-19 15:36:15 +00:00
|
|
|
else throw TypeError(format("%1% is not allowed as a derivation argument") % showType(e));
|
2004-03-28 20:34:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static string concatStrings(const Strings & ss)
|
|
|
|
|
{
|
|
|
|
|
string s;
|
|
|
|
|
bool first = true;
|
|
|
|
|
for (Strings::const_iterator i = ss.begin(); i != ss.end(); ++i) {
|
|
|
|
|
if (!first) s += " "; else first = false;
|
|
|
|
|
s += *i;
|
|
|
|
|
}
|
|
|
|
|
return s;
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Construct (as a unobservable side effect) a Nix derivation
|
|
|
|
|
expression that performs the derivation described by the argument
|
|
|
|
|
set. Returns the original set extended with the following
|
|
|
|
|
attributes: `outPath' containing the primary output path of the
|
|
|
|
|
derivation; `drvPath' containing the path of the Nix expression;
|
|
|
|
|
and `type' set to `derivation' to indicate that this is a
|
|
|
|
|
derivation. */
|
2005-05-07 21:48:49 +00:00
|
|
|
static Expr primDerivationStrict(EvalState & state, const ATermVector & args)
|
2003-10-31 17:09:31 +00:00
|
|
|
{
|
2003-11-09 10:35:45 +00:00
|
|
|
startNest(nest, lvlVomit, "evaluating derivation");
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2006-05-04 12:21:08 +00:00
|
|
|
ATermMap attrs(128); /* !!! */
|
2005-05-07 21:48:49 +00:00
|
|
|
queryAllAttrs(evalExpr(state, args[0]), attrs, true);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2006-03-24 14:02:44 +00:00
|
|
|
/* Figure out the name already (for stack backtraces). */
|
2006-05-04 12:21:08 +00:00
|
|
|
Expr eDrvName = attrs.get(toATerm("name"));
|
2006-03-24 14:02:44 +00:00
|
|
|
if (!eDrvName)
|
2006-07-19 15:36:15 +00:00
|
|
|
throw EvalError("required attribute `name' missing");
|
2006-03-24 14:02:44 +00:00
|
|
|
ATerm posDrvName;
|
|
|
|
|
if (!matchAttrRHS(eDrvName, eDrvName, posDrvName)) abort();
|
|
|
|
|
string drvName = evalString(state, eDrvName);
|
|
|
|
|
|
2003-10-31 17:09:31 +00:00
|
|
|
/* Build the derivation expression by processing the attributes. */
|
2005-01-19 11:16:11 +00:00
|
|
|
Derivation drv;
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
|
|
|
|
|
string outputHash;
|
|
|
|
|
string outputHashAlgo;
|
2005-02-22 21:14:41 +00:00
|
|
|
bool outputHashRecursive = false;
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2006-05-04 12:21:08 +00:00
|
|
|
for (ATermMap::const_iterator i = attrs.begin(); i != attrs.end(); ++i) {
|
|
|
|
|
string key = aterm2String(i->key);
|
2004-04-05 22:27:41 +00:00
|
|
|
ATerm value;
|
|
|
|
|
Expr pos;
|
2006-05-04 12:21:08 +00:00
|
|
|
ATerm rhs = i->value;
|
2004-10-26 22:54:26 +00:00
|
|
|
if (!matchAttrRHS(rhs, value, pos)) abort();
|
2003-11-09 10:35:45 +00:00
|
|
|
startNest(nest, lvlVomit, format("processing attribute `%1%'") % key);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2004-03-28 20:34:22 +00:00
|
|
|
Strings ss;
|
2004-04-02 10:49:37 +00:00
|
|
|
try {
|
2005-01-19 11:16:11 +00:00
|
|
|
processBinding(state, value, drv, ss);
|
2004-04-02 10:49:37 +00:00
|
|
|
} catch (Error & e) {
|
2006-03-08 14:11:19 +00:00
|
|
|
e.addPrefix(format("while processing the derivation attribute `%1%' at %2%:\n")
|
|
|
|
|
% key % showPos(pos));
|
2006-03-24 14:02:44 +00:00
|
|
|
e.addPrefix(format("while instantiating the derivation named `%1%' at %2%:\n")
|
|
|
|
|
% drvName % showPos(posDrvName));
|
2006-03-08 14:11:19 +00:00
|
|
|
throw;
|
2004-04-02 10:49:37 +00:00
|
|
|
}
|
2004-03-28 20:34:22 +00:00
|
|
|
|
2003-10-31 17:09:31 +00:00
|
|
|
/* The `args' attribute is special: it supplies the
|
|
|
|
|
command-line arguments to the builder. */
|
|
|
|
|
if (key == "args") {
|
2004-03-28 20:34:22 +00:00
|
|
|
for (Strings::iterator i = ss.begin(); i != ss.end(); ++i)
|
2005-01-19 11:16:11 +00:00
|
|
|
drv.args.push_back(*i);
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* All other attributes are passed to the builder through the
|
|
|
|
|
environment. */
|
|
|
|
|
else {
|
2004-03-28 20:34:22 +00:00
|
|
|
string s = concatStrings(ss);
|
2005-01-19 11:16:11 +00:00
|
|
|
drv.env[key] = s;
|
|
|
|
|
if (key == "builder") drv.builder = s;
|
|
|
|
|
else if (key == "system") drv.platform = s;
|
2003-10-31 17:09:31 +00:00
|
|
|
else if (key == "name") drvName = s;
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
else if (key == "outputHash") outputHash = s;
|
|
|
|
|
else if (key == "outputHashAlgo") outputHashAlgo = s;
|
2005-02-22 21:14:41 +00:00
|
|
|
else if (key == "outputHashMode") {
|
|
|
|
|
if (s == "recursive") outputHashRecursive = true;
|
|
|
|
|
else if (s == "flat") outputHashRecursive = false;
|
2006-07-19 15:36:15 +00:00
|
|
|
else throw EvalError(format("invalid value `%1%' for `outputHashMode' attribute") % s);
|
2005-02-22 21:14:41 +00:00
|
|
|
}
|
2003-10-31 17:09:31 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Do we have all required attributes? */
|
2005-01-19 11:16:11 +00:00
|
|
|
if (drv.builder == "")
|
2006-07-19 15:36:15 +00:00
|
|
|
throw EvalError("required attribute `builder' missing");
|
2005-01-19 11:16:11 +00:00
|
|
|
if (drv.platform == "")
|
2006-07-19 15:36:15 +00:00
|
|
|
throw EvalError("required attribute `system' missing");
|
2004-08-24 11:46:05 +00:00
|
|
|
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
/* If an output hash was given, check it. */
|
|
|
|
|
if (outputHash == "")
|
|
|
|
|
outputHashAlgo = "";
|
|
|
|
|
else {
|
|
|
|
|
HashType ht = parseHashType(outputHashAlgo);
|
|
|
|
|
if (ht == htUnknown)
|
2006-07-19 15:36:15 +00:00
|
|
|
throw EvalError(format("unknown hash algorithm `%1%'") % outputHashAlgo);
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
Hash h;
|
|
|
|
|
if (outputHash.size() == Hash(ht).hashSize * 2)
|
|
|
|
|
/* hexadecimal representation */
|
|
|
|
|
h = parseHash(ht, outputHash);
|
|
|
|
|
else
|
|
|
|
|
/* base-32 representation */
|
|
|
|
|
h = parseHash32(ht, outputHash);
|
|
|
|
|
string s = outputHash;
|
|
|
|
|
outputHash = printHash(h);
|
2005-02-22 21:14:41 +00:00
|
|
|
if (outputHashRecursive) outputHashAlgo = "r:" + outputHashAlgo;
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
}
|
|
|
|
|
|
2004-08-24 11:46:05 +00:00
|
|
|
/* Check the derivation name. It shouldn't contain whitespace,
|
|
|
|
|
but we are conservative here: we check whether only
|
|
|
|
|
alphanumerics and some other characters appear. */
|
2005-04-07 14:01:51 +00:00
|
|
|
checkStoreName(drvName);
|
2005-01-20 15:25:01 +00:00
|
|
|
if (isDerivation(drvName))
|
2006-07-19 15:36:15 +00:00
|
|
|
throw EvalError(format("derivation names are not allowed to end in `%1%'")
|
2005-01-20 15:25:01 +00:00
|
|
|
% drvExtension);
|
|
|
|
|
|
2005-01-19 14:36:00 +00:00
|
|
|
/* !!! the name should not end in the derivation extension (.drv).
|
|
|
|
|
Likewise for sources. */
|
|
|
|
|
|
2005-01-14 13:51:38 +00:00
|
|
|
/* Construct the "masked" derivation store expression, which is
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
the final one except that in the list of outputs, the output
|
|
|
|
|
paths are empty, and the corresponding environment variables
|
|
|
|
|
have an empty value. This ensures that changes in the set of
|
|
|
|
|
output names do get reflected in the hash. */
|
2005-01-19 11:16:11 +00:00
|
|
|
drv.env["out"] = "";
|
|
|
|
|
drv.outputs["out"] =
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
DerivationOutput("", outputHashAlgo, outputHash);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
/* Use the masked derivation expression to compute the output
|
|
|
|
|
path. */
|
2005-01-14 13:51:38 +00:00
|
|
|
Path outPath = makeStorePath("output:out",
|
2005-01-19 11:16:11 +00:00
|
|
|
hashDerivationModulo(state, drv), drvName);
|
2005-01-14 13:51:38 +00:00
|
|
|
|
|
|
|
|
/* Construct the final derivation store expression. */
|
2005-01-19 11:16:11 +00:00
|
|
|
drv.env["out"] = outPath;
|
|
|
|
|
drv.outputs["out"] =
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
DerivationOutput(outPath, outputHashAlgo, outputHash);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
|
|
|
/* Write the resulting term into the Nix store directory. */
|
2005-01-19 14:36:00 +00:00
|
|
|
Path drvPath = writeDerivation(drv, drvName);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2003-11-09 10:35:45 +00:00
|
|
|
printMsg(lvlChatty, format("instantiated `%1%' -> `%2%'")
|
2003-10-31 17:09:31 +00:00
|
|
|
% drvName % drvPath);
|
|
|
|
|
|
2005-01-18 11:15:50 +00:00
|
|
|
/* Optimisation, but required in read-only mode! because in that
|
|
|
|
|
case we don't actually write store expressions, so we can't
|
|
|
|
|
read them later. */
|
2005-01-19 11:16:11 +00:00
|
|
|
state.drvHashes[drvPath] = hashDerivationModulo(state, drv);
|
2005-01-18 11:15:50 +00:00
|
|
|
|
* Removed the `id' attribute hack.
* Formalise the notion of fixed-output derivations, i.e., derivations
for which a cryptographic hash of the output is known in advance.
Changes to such derivations should not propagate upwards through the
dependency graph. Previously this was done by specifying the hash
component of the output path through the `id' attribute, but this is
insecure since you can lie about it (i.e., you can specify any hash
and then produce a completely different output). Now the
responsibility for checking the output is moved from the builder to
Nix itself.
A fixed-output derivation can be created by specifying the
`outputHash' and `outputHashAlgo' attributes, the latter taking
values `md5', `sha1', and `sha256', and the former specifying the
actual hash in hexadecimal or in base-32 (auto-detected by looking
at the length of the attribute value). MD5 is included for
compatibility but should be considered deprecated.
* Removed the `drvPath' pseudo-attribute in derivation results. It's
no longer necessary.
* Cleaned up the support for multiple output paths in derivation store
expressions. Each output now has a unique identifier (e.g., `out',
`devel', `docs'). Previously there was no way to tell output paths
apart at the store expression level.
* `nix-hash' now has a flag `--base32' to specify that the hash should
be printed in base-32 notation.
* `fetchurl' accepts parameters `sha256' and `sha1' in addition to
`md5'.
* `nix-prefetch-url' now prints out a SHA-1 hash in base-32. (TODO: a
flag to specify the hash.)
2005-01-17 16:55:19 +00:00
|
|
|
/* !!! assumes a single output */
|
2006-05-04 12:21:08 +00:00
|
|
|
ATermMap outAttrs(2);
|
|
|
|
|
outAttrs.set(toATerm("outPath"),
|
|
|
|
|
makeAttrRHS(makePath(toATerm(outPath)), makeNoPos()));
|
|
|
|
|
outAttrs.set(toATerm("drvPath"),
|
|
|
|
|
makeAttrRHS(makePath(toATerm(drvPath)), makeNoPos()));
|
2005-05-07 21:48:49 +00:00
|
|
|
|
|
|
|
|
return makeAttrs(outAttrs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static Expr primDerivationLazy(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
|
|
|
|
Expr eAttrs = evalExpr(state, args[0]);
|
2006-05-04 12:21:08 +00:00
|
|
|
ATermMap attrs(128); /* !!! */
|
2005-05-07 21:48:49 +00:00
|
|
|
queryAllAttrs(eAttrs, attrs, true);
|
|
|
|
|
|
2006-05-04 12:21:08 +00:00
|
|
|
attrs.set(toATerm("type"),
|
|
|
|
|
makeAttrRHS(makeStr(toATerm("derivation")), makeNoPos()));
|
2003-10-31 17:09:31 +00:00
|
|
|
|
2005-05-07 21:48:49 +00:00
|
|
|
Expr drvStrict = makeCall(makeVar(toATerm("derivation!")), eAttrs);
|
|
|
|
|
|
2006-05-04 12:21:08 +00:00
|
|
|
attrs.set(toATerm("outPath"),
|
|
|
|
|
makeAttrRHS(makeSelect(drvStrict, toATerm("outPath")), makeNoPos()));
|
|
|
|
|
attrs.set(toATerm("drvPath"),
|
|
|
|
|
makeAttrRHS(makeSelect(drvStrict, toATerm("drvPath")), makeNoPos()));
|
2005-05-07 21:48:49 +00:00
|
|
|
|
2003-10-31 17:09:31 +00:00
|
|
|
return makeAttrs(attrs);
|
|
|
|
|
}
|
2003-11-02 16:31:35 +00:00
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Return the base name of the given string, i.e., everything
|
|
|
|
|
following the last slash. */
|
|
|
|
|
static Expr primBaseNameOf(EvalState & state, const ATermVector & args)
|
2003-11-02 16:31:35 +00:00
|
|
|
{
|
2004-11-03 18:12:03 +00:00
|
|
|
return makeStr(toATerm(baseNameOf(evalString(state, args[0]))));
|
2003-11-02 16:31:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
/* Return the directory of the given path, i.e., everything before the
|
|
|
|
|
last slash. */
|
|
|
|
|
static Expr primDirOf(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
|
|
|
|
return makePath(toATerm(dirOf(evalPath(state, args[0]))));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-03-10 16:20:42 +00:00
|
|
|
ATerm coerceToString(Expr e)
|
|
|
|
|
{
|
|
|
|
|
ATerm s;
|
|
|
|
|
if (matchStr(e, s) || matchPath(e, s) || matchUri(e, s))
|
|
|
|
|
return s;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Convert the argument (which can be a path or a uri) to a string. */
|
|
|
|
|
static Expr primToString(EvalState & state, const ATermVector & args)
|
2003-11-02 16:31:35 +00:00
|
|
|
{
|
2006-05-01 09:56:56 +00:00
|
|
|
ATermList context = ATempty;
|
|
|
|
|
bool dummy;
|
|
|
|
|
string s = coerceToStringWithContext(state, context, args[0], dummy);
|
|
|
|
|
return wrapInContext(context, makeStr(toATerm(s)));
|
2003-11-02 16:31:35 +00:00
|
|
|
}
|
2003-11-05 16:27:40 +00:00
|
|
|
|
|
|
|
|
|
2006-08-24 14:34:29 +00:00
|
|
|
static Expr primToXML(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
|
|
|
|
ostringstream out;
|
|
|
|
|
printTermAsXML(strictEvalExpr(state, args[0]), out);
|
|
|
|
|
return makeStr(toATerm(out.str()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Boolean constructors. */
|
|
|
|
|
static Expr primTrue(EvalState & state, const ATermVector & args)
|
2004-02-04 16:03:29 +00:00
|
|
|
{
|
2004-10-26 22:54:26 +00:00
|
|
|
return eTrue;
|
2004-02-04 16:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
static Expr primFalse(EvalState & state, const ATermVector & args)
|
2004-02-04 16:03:29 +00:00
|
|
|
{
|
2004-10-26 22:54:26 +00:00
|
|
|
return eFalse;
|
2004-02-04 16:03:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Return the null value. */
|
2005-04-10 17:38:19 +00:00
|
|
|
static Expr primNull(EvalState & state, const ATermVector & args)
|
2003-11-05 16:27:40 +00:00
|
|
|
{
|
2004-10-26 22:54:26 +00:00
|
|
|
return makeNull();
|
2003-11-05 16:27:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Determine whether the argument is the null value. */
|
2005-04-10 17:38:19 +00:00
|
|
|
static Expr primIsNull(EvalState & state, const ATermVector & args)
|
2003-11-05 16:27:40 +00:00
|
|
|
{
|
2004-10-26 22:54:26 +00:00
|
|
|
return makeBool(matchNull(evalExpr(state, args[0])));
|
2003-11-05 16:27:40 +00:00
|
|
|
}
|
2004-08-04 10:59:20 +00:00
|
|
|
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
static Path findDependency(Path dir, string dep)
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
{
|
2006-07-19 15:36:15 +00:00
|
|
|
if (dep[0] == '/') throw EvalError(
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
format("illegal absolute dependency `%1%'") % dep);
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
Path p = canonPath(dir + "/" + dep);
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
|
|
|
if (pathExists(p))
|
|
|
|
|
return p;
|
|
|
|
|
else
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Make path `p' relative to directory `pivot'. E.g.,
|
|
|
|
|
relativise("/a/b/c", "a/b/x/y") => "../x/y". Both input paths
|
|
|
|
|
should be in absolute canonical form. */
|
|
|
|
|
static string relativise(Path pivot, Path p)
|
|
|
|
|
{
|
|
|
|
|
assert(pivot.size() > 0 && pivot[0] == '/');
|
|
|
|
|
assert(p.size() > 0 && p[0] == '/');
|
|
|
|
|
|
|
|
|
|
if (pivot == p) return ".";
|
|
|
|
|
|
|
|
|
|
/* `p' is in `pivot'? */
|
|
|
|
|
Path pivot2 = pivot + "/";
|
|
|
|
|
if (p.substr(0, pivot2.size()) == pivot2) {
|
|
|
|
|
return p.substr(pivot2.size());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Otherwise, `p' is in a parent of `pivot'. Find up till which
|
|
|
|
|
path component `p' and `pivot' match, and add an appropriate
|
|
|
|
|
number of `..' components. */
|
2006-05-11 02:19:43 +00:00
|
|
|
string::size_type i = 1;
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
while (1) {
|
2006-05-11 02:19:43 +00:00
|
|
|
string::size_type j = pivot.find('/', i);
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
if (j == string::npos) break;
|
|
|
|
|
j++;
|
|
|
|
|
if (pivot.substr(0, j) != p.substr(0, j)) break;
|
|
|
|
|
i = j;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
string prefix;
|
|
|
|
|
unsigned int slashes = count(pivot.begin() + i, pivot.end(), '/') + 1;
|
|
|
|
|
while (slashes--) {
|
|
|
|
|
prefix += "../";
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return prefix + p.substr(i);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static Expr primDependencyClosure(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
2005-08-14 14:00:39 +00:00
|
|
|
startNest(nest, lvlDebug, "finding dependencies");
|
|
|
|
|
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
Expr attrs = evalExpr(state, args[0]);
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
/* Get the start set. */
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
Expr startSet = queryAttr(attrs, "startSet");
|
2006-07-19 15:36:15 +00:00
|
|
|
if (!startSet) throw EvalError("attribute `startSet' required");
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
ATermList startSet2 = evalList(state, startSet);
|
|
|
|
|
|
|
|
|
|
Path pivot;
|
|
|
|
|
PathSet workSet;
|
|
|
|
|
for (ATermIterator i(startSet2); i; ++i) {
|
|
|
|
|
Path p = evalPath(state, *i);
|
|
|
|
|
workSet.insert(p);
|
|
|
|
|
pivot = dirOf(p);
|
|
|
|
|
}
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
/* Get the search path. */
|
|
|
|
|
PathSet searchPath;
|
|
|
|
|
Expr e = queryAttr(attrs, "searchPath");
|
|
|
|
|
if (e) {
|
|
|
|
|
ATermList list = evalList(state, e);
|
|
|
|
|
for (ATermIterator i(list); i; ++i) {
|
|
|
|
|
Path p = evalPath(state, *i);
|
|
|
|
|
searchPath.insert(p);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Expr scanner = queryAttr(attrs, "scanner");
|
2006-07-19 15:36:15 +00:00
|
|
|
if (!scanner) throw EvalError("attribute `scanner' required");
|
2005-08-14 14:00:39 +00:00
|
|
|
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
/* Construct the dependency closure by querying the dependency of
|
|
|
|
|
each path in `workSet', adding the dependencies to
|
|
|
|
|
`workSet'. */
|
|
|
|
|
PathSet doneSet;
|
|
|
|
|
while (!workSet.empty()) {
|
|
|
|
|
Path path = *(workSet.begin());
|
|
|
|
|
workSet.erase(path);
|
|
|
|
|
|
|
|
|
|
if (doneSet.find(path) != doneSet.end()) continue;
|
|
|
|
|
doneSet.insert(path);
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
try {
|
|
|
|
|
|
|
|
|
|
/* Call the `scanner' function with `path' as argument. */
|
|
|
|
|
debug(format("finding dependencies in `%1%'") % path);
|
|
|
|
|
ATermList deps = evalList(state, makeCall(scanner, makePath(toATerm(path))));
|
|
|
|
|
|
|
|
|
|
/* Try to find the dependencies relative to the `path'. */
|
|
|
|
|
for (ATermIterator i(deps); i; ++i) {
|
|
|
|
|
string s = evalString(state, *i);
|
|
|
|
|
|
|
|
|
|
Path dep = findDependency(dirOf(path), s);
|
|
|
|
|
|
|
|
|
|
if (dep == "") {
|
|
|
|
|
for (PathSet::iterator j = searchPath.begin();
|
|
|
|
|
j != searchPath.end(); ++j)
|
|
|
|
|
{
|
|
|
|
|
dep = findDependency(*j, s);
|
|
|
|
|
if (dep != "") break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dep == "")
|
|
|
|
|
debug(format("did NOT find dependency `%1%'") % s);
|
|
|
|
|
else {
|
|
|
|
|
debug(format("found dependency `%1%'") % dep);
|
|
|
|
|
workSet.insert(dep);
|
|
|
|
|
}
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
}
|
2005-08-14 14:00:39 +00:00
|
|
|
|
|
|
|
|
} catch (Error & e) {
|
2006-03-08 14:11:19 +00:00
|
|
|
e.addPrefix(format("while finding dependencies in `%1%':\n")
|
|
|
|
|
% path);
|
|
|
|
|
throw;
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return a list of the dependencies we've just found. */
|
|
|
|
|
ATermList deps = ATempty;
|
|
|
|
|
for (PathSet::iterator i = doneSet.begin(); i != doneSet.end(); ++i) {
|
|
|
|
|
deps = ATinsert(deps, makeStr(toATerm(relativise(pivot, *i))));
|
|
|
|
|
deps = ATinsert(deps, makePath(toATerm(*i)));
|
|
|
|
|
}
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
debug(format("dependency list is `%1%'") % makeList(deps));
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
|
|
|
return makeList(deps);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-08-23 15:46:00 +00:00
|
|
|
static Expr primAbort(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
2006-08-23 15:46:27 +00:00
|
|
|
throw Abort(format("evaluation aborted with the following error message: `%1%'") %
|
2006-08-23 15:46:00 +00:00
|
|
|
evalString(state, args[0]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
/* Apply a function to every element of a list. */
|
2005-04-10 17:38:19 +00:00
|
|
|
static Expr primMap(EvalState & state, const ATermVector & args)
|
2004-08-04 10:59:20 +00:00
|
|
|
{
|
2004-08-04 11:27:53 +00:00
|
|
|
Expr fun = evalExpr(state, args[0]);
|
2005-07-25 15:05:34 +00:00
|
|
|
ATermList list = evalList(state, args[1]);
|
2004-08-04 11:27:53 +00:00
|
|
|
|
2005-07-25 15:05:34 +00:00
|
|
|
ATermList res = ATempty;
|
|
|
|
|
for (ATermIterator i(list); i; ++i)
|
|
|
|
|
res = ATinsert(res, makeCall(fun, *i));
|
2004-08-04 11:27:53 +00:00
|
|
|
|
2005-07-25 15:05:34 +00:00
|
|
|
return makeList(ATreverse(res));
|
2004-08-04 10:59:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-04-10 17:38:19 +00:00
|
|
|
/* Return a string constant representing the current platform. Note!
|
|
|
|
|
that differs between platforms, so Nix expressions using
|
|
|
|
|
`__currentSystem' can evaluate to different values on different
|
|
|
|
|
platforms. */
|
|
|
|
|
static Expr primCurrentSystem(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
|
|
|
|
return makeStr(toATerm(thisSystem));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-05-02 14:44:58 +00:00
|
|
|
static Expr primCurrentTime(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
|
|
|
|
return ATmake("Int(<int>)", time(0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-05-18 17:19:21 +00:00
|
|
|
static Expr primRemoveAttrs(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
2006-05-04 12:21:08 +00:00
|
|
|
ATermMap attrs(128); /* !!! */
|
2005-05-18 17:19:21 +00:00
|
|
|
queryAllAttrs(evalExpr(state, args[0]), attrs, true);
|
|
|
|
|
|
2005-07-25 15:05:34 +00:00
|
|
|
ATermList list = evalList(state, args[1]);
|
2005-05-18 17:19:21 +00:00
|
|
|
|
|
|
|
|
for (ATermIterator i(list); i; ++i)
|
|
|
|
|
/* It's not an error for *i not to exist. */
|
2006-05-04 12:21:08 +00:00
|
|
|
attrs.remove(toATerm(evalString(state, *i)));
|
2005-05-18 17:19:21 +00:00
|
|
|
|
|
|
|
|
return makeAttrs(attrs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2005-08-14 14:00:39 +00:00
|
|
|
static Expr primRelativise(EvalState & state, const ATermVector & args)
|
|
|
|
|
{
|
|
|
|
|
Path pivot = evalPath(state, args[0]);
|
|
|
|
|
Path path = evalPath(state, args[1]);
|
|
|
|
|
return makeStr(toATerm(relativise(pivot, path)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
void EvalState::addPrimOps()
|
|
|
|
|
{
|
2006-08-23 14:39:11 +00:00
|
|
|
addPrimOp("builtins", 0, primBuiltins);
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
addPrimOp("true", 0, primTrue);
|
|
|
|
|
addPrimOp("false", 0, primFalse);
|
|
|
|
|
addPrimOp("null", 0, primNull);
|
2005-04-10 17:38:19 +00:00
|
|
|
addPrimOp("__currentSystem", 0, primCurrentSystem);
|
2005-05-02 14:44:58 +00:00
|
|
|
addPrimOp("__currentTime", 0, primCurrentTime);
|
2004-08-04 10:59:20 +00:00
|
|
|
|
|
|
|
|
addPrimOp("import", 1, primImport);
|
2005-05-07 21:48:49 +00:00
|
|
|
addPrimOp("derivation!", 1, primDerivationStrict);
|
|
|
|
|
addPrimOp("derivation", 1, primDerivationLazy);
|
2004-08-04 10:59:20 +00:00
|
|
|
addPrimOp("baseNameOf", 1, primBaseNameOf);
|
2005-08-14 14:00:39 +00:00
|
|
|
addPrimOp("dirOf", 1, primDirOf);
|
2004-08-04 10:59:20 +00:00
|
|
|
addPrimOp("toString", 1, primToString);
|
2006-08-24 14:34:29 +00:00
|
|
|
addPrimOp("__toXML", 1, primToXML);
|
2004-08-04 10:59:20 +00:00
|
|
|
addPrimOp("isNull", 1, primIsNull);
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
addPrimOp("dependencyClosure", 1, primDependencyClosure);
|
2006-08-23 15:46:00 +00:00
|
|
|
addPrimOp("abort", 1, primAbort);
|
2004-08-04 11:27:53 +00:00
|
|
|
|
|
|
|
|
addPrimOp("map", 2, primMap);
|
2005-05-18 17:19:21 +00:00
|
|
|
addPrimOp("removeAttrs", 2, primRemoveAttrs);
|
2005-08-14 14:00:39 +00:00
|
|
|
addPrimOp("relativise", 2, primRelativise);
|
2004-08-04 10:59:20 +00:00
|
|
|
}
|