#include "eval.hh"

#include "misc.hh"

#include "globals.hh"

#include "store-api.hh"

#include "util.hh"

#include "archive.hh"

#include "value-to-xml.hh"

#include "value-to-json.hh"

#include "names.hh"

#include "eval-inline.hh"

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <algorithm>

#include <cstring>

#include <dlfcn.h>

namespace nix {

/*************************************************************

* Miscellaneous

*************************************************************/

/* Decode a context string ‘!<name>!<path>’ into a pair <path,

name>. */

std::pair<string, string> decodeContext(const string & s)

{

if (s.at(0) == '!') {

size_t index = s.find("!", 1);

return std::pair<string, string>(string(s, index + 1), string(s, 1, index - 1));

} else

return std::pair<string, string>(s, "");

}

struct InvalidPathError : EvalError

{

Path path;

InvalidPathError(const Path & path) :

EvalError(format("path `%1%' is not valid") % path), path(path) {};

};

static void realiseContext(const PathSet & context)

{

PathSet drvs;

for (auto & i : context) {

std::pair<string, string> decoded = decodeContext(i);

Path ctx = decoded.first;

assert(isStorePath(ctx));

if (!store->isValidPath(ctx))

throw InvalidPathError(ctx);

if (isDerivation(ctx))

drvs.insert(decoded.first + "!" + decoded.second);

}

if (!drvs.empty()) {

/* For performance, prefetch all substitute info. */

PathSet willBuild, willSubstitute, unknown;

unsigned long long downloadSize, narSize;

queryMissing(*store, drvs,

willBuild, willSubstitute, unknown, downloadSize, narSize);

store->buildPaths(drvs);

}

}

/* Load and evaluate an expression from path specified by the

argument. */

static void prim_scopedImport(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path path = state.coerceToPath(pos, *args[1], context);

try {

realiseContext(context);

} catch (InvalidPathError & e) {

throw EvalError(format("cannot import `%1%', since path `%2%' is not valid, at %3%")

% path % e.path % pos);

}

if (isStorePath(path) && store->isValidPath(path) && isDerivation(path)) {

Derivation drv = readDerivation(path);

Value & w = *state.allocValue();

state.mkAttrs(w, 1 + drv.outputs.size());

mkString(*state.allocAttr(w, state.sDrvPath), path, singleton<PathSet>("=" + path));

state.mkList(*state.allocAttr(w, state.symbols.create("outputs")), drv.outputs.size());

unsigned int outputs_index = 0;

Value * outputsVal = w.attrs->find(state.symbols.create("outputs"))->value;

foreach (DerivationOutputs::iterator, i, drv.outputs) {

mkString(*state.allocAttr(w, state.symbols.create(i->first)),

i->second.path, singleton<PathSet>("!" + i->first + "!" + path));

mkString(*(outputsVal->list.elems[outputs_index++] = state.allocValue()),

i->first);

}

w.attrs->sort();

Value fun;

state.evalFile(state.findFile("nix/imported-drv-to-derivation.nix"), fun);

state.forceFunction(fun, pos);

mkApp(v, fun, w);

state.forceAttrs(v, pos);

} else {

state.forceAttrs(*args[0]);

if (args[0]->attrs->empty())

state.evalFile(path, v);

else {

Env * env = &state.allocEnv(args[0]->attrs->size());

env->up = &state.baseEnv;

StaticEnv staticEnv(false, &state.staticBaseEnv);

unsigned int displ = 0;

for (auto & attr : *args[0]->attrs) {

staticEnv.vars[attr.name] = displ;

env->values[displ++] = attr.value;

}

startNest(nest, lvlTalkative, format("evaluating file `%1%'") % path);

Expr * e = state.parseExprFromFile(resolveExprPath(path), staticEnv);

e->eval(state, *env, v);

}

}

}

/* Want reasonable symbol names, so extern C */

/* !!! Should we pass the Pos or the file name too? */

extern "C" typedef void (*ValueInitializer)(EvalState & state, Value & v);

/* Load a ValueInitializer from a dso and return whatever it initializes */

static void prim_importNative(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path path = state.coerceToPath(pos, *args[0], context);

try {

realiseContext(context);

} catch (InvalidPathError & e) {

throw EvalError(format("cannot import `%1%', since path `%2%' is not valid, at %3%")

% path % e.path % pos);

}

string sym = state.forceStringNoCtx(*args[1], pos);

void *handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);

if (!handle)

throw EvalError(format("could not open `%1%': %2%") % path % dlerror());

dlerror();

ValueInitializer func = (ValueInitializer) dlsym(handle, sym.c_str());

if(!func) {

char *message = dlerror();

if (message)

throw EvalError(format("could not load symbol `%1%' from `%2%': %3%") % sym % path % message);

else

throw EvalError(format("symbol `%1%' from `%2%' resolved to NULL when a function pointer was expected")

% sym % path);

}

(func)(state, v);

/* We don't dlclose because v may be a primop referencing a function in the shared object file */

}

/* Return a string representing the type of the expression. */

static void prim_typeOf(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceValue(*args[0]);

string t;

switch (args[0]->type) {

case tInt: t = "int"; break;

case tBool: t = "bool"; break;

case tString: t = "string"; break;

case tPath: t = "path"; break;

case tNull: t = "null"; break;

case tAttrs: t = "set"; break;

case tList: t = "list"; break;

case tLambda:

case tPrimOp:

case tPrimOpApp:

t = "lambda";

break;

default: abort();

}

mkString(v, state.symbols.create(t));

}

/* Determine whether the argument is the null value. */

static void prim_isNull(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceValue(*args[0]);

mkBool(v, args[0]->type == tNull);

}

/* Determine whether the argument is a function. */

static void prim_isFunction(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceValue(*args[0]);

mkBool(v, args[0]->type == tLambda);

}

/* Determine whether the argument is an integer. */

static void prim_isInt(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceValue(*args[0]);

mkBool(v, args[0]->type == tInt);

}

/* Determine whether the argument is a string. */

static void prim_isString(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceValue(*args[0]);

mkBool(v, args[0]->type == tString);

}

/* Determine whether the argument is a Boolean. */

static void prim_isBool(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceValue(*args[0]);

mkBool(v, args[0]->type == tBool);

}

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));

}

}

};

#if HAVE_BOEHMGC

typedef list<Value *, gc_allocator<Value *> > ValueList;

#else

typedef list<Value *> ValueList;

#endif

static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

startNest(nest, lvlDebug, "finding dependencies");

state.forceAttrs(*args[0], pos);

/* Get the start set. */

Bindings::iterator startSet =

args[0]->attrs->find(state.symbols.create("startSet"));

if (startSet == args[0]->attrs->end())

throw EvalError(format("attribute `startSet' required, at %1%") % pos);

state.forceList(*startSet->value, pos);

ValueList workSet;

for (unsigned int n = 0; n < startSet->value->list.length; ++n)

workSet.push_back(startSet->value->list.elems[n]);

/* Get the operator. */

Bindings::iterator op =

args[0]->attrs->find(state.symbols.create("operator"));

if (op == args[0]->attrs->end())

throw EvalError(format("attribute `operator' required, at %1%") % pos);

state.forceValue(*op->value);

/* Construct the closure by applying the operator to element of

`workSet', adding the result to `workSet', continuing until

no new elements are found. */

ValueList res;

// `doneKeys' doesn't need to be a GC root, because its values are

// reachable from res.

set<Value *, CompareValues> doneKeys;

while (!workSet.empty()) {

Value * e = *(workSet.begin());

workSet.pop_front();

state.forceAttrs(*e, pos);

Bindings::iterator key =

e->attrs->find(state.symbols.create("key"));

if (key == e->attrs->end())

throw EvalError(format("attribute `key' required, at %1%") % pos);

state.forceValue(*key->value);

if (doneKeys.find(key->value) != doneKeys.end()) continue;

doneKeys.insert(key->value);

res.push_back(e);

/* Call the `operator' function with `e' as argument. */

Value call;

mkApp(call, *op->value, *e);

state.forceList(call, pos);

/* 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]);

}

}

/* Create the result list. */

state.mkList(v, res.size());

unsigned int n = 0;

foreach (ValueList::iterator, i, res)

v.list.elems[n++] = *i;

}

static void prim_abort(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

throw Abort(format("evaluation aborted with the following error message: `%1%'") %

state.coerceToString(pos, *args[0], context));

}

static void prim_throw(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

throw ThrownError(format("%1%") % state.coerceToString(pos, *args[0], context));

}

static void prim_addErrorContext(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

try {

state.forceValue(*args[1]);

v = *args[1];

} catch (Error & e) {

PathSet context;

e.addPrefix(format("%1%\n") % state.coerceToString(pos, *args[0], context));

throw;

}

}

/* Try evaluating the argument. Success => {success=true; value=something;},

* else => {success=false; value=false;} */

static void prim_tryEval(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.mkAttrs(v, 2);

try {

state.forceValue(*args[0]);

v.attrs->push_back(Attr(state.sValue, args[0]));

mkBool(*state.allocAttr(v, state.symbols.create("success")), true);

} catch (AssertionError & e) {

mkBool(*state.allocAttr(v, state.sValue), false);

mkBool(*state.allocAttr(v, state.symbols.create("success")), false);

}

v.attrs->sort();

}

/* Return an environment variable. Use with care. */

static void prim_getEnv(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

string name = state.forceStringNoCtx(*args[0], pos);

mkString(v, getEnv(name));

}

/* Evaluate the first expression and print it on standard error. Then

return the second expression. Useful for debugging. */

static void prim_trace(EvalState & state, const Pos & pos, 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];

}

/*************************************************************

* 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. */

static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

startNest(nest, lvlVomit, "evaluating derivation");

state.forceAttrs(*args[0], pos);

/* Figure out the name first (for stack backtraces). */

Bindings::iterator attr = args[0]->attrs->find(state.sName);

if (attr == args[0]->attrs->end())

throw EvalError(format("required attribute `name' missing, at %1%") % pos);

string drvName;

Pos & posDrvName(*attr->pos);

try {

drvName = state.forceStringNoCtx(*attr->value, pos);

} catch (Error & e) {

e.addPrefix(format("while evaluating the derivation attribute `name' at %1%:\n") % posDrvName);

throw;

}

/* Check whether null attributes should be ignored. */

bool ignoreNulls = false;

attr = args[0]->attrs->find(state.sIgnoreNulls);

if (attr != args[0]->attrs->end())

ignoreNulls = state.forceBool(*attr->value);

/* Build the derivation expression by processing the attributes. */

Derivation drv;

PathSet context;

string outputHash, outputHashAlgo;

bool outputHashRecursive = false;

StringSet outputs;

outputs.insert("out");

foreach (Bindings::iterator, i, *args[0]->attrs) {

if (i->name == state.sIgnoreNulls) continue;

string key = i->name;

startNest(nest, lvlVomit, format("processing attribute `%1%'") % key);

try {

if (ignoreNulls) {

state.forceValue(*i->value);

if (i->value->type == tNull) continue;

}

/* The `args' attribute is special: it supplies the

command-line arguments to the builder. */

if (key == "args") {

state.forceList(*i->value, pos);

for (unsigned int n = 0; n < i->value->list.length; ++n) {

string s = state.coerceToString(posDrvName, *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(posDrvName, *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, at %2%") % s % posDrvName);

}

else if (key == "outputs") {

Strings tmp = tokenizeString<Strings>(s);

outputs.clear();

foreach (Strings::iterator, j, tmp) {

if (outputs.find(*j) != outputs.end())

throw EvalError(format("duplicate derivation output `%1%', at %2%") % *j % posDrvName);

/* !!! 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', at %1%") % posDrvName);

outputs.insert(*j);

}

if (outputs.empty())

throw EvalError(format("derivation cannot have an empty set of outputs, at %1%") % posDrvName);

}

}

} catch (Error & e) {

e.addPrefix(format("while evaluating the attribute `%1%' of the derivation `%2%' at %3%:\n")

% key % 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. */

PathSet refs; computeFSClosure(*store, string(path, 1), refs);

foreach (PathSet::iterator, j, refs) {

drv.inputSrcs.insert(*j);

if (isDerivation(*j))

drv.inputDrvs[*j] = store->queryDerivationOutputNames(*j);

}

}

/* See prim_unsafeDiscardOutputDependency. */

else if (path.at(0) == '~')

drv.inputSrcs.insert(string(path, 1));

/* Handle derivation outputs of the form ‘!<name>!<path>’. */

else if (path.at(0) == '!') {

std::pair<string, string> ctx = decodeContext(path);

drv.inputDrvs[ctx.first].insert(ctx.second);

}

/* Handle derivation contexts returned by

‘builtins.storePath’. */

else if (isDerivation(path))

drv.inputDrvs[path] = store->queryDerivationOutputNames(path);

/* Otherwise it's a source file. */

else

drv.inputSrcs.insert(path);

}

/* Do we have all required attributes? */

if (drv.builder == "")

throw EvalError(format("required attribute `builder' missing, at %1%") % posDrvName);

if (drv.platform == "")

throw EvalError(format("required attribute `system' missing, at %1%") % posDrvName);

/* Check whether the derivation name is valid. */

checkStoreName(drvName);

if (isDerivation(drvName))

throw EvalError(format("derivation names are not allowed to end in `%1%', at %2%")

% drvExtension % posDrvName);

if (outputHash != "") {

/* Handle fixed-output derivations. */

if (outputs.size() != 1 || *(outputs.begin()) != "out")

throw Error(format("multiple outputs are not supported in fixed-output derivations, at %1%") % posDrvName);

HashType ht = parseHashType(outputHashAlgo);

if (ht == htUnknown)

throw EvalError(format("unknown hash algorithm `%1%', at %2%") % outputHashAlgo % posDrvName);

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) {

drv.env[*i] = "";

drv.outputs[*i] = DerivationOutput("", "", "");

}

/* Use the masked derivation expression to compute the output

path. */

Hash h = hashDerivationModulo(*store, drv);

foreach (DerivationOutputs::iterator, i, drv.outputs)

if (i->second.path == "") {

Path outPath = makeOutputPath(i->first, h, drvName);

drv.env[i->first] = outPath;

i->second.path = outPath;

}

}

/* Write the resulting term into the Nix store directory. */

Path drvPath = writeDerivation(*store, drv, drvName, state.repair);

printMsg(lvlChatty, format("instantiated `%1%' -> `%2%'")

% drvName % drvPath);

/* Optimisation, but required in read-only mode! because in that

case we don't actually write store derivations, so we can't

read them later. */

drvHashes[drvPath] = hashDerivationModulo(*store, drv);

state.mkAttrs(v, 1 + drv.outputs.size());

mkString(*state.allocAttr(v, state.sDrvPath), drvPath, singleton<PathSet>("=" + drvPath));

foreach (DerivationOutputs::iterator, i, drv.outputs) {

mkString(*state.allocAttr(v, state.symbols.create(i->first)),

i->second.path, singleton<PathSet>("!" + i->first + "!" + drvPath));

}

v.attrs->sort();

}

/*************************************************************

* Paths

*************************************************************/

/* Convert the argument to a path. !!! obsolete? */

static void prim_toPath(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path path = state.coerceToPath(pos, *args[0], context);

mkString(v, canonPath(path), context);

}

/* 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. */

static void prim_storePath(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path path = state.coerceToPath(pos, *args[0], context);

/* Resolve symlinks in ‘path’, unless ‘path’ itself is a symlink

directly in the store. The latter condition is necessary so

e.g. nix-push does the right thing. */

if (!isStorePath(path)) path = canonPath(path, true);

if (!isInStore(path))

throw EvalError(format("path `%1%' is not in the Nix store, at %2%") % path % pos);

Path path2 = toStorePath(path);

if (!settings.readOnlyMode)

store->ensurePath(path2);

context.insert(path2);

mkString(v, path, context);

}

static void prim_pathExists(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path path = state.coerceToPath(pos, *args[0], context);

if (!context.empty())

throw EvalError(format("string `%1%' cannot refer to other paths, at %2%") % path % pos);

mkBool(v, pathExists(path));

}

/* Return the base name of the given string, i.e., everything

following the last slash. */

static void prim_baseNameOf(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

mkString(v, baseNameOf(state.coerceToString(pos, *args[0], context)), context);

}

/* 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. */

static void prim_dirOf(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path dir = dirOf(state.coerceToPath(pos, *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. */

static void prim_readFile(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path path = state.coerceToPath(pos, *args[0], context);

if (!context.empty())

throw EvalError(format("string `%1%' cannot refer to other paths, at %2%") % path % pos);

mkString(v, readFile(path).c_str());

}

/* Find a file in the Nix search path. Used to implement <x> paths,

which are desugared to ‘findFile nixPath "x"’. */

static void prim_findFile(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceList(*args[0], pos);

SearchPath searchPath;

PathSet context;

for (unsigned int n = 0; n < args[0]->list.length; ++n) {

Value & v2(*args[0]->list.elems[n]);

state.forceAttrs(v2, pos);

string prefix;

Bindings::iterator i = v2.attrs->find(state.symbols.create("prefix"));

if (i != v2.attrs->end())

prefix = state.forceStringNoCtx(*i->value, pos);

i = v2.attrs->find(state.symbols.create("path"));

if (i == v2.attrs->end())

throw EvalError(format("attribute `path' missing, at %1%") % pos);

string path = state.coerceToPath(pos, *i->value, context);

searchPath.push_back(std::pair<string, Path>(prefix, path));

}

string path = state.forceStringNoCtx(*args[1], pos);

try {

realiseContext(context);

} catch (InvalidPathError & e) {

throw EvalError(format("cannot find `%1%', since path `%2%' is not valid, at %3%")

% path % e.path % pos);

}

mkPath(v, state.findFile(searchPath, path).c_str());

}

/*************************************************************

* 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). */

static void prim_toXML(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

std::ostringstream out;

PathSet context;

printValueAsXML(state, true, false, *args[0], out, context);

mkString(v, out.str(), context);

}

/* Convert the argument (which can be any Nix expression) to a JSON

string. Not all Nix expressions can be sensibly or completely

represented (e.g., functions). */

static void prim_toJSON(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

std::ostringstream out;

PathSet context;

printValueAsJSON(state, true, *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. */

static void prim_toFile(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

string name = state.forceStringNoCtx(*args[0], pos);

string contents = state.forceString(*args[1], context);

PathSet refs;

foreach (PathSet::iterator, i, context) {

Path path = *i;

if (path.at(0) == '=') path = string(path, 1);

if (isDerivation(path))

throw EvalError(format("in `toFile': the file `%1%' cannot refer to derivation outputs, at %2%") % name % pos);

refs.insert(path);

}

Path storePath = settings.readOnlyMode

? computeStorePathForText(name, contents, refs)

: store->addTextToStore(name, contents, refs, state.repair);

/* 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]. */

mkString(v, storePath, singleton<PathSet>(storePath));

}

struct FilterFromExpr : PathFilter

{

EvalState & state;

Value & filter;

FilterFromExpr(EvalState & state, Value & filter)

: state(state), filter(filter)

{

}

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, noPos);

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, noPos);

return state.forceBool(res);

}

};

static void prim_filterSource(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

PathSet context;

Path path = state.coerceToPath(pos, *args[1], context);

if (!context.empty())

throw EvalError(format("string `%1%' cannot refer to other paths, at %2%") % path % pos);

state.forceValue(*args[0]);

if (args[0]->type != tLambda)

throw TypeError(format("first argument in call to `filterSource' is not a function but %1%, at %2%") % showType(*args[0]) % pos);

FilterFromExpr filter(state, *args[0]);

Path dstPath = settings.readOnlyMode

? computeStorePathForPath(path, true, htSHA256, filter).first

: store->addToStore(path, true, htSHA256, filter, state.repair);

mkString(v, dstPath, singleton<PathSet>(dstPath));

}

/*************************************************************

* Sets

*************************************************************/

/* Return the names of the attributes in a set as a sorted list of

strings. */

static void prim_attrNames(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceAttrs(*args[0], pos);

state.mkList(v, args[0]->attrs->size());

StringSet names;

foreach (Bindings::iterator, i, *args[0]->attrs)

names.insert(i->name);

unsigned int n = 0;

foreach (StringSet::iterator, i, names)

mkString(*(v.list.elems[n++] = state.allocValue()), *i);

}

/* Dynamic version of the `.' operator. */

void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

string attr = state.forceStringNoCtx(*args[0], pos);

state.forceAttrs(*args[1], pos);

// !!! Should we create a symbol here or just do a lookup?

Bindings::iterator i = args[1]->attrs->find(state.symbols.create(attr));

if (i == args[1]->attrs->end())

throw EvalError(format("attribute `%1%' missing, at %2%") % attr % pos);

// !!! add to stack trace?

if (state.countCalls && i->pos) state.attrSelects[*i->pos]++;

state.forceValue(*i->value);

v = *i->value;

}

/* Return position information of the specified attribute. */

void prim_unsafeGetAttrPos(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

string attr = state.forceStringNoCtx(*args[0], pos);

state.forceAttrs(*args[1], pos);

Bindings::iterator i = args[1]->attrs->find(state.symbols.create(attr));

if (i == args[1]->attrs->end())

mkNull(v);

else

state.mkPos(v, i->pos);

}

/* Dynamic version of the `?' operator. */

static void prim_hasAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

string attr = state.forceStringNoCtx(*args[0], pos);

state.forceAttrs(*args[1], pos);

mkBool(v, args[1]->attrs->find(state.symbols.create(attr)) != args[1]->attrs->end());

}

/* Determine whether the argument is a set. */

static void prim_isAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceValue(*args[0]);

mkBool(v, args[0]->type == tAttrs);

}

static void prim_removeAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceAttrs(*args[0], pos);

state.forceList(*args[1], pos);

/* Get the attribute names to be removed. */

std::set<Symbol> names;

for (unsigned int i = 0; i < args[1]->list.length; ++i) {

state.forceStringNoCtx(*args[1]->list.elems[i], pos);

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);

}

}

/* Builds a 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;}. In case of duplicate occurences of the same

name, the first takes precedence. */

static void prim_listToAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)

{

state.forceList(*args[0], pos);

state.mkAttrs(v, args[0]->list.length);

std::set<Symbol> seen;

for (unsigned int i = 0; i < args[0]->list.length; ++i) {

Value & v2(*args[0]->list.elems[i]);

state.forceAttrs(v2, pos);

Bindings::iterator j = v2.attrs->find(state.sName);

if (j == v2.attrs->end())

throw TypeError(format("`name' attribute missing in a call to `listToAttrs', at %1%") % pos);

string name = state.forceStringNoCtx(*j->value, pos);

Symbol sym = state.symbols.create(name);

if (seen.find(sym) == seen.end()) {

Bindings::iterator j2 = v2.attrs->find(state.symbols.create(state.sValue));

if (j2 == v2.attrs->end())

throw TypeError(format("`value' attribute missing in a call to `listToAttrs', at %1%") % pos);

v.attrs->push_back(Attr(sym, j2->value, j2->pos));

seen.insert(sym);

}

}

v.attrs->sort();

}

/* Return the right-biased intersection of two sets as1 and as2,

i.e. a set that contains every attribute from as2 that is also a

member of as1. */

static void prim_intersectAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)