lix-releng-staging/src/libexpr/primops.cc

1113 lines
36 KiB
C++
Raw Normal View History

#include "eval.hh"
#include "misc.hh"
#include "globals.hh"
#include "store-api.hh"
#include "util.hh"
#include "archive.hh"
2010-04-07 13:59:45 +00:00
#include "value-to-xml.hh"
#include "names.hh"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <algorithm>
2010-03-30 09:22:33 +00:00
#include <cstring>
namespace nix {
2007-01-29 15:11:32 +00:00
/*************************************************************
* Miscellaneous
*************************************************************/
/* Load and evaluate an expression from path specified by the
argument. */
2010-03-30 09:22:33 +00:00
static void prim_import(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-03-30 09:22:33 +00:00
Path path = state.coerceToPath(*args[0], context);
2006-11-03 16:17:39 +00:00
for (PathSet::iterator i = context.begin(); i != context.end(); ++i) {
assert(isStorePath(*i));
if (!store->isValidPath(*i))
2006-11-03 16:17:39 +00:00
throw EvalError(format("cannot import `%1%', since path `%2%' is not valid")
% path % *i);
if (isDerivation(*i))
try {
store->buildDerivations(singleton<PathSet>(*i));
} catch (Error & e) {
throw ImportError(e.msg());
}
2006-11-03 16:17:39 +00:00
}
2010-03-30 09:22:33 +00:00
state.evalFile(path, v);
}
2007-01-29 15:11:32 +00:00
/* Determine whether the argument is the null value. */
2010-03-30 15:18:20 +00:00
static void prim_isNull(EvalState & state, Value * * args, Value & v)
2007-01-29 15:11:32 +00:00
{
2010-03-30 22:39:48 +00:00
state.forceValue(*args[0]);
mkBool(v, args[0]->type == tNull);
2007-01-29 15:11:32 +00:00
}
/* Determine whether the argument is a function. */
2010-03-30 15:18:20 +00:00
static void prim_isFunction(EvalState & state, Value * * args, Value & v)
{
2010-03-30 22:39:48 +00:00
state.forceValue(*args[0]);
mkBool(v, args[0]->type == tLambda);
}
2010-03-30 22:39:48 +00:00
/* Determine whether the argument is an Int. */
2010-03-30 15:18:20 +00:00
static void prim_isInt(EvalState & state, Value * * args, Value & v)
{
2010-03-30 22:39:48 +00:00
state.forceValue(*args[0]);
mkBool(v, args[0]->type == tInt);
}
2010-03-30 22:39:48 +00:00
/* Determine whether the argument is an String. */
2010-03-30 15:18:20 +00:00
static void prim_isString(EvalState & state, Value * * args, Value & v)
{
2010-03-30 22:39:48 +00:00
state.forceValue(*args[0]);
mkBool(v, args[0]->type == tString);
}
2010-03-30 22:39:48 +00:00
/* Determine whether the argument is an Bool. */
2010-03-30 15:18:20 +00:00
static void prim_isBool(EvalState & state, Value * * args, Value & v)
{
2010-03-30 22:39:48 +00:00
state.forceValue(*args[0]);
mkBool(v, args[0]->type == tBool);
}
2010-03-30 22:39:48 +00:00
2010-04-21 15:57:11 +00:00
struct CompareValues
{
bool operator () (const Value & v1, const Value & v2) const
{
if (v1.type != v2.type)
throw EvalError("cannot compare values of different types");
switch (v1.type) {
case tInt:
return v1.integer < v2.integer;
case tString:
return strcmp(v1.string.s, v2.string.s) < 0;
case tPath:
return strcmp(v1.path, v2.path) < 0;
default:
throw EvalError(format("cannot compare %1% with %2%") % showType(v1) % showType(v2));
}
}
};
2010-03-30 15:18:20 +00:00
static void prim_genericClosure(EvalState & state, Value * * args, Value & v)
2007-01-29 15:11:32 +00:00
{
startNest(nest, lvlDebug, "finding dependencies");
state.forceAttrs(*args[0]);
2007-01-29 15:11:32 +00:00
/* Get the start set. */
Bindings::iterator startSet =
args[0]->attrs->find(state.symbols.create("startSet"));
if (startSet == args[0]->attrs->end())
throw EvalError("attribute `startSet' required");
state.forceList(*startSet->value);
2007-01-29 15:11:32 +00:00
2010-04-21 15:57:11 +00:00
list<Value *> workSet;
for (unsigned int n = 0; n < startSet->value->list.length; ++n)
workSet.push_back(startSet->value->list.elems[n]);
2007-01-29 15:11:32 +00:00
/* Get the operator. */
Bindings::iterator op =
args[0]->attrs->find(state.symbols.create("operator"));
if (op == args[0]->attrs->end())
throw EvalError("attribute `operator' required");
state.forceValue(*op->value);
2010-04-21 15:57:11 +00:00
/* Construct the closure by applying the operator to element of
`workSet', adding the result to `workSet', continuing until
no new elements are found. */
list<Value> res;
set<Value, CompareValues> doneKeys; // !!! use Value *?
2007-01-29 15:11:32 +00:00
while (!workSet.empty()) {
2010-04-21 15:57:11 +00:00
Value * e = *(workSet.begin());
workSet.pop_front();
2007-01-29 15:11:32 +00:00
2010-04-21 15:57:11 +00:00
state.forceAttrs(*e);
2007-01-29 15:11:32 +00:00
2010-04-21 15:57:11 +00:00
Bindings::iterator key =
e->attrs->find(state.symbols.create("key"));
if (key == e->attrs->end())
throw EvalError("attribute `key' required");
state.forceValue(*key->value);
2007-01-29 15:11:32 +00:00
if (doneKeys.find(*key->value) != doneKeys.end()) continue;
doneKeys.insert(*key->value);
2010-04-21 15:57:11 +00:00
res.push_back(*e);
/* Call the `operator' function with `e' as argument. */
2010-04-21 15:57:11 +00:00
Value call;
mkApp(call, *op->value, *e);
2010-04-21 15:57:11 +00:00
state.forceList(call);
/* Add the values returned by the operator to the work set. */
for (unsigned int n = 0; n < call.list.length; ++n) {
state.forceValue(*call.list.elems[n]);
workSet.push_back(call.list.elems[n]);
}
2007-01-29 15:11:32 +00:00
}
2010-04-21 15:57:11 +00:00
/* Create the result list. */
state.mkList(v, res.size());
unsigned int n = 0;
2010-10-23 18:18:07 +00:00
foreach (list<Value>::iterator, i, res)
*(v.list.elems[n++] = state.allocValue()) = *i;
2007-01-29 15:11:32 +00:00
}
2010-03-30 15:18:20 +00:00
static void prim_abort(EvalState & state, Value * * args, Value & v)
2007-01-29 15:11:32 +00:00
{
PathSet context;
throw Abort(format("evaluation aborted with the following error message: `%1%'") %
2010-03-30 22:39:48 +00:00
state.coerceToString(*args[0], context));
2007-01-29 15:11:32 +00:00
}
2010-03-30 15:18:20 +00:00
static void prim_throw(EvalState & state, Value * * args, Value & v)
{
PathSet context;
throw ThrownError(format("user-thrown exception: %1%") %
2010-03-30 22:39:48 +00:00
state.coerceToString(*args[0], context));
}
2010-03-30 15:18:20 +00:00
static void prim_addErrorContext(EvalState & state, Value * * args, Value & v)
{
try {
2010-05-07 12:33:14 +00:00
state.forceValue(*args[1]);
v = *args[1];
} catch (Error & e) {
2010-05-07 12:33:14 +00:00
PathSet context;
e.addPrefix(format("%1%\n") % state.coerceToString(*args[0], context));
throw;
}
}
2010-05-07 12:33:14 +00:00
/* Try evaluating the argument. Success => {success=true; value=something;},
* else => {success=false; value=false;} */
2010-03-30 15:18:20 +00:00
static void prim_tryEval(EvalState & state, Value * * args, Value & v)
{
state.mkAttrs(v, 2);
try {
state.forceValue(*args[0]);
v.attrs->push_back(Attr(state.symbols.create("value"), args[0]));
mkBool(*state.allocAttr(v, state.symbols.create("success")), true);
} catch (AssertionError & e) {
mkBool(*state.allocAttr(v, state.symbols.create("value")), false);
mkBool(*state.allocAttr(v, state.symbols.create("success")), false);
}
v.attrs->sort();
}
2007-01-29 15:11:32 +00:00
/* Return an environment variable. Use with care. */
2010-03-30 15:18:20 +00:00
static void prim_getEnv(EvalState & state, Value * * args, Value & v)
2007-01-29 15:11:32 +00:00
{
2010-03-30 22:39:48 +00:00
string name = state.forceStringNoCtx(*args[0]);
mkString(v, getEnv(name));
2007-01-29 15:11:32 +00:00
}
/* Evaluate the first expression and print it on standard error. Then
return the second expression. Useful for debugging. */
2010-03-30 15:18:20 +00:00
static void prim_trace(EvalState & state, Value * * args, Value & v)
{
state.forceValue(*args[0]);
if (args[0]->type == tString)
printMsg(lvlError, format("trace: %1%") % args[0]->string.s);
else
printMsg(lvlError, format("trace: %1%") % *args[0]);
state.forceValue(*args[1]);
v = *args[1];
}
2007-01-29 15:11:32 +00:00
2007-01-29 15:11:32 +00:00
/*************************************************************
* Derivations
*************************************************************/
/* 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. */
2010-03-30 15:18:20 +00:00
static void prim_derivationStrict(EvalState & state, Value * * args, Value & v)
{
startNest(nest, lvlVomit, "evaluating derivation");
2010-03-31 15:38:03 +00:00
state.forceAttrs(*args[0]);
2010-03-31 15:38:03 +00:00
/* Figure out the name first (for stack backtraces). */
Bindings::iterator attr = args[0]->attrs->find(state.sName);
2010-03-31 15:38:03 +00:00
if (attr == args[0]->attrs->end())
throw EvalError("required attribute `name' missing");
2006-10-23 16:45:19 +00:00
string drvName;
Pos & posDrvName(*attr->pos);
2006-10-23 16:45:19 +00:00
try {
drvName = state.forceStringNoCtx(*attr->value);
2006-10-23 16:45:19 +00:00
} catch (Error & e) {
e.addPrefix(format("while evaluating the derivation attribute `name' at %1%:\n") % posDrvName);
2006-10-23 16:45:19 +00:00
throw;
}
2010-03-31 15:38:03 +00:00
/* Build the derivation expression by processing the attributes. */
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
PathSet context;
string outputHash, outputHashAlgo;
bool outputHashRecursive = false;
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
StringSet outputs;
outputs.insert("out");
2010-03-31 15:38:03 +00:00
foreach (Bindings::iterator, i, *args[0]->attrs) {
string key = i->name;
startNest(nest, lvlVomit, format("processing attribute `%1%'") % key);
try {
/* The `args' attribute is special: it supplies the
command-line arguments to the builder. */
if (key == "args") {
state.forceList(*i->value);
for (unsigned int n = 0; n < i->value->list.length; ++n) {
string s = state.coerceToString(*i->value->list.elems[n], context, true);
drv.args.push_back(s);
}
}
/* All other attributes are passed to the builder through
the environment. */
else {
string s = state.coerceToString(*i->value, context, true);
drv.env[key] = s;
if (key == "builder") drv.builder = s;
else if (i->name == state.sSystem) drv.platform = s;
else if (i->name == state.sName) {
drvName = s;
printMsg(lvlVomit, format("derivation name is `%1%'") % drvName);
}
else if (key == "outputHash") outputHash = s;
else if (key == "outputHashAlgo") outputHashAlgo = s;
else if (key == "outputHashMode") {
if (s == "recursive") outputHashRecursive = true;
else if (s == "flat") outputHashRecursive = false;
else throw EvalError(format("invalid value `%1%' for `outputHashMode' attribute") % s);
}
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
else if (key == "outputs") {
Strings tmp = tokenizeString(s);
outputs.clear();
foreach (Strings::iterator, j, tmp) {
if (outputs.find(*j) != outputs.end())
throw EvalError(format("duplicate derivation output `%1%'") % *j);
/* !!! Check whether *j is a valid attribute
name. */
/* Derivations cannot be named drv, because
then we'd have an attribute drvPath in
the resulting set. */
if (*j == "drv")
throw EvalError(format("invalid derivation output name `drv'") % *j);
outputs.insert(*j);
}
if (outputs.empty())
throw EvalError("derivation cannot have an empty set of outputs");
}
}
} catch (Error & e) {
e.addPrefix(format("while evaluating the derivation attribute `%1%' at %2%:\n")
% key % *i->pos);
e.addPrefix(format("while instantiating the derivation named `%1%' at %2%:\n")
% drvName % posDrvName);
throw;
}
}
/* Everything in the context of the strings in the derivation
attributes should be added as dependencies of the resulting
derivation. */
foreach (PathSet::iterator, i, context) {
Path path = *i;
/* Paths marked with `=' denote that the path of a derivation
is explicitly passed to the builder. Since that allows the
builder to gain access to every path in the dependency
graph of the derivation (including all outputs), all paths
in the graph must be added to this derivation's list of
inputs to ensure that they are available when the builder
runs. */
if (path.at(0) == '=') {
/* !!! This doesn't work if readOnlyMode is set. */
2011-12-21 15:33:30 +00:00
PathSet refs; computeFSClosure(*store, string(path, 1), refs);
foreach (PathSet::iterator, j, refs) {
drv.inputSrcs.insert(*j);
if (isDerivation(*j))
2011-12-16 23:33:01 +00:00
drv.inputDrvs[*j] = store->queryDerivationOutputNames(*j);
}
}
/* See prim_unsafeDiscardOutputDependency. */
2011-12-21 15:33:30 +00:00
else if (path.at(0) == '~')
drv.inputSrcs.insert(string(path, 1));
/* Handle derivation outputs of the form !<name>!<path>. */
else if (path.at(0) == '!') {
size_t index = path.find("!", 1);
drv.inputDrvs[string(path, index + 1)].insert(string(path, 1, index - 1));
}
2011-12-21 15:33:30 +00:00
/* Handle derivation contexts returned by
builtins.storePath. */
else if (isDerivation(path))
drv.inputDrvs[path] = store->queryDerivationOutputNames(path);
2011-12-21 15:33:30 +00:00
/* Otherwise it's a source file. */
else
drv.inputSrcs.insert(path);
}
/* Do we have all required attributes? */
if (drv.builder == "")
throw EvalError("required attribute `builder' missing");
if (drv.platform == "")
throw EvalError("required attribute `system' missing");
2006-09-21 18:52:05 +00:00
/* Check whether the derivation name is valid. */
checkStoreName(drvName);
if (isDerivation(drvName))
throw EvalError(format("derivation names are not allowed to end in `%1%'")
% drvExtension);
if (outputHash != "") {
/* Handle fixed-output derivations. */
if (outputs.size() != 1 || *(outputs.begin()) != "out")
throw Error("multiple outputs are not supported in fixed-output derivations");
HashType ht = parseHashType(outputHashAlgo);
if (ht == htUnknown)
throw EvalError(format("unknown hash algorithm `%1%'") % outputHashAlgo);
Hash h = parseHash16or32(ht, outputHash);
outputHash = printHash(h);
if (outputHashRecursive) outputHashAlgo = "r:" + outputHashAlgo;
Path outPath = makeFixedOutputPath(outputHashRecursive, ht, h, drvName);
drv.env["out"] = outPath;
drv.outputs["out"] = DerivationOutput(outPath, outputHashAlgo, outputHash);
}
else {
/* Construct the "masked" store derivation, which is 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. */
foreach (StringSet::iterator, i, outputs) {
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
drv.env[*i] = "";
drv.outputs[*i] = DerivationOutput("", "", "");
}
/* Use the masked derivation expression to compute the output
path. */
Hash h = hashDerivationModulo(*store, drv);
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
foreach (DerivationOutputs::iterator, i, drv.outputs)
if (i->second.path == "") {
Path outPath = makeOutputPath(i->first, h, drvName);
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
drv.env[i->first] = outPath;
i->second.path = outPath;
}
}
/* Write the resulting term into the Nix store directory. */
Path drvPath = writeDerivation(*store, drv, drvName);
printMsg(lvlChatty, format("instantiated `%1%' -> `%2%'")
% drvName % drvPath);
2005-01-18 11:15:50 +00:00
/* Optimisation, but required in read-only mode! because in that
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
case we don't actually write store derivations, so we can't
2005-01-18 11:15:50 +00:00
read them later. */
drvHashes[drvPath] = hashDerivationModulo(*store, drv);
2005-01-18 11:15:50 +00:00
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
state.mkAttrs(v, 1 + drv.outputs.size());
mkString(*state.allocAttr(v, state.sDrvPath), drvPath, singleton<PathSet>("=" + drvPath));
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
foreach (DerivationOutputs::iterator, i, drv.outputs) {
mkString(*state.allocAttr(v, state.symbols.create(i->first)),
i->second.path, singleton<PathSet>("!" + i->first + "!" + drvPath));
* Support multiple outputs. A derivation can declare multiple outputs by setting the ‘outputs’ attribute. For example: stdenv.mkDerivation { name = "aterm-2.5"; src = ...; outputs = [ "out" "tools" "dev" ]; configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include"; } This derivation creates three outputs, named like this: /nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5 /nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools /nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev That is, the symbolic name of the output is suffixed to the store path (except for the ‘out’ output). Each path is passed to the builder through the corresponding environment variable, e.g., ${tools}. The main reason for multiple outputs is to allow parts of a package to be distributed and garbage-collected separately. For instance, most packages depend on Glibc for its libraries, but don't need its header files. If these are separated into different store paths, then a package that depends on the Glibc libraries only causes the libraries and not the headers to be downloaded. The main problem with multiple outputs is that if one output exists while the others have been garbage-collected (or never downloaded in the first place), and we want to rebuild the other outputs, then this isn't possible because we can't clobber a valid output (it might be in active use). This currently gives an error message like: error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths There are two solutions: 1) Do the build in a chroot. Then we don't need to overwrite the existing path. 2) Use hash rewriting (see the ASE-2005 paper). Scary but it should work. This is not finished yet. There is not yet an easy way to refer to non-default outputs in Nix expressions. Also, mutually recursive outputs aren't detected yet and cause the garbage collector to crash.
2011-07-18 23:31:03 +00:00
}
v.attrs->sort();
2010-03-31 15:38:03 +00:00
}
2003-11-02 16:31:35 +00:00
2007-01-29 15:11:32 +00:00
/*************************************************************
* Paths
*************************************************************/
/* Convert the argument to a path. !!! obsolete? */
2010-03-30 15:18:20 +00:00
static void prim_toPath(EvalState & state, Value * * args, Value & v)
2003-11-02 16:31:35 +00:00
{
PathSet context;
2010-04-16 15:13:47 +00:00
Path path = state.coerceToPath(*args[0], context);
2010-03-30 22:39:48 +00:00
mkString(v, canonPath(path), context);
2003-11-02 16:31:35 +00:00
}
/* Allow a valid store path to be used in an expression. This is
useful in some generated expressions such as in nix-push, which
generates a call to a function with an already existing store path
as argument. You don't want to use `toPath' here because it copies
the path to the Nix store, which yields a copy like
/nix/store/newhash-oldhash-oldname. In the past, `toPath' had
special case behaviour for store paths, but that created weird
corner cases. */
2010-03-30 15:18:20 +00:00
static void prim_storePath(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-04-16 15:13:47 +00:00
Path path = canonPath(state.coerceToPath(*args[0], context));
if (!isInStore(path))
throw EvalError(format("path `%1%' is not in the Nix store") % path);
Path path2 = toStorePath(path);
if (!store->isValidPath(path2))
throw EvalError(format("store path `%1%' is not valid") % path2);
context.insert(path2);
2010-04-16 15:13:47 +00:00
mkString(v, path, context);
}
2010-03-30 15:18:20 +00:00
static void prim_pathExists(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-03-30 22:39:48 +00:00
Path path = state.coerceToPath(*args[0], context);
2007-01-29 15:11:32 +00:00
if (!context.empty())
throw EvalError(format("string `%1%' cannot refer to other paths") % path);
2010-03-30 22:39:48 +00:00
mkBool(v, pathExists(path));
}
2007-01-29 15:11:32 +00:00
/* Return the base name of the given string, i.e., everything
following the last slash. */
2010-03-30 15:18:20 +00:00
static void prim_baseNameOf(EvalState & state, Value * * args, Value & v)
2003-11-02 16:31:35 +00:00
{
PathSet context;
2010-03-30 22:39:48 +00:00
mkString(v, baseNameOf(state.coerceToString(*args[0], context)), context);
2003-11-02 16:31:35 +00:00
}
2007-01-29 15:11:32 +00:00
/* Return the directory of the given path, i.e., everything before the
last slash. Return either a path or a string depending on the type
of the argument. */
2010-03-30 15:18:20 +00:00
static void prim_dirOf(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-03-30 22:39:48 +00:00
Path dir = dirOf(state.coerceToPath(*args[0], context));
if (args[0]->type == tPath) mkPath(v, dir.c_str()); else mkString(v, dir, context);
}
/* Return the contents of a file as a string. */
2010-03-30 15:18:20 +00:00
static void prim_readFile(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-03-30 22:39:48 +00:00
Path path = state.coerceToPath(*args[0], context);
if (!context.empty())
throw EvalError(format("string `%1%' cannot refer to other paths") % path);
2010-03-30 22:39:48 +00:00
mkString(v, readFile(path).c_str());
}
2007-01-29 15:11:32 +00:00
/*************************************************************
* Creating files
*************************************************************/
/* Convert the argument (which can be any Nix expression) to an XML
representation returned in a string. Not all Nix expressions can
be sensibly or completely represented (e.g., functions). */
2010-03-30 15:18:20 +00:00
static void prim_toXML(EvalState & state, Value * * args, Value & v)
{
std::ostringstream out;
PathSet context;
2010-05-07 14:46:47 +00:00
printValueAsXML(state, true, false, *args[0], out, context);
mkString(v, out.str(), context);
}
/* Store a string in the Nix store as a source file that can be used
as an input by derivations. */
2010-03-30 15:18:20 +00:00
static void prim_toFile(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-03-31 15:38:03 +00:00
string name = state.forceStringNoCtx(*args[0]);
string contents = state.forceString(*args[1], context);
PathSet refs;
2010-03-31 15:38:03 +00:00
foreach (PathSet::iterator, i, context) {
2008-12-04 10:45:47 +00:00
Path path = *i;
if (path.at(0) == '=') path = string(path, 1);
if (isDerivation(path))
2006-10-19 17:43:58 +00:00
throw EvalError(format("in `toFile': the file `%1%' cannot refer to derivation outputs") % name);
2008-12-04 10:45:47 +00:00
refs.insert(path);
}
Path storePath = readOnlyMode
? computeStorePathForText(name, contents, refs)
: store->addTextToStore(name, contents, refs);
/* Note: we don't need to add `context' to the context of the
result, since `storePath' itself has references to the paths
used in args[1]. */
2010-03-31 15:38:03 +00:00
mkString(v, storePath, singleton<PathSet>(storePath));
}
2007-01-29 15:11:32 +00:00
struct FilterFromExpr : PathFilter
{
2007-01-29 15:11:32 +00:00
EvalState & state;
Value & filter;
2007-01-29 15:11:32 +00:00
FilterFromExpr(EvalState & state, Value & filter)
2007-01-29 15:11:32 +00:00
: state(state), filter(filter)
{
}
2007-01-29 15:11:32 +00:00
bool operator () (const Path & path)
{
struct stat st;
if (lstat(path.c_str(), &st))
throw SysError(format("getting attributes of path `%1%'") % path);
/* Call the filter function. The first argument is the path,
the second is a string indicating the type of the file. */
Value arg1;
mkString(arg1, path);
Value fun2;
state.callFunction(filter, arg1, fun2);
Value arg2;
mkString(arg2,
S_ISREG(st.st_mode) ? "regular" :
S_ISDIR(st.st_mode) ? "directory" :
S_ISLNK(st.st_mode) ? "symlink" :
"unknown" /* not supported, will fail! */);
Value res;
state.callFunction(fun2, arg2, res);
return state.forceBool(res);
2007-01-29 15:11:32 +00:00
}
};
2010-03-30 15:18:20 +00:00
static void prim_filterSource(EvalState & state, Value * * args, Value & v)
{
2007-01-29 15:11:32 +00:00
PathSet context;
Path path = state.coerceToPath(*args[1], context);
2007-01-29 15:11:32 +00:00
if (!context.empty())
throw EvalError(format("string `%1%' cannot refer to other paths") % path);
state.forceValue(*args[0]);
if (args[0]->type != tLambda)
throw TypeError(format("first argument in call to `filterSource' is not a function but %1%") % showType(*args[0]));
FilterFromExpr filter(state, *args[0]);
2007-01-29 15:11:32 +00:00
Path dstPath = readOnlyMode
? computeStorePathForPath(path, true, htSHA256, filter).first
: store->addToStore(path, true, htSHA256, filter);
mkString(v, dstPath, singleton<PathSet>(dstPath));
}
2007-01-29 15:11:32 +00:00
/*************************************************************
* Attribute sets
*************************************************************/
* 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
2007-01-29 15:11:32 +00:00
/* Return the names of the attributes in an attribute set as a sorted
list of strings. */
2010-03-30 15:18:20 +00:00
static void prim_attrNames(EvalState & state, Value * * args, Value & v)
* 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
{
2010-03-30 22:39:48 +00:00
state.forceAttrs(*args[0]);
* 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
2010-03-30 22:39:48 +00:00
state.mkList(v, args[0]->attrs->size());
* 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
2010-03-30 22:39:48 +00:00
StringSet names;
foreach (Bindings::iterator, i, *args[0]->attrs)
names.insert(i->name);
* 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
2010-03-30 22:39:48 +00:00
unsigned int n = 0;
2010-10-23 18:18:07 +00:00
foreach (StringSet::iterator, i, names)
mkString(*(v.list.elems[n++] = state.allocValue()), *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
}
2007-01-29 15:11:32 +00:00
/* Dynamic version of the `.' operator. */
2010-03-30 15:18:20 +00:00
static void prim_getAttr(EvalState & state, Value * * args, Value & v)
* 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
{
2010-03-30 18:05:54 +00:00
string attr = state.forceStringNoCtx(*args[0]);
state.forceAttrs(*args[1]);
// !!! Should we create a symbol here or just do a lookup?
Bindings::iterator i = args[1]->attrs->find(state.symbols.create(attr));
2010-03-30 18:05:54 +00:00
if (i == args[1]->attrs->end())
throw EvalError(format("attribute `%1%' missing") % attr);
// !!! add to stack trace?
state.forceValue(*i->value);
v = *i->value;
2007-01-29 15:11:32 +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
2007-01-29 15:11:32 +00:00
/* Dynamic version of the `?' operator. */
2010-03-30 15:18:20 +00:00
static void prim_hasAttr(EvalState & state, Value * * args, Value & v)
2007-01-29 15:11:32 +00:00
{
2010-03-30 18:05:54 +00:00
string attr = state.forceStringNoCtx(*args[0]);
state.forceAttrs(*args[1]);
mkBool(v, args[1]->attrs->find(state.symbols.create(attr)) != args[1]->attrs->end());
2007-01-29 15:11:32 +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
2010-03-30 22:39:48 +00:00
/* Determine whether the argument is an attribute set. */
static void prim_isAttrs(EvalState & state, Value * * args, Value & v)
{
state.forceValue(*args[0]);
mkBool(v, args[0]->type == tAttrs);
}
static void prim_removeAttrs(EvalState & state, Value * * args, Value & v)
{
state.forceAttrs(*args[0]);
state.forceList(*args[1]);
/* Get the attribute names to be removed. */
std::set<Symbol> names;
2010-03-30 22:39:48 +00:00
for (unsigned int i = 0; i < args[1]->list.length; ++i) {
state.forceStringNoCtx(*args[1]->list.elems[i]);
names.insert(state.symbols.create(args[1]->list.elems[i]->string.s));
}
/* Copy all attributes not in that set. Note that we don't need
to sort v.attrs because it's a subset of an already sorted
vector. */
state.mkAttrs(v, args[0]->attrs->size());
foreach (Bindings::iterator, i, *args[0]->attrs) {
if (names.find(i->name) == names.end())
v.attrs->push_back(*i);
2010-03-30 22:39:48 +00:00
}
}
/* Builds an attribute set from a list specifying (name, value)
pairs. To be precise, a list [{name = "name1"; value = value1;}
... {name = "nameN"; value = valueN;}] is transformed to {name1 =
value1; ... nameN = valueN;}. */
2010-03-30 15:18:20 +00:00
static void prim_listToAttrs(EvalState & state, Value * * args, Value & v)
{
2010-03-31 15:38:03 +00:00
state.forceList(*args[0]);
state.mkAttrs(v, args[0]->list.length);
2010-03-31 15:38:03 +00:00
std::set<Symbol> seen;
2010-03-31 15:38:03 +00:00
for (unsigned int i = 0; i < args[0]->list.length; ++i) {
Value & v2(*args[0]->list.elems[i]);
2010-03-31 15:38:03 +00:00
state.forceAttrs(v2);
Bindings::iterator j = v2.attrs->find(state.sName);
2010-03-31 15:38:03 +00:00
if (j == v2.attrs->end())
throw TypeError("`name' attribute missing in a call to `listToAttrs'");
string name = state.forceStringNoCtx(*j->value);
2010-03-31 15:38:03 +00:00
Bindings::iterator j2 = v2.attrs->find(state.symbols.create("value"));
if (j2 == v2.attrs->end())
2010-03-31 15:38:03 +00:00
throw TypeError("`value' attribute missing in a call to `listToAttrs'");
Symbol sym = state.symbols.create(name);
if (seen.find(sym) == seen.end()) {
v.attrs->push_back(Attr(sym, j2->value, j2->pos));
seen.insert(sym);
}
/* !!! Throw an error if `name' already exists? */
}
v.attrs->sort();
}
2007-10-31 18:01:56 +00:00
* Two primops: builtins.intersectAttrs and builtins.functionArgs. intersectAttrs returns the (right-biased) intersection between two attribute sets, e.g. every attribute from the second set that also exists in the first. functionArgs returns the set of attributes expected by a function. The main goal of these is to allow the elimination of most of all-packages.nix. Most package instantiations in all-packages.nix have this form: foo = import ./foo.nix { inherit a b c; }; With intersectAttrs and functionArgs, this can be written as: foo = callPackage (import ./foo.nix) { }; where callPackage = f: args: f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args); I.e., foo.nix is called with all attributes from "pkgs" that it actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can do any other generic package-level stuff we might want, such as applying makeOverridable.) Of course, the automatically supplied arguments can be overriden if needed, e.g. foo = callPackage (import ./foo.nix) { c = c_version_2; }; but for the vast majority of packages, this won't be needed. The advantages are to reduce the amount of typing needed to add a dependency (from three sites to two), and to reduce the number of trivial commits to all-packages.nix. For the former, there have been two previous attempts: - Use "args: with args;" in the package's function definition. This however obscures the actual expected arguments of a function, which is very bad. - Use "{ arg1, arg2, ... }:" in the package's function definition (i.e. use the ellipis "..." to allow arbitrary additional arguments), and then call the function with all of "pkgs" as an argument. But this inhibits error detection if you call it with an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
/* Return the right-biased intersection of two attribute sets as1 and
as2, i.e. a set that contains every attribute from as2 that is also
a member of as1. */
2010-03-30 15:18:20 +00:00
static void prim_intersectAttrs(EvalState & state, Value * * args, Value & v)
* Two primops: builtins.intersectAttrs and builtins.functionArgs. intersectAttrs returns the (right-biased) intersection between two attribute sets, e.g. every attribute from the second set that also exists in the first. functionArgs returns the set of attributes expected by a function. The main goal of these is to allow the elimination of most of all-packages.nix. Most package instantiations in all-packages.nix have this form: foo = import ./foo.nix { inherit a b c; }; With intersectAttrs and functionArgs, this can be written as: foo = callPackage (import ./foo.nix) { }; where callPackage = f: args: f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args); I.e., foo.nix is called with all attributes from "pkgs" that it actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can do any other generic package-level stuff we might want, such as applying makeOverridable.) Of course, the automatically supplied arguments can be overriden if needed, e.g. foo = callPackage (import ./foo.nix) { c = c_version_2; }; but for the vast majority of packages, this won't be needed. The advantages are to reduce the amount of typing needed to add a dependency (from three sites to two), and to reduce the number of trivial commits to all-packages.nix. For the former, there have been two previous attempts: - Use "args: with args;" in the package's function definition. This however obscures the actual expected arguments of a function, which is very bad. - Use "{ arg1, arg2, ... }:" in the package's function definition (i.e. use the ellipis "..." to allow arbitrary additional arguments), and then call the function with all of "pkgs" as an argument. But this inhibits error detection if you call it with an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
{
2010-04-16 15:13:47 +00:00
state.forceAttrs(*args[0]);
state.forceAttrs(*args[1]);
state.mkAttrs(v, std::min(args[0]->attrs->size(), args[1]->attrs->size()));
foreach (Bindings::iterator, i, *args[0]->attrs) {
Bindings::iterator j = args[1]->attrs->find(i->name);
if (j != args[1]->attrs->end())
v.attrs->push_back(*j);
* Two primops: builtins.intersectAttrs and builtins.functionArgs. intersectAttrs returns the (right-biased) intersection between two attribute sets, e.g. every attribute from the second set that also exists in the first. functionArgs returns the set of attributes expected by a function. The main goal of these is to allow the elimination of most of all-packages.nix. Most package instantiations in all-packages.nix have this form: foo = import ./foo.nix { inherit a b c; }; With intersectAttrs and functionArgs, this can be written as: foo = callPackage (import ./foo.nix) { }; where callPackage = f: args: f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args); I.e., foo.nix is called with all attributes from "pkgs" that it actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can do any other generic package-level stuff we might want, such as applying makeOverridable.) Of course, the automatically supplied arguments can be overriden if needed, e.g. foo = callPackage (import ./foo.nix) { c = c_version_2; }; but for the vast majority of packages, this won't be needed. The advantages are to reduce the amount of typing needed to add a dependency (from three sites to two), and to reduce the number of trivial commits to all-packages.nix. For the former, there have been two previous attempts: - Use "args: with args;" in the package's function definition. This however obscures the actual expected arguments of a function, which is very bad. - Use "{ arg1, arg2, ... }:" in the package's function definition (i.e. use the ellipis "..." to allow arbitrary additional arguments), and then call the function with all of "pkgs" as an argument. But this inhibits error detection if you call it with an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
}
}
/* Return a set containing the names of the formal arguments expected
by the function `f'. The value of each attribute is a Boolean
denoting whether has a default value. For instance,
functionArgs ({ x, y ? 123}: ...)
=> { x = false; y = true; }
"Formal argument" here refers to the attributes pattern-matched by
the function. Plain lambdas are not included, e.g.
functionArgs (x: ...)
=> { }
*/
2010-03-30 15:18:20 +00:00
static void prim_functionArgs(EvalState & state, Value * * args, Value & v)
* Two primops: builtins.intersectAttrs and builtins.functionArgs. intersectAttrs returns the (right-biased) intersection between two attribute sets, e.g. every attribute from the second set that also exists in the first. functionArgs returns the set of attributes expected by a function. The main goal of these is to allow the elimination of most of all-packages.nix. Most package instantiations in all-packages.nix have this form: foo = import ./foo.nix { inherit a b c; }; With intersectAttrs and functionArgs, this can be written as: foo = callPackage (import ./foo.nix) { }; where callPackage = f: args: f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args); I.e., foo.nix is called with all attributes from "pkgs" that it actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can do any other generic package-level stuff we might want, such as applying makeOverridable.) Of course, the automatically supplied arguments can be overriden if needed, e.g. foo = callPackage (import ./foo.nix) { c = c_version_2; }; but for the vast majority of packages, this won't be needed. The advantages are to reduce the amount of typing needed to add a dependency (from three sites to two), and to reduce the number of trivial commits to all-packages.nix. For the former, there have been two previous attempts: - Use "args: with args;" in the package's function definition. This however obscures the actual expected arguments of a function, which is very bad. - Use "{ arg1, arg2, ... }:" in the package's function definition (i.e. use the ellipis "..." to allow arbitrary additional arguments), and then call the function with all of "pkgs" as an argument. But this inhibits error detection if you call it with an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
{
2010-04-16 15:13:47 +00:00
state.forceValue(*args[0]);
if (args[0]->type != tLambda)
throw TypeError("`functionArgs' requires a function");
* Two primops: builtins.intersectAttrs and builtins.functionArgs. intersectAttrs returns the (right-biased) intersection between two attribute sets, e.g. every attribute from the second set that also exists in the first. functionArgs returns the set of attributes expected by a function. The main goal of these is to allow the elimination of most of all-packages.nix. Most package instantiations in all-packages.nix have this form: foo = import ./foo.nix { inherit a b c; }; With intersectAttrs and functionArgs, this can be written as: foo = callPackage (import ./foo.nix) { }; where callPackage = f: args: f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args); I.e., foo.nix is called with all attributes from "pkgs" that it actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can do any other generic package-level stuff we might want, such as applying makeOverridable.) Of course, the automatically supplied arguments can be overriden if needed, e.g. foo = callPackage (import ./foo.nix) { c = c_version_2; }; but for the vast majority of packages, this won't be needed. The advantages are to reduce the amount of typing needed to add a dependency (from three sites to two), and to reduce the number of trivial commits to all-packages.nix. For the former, there have been two previous attempts: - Use "args: with args;" in the package's function definition. This however obscures the actual expected arguments of a function, which is very bad. - Use "{ arg1, arg2, ... }:" in the package's function definition (i.e. use the ellipis "..." to allow arbitrary additional arguments), and then call the function with all of "pkgs" as an argument. But this inhibits error detection if you call it with an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
if (!args[0]->lambda.fun->matchAttrs) {
state.mkAttrs(v, 0);
return;
}
2010-04-16 15:13:47 +00:00
state.mkAttrs(v, args[0]->lambda.fun->formals->formals.size());
2010-04-16 15:13:47 +00:00
foreach (Formals::Formals_::iterator, i, args[0]->lambda.fun->formals->formals)
// !!! should optimise booleans (allocate only once)
mkBool(*state.allocAttr(v, i->name), i->def);
v.attrs->sort();
* Two primops: builtins.intersectAttrs and builtins.functionArgs. intersectAttrs returns the (right-biased) intersection between two attribute sets, e.g. every attribute from the second set that also exists in the first. functionArgs returns the set of attributes expected by a function. The main goal of these is to allow the elimination of most of all-packages.nix. Most package instantiations in all-packages.nix have this form: foo = import ./foo.nix { inherit a b c; }; With intersectAttrs and functionArgs, this can be written as: foo = callPackage (import ./foo.nix) { }; where callPackage = f: args: f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args); I.e., foo.nix is called with all attributes from "pkgs" that it actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can do any other generic package-level stuff we might want, such as applying makeOverridable.) Of course, the automatically supplied arguments can be overriden if needed, e.g. foo = callPackage (import ./foo.nix) { c = c_version_2; }; but for the vast majority of packages, this won't be needed. The advantages are to reduce the amount of typing needed to add a dependency (from three sites to two), and to reduce the number of trivial commits to all-packages.nix. For the former, there have been two previous attempts: - Use "args: with args;" in the package's function definition. This however obscures the actual expected arguments of a function, which is very bad. - Use "{ arg1, arg2, ... }:" in the package's function definition (i.e. use the ellipis "..." to allow arbitrary additional arguments), and then call the function with all of "pkgs" as an argument. But this inhibits error detection if you call it with an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
}
2007-01-29 15:11:32 +00:00
/*************************************************************
* Lists
*************************************************************/
* 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
2007-01-29 15:11:32 +00:00
/* Determine whether the argument is a list. */
2010-03-30 15:18:20 +00:00
static void prim_isList(EvalState & state, Value * * args, Value & v)
2006-08-23 15:46:00 +00:00
{
2010-03-30 22:39:48 +00:00
state.forceValue(*args[0]);
mkBool(v, args[0]->type == tList);
2006-08-23 15:46:00 +00:00
}
/* Return the first element of a list. */
static void prim_head(EvalState & state, Value * * args, Value & v)
{
state.forceList(*args[0]);
if (args[0]->list.length == 0)
throw Error("`head' called on an empty list");
state.forceValue(*args[0]->list.elems[0]);
v = *args[0]->list.elems[0];
}
/* Return a list consisting of everything but the the first element of
a list. */
2010-03-30 14:39:27 +00:00
static void prim_tail(EvalState & state, Value * * args, Value & v)
{
2010-03-30 14:39:27 +00:00
state.forceList(*args[0]);
if (args[0]->list.length == 0)
throw Error("`tail' called on an empty list");
2010-03-30 14:39:27 +00:00
state.mkList(v, args[0]->list.length - 1);
for (unsigned int n = 0; n < v.list.length; ++n)
v.list.elems[n] = args[0]->list.elems[n + 1];
}
/* Apply a function to every element of a list. */
2010-03-30 13:47:59 +00:00
static void prim_map(EvalState & state, Value * * args, Value & v)
{
2010-03-30 13:47:59 +00:00
state.forceFunction(*args[0]);
state.forceList(*args[1]);
2010-03-30 14:39:27 +00:00
state.mkList(v, args[1]->list.length);
2010-10-23 18:18:07 +00:00
for (unsigned int n = 0; n < v.list.length; ++n)
mkApp(*(v.list.elems[n] = state.allocValue()),
*args[0], *args[1]->list.elems[n]);
}
/* Return the length of a list. This is an O(1) time operation. */
2010-03-30 15:18:20 +00:00
static void prim_length(EvalState & state, Value * * args, Value & v)
{
2010-03-30 22:39:48 +00:00
state.forceList(*args[0]);
2010-03-31 15:38:03 +00:00
mkInt(v, args[0]->list.length);
}
2007-01-29 15:11:32 +00:00
/*************************************************************
* Integer arithmetic
*************************************************************/
static void prim_add(EvalState & state, Value * * args, Value & v)
{
mkInt(v, state.forceInt(*args[0]) + state.forceInt(*args[1]));
}
2010-03-30 15:18:20 +00:00
static void prim_sub(EvalState & state, Value * * args, Value & v)
{
2010-03-30 18:05:54 +00:00
mkInt(v, state.forceInt(*args[0]) - state.forceInt(*args[1]));
}
2010-03-30 15:18:20 +00:00
static void prim_mul(EvalState & state, Value * * args, Value & v)
{
2010-03-30 18:05:54 +00:00
mkInt(v, state.forceInt(*args[0]) * state.forceInt(*args[1]));
}
2010-03-30 15:18:20 +00:00
static void prim_div(EvalState & state, Value * * args, Value & v)
{
2010-03-30 18:05:54 +00:00
int i2 = state.forceInt(*args[1]);
if (i2 == 0) throw EvalError("division by zero");
2010-03-30 18:05:54 +00:00
mkInt(v, state.forceInt(*args[0]) / i2);
}
2010-03-30 15:18:20 +00:00
static void prim_lessThan(EvalState & state, Value * * args, Value & v)
{
2010-03-30 15:18:20 +00:00
mkBool(v, state.forceInt(*args[0]) < state.forceInt(*args[1]));
}
/*************************************************************
* String manipulation
*************************************************************/
/* Convert the argument to a string. Paths are *not* copied to the
store, so `toString /foo/bar' yields `"/foo/bar"', not
`"/nix/store/whatever..."'. */
2010-03-30 15:18:20 +00:00
static void prim_toString(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-03-30 15:18:20 +00:00
string s = state.coerceToString(*args[0], context, true, false);
mkString(v, s, context);
}
2007-12-31 00:08:09 +00:00
/* `substring start len str' returns the substring of `str' starting
at character position `min(start, stringLength str)' inclusive and
ending at `min(start + len, stringLength str)'. `start' must be
non-negative. */
2010-03-30 15:18:20 +00:00
static void prim_substring(EvalState & state, Value * * args, Value & v)
{
2010-03-30 18:05:54 +00:00
int start = state.forceInt(*args[0]);
int len = state.forceInt(*args[1]);
PathSet context;
2010-03-30 18:05:54 +00:00
string s = state.coerceToString(*args[2], context);
if (start < 0) throw EvalError("negative start position in `substring'");
mkString(v, start >= s.size() ? "" : string(s, start, len), context);
}
2010-03-30 15:18:20 +00:00
static void prim_stringLength(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-03-30 18:05:54 +00:00
string s = state.coerceToString(*args[0], context);
mkInt(v, s.size());
}
2010-03-30 15:18:20 +00:00
static void prim_unsafeDiscardStringContext(EvalState & state, Value * * args, Value & v)
{
PathSet context;
string s = state.coerceToString(*args[0], context);
mkString(v, s, PathSet());
}
2008-01-20 20:44:03 +00:00
/* Sometimes we want to pass a derivation path (i.e. pkg.drvPath) to a
builder without causing the derivation to be built (for instance,
in the derivation that builds NARs in nix-push, when doing
source-only deployment). This primop marks the string context so
that builtins.derivation adds the path to drv.inputSrcs rather than
drv.inputDrvs. */
2010-03-30 15:18:20 +00:00
static void prim_unsafeDiscardOutputDependency(EvalState & state, Value * * args, Value & v)
{
PathSet context;
2010-04-16 15:13:47 +00:00
string s = state.coerceToString(*args[0], context);
PathSet context2;
foreach (PathSet::iterator, i, context) {
Path p = *i;
if (p.at(0) == '=') p = "~" + string(p, 1);
context2.insert(p);
}
2010-04-16 15:13:47 +00:00
mkString(v, s, context2);
}
/*************************************************************
* Versions
*************************************************************/
2010-03-30 15:18:20 +00:00
static void prim_parseDrvName(EvalState & state, Value * * args, Value & v)
{
2010-03-30 22:39:48 +00:00
string name = state.forceStringNoCtx(*args[0]);
DrvName parsed(name);
state.mkAttrs(v, 2);
mkString(*state.allocAttr(v, state.sName), parsed.name);
mkString(*state.allocAttr(v, state.symbols.create("version")), parsed.version);
v.attrs->sort();
}
2010-03-30 15:18:20 +00:00
static void prim_compareVersions(EvalState & state, Value * * args, Value & v)
{
2010-03-30 22:39:48 +00:00
string version1 = state.forceStringNoCtx(*args[0]);
string version2 = state.forceStringNoCtx(*args[1]);
mkInt(v, compareVersions(version1, version2));
}
/*************************************************************
* Primop registration
*************************************************************/
void EvalState::createBaseEnv()
{
baseEnv.up = 0;
/* Add global constants such as `true' to the base environment. */
2010-03-30 14:39:27 +00:00
Value v;
2010-04-14 22:59:39 +00:00
/* `builtins' must be first! */
mkAttrs(v, 128);
2010-04-14 22:59:39 +00:00
addConstant("builtins", v);
2010-03-30 14:39:27 +00:00
mkBool(v, true);
addConstant("true", v);
mkBool(v, false);
addConstant("false", v);
v.type = tNull;
addConstant("null", v);
mkInt(v, time(0));
addConstant("__currentTime", v);
2010-03-30 18:05:54 +00:00
mkString(v, thisSystem.c_str());
2010-03-30 14:39:27 +00:00
addConstant("__currentSystem", v);
2007-01-29 15:11:32 +00:00
// Miscellaneous
addPrimOp("import", 1, prim_import);
addPrimOp("isNull", 1, prim_isNull);
addPrimOp("__isFunction", 1, prim_isFunction);
addPrimOp("__isString", 1, prim_isString);
addPrimOp("__isInt", 1, prim_isInt);
addPrimOp("__isBool", 1, prim_isBool);
addPrimOp("__genericClosure", 1, prim_genericClosure);
addPrimOp("abort", 1, prim_abort);
addPrimOp("throw", 1, prim_throw);
addPrimOp("__addErrorContext", 2, prim_addErrorContext);
addPrimOp("__tryEval", 1, prim_tryEval);
addPrimOp("__getEnv", 1, prim_getEnv);
addPrimOp("__trace", 2, prim_trace);
2007-01-29 15:11:32 +00:00
// Paths
addPrimOp("__toPath", 1, prim_toPath);
addPrimOp("__storePath", 1, prim_storePath);
addPrimOp("__pathExists", 1, prim_pathExists);
addPrimOp("baseNameOf", 1, prim_baseNameOf);
addPrimOp("dirOf", 1, prim_dirOf);
addPrimOp("__readFile", 1, prim_readFile);
2007-01-29 15:11:32 +00:00
// Creating files
addPrimOp("__toXML", 1, prim_toXML);
addPrimOp("__toFile", 2, prim_toFile);
addPrimOp("__filterSource", 2, prim_filterSource);
2007-01-29 15:11:32 +00:00
// Attribute sets
addPrimOp("__attrNames", 1, prim_attrNames);
addPrimOp("__getAttr", 2, prim_getAttr);
addPrimOp("__hasAttr", 2, prim_hasAttr);
addPrimOp("__isAttrs", 1, prim_isAttrs);
addPrimOp("removeAttrs", 2, prim_removeAttrs);
addPrimOp("__listToAttrs", 1, prim_listToAttrs);
* Two primops: builtins.intersectAttrs and builtins.functionArgs. intersectAttrs returns the (right-biased) intersection between two attribute sets, e.g. every attribute from the second set that also exists in the first. functionArgs returns the set of attributes expected by a function. The main goal of these is to allow the elimination of most of all-packages.nix. Most package instantiations in all-packages.nix have this form: foo = import ./foo.nix { inherit a b c; }; With intersectAttrs and functionArgs, this can be written as: foo = callPackage (import ./foo.nix) { }; where callPackage = f: args: f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args); I.e., foo.nix is called with all attributes from "pkgs" that it actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can do any other generic package-level stuff we might want, such as applying makeOverridable.) Of course, the automatically supplied arguments can be overriden if needed, e.g. foo = callPackage (import ./foo.nix) { c = c_version_2; }; but for the vast majority of packages, this won't be needed. The advantages are to reduce the amount of typing needed to add a dependency (from three sites to two), and to reduce the number of trivial commits to all-packages.nix. For the former, there have been two previous attempts: - Use "args: with args;" in the package's function definition. This however obscures the actual expected arguments of a function, which is very bad. - Use "{ arg1, arg2, ... }:" in the package's function definition (i.e. use the ellipis "..." to allow arbitrary additional arguments), and then call the function with all of "pkgs" as an argument. But this inhibits error detection if you call it with an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
addPrimOp("__intersectAttrs", 2, prim_intersectAttrs);
addPrimOp("__functionArgs", 1, prim_functionArgs);
2007-01-29 15:11:32 +00:00
// Lists
addPrimOp("__isList", 1, prim_isList);
addPrimOp("__head", 1, prim_head);
addPrimOp("__tail", 1, prim_tail);
addPrimOp("map", 2, prim_map);
addPrimOp("__length", 1, prim_length);
2007-01-29 15:11:32 +00:00
// Integer arithmetic
addPrimOp("__add", 2, prim_add);
addPrimOp("__sub", 2, prim_sub);
addPrimOp("__mul", 2, prim_mul);
addPrimOp("__div", 2, prim_div);
addPrimOp("__lessThan", 2, prim_lessThan);
2007-01-29 15:11:32 +00:00
// String manipulation
addPrimOp("toString", 1, prim_toString);
addPrimOp("__substring", 3, prim_substring);
addPrimOp("__stringLength", 1, prim_stringLength);
addPrimOp("__unsafeDiscardStringContext", 1, prim_unsafeDiscardStringContext);
addPrimOp("__unsafeDiscardOutputDependency", 1, prim_unsafeDiscardOutputDependency);
// Versions
addPrimOp("__parseDrvName", 1, prim_parseDrvName);
addPrimOp("__compareVersions", 2, prim_compareVersions);
// Derivations
addPrimOp("derivationStrict", 1, prim_derivationStrict);
/* Add a wrapper around the derivation primop that computes the
`drvPath' and `outPath' attributes lazily. */
mkThunk_(v, parseExprFromFile(findFile("nix/derivation.nix")));
addConstant("derivation", v);
/* Now that we've added all primops, sort the `builtins' attribute
set, because attribute lookups expect it to be sorted. */
baseEnv.values[0]->attrs->sort();
}
}