forked from lix-project/lix
363f37d084
Thus, -I / $NIX_PATH entries are now downloaded only when they are
needed for evaluation. An error to download an entry is a non-fatal
warning (just like non-existant paths).
This does change the semantics of builtins.nixPath, which now returns
the original, rather than resulting path. E.g., before we had
[ { path = "/nix/store/hgm3yxf1lrrwa3z14zpqaj5p9vs0qklk-nixexprs.tar.xz"; prefix = "nixpkgs"; } ... ]
but now
[ { path = "https://nixos.org/channels/nixos-16.03/nixexprs.tar.xz"; prefix = "nixpkgs"; } ... ]
Fixes #792.
1780 lines
50 KiB
C++
1780 lines
50 KiB
C++
#include "eval.hh"
|
||
#include "hash.hh"
|
||
#include "util.hh"
|
||
#include "store-api.hh"
|
||
#include "derivations.hh"
|
||
#include "globals.hh"
|
||
#include "eval-inline.hh"
|
||
|
||
#include <algorithm>
|
||
#include <cstring>
|
||
#include <unistd.h>
|
||
#include <sys/time.h>
|
||
#include <sys/resource.h>
|
||
|
||
#if HAVE_BOEHMGC
|
||
|
||
#include <gc/gc.h>
|
||
#include <gc/gc_cpp.h>
|
||
|
||
#define NEW new (UseGC)
|
||
|
||
#else
|
||
|
||
#define NEW new
|
||
|
||
#endif
|
||
|
||
|
||
namespace nix {
|
||
|
||
|
||
static char * dupString(const char * s)
|
||
{
|
||
char * t;
|
||
#if HAVE_BOEHMGC
|
||
t = GC_strdup(s);
|
||
#else
|
||
t = strdup(s);
|
||
#endif
|
||
if (!t) throw std::bad_alloc();
|
||
return t;
|
||
}
|
||
|
||
|
||
static void * allocBytes(size_t n)
|
||
{
|
||
void * p;
|
||
#if HAVE_BOEHMGC
|
||
p = GC_malloc(n);
|
||
#else
|
||
p = malloc(n);
|
||
#endif
|
||
if (!p) throw std::bad_alloc();
|
||
return p;
|
||
}
|
||
|
||
|
||
static void printValue(std::ostream & str, std::set<const Value *> & active, const Value & v)
|
||
{
|
||
checkInterrupt();
|
||
|
||
if (active.find(&v) != active.end()) {
|
||
str << "<CYCLE>";
|
||
return;
|
||
}
|
||
active.insert(&v);
|
||
|
||
switch (v.type) {
|
||
case tInt:
|
||
str << v.integer;
|
||
break;
|
||
case tBool:
|
||
str << (v.boolean ? "true" : "false");
|
||
break;
|
||
case tString:
|
||
str << "\"";
|
||
for (const char * i = v.string.s; *i; i++)
|
||
if (*i == '\"' || *i == '\\') str << "\\" << *i;
|
||
else if (*i == '\n') str << "\\n";
|
||
else if (*i == '\r') str << "\\r";
|
||
else if (*i == '\t') str << "\\t";
|
||
else str << *i;
|
||
str << "\"";
|
||
break;
|
||
case tPath:
|
||
str << v.path; // !!! escaping?
|
||
break;
|
||
case tNull:
|
||
str << "null";
|
||
break;
|
||
case tAttrs: {
|
||
str << "{ ";
|
||
typedef std::map<string, Value *> Sorted;
|
||
Sorted sorted;
|
||
for (auto & i : *v.attrs)
|
||
sorted[i.name] = i.value;
|
||
for (auto & i : sorted) {
|
||
str << i.first << " = ";
|
||
printValue(str, active, *i.second);
|
||
str << "; ";
|
||
}
|
||
str << "}";
|
||
break;
|
||
}
|
||
case tList1:
|
||
case tList2:
|
||
case tListN:
|
||
str << "[ ";
|
||
for (unsigned int n = 0; n < v.listSize(); ++n) {
|
||
printValue(str, active, *v.listElems()[n]);
|
||
str << " ";
|
||
}
|
||
str << "]";
|
||
break;
|
||
case tThunk:
|
||
case tApp:
|
||
str << "<CODE>";
|
||
break;
|
||
case tLambda:
|
||
str << "<LAMBDA>";
|
||
break;
|
||
case tPrimOp:
|
||
str << "<PRIMOP>";
|
||
break;
|
||
case tPrimOpApp:
|
||
str << "<PRIMOP-APP>";
|
||
break;
|
||
case tExternal:
|
||
str << *v.external;
|
||
break;
|
||
case tFloat:
|
||
str << v.fpoint;
|
||
break;
|
||
default:
|
||
throw Error("invalid value");
|
||
}
|
||
|
||
active.erase(&v);
|
||
}
|
||
|
||
|
||
std::ostream & operator << (std::ostream & str, const Value & v)
|
||
{
|
||
std::set<const Value *> active;
|
||
printValue(str, active, v);
|
||
return str;
|
||
}
|
||
|
||
|
||
string showType(const Value & v)
|
||
{
|
||
switch (v.type) {
|
||
case tInt: return "an integer";
|
||
case tBool: return "a boolean";
|
||
case tString: return "a string";
|
||
case tPath: return "a path";
|
||
case tNull: return "null";
|
||
case tAttrs: return "a set";
|
||
case tList1: case tList2: case tListN: return "a list";
|
||
case tThunk: return "a thunk";
|
||
case tApp: return "a function application";
|
||
case tLambda: return "a function";
|
||
case tBlackhole: return "a black hole";
|
||
case tPrimOp: return "a built-in function";
|
||
case tPrimOpApp: return "a partially applied built-in function";
|
||
case tExternal: return v.external->showType();
|
||
case tFloat: return "a float";
|
||
}
|
||
abort();
|
||
}
|
||
|
||
|
||
#if HAVE_BOEHMGC
|
||
/* Called when the Boehm GC runs out of memory. */
|
||
static void * oomHandler(size_t requested)
|
||
{
|
||
/* Convert this to a proper C++ exception. */
|
||
throw std::bad_alloc();
|
||
}
|
||
#endif
|
||
|
||
|
||
static Symbol getName(const AttrName & name, EvalState & state, Env & env)
|
||
{
|
||
if (name.symbol.set()) {
|
||
return name.symbol;
|
||
} else {
|
||
Value nameValue;
|
||
name.expr->eval(state, env, nameValue);
|
||
state.forceStringNoCtx(nameValue);
|
||
return state.symbols.create(nameValue.string.s);
|
||
}
|
||
}
|
||
|
||
|
||
static bool gcInitialised = false;
|
||
|
||
void initGC()
|
||
{
|
||
if (gcInitialised) return;
|
||
|
||
#if HAVE_BOEHMGC
|
||
/* Initialise the Boehm garbage collector. */
|
||
GC_set_all_interior_pointers(0);
|
||
|
||
GC_INIT();
|
||
|
||
GC_oom_fn = oomHandler;
|
||
|
||
/* Set the initial heap size to something fairly big (25% of
|
||
physical RAM, up to a maximum of 384 MiB) so that in most cases
|
||
we don't need to garbage collect at all. (Collection has a
|
||
fairly significant overhead.) The heap size can be overridden
|
||
through libgc's GC_INITIAL_HEAP_SIZE environment variable. We
|
||
should probably also provide a nix.conf setting for this. Note
|
||
that GC_expand_hp() causes a lot of virtual, but not physical
|
||
(resident) memory to be allocated. This might be a problem on
|
||
systems that don't overcommit. */
|
||
if (!getenv("GC_INITIAL_HEAP_SIZE")) {
|
||
size_t size = 32 * 1024 * 1024;
|
||
#if HAVE_SYSCONF && defined(_SC_PAGESIZE) && defined(_SC_PHYS_PAGES)
|
||
size_t maxSize = 384 * 1024 * 1024;
|
||
long pageSize = sysconf(_SC_PAGESIZE);
|
||
long pages = sysconf(_SC_PHYS_PAGES);
|
||
if (pageSize != -1)
|
||
size = (pageSize * pages) / 4; // 25% of RAM
|
||
if (size > maxSize) size = maxSize;
|
||
#endif
|
||
debug(format("setting initial heap size to %1% bytes") % size);
|
||
GC_expand_hp(size);
|
||
}
|
||
|
||
#endif
|
||
|
||
gcInitialised = true;
|
||
}
|
||
|
||
|
||
/* Very hacky way to parse $NIX_PATH, which is colon-separated, but
|
||
can contain URLs (e.g. "nixpkgs=https://bla...:foo=https://"). */
|
||
static Strings parseNixPath(const string & in)
|
||
{
|
||
string marker = "\001//";
|
||
auto res = tokenizeString<Strings>(replaceStrings(in, "://", marker), ":");
|
||
for (auto & s : res)
|
||
s = replaceStrings(s, marker, "://");
|
||
return res;
|
||
}
|
||
|
||
|
||
EvalState::EvalState(const Strings & _searchPath, ref<Store> store)
|
||
: sWith(symbols.create("<with>"))
|
||
, sOutPath(symbols.create("outPath"))
|
||
, sDrvPath(symbols.create("drvPath"))
|
||
, sType(symbols.create("type"))
|
||
, sMeta(symbols.create("meta"))
|
||
, sName(symbols.create("name"))
|
||
, sValue(symbols.create("value"))
|
||
, sSystem(symbols.create("system"))
|
||
, sOverrides(symbols.create("__overrides"))
|
||
, sOutputs(symbols.create("outputs"))
|
||
, sOutputName(symbols.create("outputName"))
|
||
, sIgnoreNulls(symbols.create("__ignoreNulls"))
|
||
, sFile(symbols.create("file"))
|
||
, sLine(symbols.create("line"))
|
||
, sColumn(symbols.create("column"))
|
||
, sFunctor(symbols.create("__functor"))
|
||
, sToString(symbols.create("__toString"))
|
||
, store(store)
|
||
, baseEnv(allocEnv(128))
|
||
, staticBaseEnv(false, 0)
|
||
{
|
||
countCalls = getEnv("NIX_COUNT_CALLS", "0") != "0";
|
||
|
||
restricted = settings.get("restrict-eval", false);
|
||
|
||
assert(gcInitialised);
|
||
|
||
/* Initialise the Nix expression search path. */
|
||
Strings paths = parseNixPath(getEnv("NIX_PATH", ""));
|
||
for (auto & i : _searchPath) addToSearchPath(i);
|
||
for (auto & i : paths) addToSearchPath(i);
|
||
addToSearchPath("nix=" + settings.nixDataDir + "/nix/corepkgs");
|
||
|
||
clearValue(vEmptySet);
|
||
vEmptySet.type = tAttrs;
|
||
vEmptySet.attrs = allocBindings(0);
|
||
|
||
createBaseEnv();
|
||
}
|
||
|
||
|
||
EvalState::~EvalState()
|
||
{
|
||
fileEvalCache.clear();
|
||
}
|
||
|
||
|
||
Path EvalState::checkSourcePath(const Path & path_)
|
||
{
|
||
if (!restricted) return path_;
|
||
|
||
/* Resolve symlinks. */
|
||
debug(format("checking access to ‘%s’") % path_);
|
||
Path path = canonPath(path_, true);
|
||
|
||
for (auto & i : searchPath) {
|
||
auto r = resolveSearchPathElem(i);
|
||
if (!r.first) continue;
|
||
if (path == r.second || isInDir(path, r.second))
|
||
return path;
|
||
}
|
||
|
||
/* To support import-from-derivation, allow access to anything in
|
||
the store. FIXME: only allow access to paths that have been
|
||
constructed by this evaluation. */
|
||
if (isInStore(path)) return path;
|
||
|
||
#if 0
|
||
/* Hack to support the chroot dependencies of corepkgs (see
|
||
corepkgs/config.nix.in). */
|
||
if (path == settings.nixPrefix && isStorePath(settings.nixPrefix))
|
||
return path;
|
||
#endif
|
||
|
||
throw RestrictedPathError(format("access to path ‘%1%’ is forbidden in restricted mode") % path_);
|
||
}
|
||
|
||
|
||
void EvalState::addConstant(const string & name, Value & v)
|
||
{
|
||
Value * v2 = allocValue();
|
||
*v2 = v;
|
||
staticBaseEnv.vars[symbols.create(name)] = baseEnvDispl;
|
||
baseEnv.values[baseEnvDispl++] = v2;
|
||
string name2 = string(name, 0, 2) == "__" ? string(name, 2) : name;
|
||
baseEnv.values[0]->attrs->push_back(Attr(symbols.create(name2), v2));
|
||
}
|
||
|
||
|
||
void EvalState::addPrimOp(const string & name,
|
||
unsigned int arity, PrimOpFun primOp)
|
||
{
|
||
Value * v = allocValue();
|
||
string name2 = string(name, 0, 2) == "__" ? string(name, 2) : name;
|
||
Symbol sym = symbols.create(name2);
|
||
v->type = tPrimOp;
|
||
v->primOp = NEW PrimOp(primOp, arity, sym);
|
||
staticBaseEnv.vars[symbols.create(name)] = baseEnvDispl;
|
||
baseEnv.values[baseEnvDispl++] = v;
|
||
baseEnv.values[0]->attrs->push_back(Attr(sym, v));
|
||
}
|
||
|
||
|
||
void EvalState::getBuiltin(const string & name, Value & v)
|
||
{
|
||
v = *baseEnv.values[0]->attrs->find(symbols.create(name))->value;
|
||
}
|
||
|
||
|
||
/* Every "format" object (even temporary) takes up a few hundred bytes
|
||
of stack space, which is a real killer in the recursive
|
||
evaluator. So here are some helper functions for throwing
|
||
exceptions. */
|
||
|
||
LocalNoInlineNoReturn(void throwEvalError(const char * s, const string & s2))
|
||
{
|
||
throw EvalError(format(s) % s2);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwEvalError(const char * s, const string & s2, const Pos & pos))
|
||
{
|
||
throw EvalError(format(s) % s2 % pos);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwEvalError(const char * s, const string & s2, const string & s3))
|
||
{
|
||
throw EvalError(format(s) % s2 % s3);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwEvalError(const char * s, const string & s2, const string & s3, const Pos & pos))
|
||
{
|
||
throw EvalError(format(s) % s2 % s3 % pos);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwEvalError(const char * s, const Symbol & sym, const Pos & p1, const Pos & p2))
|
||
{
|
||
throw EvalError(format(s) % sym % p1 % p2);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwTypeError(const char * s, const Pos & pos))
|
||
{
|
||
throw TypeError(format(s) % pos);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwTypeError(const char * s, const string & s1))
|
||
{
|
||
throw TypeError(format(s) % s1);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwTypeError(const char * s, const ExprLambda & fun, const Symbol & s2, const Pos & pos))
|
||
{
|
||
throw TypeError(format(s) % fun.showNamePos() % s2 % pos);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwAssertionError(const char * s, const Pos & pos))
|
||
{
|
||
throw AssertionError(format(s) % pos);
|
||
}
|
||
|
||
LocalNoInlineNoReturn(void throwUndefinedVarError(const char * s, const string & s1, const Pos & pos))
|
||
{
|
||
throw UndefinedVarError(format(s) % s1 % pos);
|
||
}
|
||
|
||
LocalNoInline(void addErrorPrefix(Error & e, const char * s, const string & s2))
|
||
{
|
||
e.addPrefix(format(s) % s2);
|
||
}
|
||
|
||
LocalNoInline(void addErrorPrefix(Error & e, const char * s, const ExprLambda & fun, const Pos & pos))
|
||
{
|
||
e.addPrefix(format(s) % fun.showNamePos() % pos);
|
||
}
|
||
|
||
LocalNoInline(void addErrorPrefix(Error & e, const char * s, const string & s2, const Pos & pos))
|
||
{
|
||
e.addPrefix(format(s) % s2 % pos);
|
||
}
|
||
|
||
|
||
void mkString(Value & v, const char * s)
|
||
{
|
||
mkStringNoCopy(v, dupString(s));
|
||
}
|
||
|
||
|
||
void mkString(Value & v, const string & s, const PathSet & context)
|
||
{
|
||
mkString(v, s.c_str());
|
||
if (!context.empty()) {
|
||
unsigned int n = 0;
|
||
v.string.context = (const char * *)
|
||
allocBytes((context.size() + 1) * sizeof(char *));
|
||
for (auto & i : context)
|
||
v.string.context[n++] = dupString(i.c_str());
|
||
v.string.context[n] = 0;
|
||
}
|
||
}
|
||
|
||
|
||
void mkPath(Value & v, const char * s)
|
||
{
|
||
mkPathNoCopy(v, dupString(s));
|
||
}
|
||
|
||
|
||
inline Value * EvalState::lookupVar(Env * env, const ExprVar & var, bool noEval)
|
||
{
|
||
for (unsigned int l = var.level; l; --l, env = env->up) ;
|
||
|
||
if (!var.fromWith) return env->values[var.displ];
|
||
|
||
while (1) {
|
||
if (!env->haveWithAttrs) {
|
||
if (noEval) return 0;
|
||
Value * v = allocValue();
|
||
evalAttrs(*env->up, (Expr *) env->values[0], *v);
|
||
env->values[0] = v;
|
||
env->haveWithAttrs = true;
|
||
}
|
||
Bindings::iterator j = env->values[0]->attrs->find(var.name);
|
||
if (j != env->values[0]->attrs->end()) {
|
||
if (countCalls && j->pos) attrSelects[*j->pos]++;
|
||
return j->value;
|
||
}
|
||
if (!env->prevWith)
|
||
throwUndefinedVarError("undefined variable ‘%1%’ at %2%", var.name, var.pos);
|
||
for (unsigned int l = env->prevWith; l; --l, env = env->up) ;
|
||
}
|
||
}
|
||
|
||
|
||
Value * EvalState::allocValue()
|
||
{
|
||
nrValues++;
|
||
return (Value *) allocBytes(sizeof(Value));
|
||
}
|
||
|
||
|
||
Env & EvalState::allocEnv(unsigned int size)
|
||
{
|
||
assert(size <= std::numeric_limits<decltype(Env::size)>::max());
|
||
|
||
nrEnvs++;
|
||
nrValuesInEnvs += size;
|
||
Env * env = (Env *) allocBytes(sizeof(Env) + size * sizeof(Value *));
|
||
env->size = size;
|
||
|
||
/* Clear the values because maybeThunk() and lookupVar fromWith expect this. */
|
||
for (unsigned i = 0; i < size; ++i)
|
||
env->values[i] = 0;
|
||
|
||
return *env;
|
||
}
|
||
|
||
|
||
void EvalState::mkList(Value & v, unsigned int size)
|
||
{
|
||
clearValue(v);
|
||
if (size == 1)
|
||
v.type = tList1;
|
||
else if (size == 2)
|
||
v.type = tList2;
|
||
else {
|
||
v.type = tListN;
|
||
v.bigList.size = size;
|
||
v.bigList.elems = size ? (Value * *) allocBytes(size * sizeof(Value *)) : 0;
|
||
}
|
||
nrListElems += size;
|
||
}
|
||
|
||
|
||
unsigned long nrThunks = 0;
|
||
|
||
static inline void mkThunk(Value & v, Env & env, Expr * expr)
|
||
{
|
||
v.type = tThunk;
|
||
v.thunk.env = &env;
|
||
v.thunk.expr = expr;
|
||
nrThunks++;
|
||
}
|
||
|
||
|
||
void EvalState::mkThunk_(Value & v, Expr * expr)
|
||
{
|
||
mkThunk(v, baseEnv, expr);
|
||
}
|
||
|
||
|
||
void EvalState::mkPos(Value & v, Pos * pos)
|
||
{
|
||
if (pos) {
|
||
mkAttrs(v, 3);
|
||
mkString(*allocAttr(v, sFile), pos->file);
|
||
mkInt(*allocAttr(v, sLine), pos->line);
|
||
mkInt(*allocAttr(v, sColumn), pos->column);
|
||
v.attrs->sort();
|
||
} else
|
||
mkNull(v);
|
||
}
|
||
|
||
|
||
/* Create a thunk for the delayed computation of the given expression
|
||
in the given environment. But if the expression is a variable,
|
||
then look it up right away. This significantly reduces the number
|
||
of thunks allocated. */
|
||
Value * Expr::maybeThunk(EvalState & state, Env & env)
|
||
{
|
||
Value * v = state.allocValue();
|
||
mkThunk(*v, env, this);
|
||
return v;
|
||
}
|
||
|
||
|
||
unsigned long nrAvoided = 0;
|
||
|
||
Value * ExprVar::maybeThunk(EvalState & state, Env & env)
|
||
{
|
||
Value * v = state.lookupVar(&env, *this, true);
|
||
/* The value might not be initialised in the environment yet.
|
||
In that case, ignore it. */
|
||
if (v) { nrAvoided++; return v; }
|
||
return Expr::maybeThunk(state, env);
|
||
}
|
||
|
||
|
||
Value * ExprString::maybeThunk(EvalState & state, Env & env)
|
||
{
|
||
nrAvoided++;
|
||
return &v;
|
||
}
|
||
|
||
Value * ExprInt::maybeThunk(EvalState & state, Env & env)
|
||
{
|
||
nrAvoided++;
|
||
return &v;
|
||
}
|
||
|
||
Value * ExprFloat::maybeThunk(EvalState & state, Env & env)
|
||
{
|
||
nrAvoided++;
|
||
return &v;
|
||
}
|
||
|
||
Value * ExprPath::maybeThunk(EvalState & state, Env & env)
|
||
{
|
||
nrAvoided++;
|
||
return &v;
|
||
}
|
||
|
||
|
||
void EvalState::evalFile(const Path & path, Value & v)
|
||
{
|
||
FileEvalCache::iterator i;
|
||
if ((i = fileEvalCache.find(path)) != fileEvalCache.end()) {
|
||
v = i->second;
|
||
return;
|
||
}
|
||
|
||
Path path2 = resolveExprPath(path);
|
||
if ((i = fileEvalCache.find(path2)) != fileEvalCache.end()) {
|
||
v = i->second;
|
||
return;
|
||
}
|
||
|
||
startNest(nest, lvlTalkative, format("evaluating file ‘%1%’") % path2);
|
||
Expr * e = parseExprFromFile(checkSourcePath(path2));
|
||
try {
|
||
eval(e, v);
|
||
} catch (Error & e) {
|
||
addErrorPrefix(e, "while evaluating the file ‘%1%’:\n", path2);
|
||
throw;
|
||
}
|
||
|
||
fileEvalCache[path2] = v;
|
||
if (path != path2) fileEvalCache[path] = v;
|
||
}
|
||
|
||
|
||
void EvalState::resetFileCache()
|
||
{
|
||
fileEvalCache.clear();
|
||
}
|
||
|
||
|
||
void EvalState::eval(Expr * e, Value & v)
|
||
{
|
||
e->eval(*this, baseEnv, v);
|
||
}
|
||
|
||
|
||
inline bool EvalState::evalBool(Env & env, Expr * e)
|
||
{
|
||
Value v;
|
||
e->eval(*this, env, v);
|
||
if (v.type != tBool)
|
||
throwTypeError("value is %1% while a Boolean was expected", v);
|
||
return v.boolean;
|
||
}
|
||
|
||
|
||
inline bool EvalState::evalBool(Env & env, Expr * e, const Pos & pos)
|
||
{
|
||
Value v;
|
||
e->eval(*this, env, v);
|
||
if (v.type != tBool)
|
||
throwTypeError("value is %1% while a Boolean was expected, at %2%", v, pos);
|
||
return v.boolean;
|
||
}
|
||
|
||
|
||
inline void EvalState::evalAttrs(Env & env, Expr * e, Value & v)
|
||
{
|
||
e->eval(*this, env, v);
|
||
if (v.type != tAttrs)
|
||
throwTypeError("value is %1% while a set was expected", v);
|
||
}
|
||
|
||
|
||
void Expr::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
abort();
|
||
}
|
||
|
||
|
||
void ExprInt::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
v = this->v;
|
||
}
|
||
|
||
|
||
void ExprFloat::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
v = this->v;
|
||
}
|
||
|
||
void ExprString::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
v = this->v;
|
||
}
|
||
|
||
|
||
void ExprPath::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
v = this->v;
|
||
}
|
||
|
||
|
||
void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
state.mkAttrs(v, attrs.size() + dynamicAttrs.size());
|
||
Env *dynamicEnv = &env;
|
||
|
||
if (recursive) {
|
||
/* Create a new environment that contains the attributes in
|
||
this `rec'. */
|
||
Env & env2(state.allocEnv(attrs.size()));
|
||
env2.up = &env;
|
||
dynamicEnv = &env2;
|
||
|
||
AttrDefs::iterator overrides = attrs.find(state.sOverrides);
|
||
bool hasOverrides = overrides != attrs.end();
|
||
|
||
/* The recursive attributes are evaluated in the new
|
||
environment, while the inherited attributes are evaluated
|
||
in the original environment. */
|
||
unsigned int displ = 0;
|
||
for (auto & i : attrs) {
|
||
Value * vAttr;
|
||
if (hasOverrides && !i.second.inherited) {
|
||
vAttr = state.allocValue();
|
||
mkThunk(*vAttr, env2, i.second.e);
|
||
} else
|
||
vAttr = i.second.e->maybeThunk(state, i.second.inherited ? env : env2);
|
||
env2.values[displ++] = vAttr;
|
||
v.attrs->push_back(Attr(i.first, vAttr, &i.second.pos));
|
||
}
|
||
|
||
/* If the rec contains an attribute called `__overrides', then
|
||
evaluate it, and add the attributes in that set to the rec.
|
||
This allows overriding of recursive attributes, which is
|
||
otherwise not possible. (You can use the // operator to
|
||
replace an attribute, but other attributes in the rec will
|
||
still reference the original value, because that value has
|
||
been substituted into the bodies of the other attributes.
|
||
Hence we need __overrides.) */
|
||
if (hasOverrides) {
|
||
Value * vOverrides = (*v.attrs)[overrides->second.displ].value;
|
||
state.forceAttrs(*vOverrides);
|
||
Bindings * newBnds = state.allocBindings(v.attrs->size() + vOverrides->attrs->size());
|
||
for (auto & i : *v.attrs)
|
||
newBnds->push_back(i);
|
||
for (auto & i : *vOverrides->attrs) {
|
||
AttrDefs::iterator j = attrs.find(i.name);
|
||
if (j != attrs.end()) {
|
||
(*newBnds)[j->second.displ] = i;
|
||
env2.values[j->second.displ] = i.value;
|
||
} else
|
||
newBnds->push_back(i);
|
||
}
|
||
newBnds->sort();
|
||
v.attrs = newBnds;
|
||
}
|
||
}
|
||
|
||
else
|
||
for (auto & i : attrs)
|
||
v.attrs->push_back(Attr(i.first, i.second.e->maybeThunk(state, env), &i.second.pos));
|
||
|
||
/* Dynamic attrs apply *after* rec and __overrides. */
|
||
for (auto & i : dynamicAttrs) {
|
||
Value nameVal;
|
||
i.nameExpr->eval(state, *dynamicEnv, nameVal);
|
||
state.forceValue(nameVal, i.pos);
|
||
if (nameVal.type == tNull)
|
||
continue;
|
||
state.forceStringNoCtx(nameVal);
|
||
Symbol nameSym = state.symbols.create(nameVal.string.s);
|
||
Bindings::iterator j = v.attrs->find(nameSym);
|
||
if (j != v.attrs->end())
|
||
throwEvalError("dynamic attribute ‘%1%’ at %2% already defined at %3%", nameSym, i.pos, *j->pos);
|
||
|
||
i.valueExpr->setName(nameSym);
|
||
/* Keep sorted order so find can catch duplicates */
|
||
v.attrs->push_back(Attr(nameSym, i.valueExpr->maybeThunk(state, *dynamicEnv), &i.pos));
|
||
v.attrs->sort(); // FIXME: inefficient
|
||
}
|
||
}
|
||
|
||
|
||
void ExprLet::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
/* Create a new environment that contains the attributes in this
|
||
`let'. */
|
||
Env & env2(state.allocEnv(attrs->attrs.size()));
|
||
env2.up = &env;
|
||
|
||
/* The recursive attributes are evaluated in the new environment,
|
||
while the inherited attributes are evaluated in the original
|
||
environment. */
|
||
unsigned int displ = 0;
|
||
for (auto & i : attrs->attrs)
|
||
env2.values[displ++] = i.second.e->maybeThunk(state, i.second.inherited ? env : env2);
|
||
|
||
body->eval(state, env2, v);
|
||
}
|
||
|
||
|
||
void ExprList::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
state.mkList(v, elems.size());
|
||
for (unsigned int n = 0; n < elems.size(); ++n)
|
||
v.listElems()[n] = elems[n]->maybeThunk(state, env);
|
||
}
|
||
|
||
|
||
void ExprVar::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Value * v2 = state.lookupVar(&env, *this, false);
|
||
state.forceValue(*v2, pos);
|
||
v = *v2;
|
||
}
|
||
|
||
|
||
static string showAttrPath(EvalState & state, Env & env, const AttrPath & attrPath)
|
||
{
|
||
std::ostringstream out;
|
||
bool first = true;
|
||
for (auto & i : attrPath) {
|
||
if (!first) out << '.'; else first = false;
|
||
try {
|
||
out << getName(i, state, env);
|
||
} catch (Error & e) {
|
||
assert(!i.symbol.set());
|
||
out << "\"${" << *i.expr << "}\"";
|
||
}
|
||
}
|
||
return out.str();
|
||
}
|
||
|
||
|
||
unsigned long nrLookups = 0;
|
||
|
||
void ExprSelect::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Value vTmp;
|
||
Pos * pos2 = 0;
|
||
Value * vAttrs = &vTmp;
|
||
|
||
e->eval(state, env, vTmp);
|
||
|
||
try {
|
||
|
||
for (auto & i : attrPath) {
|
||
nrLookups++;
|
||
Bindings::iterator j;
|
||
Symbol name = getName(i, state, env);
|
||
if (def) {
|
||
state.forceValue(*vAttrs, pos);
|
||
if (vAttrs->type != tAttrs ||
|
||
(j = vAttrs->attrs->find(name)) == vAttrs->attrs->end())
|
||
{
|
||
def->eval(state, env, v);
|
||
return;
|
||
}
|
||
} else {
|
||
state.forceAttrs(*vAttrs, pos);
|
||
if ((j = vAttrs->attrs->find(name)) == vAttrs->attrs->end())
|
||
throwEvalError("attribute ‘%1%’ missing, at %2%", name, pos);
|
||
}
|
||
vAttrs = j->value;
|
||
pos2 = j->pos;
|
||
if (state.countCalls && pos2) state.attrSelects[*pos2]++;
|
||
}
|
||
|
||
state.forceValue(*vAttrs, ( pos2 != NULL ? *pos2 : this->pos ) );
|
||
|
||
} catch (Error & e) {
|
||
if (pos2 && pos2->file != state.sDerivationNix)
|
||
addErrorPrefix(e, "while evaluating the attribute ‘%1%’ at %2%:\n",
|
||
showAttrPath(state, env, attrPath), *pos2);
|
||
throw;
|
||
}
|
||
|
||
v = *vAttrs;
|
||
}
|
||
|
||
|
||
void ExprOpHasAttr::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Value vTmp;
|
||
Value * vAttrs = &vTmp;
|
||
|
||
e->eval(state, env, vTmp);
|
||
|
||
for (auto & i : attrPath) {
|
||
state.forceValue(*vAttrs);
|
||
Bindings::iterator j;
|
||
Symbol name = getName(i, state, env);
|
||
if (vAttrs->type != tAttrs ||
|
||
(j = vAttrs->attrs->find(name)) == vAttrs->attrs->end())
|
||
{
|
||
mkBool(v, false);
|
||
return;
|
||
} else {
|
||
vAttrs = j->value;
|
||
}
|
||
}
|
||
|
||
mkBool(v, true);
|
||
}
|
||
|
||
|
||
void ExprLambda::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
v.type = tLambda;
|
||
v.lambda.env = &env;
|
||
v.lambda.fun = this;
|
||
}
|
||
|
||
|
||
void ExprApp::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
/* FIXME: vFun prevents GCC from doing tail call optimisation. */
|
||
Value vFun;
|
||
e1->eval(state, env, vFun);
|
||
state.callFunction(vFun, *(e2->maybeThunk(state, env)), v, pos);
|
||
}
|
||
|
||
|
||
void EvalState::callPrimOp(Value & fun, Value & arg, Value & v, const Pos & pos)
|
||
{
|
||
/* Figure out the number of arguments still needed. */
|
||
unsigned int argsDone = 0;
|
||
Value * primOp = &fun;
|
||
while (primOp->type == tPrimOpApp) {
|
||
argsDone++;
|
||
primOp = primOp->primOpApp.left;
|
||
}
|
||
assert(primOp->type == tPrimOp);
|
||
unsigned int arity = primOp->primOp->arity;
|
||
unsigned int argsLeft = arity - argsDone;
|
||
|
||
if (argsLeft == 1) {
|
||
/* We have all the arguments, so call the primop. */
|
||
|
||
/* Put all the arguments in an array. */
|
||
Value * vArgs[arity];
|
||
unsigned int n = arity - 1;
|
||
vArgs[n--] = &arg;
|
||
for (Value * arg = &fun; arg->type == tPrimOpApp; arg = arg->primOpApp.left)
|
||
vArgs[n--] = arg->primOpApp.right;
|
||
|
||
/* And call the primop. */
|
||
nrPrimOpCalls++;
|
||
if (countCalls) primOpCalls[primOp->primOp->name]++;
|
||
primOp->primOp->fun(*this, pos, vArgs, v);
|
||
} else {
|
||
Value * fun2 = allocValue();
|
||
*fun2 = fun;
|
||
v.type = tPrimOpApp;
|
||
v.primOpApp.left = fun2;
|
||
v.primOpApp.right = &arg;
|
||
}
|
||
}
|
||
|
||
|
||
void EvalState::callFunction(Value & fun, Value & arg, Value & v, const Pos & pos)
|
||
{
|
||
if (fun.type == tPrimOp || fun.type == tPrimOpApp) {
|
||
callPrimOp(fun, arg, v, pos);
|
||
return;
|
||
}
|
||
|
||
if (fun.type == tAttrs) {
|
||
auto found = fun.attrs->find(sFunctor);
|
||
if (found != fun.attrs->end()) {
|
||
forceValue(*found->value, pos);
|
||
Value * v2 = allocValue();
|
||
callFunction(*found->value, fun, *v2, pos);
|
||
forceValue(*v2, pos);
|
||
return callFunction(*v2, arg, v, pos);
|
||
}
|
||
}
|
||
|
||
if (fun.type != tLambda)
|
||
throwTypeError("attempt to call something which is not a function but %1%, at %2%", fun, pos);
|
||
|
||
ExprLambda & lambda(*fun.lambda.fun);
|
||
|
||
unsigned int size =
|
||
(lambda.arg.empty() ? 0 : 1) +
|
||
(lambda.matchAttrs ? lambda.formals->formals.size() : 0);
|
||
Env & env2(allocEnv(size));
|
||
env2.up = fun.lambda.env;
|
||
|
||
unsigned int displ = 0;
|
||
|
||
if (!lambda.matchAttrs)
|
||
env2.values[displ++] = &arg;
|
||
|
||
else {
|
||
forceAttrs(arg, pos);
|
||
|
||
if (!lambda.arg.empty())
|
||
env2.values[displ++] = &arg;
|
||
|
||
/* For each formal argument, get the actual argument. If
|
||
there is no matching actual argument but the formal
|
||
argument has a default, use the default. */
|
||
unsigned int attrsUsed = 0;
|
||
for (auto & i : lambda.formals->formals) {
|
||
Bindings::iterator j = arg.attrs->find(i.name);
|
||
if (j == arg.attrs->end()) {
|
||
if (!i.def) throwTypeError("%1% called without required argument ‘%2%’, at %3%",
|
||
lambda, i.name, pos);
|
||
env2.values[displ++] = i.def->maybeThunk(*this, env2);
|
||
} else {
|
||
attrsUsed++;
|
||
env2.values[displ++] = j->value;
|
||
}
|
||
}
|
||
|
||
/* Check that each actual argument is listed as a formal
|
||
argument (unless the attribute match specifies a `...'). */
|
||
if (!lambda.formals->ellipsis && attrsUsed != arg.attrs->size()) {
|
||
/* Nope, so show the first unexpected argument to the
|
||
user. */
|
||
for (auto & i : *arg.attrs)
|
||
if (lambda.formals->argNames.find(i.name) == lambda.formals->argNames.end())
|
||
throwTypeError("%1% called with unexpected argument ‘%2%’, at %3%", lambda, i.name, pos);
|
||
abort(); // can't happen
|
||
}
|
||
}
|
||
|
||
nrFunctionCalls++;
|
||
if (countCalls) incrFunctionCall(&lambda);
|
||
|
||
/* Evaluate the body. This is conditional on showTrace, because
|
||
catching exceptions makes this function not tail-recursive. */
|
||
if (settings.showTrace)
|
||
try {
|
||
lambda.body->eval(*this, env2, v);
|
||
} catch (Error & e) {
|
||
addErrorPrefix(e, "while evaluating %1%, called from %2%:\n", lambda, pos);
|
||
throw;
|
||
}
|
||
else
|
||
fun.lambda.fun->body->eval(*this, env2, v);
|
||
}
|
||
|
||
|
||
// Lifted out of callFunction() because it creates a temporary that
|
||
// prevents tail-call optimisation.
|
||
void EvalState::incrFunctionCall(ExprLambda * fun)
|
||
{
|
||
functionCalls[fun]++;
|
||
}
|
||
|
||
|
||
void EvalState::autoCallFunction(Bindings & args, Value & fun, Value & res)
|
||
{
|
||
forceValue(fun);
|
||
|
||
if (fun.type == tAttrs) {
|
||
auto found = fun.attrs->find(sFunctor);
|
||
if (found != fun.attrs->end()) {
|
||
forceValue(*found->value);
|
||
Value * v = allocValue();
|
||
callFunction(*found->value, fun, *v, noPos);
|
||
forceValue(*v);
|
||
return autoCallFunction(args, *v, res);
|
||
}
|
||
}
|
||
|
||
if (fun.type != tLambda || !fun.lambda.fun->matchAttrs) {
|
||
res = fun;
|
||
return;
|
||
}
|
||
|
||
Value * actualArgs = allocValue();
|
||
mkAttrs(*actualArgs, fun.lambda.fun->formals->formals.size());
|
||
|
||
for (auto & i : fun.lambda.fun->formals->formals) {
|
||
Bindings::iterator j = args.find(i.name);
|
||
if (j != args.end())
|
||
actualArgs->attrs->push_back(*j);
|
||
else if (!i.def)
|
||
throwTypeError("cannot auto-call a function that has an argument without a default value (‘%1%’)", i.name);
|
||
}
|
||
|
||
actualArgs->attrs->sort();
|
||
|
||
callFunction(fun, *actualArgs, res, noPos);
|
||
}
|
||
|
||
|
||
void ExprWith::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Env & env2(state.allocEnv(1));
|
||
env2.up = &env;
|
||
env2.prevWith = prevWith;
|
||
env2.haveWithAttrs = false;
|
||
env2.values[0] = (Value *) attrs;
|
||
|
||
body->eval(state, env2, v);
|
||
}
|
||
|
||
|
||
void ExprIf::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
(state.evalBool(env, cond) ? then : else_)->eval(state, env, v);
|
||
}
|
||
|
||
|
||
void ExprAssert::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
if (!state.evalBool(env, cond, pos))
|
||
throwAssertionError("assertion failed at %1%", pos);
|
||
body->eval(state, env, v);
|
||
}
|
||
|
||
|
||
void ExprOpNot::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
mkBool(v, !state.evalBool(env, e));
|
||
}
|
||
|
||
|
||
void ExprOpEq::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Value v1; e1->eval(state, env, v1);
|
||
Value v2; e2->eval(state, env, v2);
|
||
mkBool(v, state.eqValues(v1, v2));
|
||
}
|
||
|
||
|
||
void ExprOpNEq::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Value v1; e1->eval(state, env, v1);
|
||
Value v2; e2->eval(state, env, v2);
|
||
mkBool(v, !state.eqValues(v1, v2));
|
||
}
|
||
|
||
|
||
void ExprOpAnd::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
mkBool(v, state.evalBool(env, e1, pos) && state.evalBool(env, e2, pos));
|
||
}
|
||
|
||
|
||
void ExprOpOr::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
mkBool(v, state.evalBool(env, e1, pos) || state.evalBool(env, e2, pos));
|
||
}
|
||
|
||
|
||
void ExprOpImpl::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
mkBool(v, !state.evalBool(env, e1, pos) || state.evalBool(env, e2, pos));
|
||
}
|
||
|
||
|
||
void ExprOpUpdate::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Value v1, v2;
|
||
state.evalAttrs(env, e1, v1);
|
||
state.evalAttrs(env, e2, v2);
|
||
|
||
state.nrOpUpdates++;
|
||
|
||
if (v1.attrs->size() == 0) { v = v2; return; }
|
||
if (v2.attrs->size() == 0) { v = v1; return; }
|
||
|
||
state.mkAttrs(v, v1.attrs->size() + v2.attrs->size());
|
||
|
||
/* Merge the sets, preferring values from the second set. Make
|
||
sure to keep the resulting vector in sorted order. */
|
||
Bindings::iterator i = v1.attrs->begin();
|
||
Bindings::iterator j = v2.attrs->begin();
|
||
|
||
while (i != v1.attrs->end() && j != v2.attrs->end()) {
|
||
if (i->name == j->name) {
|
||
v.attrs->push_back(*j);
|
||
++i; ++j;
|
||
}
|
||
else if (i->name < j->name)
|
||
v.attrs->push_back(*i++);
|
||
else
|
||
v.attrs->push_back(*j++);
|
||
}
|
||
|
||
while (i != v1.attrs->end()) v.attrs->push_back(*i++);
|
||
while (j != v2.attrs->end()) v.attrs->push_back(*j++);
|
||
|
||
state.nrOpUpdateValuesCopied += v.attrs->size();
|
||
}
|
||
|
||
|
||
void ExprOpConcatLists::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
Value v1; e1->eval(state, env, v1);
|
||
Value v2; e2->eval(state, env, v2);
|
||
Value * lists[2] = { &v1, &v2 };
|
||
state.concatLists(v, 2, lists, pos);
|
||
}
|
||
|
||
|
||
void EvalState::concatLists(Value & v, unsigned int nrLists, Value * * lists, const Pos & pos)
|
||
{
|
||
nrListConcats++;
|
||
|
||
Value * nonEmpty = 0;
|
||
unsigned int len = 0;
|
||
for (unsigned int n = 0; n < nrLists; ++n) {
|
||
forceList(*lists[n], pos);
|
||
unsigned int l = lists[n]->listSize();
|
||
len += l;
|
||
if (l) nonEmpty = lists[n];
|
||
}
|
||
|
||
if (nonEmpty && len == nonEmpty->listSize()) {
|
||
v = *nonEmpty;
|
||
return;
|
||
}
|
||
|
||
mkList(v, len);
|
||
auto out = v.listElems();
|
||
for (unsigned int n = 0, pos = 0; n < nrLists; ++n) {
|
||
unsigned int l = lists[n]->listSize();
|
||
memcpy(out + pos, lists[n]->listElems(), l * sizeof(Value *));
|
||
pos += l;
|
||
}
|
||
}
|
||
|
||
|
||
void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
PathSet context;
|
||
std::ostringstream s;
|
||
NixInt n = 0;
|
||
NixFloat nf = 0;
|
||
|
||
bool first = !forceString;
|
||
ValueType firstType = tString;
|
||
|
||
for (auto & i : *es) {
|
||
Value vTmp;
|
||
i->eval(state, env, vTmp);
|
||
|
||
/* If the first element is a path, then the result will also
|
||
be a path, we don't copy anything (yet - that's done later,
|
||
since paths are copied when they are used in a derivation),
|
||
and none of the strings are allowed to have contexts. */
|
||
if (first) {
|
||
firstType = vTmp.type;
|
||
first = false;
|
||
}
|
||
|
||
if (firstType == tInt) {
|
||
if (vTmp.type == tInt) {
|
||
n += vTmp.integer;
|
||
} else if (vTmp.type == tFloat) {
|
||
// Upgrade the type from int to float;
|
||
firstType = tFloat;
|
||
nf = n;
|
||
nf += vTmp.fpoint;
|
||
} else
|
||
throwEvalError("cannot add %1% to an integer, at %2%", showType(vTmp), pos);
|
||
} else if (firstType == tFloat) {
|
||
if (vTmp.type == tInt) {
|
||
nf += vTmp.integer;
|
||
} else if (vTmp.type == tFloat) {
|
||
nf += vTmp.fpoint;
|
||
} else
|
||
throwEvalError("cannot add %1% to a float, at %2%", showType(vTmp), pos);
|
||
} else
|
||
s << state.coerceToString(pos, vTmp, context, false, firstType == tString);
|
||
}
|
||
|
||
if (firstType == tInt)
|
||
mkInt(v, n);
|
||
else if (firstType == tFloat)
|
||
mkFloat(v, nf);
|
||
else if (firstType == tPath) {
|
||
if (!context.empty())
|
||
throwEvalError("a string that refers to a store path cannot be appended to a path, at %1%", pos);
|
||
auto path = canonPath(s.str());
|
||
mkPath(v, path.c_str());
|
||
} else
|
||
mkString(v, s.str(), context);
|
||
}
|
||
|
||
|
||
void ExprPos::eval(EvalState & state, Env & env, Value & v)
|
||
{
|
||
state.mkPos(v, &pos);
|
||
}
|
||
|
||
|
||
void EvalState::forceValueDeep(Value & v)
|
||
{
|
||
std::set<const Value *> seen;
|
||
|
||
std::function<void(Value & v)> recurse;
|
||
|
||
recurse = [&](Value & v) {
|
||
if (seen.find(&v) != seen.end()) return;
|
||
seen.insert(&v);
|
||
|
||
forceValue(v);
|
||
|
||
if (v.type == tAttrs) {
|
||
for (auto & i : *v.attrs)
|
||
try {
|
||
recurse(*i.value);
|
||
} catch (Error & e) {
|
||
addErrorPrefix(e, "while evaluating the attribute ‘%1%’ at %2%:\n", i.name, *i.pos);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
else if (v.isList()) {
|
||
for (unsigned int n = 0; n < v.listSize(); ++n)
|
||
recurse(*v.listElems()[n]);
|
||
}
|
||
};
|
||
|
||
recurse(v);
|
||
}
|
||
|
||
|
||
NixInt EvalState::forceInt(Value & v, const Pos & pos)
|
||
{
|
||
forceValue(v, pos);
|
||
if (v.type != tInt)
|
||
throwTypeError("value is %1% while an integer was expected, at %2%", v, pos);
|
||
return v.integer;
|
||
}
|
||
|
||
|
||
NixFloat EvalState::forceFloat(Value & v, const Pos & pos)
|
||
{
|
||
forceValue(v, pos);
|
||
if (v.type == tInt)
|
||
return v.integer;
|
||
else if (v.type != tFloat)
|
||
throwTypeError("value is %1% while a float was expected, at %2%", v, pos);
|
||
return v.fpoint;
|
||
}
|
||
|
||
|
||
bool EvalState::forceBool(Value & v)
|
||
{
|
||
forceValue(v);
|
||
if (v.type != tBool)
|
||
throwTypeError("value is %1% while a Boolean was expected", v);
|
||
return v.boolean;
|
||
}
|
||
|
||
|
||
bool EvalState::isFunctor(Value & fun)
|
||
{
|
||
return fun.type == tAttrs && fun.attrs->find(sFunctor) != fun.attrs->end();
|
||
}
|
||
|
||
|
||
void EvalState::forceFunction(Value & v, const Pos & pos)
|
||
{
|
||
forceValue(v);
|
||
if (v.type != tLambda && v.type != tPrimOp && v.type != tPrimOpApp && !isFunctor(v))
|
||
throwTypeError("value is %1% while a function was expected, at %2%", v, pos);
|
||
}
|
||
|
||
|
||
string EvalState::forceString(Value & v, const Pos & pos)
|
||
{
|
||
forceValue(v, pos);
|
||
if (v.type != tString) {
|
||
if (pos)
|
||
throwTypeError("value is %1% while a string was expected, at %2%", v, pos);
|
||
else
|
||
throwTypeError("value is %1% while a string was expected", v);
|
||
}
|
||
return string(v.string.s);
|
||
}
|
||
|
||
|
||
void copyContext(const Value & v, PathSet & context)
|
||
{
|
||
if (v.string.context)
|
||
for (const char * * p = v.string.context; *p; ++p)
|
||
context.insert(*p);
|
||
}
|
||
|
||
|
||
string EvalState::forceString(Value & v, PathSet & context, const Pos & pos)
|
||
{
|
||
string s = forceString(v, pos);
|
||
copyContext(v, context);
|
||
return s;
|
||
}
|
||
|
||
|
||
string EvalState::forceStringNoCtx(Value & v, const Pos & pos)
|
||
{
|
||
string s = forceString(v, pos);
|
||
if (v.string.context) {
|
||
if (pos)
|
||
throwEvalError("the string ‘%1%’ is not allowed to refer to a store path (such as ‘%2%’), at %3%",
|
||
v.string.s, v.string.context[0], pos);
|
||
else
|
||
throwEvalError("the string ‘%1%’ is not allowed to refer to a store path (such as ‘%2%’)",
|
||
v.string.s, v.string.context[0]);
|
||
}
|
||
return s;
|
||
}
|
||
|
||
|
||
bool EvalState::isDerivation(Value & v)
|
||
{
|
||
if (v.type != tAttrs) return false;
|
||
Bindings::iterator i = v.attrs->find(sType);
|
||
if (i == v.attrs->end()) return false;
|
||
forceValue(*i->value);
|
||
if (i->value->type != tString) return false;
|
||
return strcmp(i->value->string.s, "derivation") == 0;
|
||
}
|
||
|
||
|
||
string EvalState::coerceToString(const Pos & pos, Value & v, PathSet & context,
|
||
bool coerceMore, bool copyToStore)
|
||
{
|
||
forceValue(v);
|
||
|
||
string s;
|
||
|
||
if (v.type == tString) {
|
||
copyContext(v, context);
|
||
return v.string.s;
|
||
}
|
||
|
||
if (v.type == tPath) {
|
||
Path path(canonPath(v.path));
|
||
return copyToStore ? copyPathToStore(context, path) : path;
|
||
}
|
||
|
||
if (v.type == tAttrs) {
|
||
auto i = v.attrs->find(sToString);
|
||
if (i != v.attrs->end()) {
|
||
forceValue(*i->value, pos);
|
||
Value v1;
|
||
callFunction(*i->value, v, v1, pos);
|
||
return coerceToString(pos, v1, context, coerceMore, copyToStore);
|
||
}
|
||
i = v.attrs->find(sOutPath);
|
||
if (i == v.attrs->end()) throwTypeError("cannot coerce a set to a string, at %1%", pos);
|
||
return coerceToString(pos, *i->value, context, coerceMore, copyToStore);
|
||
}
|
||
|
||
if (v.type == tExternal)
|
||
return v.external->coerceToString(pos, context, coerceMore, copyToStore);
|
||
|
||
if (coerceMore) {
|
||
|
||
/* Note that `false' is represented as an empty string for
|
||
shell scripting convenience, just like `null'. */
|
||
if (v.type == tBool && v.boolean) return "1";
|
||
if (v.type == tBool && !v.boolean) return "";
|
||
if (v.type == tInt) return std::to_string(v.integer);
|
||
if (v.type == tFloat) return std::to_string(v.fpoint);
|
||
if (v.type == tNull) return "";
|
||
|
||
if (v.isList()) {
|
||
string result;
|
||
for (unsigned int n = 0; n < v.listSize(); ++n) {
|
||
result += coerceToString(pos, *v.listElems()[n],
|
||
context, coerceMore, copyToStore);
|
||
if (n < v.listSize() - 1
|
||
/* !!! not quite correct */
|
||
&& (!v.listElems()[n]->isList() || v.listElems()[n]->listSize() != 0))
|
||
result += " ";
|
||
}
|
||
return result;
|
||
}
|
||
}
|
||
|
||
throwTypeError("cannot coerce %1% to a string, at %2%", v, pos);
|
||
}
|
||
|
||
|
||
string EvalState::copyPathToStore(PathSet & context, const Path & path)
|
||
{
|
||
if (nix::isDerivation(path))
|
||
throwEvalError("file names are not allowed to end in ‘%1%’", drvExtension);
|
||
|
||
Path dstPath;
|
||
if (srcToStore[path] != "")
|
||
dstPath = srcToStore[path];
|
||
else {
|
||
dstPath = settings.readOnlyMode
|
||
? computeStorePathForPath(checkSourcePath(path)).first
|
||
: store->addToStore(baseNameOf(path), checkSourcePath(path), true, htSHA256, defaultPathFilter, repair);
|
||
srcToStore[path] = dstPath;
|
||
printMsg(lvlChatty, format("copied source ‘%1%’ -> ‘%2%’")
|
||
% path % dstPath);
|
||
}
|
||
|
||
context.insert(dstPath);
|
||
return dstPath;
|
||
}
|
||
|
||
|
||
Path EvalState::coerceToPath(const Pos & pos, Value & v, PathSet & context)
|
||
{
|
||
string path = coerceToString(pos, v, context, false, false);
|
||
if (path == "" || path[0] != '/')
|
||
throwEvalError("string ‘%1%’ doesn't represent an absolute path, at %2%", path, pos);
|
||
return path;
|
||
}
|
||
|
||
|
||
bool EvalState::eqValues(Value & v1, Value & v2)
|
||
{
|
||
forceValue(v1);
|
||
forceValue(v2);
|
||
|
||
/* !!! Hack to support some old broken code that relies on pointer
|
||
equality tests between sets. (Specifically, builderDefs calls
|
||
uniqList on a list of sets.) Will remove this eventually. */
|
||
if (&v1 == &v2) return true;
|
||
|
||
// Special case type-compatibility between float and int
|
||
if (v1.type == tInt && v2.type == tFloat)
|
||
return v1.integer == v2.fpoint;
|
||
if (v1.type == tFloat && v2.type == tInt)
|
||
return v1.fpoint == v2.integer;
|
||
|
||
// All other types are not compatible with each other.
|
||
if (v1.type != v2.type) return false;
|
||
|
||
switch (v1.type) {
|
||
|
||
case tInt:
|
||
return v1.integer == v2.integer;
|
||
|
||
case tBool:
|
||
return v1.boolean == v2.boolean;
|
||
|
||
case tString:
|
||
return strcmp(v1.string.s, v2.string.s) == 0;
|
||
|
||
case tPath:
|
||
return strcmp(v1.path, v2.path) == 0;
|
||
|
||
case tNull:
|
||
return true;
|
||
|
||
case tList1:
|
||
case tList2:
|
||
case tListN:
|
||
if (v1.listSize() != v2.listSize()) return false;
|
||
for (unsigned int n = 0; n < v1.listSize(); ++n)
|
||
if (!eqValues(*v1.listElems()[n], *v2.listElems()[n])) return false;
|
||
return true;
|
||
|
||
case tAttrs: {
|
||
/* If both sets denote a derivation (type = "derivation"),
|
||
then compare their outPaths. */
|
||
if (isDerivation(v1) && isDerivation(v2)) {
|
||
Bindings::iterator i = v1.attrs->find(sOutPath);
|
||
Bindings::iterator j = v2.attrs->find(sOutPath);
|
||
if (i != v1.attrs->end() && j != v2.attrs->end())
|
||
return eqValues(*i->value, *j->value);
|
||
}
|
||
|
||
if (v1.attrs->size() != v2.attrs->size()) return false;
|
||
|
||
/* Otherwise, compare the attributes one by one. */
|
||
Bindings::iterator i, j;
|
||
for (i = v1.attrs->begin(), j = v2.attrs->begin(); i != v1.attrs->end(); ++i, ++j)
|
||
if (i->name != j->name || !eqValues(*i->value, *j->value))
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
/* Functions are incomparable. */
|
||
case tLambda:
|
||
case tPrimOp:
|
||
case tPrimOpApp:
|
||
return false;
|
||
|
||
case tExternal:
|
||
return *v1.external == *v2.external;
|
||
|
||
case tFloat:
|
||
return v1.fpoint == v2.fpoint;
|
||
|
||
default:
|
||
throwEvalError("cannot compare %1% with %2%", showType(v1), showType(v2));
|
||
}
|
||
}
|
||
|
||
|
||
void EvalState::printStats()
|
||
{
|
||
bool showStats = getEnv("NIX_SHOW_STATS", "0") != "0";
|
||
Verbosity v = showStats ? lvlInfo : lvlDebug;
|
||
printMsg(v, "evaluation statistics:");
|
||
|
||
struct rusage buf;
|
||
getrusage(RUSAGE_SELF, &buf);
|
||
float cpuTime = buf.ru_utime.tv_sec + ((float) buf.ru_utime.tv_usec / 1000000);
|
||
|
||
uint64_t bEnvs = nrEnvs * sizeof(Env) + nrValuesInEnvs * sizeof(Value *);
|
||
uint64_t bLists = nrListElems * sizeof(Value *);
|
||
uint64_t bValues = nrValues * sizeof(Value);
|
||
uint64_t bAttrsets = nrAttrsets * sizeof(Bindings) + nrAttrsInAttrsets * sizeof(Attr);
|
||
|
||
printMsg(v, format(" time elapsed: %1%") % cpuTime);
|
||
printMsg(v, format(" size of a value: %1%") % sizeof(Value));
|
||
printMsg(v, format(" size of an attr: %1%") % sizeof(Attr));
|
||
printMsg(v, format(" environments allocated: %1% (%2% bytes)") % nrEnvs % bEnvs);
|
||
printMsg(v, format(" list elements: %1% (%2% bytes)") % nrListElems % bLists);
|
||
printMsg(v, format(" list concatenations: %1%") % nrListConcats);
|
||
printMsg(v, format(" values allocated: %1% (%2% bytes)") % nrValues % bValues);
|
||
printMsg(v, format(" sets allocated: %1% (%2% bytes)") % nrAttrsets % bAttrsets);
|
||
printMsg(v, format(" right-biased unions: %1%") % nrOpUpdates);
|
||
printMsg(v, format(" values copied in right-biased unions: %1%") % nrOpUpdateValuesCopied);
|
||
printMsg(v, format(" symbols in symbol table: %1%") % symbols.size());
|
||
printMsg(v, format(" size of symbol table: %1%") % symbols.totalSize());
|
||
printMsg(v, format(" number of thunks: %1%") % nrThunks);
|
||
printMsg(v, format(" number of thunks avoided: %1%") % nrAvoided);
|
||
printMsg(v, format(" number of attr lookups: %1%") % nrLookups);
|
||
printMsg(v, format(" number of primop calls: %1%") % nrPrimOpCalls);
|
||
printMsg(v, format(" number of function calls: %1%") % nrFunctionCalls);
|
||
printMsg(v, format(" total allocations: %1% bytes") % (bEnvs + bLists + bValues + bAttrsets));
|
||
|
||
#if HAVE_BOEHMGC
|
||
GC_word heapSize, totalBytes;
|
||
GC_get_heap_usage_safe(&heapSize, 0, 0, 0, &totalBytes);
|
||
printMsg(v, format(" current Boehm heap size: %1% bytes") % heapSize);
|
||
printMsg(v, format(" total Boehm heap allocations: %1% bytes") % totalBytes);
|
||
#endif
|
||
|
||
if (countCalls) {
|
||
v = lvlInfo;
|
||
|
||
printMsg(v, format("calls to %1% primops:") % primOpCalls.size());
|
||
typedef std::multimap<unsigned int, Symbol> PrimOpCalls_;
|
||
PrimOpCalls_ primOpCalls_;
|
||
for (auto & i : primOpCalls)
|
||
primOpCalls_.insert(std::pair<unsigned int, Symbol>(i.second, i.first));
|
||
for (auto i = primOpCalls_.rbegin(); i != primOpCalls_.rend(); ++i)
|
||
printMsg(v, format("%1$10d %2%") % i->first % i->second);
|
||
|
||
printMsg(v, format("calls to %1% functions:") % functionCalls.size());
|
||
typedef std::multimap<unsigned int, ExprLambda *> FunctionCalls_;
|
||
FunctionCalls_ functionCalls_;
|
||
for (auto & i : functionCalls)
|
||
functionCalls_.insert(std::pair<unsigned int, ExprLambda *>(i.second, i.first));
|
||
for (auto i = functionCalls_.rbegin(); i != functionCalls_.rend(); ++i)
|
||
printMsg(v, format("%1$10d %2%") % i->first % i->second->showNamePos());
|
||
|
||
printMsg(v, format("evaluations of %1% attributes:") % attrSelects.size());
|
||
typedef std::multimap<unsigned int, Pos> AttrSelects_;
|
||
AttrSelects_ attrSelects_;
|
||
for (auto & i : attrSelects)
|
||
attrSelects_.insert(std::pair<unsigned int, Pos>(i.second, i.first));
|
||
for (auto i = attrSelects_.rbegin(); i != attrSelects_.rend(); ++i)
|
||
printMsg(v, format("%1$10d %2%") % i->first % i->second);
|
||
|
||
}
|
||
}
|
||
|
||
|
||
size_t valueSize(Value & v)
|
||
{
|
||
std::set<const void *> seen;
|
||
|
||
auto doString = [&](const char * s) -> size_t {
|
||
if (seen.find(s) != seen.end()) return 0;
|
||
seen.insert(s);
|
||
return strlen(s) + 1;
|
||
};
|
||
|
||
std::function<size_t(Value & v)> doValue;
|
||
std::function<size_t(Env & v)> doEnv;
|
||
|
||
doValue = [&](Value & v) -> size_t {
|
||
if (seen.find(&v) != seen.end()) return 0;
|
||
seen.insert(&v);
|
||
|
||
size_t sz = sizeof(Value);
|
||
|
||
switch (v.type) {
|
||
case tString:
|
||
sz += doString(v.string.s);
|
||
if (v.string.context)
|
||
for (const char * * p = v.string.context; *p; ++p)
|
||
sz += doString(*p);
|
||
break;
|
||
case tPath:
|
||
sz += doString(v.path);
|
||
break;
|
||
case tAttrs:
|
||
if (seen.find(v.attrs) == seen.end()) {
|
||
seen.insert(v.attrs);
|
||
sz += sizeof(Bindings) + sizeof(Attr) * v.attrs->capacity();
|
||
for (auto & i : *v.attrs)
|
||
sz += doValue(*i.value);
|
||
}
|
||
break;
|
||
case tList1:
|
||
case tList2:
|
||
case tListN:
|
||
if (seen.find(v.listElems()) == seen.end()) {
|
||
seen.insert(v.listElems());
|
||
sz += v.listSize() * sizeof(Value *);
|
||
for (unsigned int n = 0; n < v.listSize(); ++n)
|
||
sz += doValue(*v.listElems()[n]);
|
||
}
|
||
break;
|
||
case tThunk:
|
||
sz += doEnv(*v.thunk.env);
|
||
break;
|
||
case tApp:
|
||
sz += doValue(*v.app.left);
|
||
sz += doValue(*v.app.right);
|
||
break;
|
||
case tLambda:
|
||
sz += doEnv(*v.lambda.env);
|
||
break;
|
||
case tPrimOpApp:
|
||
sz += doValue(*v.primOpApp.left);
|
||
sz += doValue(*v.primOpApp.right);
|
||
break;
|
||
case tExternal:
|
||
if (seen.find(v.external) != seen.end()) break;
|
||
seen.insert(v.external);
|
||
sz += v.external->valueSize(seen);
|
||
break;
|
||
default:
|
||
;
|
||
}
|
||
|
||
return sz;
|
||
};
|
||
|
||
doEnv = [&](Env & env) -> size_t {
|
||
if (seen.find(&env) != seen.end()) return 0;
|
||
seen.insert(&env);
|
||
|
||
size_t sz = sizeof(Env) + sizeof(Value *) * env.size;
|
||
|
||
for (unsigned int i = 0; i < env.size; ++i)
|
||
if (env.values[i])
|
||
sz += doValue(*env.values[i]);
|
||
|
||
if (env.up) sz += doEnv(*env.up);
|
||
|
||
return sz;
|
||
};
|
||
|
||
return doValue(v);
|
||
}
|
||
|
||
|
||
string ExternalValueBase::coerceToString(const Pos & pos, PathSet & context, bool copyMore, bool copyToStore) const
|
||
{
|
||
throw TypeError(format("cannot coerce %1% to a string, at %2%") %
|
||
showType() % pos);
|
||
}
|
||
|
||
|
||
bool ExternalValueBase::operator==(const ExternalValueBase & b) const
|
||
{
|
||
return false;
|
||
}
|
||
|
||
|
||
std::ostream & operator << (std::ostream & str, const ExternalValueBase & v) {
|
||
return v.print(str);
|
||
}
|
||
|
||
|
||
}
|