2003-10-30 16:48:26 +00:00
|
|
|
|
#include "eval.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
#include "hash.hh"
|
2022-01-21 15:20:54 +00:00
|
|
|
|
#include "types.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
#include "util.hh"
|
2006-11-30 17:43:04 +00:00
|
|
|
|
#include "store-api.hh"
|
2006-10-16 15:55:34 +00:00
|
|
|
|
#include "derivations.hh"
|
2006-12-01 20:51:18 +00:00
|
|
|
|
#include "globals.hh"
|
2012-02-04 13:50:25 +00:00
|
|
|
|
#include "eval-inline.hh"
|
2020-04-06 21:57:28 +00:00
|
|
|
|
#include "filetransfer.hh"
|
2018-09-01 22:50:22 +00:00
|
|
|
|
#include "json.hh"
|
2019-11-13 16:38:37 +00:00
|
|
|
|
#include "function-trace.hh"
|
2004-02-04 16:03:29 +00:00
|
|
|
|
|
2014-03-29 23:49:23 +00:00
|
|
|
|
#include <algorithm>
|
2019-04-12 16:31:33 +00:00
|
|
|
|
#include <chrono>
|
2010-03-29 14:37:56 +00:00
|
|
|
|
#include <cstring>
|
2011-02-10 14:31:04 +00:00
|
|
|
|
#include <unistd.h>
|
2012-02-04 13:27:11 +00:00
|
|
|
|
#include <sys/time.h>
|
|
|
|
|
#include <sys/resource.h>
|
2018-09-01 22:50:22 +00:00
|
|
|
|
#include <iostream>
|
|
|
|
|
#include <fstream>
|
2021-12-22 22:38:49 +00:00
|
|
|
|
#include <functional>
|
2010-03-29 14:37:56 +00:00
|
|
|
|
|
2018-06-11 14:10:50 +00:00
|
|
|
|
#include <sys/resource.h>
|
|
|
|
|
|
2010-10-22 13:39:15 +00:00
|
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
|
|
2020-04-16 14:28:07 +00:00
|
|
|
|
#define GC_INCLUDE_NEW
|
|
|
|
|
|
2010-10-20 11:38:30 +00:00
|
|
|
|
#include <gc/gc.h>
|
|
|
|
|
#include <gc/gc_cpp.h>
|
|
|
|
|
|
2020-10-30 19:55:53 +00:00
|
|
|
|
#include <boost/coroutine2/coroutine.hpp>
|
|
|
|
|
#include <boost/coroutine2/protected_fixedsize_stack.hpp>
|
|
|
|
|
#include <boost/context/stack_context.hpp>
|
|
|
|
|
|
2010-10-22 13:39:15 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
namespace nix {
|
2010-10-24 00:41:29 +00:00
|
|
|
|
|
2021-12-27 01:04:49 +00:00
|
|
|
|
static char * allocString(size_t size)
|
|
|
|
|
{
|
|
|
|
|
char * t;
|
|
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
|
t = (char *) GC_MALLOC_ATOMIC(size);
|
|
|
|
|
#else
|
|
|
|
|
t = malloc(size);
|
|
|
|
|
#endif
|
|
|
|
|
if (!t) throw std::bad_alloc();
|
|
|
|
|
return t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-03-19 13:11:35 +00:00
|
|
|
|
static char * dupString(const char * s)
|
|
|
|
|
{
|
|
|
|
|
char * t;
|
|
|
|
|
#if HAVE_BOEHMGC
|
2018-06-12 14:16:03 +00:00
|
|
|
|
t = GC_STRDUP(s);
|
2015-03-19 13:11:35 +00:00
|
|
|
|
#else
|
|
|
|
|
t = strdup(s);
|
|
|
|
|
#endif
|
|
|
|
|
if (!t) throw std::bad_alloc();
|
|
|
|
|
return t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-27 11:50:18 +00:00
|
|
|
|
// When there's no need to write to the string, we can optimize away empty
|
|
|
|
|
// string allocations.
|
|
|
|
|
// This function handles makeImmutableStringWithLen(null, 0) by returning the
|
|
|
|
|
// empty string.
|
|
|
|
|
static const char * makeImmutableStringWithLen(const char * s, size_t size)
|
2019-12-05 18:11:09 +00:00
|
|
|
|
{
|
|
|
|
|
char * t;
|
2022-02-27 11:50:18 +00:00
|
|
|
|
if (size == 0)
|
|
|
|
|
return "";
|
2019-12-05 18:11:09 +00:00
|
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
|
t = GC_STRNDUP(s, size);
|
|
|
|
|
#else
|
|
|
|
|
t = strndup(s, size);
|
|
|
|
|
#endif
|
|
|
|
|
if (!t) throw std::bad_alloc();
|
|
|
|
|
return t;
|
|
|
|
|
}
|
|
|
|
|
|
2022-02-27 11:50:18 +00:00
|
|
|
|
static inline const char * makeImmutableString(std::string_view s) {
|
|
|
|
|
return makeImmutableStringWithLen(s.data(), s.size());
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
|
2020-04-16 14:28:07 +00:00
|
|
|
|
RootValue allocRootValue(Value * v)
|
|
|
|
|
{
|
2021-06-25 22:57:37 +00:00
|
|
|
|
#if HAVE_BOEHMGC
|
2020-04-16 14:28:07 +00:00
|
|
|
|
return std::allocate_shared<Value *>(traceable_allocator<Value *>(), v);
|
2021-06-25 22:57:37 +00:00
|
|
|
|
#else
|
|
|
|
|
return std::make_shared<Value *>(v);
|
|
|
|
|
#endif
|
2020-04-16 14:28:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
|
void Value::print(const SymbolTable & symbols, std::ostream & str,
|
|
|
|
|
std::set<const void *> * seen) const
|
2003-10-30 16:48:26 +00:00
|
|
|
|
{
|
2015-07-17 09:33:39 +00:00
|
|
|
|
checkInterrupt();
|
|
|
|
|
|
2022-03-22 12:18:11 +00:00
|
|
|
|
switch (internalType) {
|
2010-03-29 14:37:56 +00:00
|
|
|
|
case tInt:
|
2022-03-22 12:18:11 +00:00
|
|
|
|
str << integer;
|
2010-03-29 14:37:56 +00:00
|
|
|
|
break;
|
|
|
|
|
case tBool:
|
2022-03-22 12:18:11 +00:00
|
|
|
|
str << (boolean ? "true" : "false");
|
2010-03-29 14:37:56 +00:00
|
|
|
|
break;
|
|
|
|
|
case tString:
|
2010-04-08 11:41:19 +00:00
|
|
|
|
str << "\"";
|
2022-03-22 12:18:11 +00:00
|
|
|
|
for (const char * i = string.s; *i; i++)
|
2010-04-08 11:41:19 +00:00
|
|
|
|
if (*i == '\"' || *i == '\\') str << "\\" << *i;
|
|
|
|
|
else if (*i == '\n') str << "\\n";
|
|
|
|
|
else if (*i == '\r') str << "\\r";
|
|
|
|
|
else if (*i == '\t') str << "\\t";
|
2020-09-14 15:19:25 +00:00
|
|
|
|
else if (*i == '$' && *(i+1) == '{') str << "\\" << *i;
|
2010-04-08 11:41:19 +00:00
|
|
|
|
else str << *i;
|
|
|
|
|
str << "\"";
|
2010-03-29 14:37:56 +00:00
|
|
|
|
break;
|
2010-03-30 09:22:33 +00:00
|
|
|
|
case tPath:
|
2022-03-22 12:18:11 +00:00
|
|
|
|
str << path; // !!! escaping?
|
2010-03-30 09:22:33 +00:00
|
|
|
|
break;
|
2010-03-29 14:37:56 +00:00
|
|
|
|
case tNull:
|
2010-08-27 12:10:56 +00:00
|
|
|
|
str << "null";
|
2010-03-29 14:37:56 +00:00
|
|
|
|
break;
|
2010-05-12 12:15:49 +00:00
|
|
|
|
case tAttrs: {
|
2022-03-22 12:18:11 +00:00
|
|
|
|
if (seen && !attrs->empty() && !seen->insert(attrs).second)
|
2022-03-22 12:00:27 +00:00
|
|
|
|
str << "«repeated»";
|
2022-03-03 12:29:14 +00:00
|
|
|
|
else {
|
|
|
|
|
str << "{ ";
|
2022-03-05 13:40:24 +00:00
|
|
|
|
for (auto & i : attrs->lexicographicOrder(symbols)) {
|
|
|
|
|
str << symbols[i->name] << " = ";
|
|
|
|
|
i->value->print(symbols, str, seen);
|
2022-03-03 12:29:14 +00:00
|
|
|
|
str << "; ";
|
|
|
|
|
}
|
|
|
|
|
str << "}";
|
2014-09-22 12:59:37 +00:00
|
|
|
|
}
|
2010-03-29 14:37:56 +00:00
|
|
|
|
break;
|
2010-05-12 12:15:49 +00:00
|
|
|
|
}
|
2015-07-23 20:05:09 +00:00
|
|
|
|
case tList1:
|
|
|
|
|
case tList2:
|
|
|
|
|
case tListN:
|
2022-03-22 12:18:11 +00:00
|
|
|
|
if (seen && listSize() && !seen->insert(listElems()).second)
|
2022-03-22 12:00:27 +00:00
|
|
|
|
str << "«repeated»";
|
2022-03-03 12:29:14 +00:00
|
|
|
|
else {
|
|
|
|
|
str << "[ ";
|
2022-03-22 12:18:11 +00:00
|
|
|
|
for (auto v2 : listItems()) {
|
2022-05-06 16:05:27 +00:00
|
|
|
|
if (v2)
|
|
|
|
|
v2->print(symbols, str, seen);
|
|
|
|
|
else
|
|
|
|
|
str << "(nullptr)";
|
2022-03-03 12:29:14 +00:00
|
|
|
|
str << " ";
|
|
|
|
|
}
|
|
|
|
|
str << "]";
|
2014-09-22 12:59:37 +00:00
|
|
|
|
}
|
2010-03-29 14:37:56 +00:00
|
|
|
|
break;
|
|
|
|
|
case tThunk:
|
2010-06-02 09:43:04 +00:00
|
|
|
|
case tApp:
|
2010-03-29 14:37:56 +00:00
|
|
|
|
str << "<CODE>";
|
|
|
|
|
break;
|
|
|
|
|
case tLambda:
|
|
|
|
|
str << "<LAMBDA>";
|
|
|
|
|
break;
|
|
|
|
|
case tPrimOp:
|
|
|
|
|
str << "<PRIMOP>";
|
|
|
|
|
break;
|
|
|
|
|
case tPrimOpApp:
|
|
|
|
|
str << "<PRIMOP-APP>";
|
|
|
|
|
break;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
case tExternal:
|
2022-03-22 12:18:11 +00:00
|
|
|
|
str << *external;
|
2014-11-30 18:16:19 +00:00
|
|
|
|
break;
|
2016-01-04 23:40:40 +00:00
|
|
|
|
case tFloat:
|
2022-03-22 12:18:11 +00:00
|
|
|
|
str << fpoint;
|
2016-01-05 08:46:37 +00:00
|
|
|
|
break;
|
2010-03-29 14:37:56 +00:00
|
|
|
|
default:
|
2022-01-04 19:29:17 +00:00
|
|
|
|
abort();
|
2010-03-29 14:37:56 +00:00
|
|
|
|
}
|
2014-09-22 12:59:37 +00:00
|
|
|
|
}
|
2014-10-01 13:54:40 +00:00
|
|
|
|
|
2014-09-22 12:59:37 +00:00
|
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
|
void Value::print(const SymbolTable & symbols, std::ostream & str, bool showRepeated) const
|
2014-09-22 12:59:37 +00:00
|
|
|
|
{
|
2022-03-03 12:29:14 +00:00
|
|
|
|
std::set<const void *> seen;
|
2022-03-05 13:40:24 +00:00
|
|
|
|
print(symbols, str, showRepeated ? nullptr : &seen);
|
2014-09-22 12:59:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-06 16:05:27 +00:00
|
|
|
|
// Pretty print types for assertion errors
|
|
|
|
|
std::ostream & operator << (std::ostream & os, const ValueType t) {
|
|
|
|
|
os << showType(t);
|
|
|
|
|
return os;
|
|
|
|
|
}
|
2014-09-22 12:59:37 +00:00
|
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
|
std::string printValue(const EvalState & state, const Value & v)
|
2014-09-22 12:59:37 +00:00
|
|
|
|
{
|
2022-03-05 13:40:24 +00:00
|
|
|
|
std::ostringstream out;
|
|
|
|
|
v.print(state.symbols, out);
|
|
|
|
|
return out.str();
|
2010-03-29 14:37:56 +00:00
|
|
|
|
}
|
2004-02-04 16:03:29 +00:00
|
|
|
|
|
2004-10-26 22:54:26 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
const Value * getPrimOp(const Value &v) {
|
2019-03-21 13:32:20 +00:00
|
|
|
|
const Value * primOp = &v;
|
2020-12-12 01:15:11 +00:00
|
|
|
|
while (primOp->isPrimOpApp()) {
|
2019-03-21 13:32:20 +00:00
|
|
|
|
primOp = primOp->primOpApp.left;
|
|
|
|
|
}
|
2020-12-12 01:15:11 +00:00
|
|
|
|
assert(primOp->isPrimOp());
|
2019-03-21 13:32:20 +00:00
|
|
|
|
return primOp;
|
|
|
|
|
}
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string_view showType(ValueType type)
|
2010-03-29 14:37:56 +00:00
|
|
|
|
{
|
2019-09-09 14:34:44 +00:00
|
|
|
|
switch (type) {
|
2020-12-11 22:32:45 +00:00
|
|
|
|
case nInt: return "an integer";
|
|
|
|
|
case nBool: return "a Boolean";
|
|
|
|
|
case nString: return "a string";
|
|
|
|
|
case nPath: return "a path";
|
|
|
|
|
case nNull: return "null";
|
|
|
|
|
case nAttrs: return "a set";
|
|
|
|
|
case nList: return "a list";
|
|
|
|
|
case nFunction: return "a function";
|
|
|
|
|
case nExternal: return "an external value";
|
|
|
|
|
case nFloat: return "a float";
|
|
|
|
|
case nThunk: return "a thunk";
|
2019-09-09 14:34:44 +00:00
|
|
|
|
}
|
|
|
|
|
abort();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string showType(const Value & v)
|
2019-09-09 14:34:44 +00:00
|
|
|
|
{
|
2020-12-17 13:42:52 +00:00
|
|
|
|
switch (v.internalType) {
|
2019-09-09 14:34:44 +00:00
|
|
|
|
case tString: return v.string.context ? "a string with context" : "a string";
|
2019-03-21 13:32:20 +00:00
|
|
|
|
case tPrimOp:
|
2022-02-25 15:00:00 +00:00
|
|
|
|
return fmt("the built-in function '%s'", std::string(v.primOp->name));
|
2019-03-21 13:32:20 +00:00
|
|
|
|
case tPrimOpApp:
|
2022-02-25 15:00:00 +00:00
|
|
|
|
return fmt("the partially applied built-in function '%s'", std::string(getPrimOp(v)->primOp->name));
|
2014-11-30 18:16:19 +00:00
|
|
|
|
case tExternal: return v.external->showType();
|
2020-12-11 22:32:45 +00:00
|
|
|
|
case tThunk: return "a thunk";
|
|
|
|
|
case tApp: return "a function application";
|
|
|
|
|
case tBlackhole: return "a black hole";
|
2019-09-09 14:34:44 +00:00
|
|
|
|
default:
|
2022-02-25 15:00:00 +00:00
|
|
|
|
return std::string(showType(v.type()));
|
2010-03-29 14:37:56 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
PosIdx Value::determinePos(const PosIdx pos) const
|
2021-01-08 21:27:00 +00:00
|
|
|
|
{
|
|
|
|
|
switch (internalType) {
|
2022-03-04 18:31:59 +00:00
|
|
|
|
case tAttrs: return attrs->pos;
|
2021-01-08 21:27:00 +00:00
|
|
|
|
case tLambda: return lambda.fun->pos;
|
|
|
|
|
case tApp: return app.left->determinePos(pos);
|
|
|
|
|
default: return pos;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-05-12 11:06:24 +00:00
|
|
|
|
|
2019-09-09 15:34:38 +00:00
|
|
|
|
bool Value::isTrivial() const
|
|
|
|
|
{
|
|
|
|
|
return
|
2020-12-17 13:42:52 +00:00
|
|
|
|
internalType != tApp
|
|
|
|
|
&& internalType != tPrimOpApp
|
|
|
|
|
&& (internalType != tThunk
|
2019-09-09 15:34:38 +00:00
|
|
|
|
|| (dynamic_cast<ExprAttrs *>(thunk.expr)
|
|
|
|
|
&& ((ExprAttrs *) thunk.expr)->dynamicAttrs.empty())
|
2020-10-26 19:37:11 +00:00
|
|
|
|
|| dynamic_cast<ExprLambda *>(thunk.expr)
|
|
|
|
|
|| dynamic_cast<ExprList *>(thunk.expr));
|
2019-09-09 15:34:38 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-04-04 15:53:52 +00:00
|
|
|
|
#if HAVE_BOEHMGC
|
2013-11-23 20:19:36 +00:00
|
|
|
|
/* 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();
|
|
|
|
|
}
|
2020-10-30 19:55:53 +00:00
|
|
|
|
|
|
|
|
|
class BoehmGCStackAllocator : public StackAllocator {
|
BoehmGCStackAllocator: ignore stack protection page
This fixes a crash that looks like:
```
Thread 1 "nix-build" received signal SIGSEGV, Segmentation fault.
0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
(gdb) bt
0 0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
1 0x00007ffff7adeefb in GC_push_all_stacks () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
2 0x00007ffff7ad5ac7 in GC_mark_some () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
3 0x00007ffff7ad77bd in GC_stopped_mark () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
4 0x00007ffff7adbe3a in GC_try_to_collect_inner.part.0 () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
5 0x00007ffff7adc2a2 in GC_collect_or_expand () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
6 0x00007ffff7adc4f8 in GC_allocobj () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
7 0x00007ffff7adc88f in GC_generic_malloc_inner () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
8 0x00007ffff7ae1a04 in GC_generic_malloc_many () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
9 0x00007ffff7ae1c72 in GC_malloc_kind () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
10 0x00007ffff7e003d6 in nix::EvalState::allocValue() () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
11 0x00007ffff7e04b9c in nix::EvalState::callPrimOp(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
12 0x00007ffff7e0a773 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
13 0x00007ffff7e0a91d in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
14 0x00007ffff7e0a8f8 in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
15 0x00007ffff7e0e0e8 in nix::ExprOpNEq::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
16 0x00007ffff7e0d708 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
17 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
18 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
19 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
20 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
21 0x00007ffff7e09e19 in nix::ExprOpNot::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
22 0x00007ffff7e0a792 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
23 0x00007ffff7e8cba0 in nix::addPath(nix::EvalState&, nix::Pos const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Value*, nix::FileIngestionMethod, std::optional<nix::Hash>, nix::Value&)::{lambda(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)#1}::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
24 0x00007ffff752e6f9 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
25 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
26 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
27 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
28 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
29 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
30 0x00007ffff757f8c0 in void boost::context::detail::fiber_entry<boost::context::detail::fiber_record<boost::context::fiber, nix::VirtualStackAllocator, boost::coroutines2::detail::pull_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >::control_block::control_block<nix::VirtualStackAllocator, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}>(boost::context::preallocated, nix::VirtualStackAllocator&&, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}&&)::{lambda(boost::context::fiber&&)#1}> >(boost::context::detail::transfer_t) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
31 0x00007ffff6f331ef in make_fcontext () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libboost_context.so.1.69.0
32 0x0000000000000000 in ?? ()
```
2020-11-16 10:03:53 +00:00
|
|
|
|
boost::coroutines2::protected_fixedsize_stack stack {
|
|
|
|
|
// We allocate 8 MB, the default max stack size on NixOS.
|
|
|
|
|
// A smaller stack might be quicker to allocate but reduces the stack
|
|
|
|
|
// depth available for source filter expressions etc.
|
|
|
|
|
std::max(boost::context::stack_traits::default_size(), static_cast<std::size_t>(8 * 1024 * 1024))
|
2020-10-30 22:18:24 +00:00
|
|
|
|
};
|
2020-10-30 19:55:53 +00:00
|
|
|
|
|
BoehmGCStackAllocator: ignore stack protection page
This fixes a crash that looks like:
```
Thread 1 "nix-build" received signal SIGSEGV, Segmentation fault.
0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
(gdb) bt
0 0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
1 0x00007ffff7adeefb in GC_push_all_stacks () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
2 0x00007ffff7ad5ac7 in GC_mark_some () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
3 0x00007ffff7ad77bd in GC_stopped_mark () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
4 0x00007ffff7adbe3a in GC_try_to_collect_inner.part.0 () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
5 0x00007ffff7adc2a2 in GC_collect_or_expand () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
6 0x00007ffff7adc4f8 in GC_allocobj () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
7 0x00007ffff7adc88f in GC_generic_malloc_inner () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
8 0x00007ffff7ae1a04 in GC_generic_malloc_many () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
9 0x00007ffff7ae1c72 in GC_malloc_kind () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
10 0x00007ffff7e003d6 in nix::EvalState::allocValue() () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
11 0x00007ffff7e04b9c in nix::EvalState::callPrimOp(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
12 0x00007ffff7e0a773 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
13 0x00007ffff7e0a91d in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
14 0x00007ffff7e0a8f8 in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
15 0x00007ffff7e0e0e8 in nix::ExprOpNEq::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
16 0x00007ffff7e0d708 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
17 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
18 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
19 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
20 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
21 0x00007ffff7e09e19 in nix::ExprOpNot::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
22 0x00007ffff7e0a792 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
23 0x00007ffff7e8cba0 in nix::addPath(nix::EvalState&, nix::Pos const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Value*, nix::FileIngestionMethod, std::optional<nix::Hash>, nix::Value&)::{lambda(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)#1}::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
24 0x00007ffff752e6f9 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
25 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
26 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
27 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
28 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
29 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
30 0x00007ffff757f8c0 in void boost::context::detail::fiber_entry<boost::context::detail::fiber_record<boost::context::fiber, nix::VirtualStackAllocator, boost::coroutines2::detail::pull_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >::control_block::control_block<nix::VirtualStackAllocator, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}>(boost::context::preallocated, nix::VirtualStackAllocator&&, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}&&)::{lambda(boost::context::fiber&&)#1}> >(boost::context::detail::transfer_t) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
31 0x00007ffff6f331ef in make_fcontext () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libboost_context.so.1.69.0
32 0x0000000000000000 in ?? ()
```
2020-11-16 10:03:53 +00:00
|
|
|
|
// This is specific to boost::coroutines2::protected_fixedsize_stack.
|
|
|
|
|
// The stack protection page is included in sctx.size, so we have to
|
|
|
|
|
// subtract one page size from the stack size.
|
|
|
|
|
std::size_t pfss_usable_stack_size(boost::context::stack_context &sctx) {
|
|
|
|
|
return sctx.size - boost::context::stack_traits::page_size();
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-30 19:55:53 +00:00
|
|
|
|
public:
|
|
|
|
|
boost::context::stack_context allocate() override {
|
|
|
|
|
auto sctx = stack.allocate();
|
BoehmGCStackAllocator: ignore stack protection page
This fixes a crash that looks like:
```
Thread 1 "nix-build" received signal SIGSEGV, Segmentation fault.
0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
(gdb) bt
0 0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
1 0x00007ffff7adeefb in GC_push_all_stacks () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
2 0x00007ffff7ad5ac7 in GC_mark_some () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
3 0x00007ffff7ad77bd in GC_stopped_mark () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
4 0x00007ffff7adbe3a in GC_try_to_collect_inner.part.0 () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
5 0x00007ffff7adc2a2 in GC_collect_or_expand () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
6 0x00007ffff7adc4f8 in GC_allocobj () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
7 0x00007ffff7adc88f in GC_generic_malloc_inner () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
8 0x00007ffff7ae1a04 in GC_generic_malloc_many () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
9 0x00007ffff7ae1c72 in GC_malloc_kind () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
10 0x00007ffff7e003d6 in nix::EvalState::allocValue() () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
11 0x00007ffff7e04b9c in nix::EvalState::callPrimOp(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
12 0x00007ffff7e0a773 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
13 0x00007ffff7e0a91d in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
14 0x00007ffff7e0a8f8 in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
15 0x00007ffff7e0e0e8 in nix::ExprOpNEq::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
16 0x00007ffff7e0d708 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
17 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
18 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
19 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
20 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
21 0x00007ffff7e09e19 in nix::ExprOpNot::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
22 0x00007ffff7e0a792 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
23 0x00007ffff7e8cba0 in nix::addPath(nix::EvalState&, nix::Pos const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Value*, nix::FileIngestionMethod, std::optional<nix::Hash>, nix::Value&)::{lambda(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)#1}::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
24 0x00007ffff752e6f9 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
25 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
26 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
27 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
28 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
29 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
30 0x00007ffff757f8c0 in void boost::context::detail::fiber_entry<boost::context::detail::fiber_record<boost::context::fiber, nix::VirtualStackAllocator, boost::coroutines2::detail::pull_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >::control_block::control_block<nix::VirtualStackAllocator, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}>(boost::context::preallocated, nix::VirtualStackAllocator&&, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}&&)::{lambda(boost::context::fiber&&)#1}> >(boost::context::detail::transfer_t) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
31 0x00007ffff6f331ef in make_fcontext () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libboost_context.so.1.69.0
32 0x0000000000000000 in ?? ()
```
2020-11-16 10:03:53 +00:00
|
|
|
|
|
|
|
|
|
// Stacks generally start at a high address and grow to lower addresses.
|
|
|
|
|
// Architectures that do the opposite are rare; in fact so rare that
|
|
|
|
|
// boost_routine does not implement it.
|
|
|
|
|
// So we subtract the stack size.
|
|
|
|
|
GC_add_roots(static_cast<char *>(sctx.sp) - pfss_usable_stack_size(sctx), sctx.sp);
|
2020-10-30 19:55:53 +00:00
|
|
|
|
return sctx;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void deallocate(boost::context::stack_context sctx) override {
|
BoehmGCStackAllocator: ignore stack protection page
This fixes a crash that looks like:
```
Thread 1 "nix-build" received signal SIGSEGV, Segmentation fault.
0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
(gdb) bt
0 0x00007ffff7ad22a0 in GC_push_all_eager () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
1 0x00007ffff7adeefb in GC_push_all_stacks () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
2 0x00007ffff7ad5ac7 in GC_mark_some () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
3 0x00007ffff7ad77bd in GC_stopped_mark () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
4 0x00007ffff7adbe3a in GC_try_to_collect_inner.part.0 () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
5 0x00007ffff7adc2a2 in GC_collect_or_expand () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
6 0x00007ffff7adc4f8 in GC_allocobj () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
7 0x00007ffff7adc88f in GC_generic_malloc_inner () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
8 0x00007ffff7ae1a04 in GC_generic_malloc_many () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
9 0x00007ffff7ae1c72 in GC_malloc_kind () from /nix/store/p1z58l18klf88iijpd0qi8yd2n9lhlk4-boehm-gc-8.0.4/lib/libgc.so.1
10 0x00007ffff7e003d6 in nix::EvalState::allocValue() () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
11 0x00007ffff7e04b9c in nix::EvalState::callPrimOp(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
12 0x00007ffff7e0a773 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
13 0x00007ffff7e0a91d in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
14 0x00007ffff7e0a8f8 in nix::ExprApp::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
15 0x00007ffff7e0e0e8 in nix::ExprOpNEq::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
16 0x00007ffff7e0d708 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
17 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
18 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
19 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
20 0x00007ffff7e0d695 in nix::ExprOpOr::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
21 0x00007ffff7e09e19 in nix::ExprOpNot::eval(nix::EvalState&, nix::Env&, nix::Value&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
22 0x00007ffff7e0a792 in nix::EvalState::callFunction(nix::Value&, nix::Value&, nix::Value&, nix::Pos const&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
23 0x00007ffff7e8cba0 in nix::addPath(nix::EvalState&, nix::Pos const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Value*, nix::FileIngestionMethod, std::optional<nix::Hash>, nix::Value&)::{lambda(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)#1}::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) const () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixexpr.so
24 0x00007ffff752e6f9 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
25 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
26 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
27 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
28 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
29 0x00007ffff752e8e2 in nix::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, nix::Sink&, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>&) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
30 0x00007ffff757f8c0 in void boost::context::detail::fiber_entry<boost::context::detail::fiber_record<boost::context::fiber, nix::VirtualStackAllocator, boost::coroutines2::detail::pull_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >::control_block::control_block<nix::VirtualStackAllocator, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}>(boost::context::preallocated, nix::VirtualStackAllocator&&, nix::sinkToSource(std::function<void (nix::Sink&)>, std::function<void ()>)::SinkToSource::read(char*, unsigned long)::{lambda(boost::coroutines2::detail::push_coroutine<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&)#1}&&)::{lambda(boost::context::fiber&&)#1}> >(boost::context::detail::transfer_t) () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libnixutil.so
31 0x00007ffff6f331ef in make_fcontext () from /nix/store/hzdzcv9d3bc8rlsaphh7x54zsf0x8nx6-nix-2.4pre20210601_5985b8b/lib/libboost_context.so.1.69.0
32 0x0000000000000000 in ?? ()
```
2020-11-16 10:03:53 +00:00
|
|
|
|
GC_remove_roots(static_cast<char *>(sctx.sp) - pfss_usable_stack_size(sctx), sctx.sp);
|
2020-10-30 19:55:53 +00:00
|
|
|
|
stack.deallocate(sctx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static BoehmGCStackAllocator boehmGCStackAllocator;
|
|
|
|
|
|
2014-04-04 15:53:52 +00:00
|
|
|
|
#endif
|
2013-11-23 20:19:36 +00:00
|
|
|
|
|
|
|
|
|
|
2014-04-04 19:14:11 +00:00
|
|
|
|
static Symbol getName(const AttrName & name, EvalState & state, Env & env)
|
|
|
|
|
{
|
2022-03-05 13:40:24 +00:00
|
|
|
|
if (name.symbol) {
|
2013-12-31 23:56:26 +00:00
|
|
|
|
return name.symbol;
|
|
|
|
|
} else {
|
|
|
|
|
Value nameValue;
|
|
|
|
|
name.expr->eval(state, env, nameValue);
|
|
|
|
|
state.forceStringNoCtx(nameValue);
|
|
|
|
|
return state.symbols.create(nameValue.string.s);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-03-19 19:02:37 +00:00
|
|
|
|
static bool gcInitialised = false;
|
|
|
|
|
|
|
|
|
|
void initGC()
|
|
|
|
|
{
|
|
|
|
|
if (gcInitialised) return;
|
|
|
|
|
|
|
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
|
/* Initialise the Boehm garbage collector. */
|
2018-06-12 13:41:37 +00:00
|
|
|
|
|
|
|
|
|
/* Don't look for interior pointers. This reduces the odds of
|
|
|
|
|
misdetection a bit. */
|
2015-03-19 19:10:08 +00:00
|
|
|
|
GC_set_all_interior_pointers(0);
|
|
|
|
|
|
2018-06-12 13:41:37 +00:00
|
|
|
|
/* We don't have any roots in data segments, so don't scan from
|
|
|
|
|
there. */
|
|
|
|
|
GC_set_no_dls(1);
|
|
|
|
|
|
2015-03-19 19:02:37 +00:00
|
|
|
|
GC_INIT();
|
|
|
|
|
|
2017-04-14 12:42:20 +00:00
|
|
|
|
GC_set_oom_fn(oomHandler);
|
2015-03-19 19:02:37 +00:00
|
|
|
|
|
2020-10-30 19:55:53 +00:00
|
|
|
|
StackAllocator::defaultAllocator = &boehmGCStackAllocator;
|
|
|
|
|
|
2015-03-19 19:02:37 +00:00
|
|
|
|
/* 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. */
|
2019-11-22 15:06:44 +00:00
|
|
|
|
if (!getEnv("GC_INITIAL_HEAP_SIZE")) {
|
2015-03-19 19:02:37 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-06-17 14:20:11 +00:00
|
|
|
|
/* Very hacky way to parse $NIX_PATH, which is colon-separated, but
|
|
|
|
|
can contain URLs (e.g. "nixpkgs=https://bla...:foo=https://"). */
|
2022-02-25 15:00:00 +00:00
|
|
|
|
static Strings parseNixPath(const std::string & s)
|
2015-06-17 14:20:11 +00:00
|
|
|
|
{
|
2016-04-14 15:25:49 +00:00
|
|
|
|
Strings res;
|
|
|
|
|
|
|
|
|
|
auto p = s.begin();
|
|
|
|
|
|
|
|
|
|
while (p != s.end()) {
|
|
|
|
|
auto start = p;
|
|
|
|
|
auto start2 = p;
|
|
|
|
|
|
|
|
|
|
while (p != s.end() && *p != ':') {
|
|
|
|
|
if (*p == '=') start2 = p + 1;
|
|
|
|
|
++p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (p == s.end()) {
|
|
|
|
|
if (p != start) res.push_back(std::string(start, p));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (*p == ':') {
|
|
|
|
|
if (isUri(std::string(start2, s.end()))) {
|
|
|
|
|
++p;
|
|
|
|
|
while (p != s.end() && *p != ':') ++p;
|
|
|
|
|
}
|
|
|
|
|
res.push_back(std::string(start, p));
|
|
|
|
|
if (p == s.end()) break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
++p;
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-17 14:20:11 +00:00
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2021-06-29 19:09:48 +00:00
|
|
|
|
EvalState::EvalState(
|
|
|
|
|
const Strings & _searchPath,
|
|
|
|
|
ref<Store> store,
|
|
|
|
|
std::shared_ptr<Store> buildStore)
|
2010-04-13 12:25:42 +00:00
|
|
|
|
: sWith(symbols.create("<with>"))
|
|
|
|
|
, sOutPath(symbols.create("outPath"))
|
|
|
|
|
, sDrvPath(symbols.create("drvPath"))
|
|
|
|
|
, sType(symbols.create("type"))
|
|
|
|
|
, sMeta(symbols.create("meta"))
|
|
|
|
|
, sName(symbols.create("name"))
|
2013-10-28 06:34:44 +00:00
|
|
|
|
, sValue(symbols.create("value"))
|
2010-04-21 15:08:58 +00:00
|
|
|
|
, sSystem(symbols.create("system"))
|
2010-05-15 08:10:12 +00:00
|
|
|
|
, sOverrides(symbols.create("__overrides"))
|
2012-11-28 12:49:44 +00:00
|
|
|
|
, sOutputs(symbols.create("outputs"))
|
2012-11-26 16:39:09 +00:00
|
|
|
|
, sOutputName(symbols.create("outputName"))
|
2012-11-27 14:01:32 +00:00
|
|
|
|
, sIgnoreNulls(symbols.create("__ignoreNulls"))
|
2013-11-18 19:14:54 +00:00
|
|
|
|
, sFile(symbols.create("file"))
|
|
|
|
|
, sLine(symbols.create("line"))
|
|
|
|
|
, sColumn(symbols.create("column"))
|
2014-10-16 02:04:48 +00:00
|
|
|
|
, sFunctor(symbols.create("__functor"))
|
2015-11-27 19:20:29 +00:00
|
|
|
|
, sToString(symbols.create("__toString"))
|
2016-08-29 15:28:20 +00:00
|
|
|
|
, sRight(symbols.create("right"))
|
|
|
|
|
, sWrong(symbols.create("wrong"))
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
, sStructuredAttrs(symbols.create("__structuredAttrs"))
|
|
|
|
|
, sBuilder(symbols.create("builder"))
|
2017-03-04 13:24:06 +00:00
|
|
|
|
, sArgs(symbols.create("args"))
|
2020-07-22 23:59:25 +00:00
|
|
|
|
, sContentAddressed(symbols.create("__contentAddressed"))
|
2022-03-30 14:31:01 +00:00
|
|
|
|
, sImpure(symbols.create("__impure"))
|
2017-03-04 13:24:06 +00:00
|
|
|
|
, sOutputHash(symbols.create("outputHash"))
|
|
|
|
|
, sOutputHashAlgo(symbols.create("outputHashAlgo"))
|
|
|
|
|
, sOutputHashMode(symbols.create("outputHashMode"))
|
2020-06-18 11:44:40 +00:00
|
|
|
|
, sRecurseForDerivations(symbols.create("recurseForDerivations"))
|
2018-11-29 18:18:36 +00:00
|
|
|
|
, sDescription(symbols.create("description"))
|
2019-08-30 09:22:34 +00:00
|
|
|
|
, sSelf(symbols.create("self"))
|
2020-04-17 21:04:21 +00:00
|
|
|
|
, sEpsilon(symbols.create(""))
|
2022-01-12 17:08:48 +00:00
|
|
|
|
, sStartSet(symbols.create("startSet"))
|
|
|
|
|
, sOperator(symbols.create("operator"))
|
|
|
|
|
, sKey(symbols.create("key"))
|
|
|
|
|
, sPath(symbols.create("path"))
|
|
|
|
|
, sPrefix(symbols.create("prefix"))
|
2022-05-30 09:32:37 +00:00
|
|
|
|
, sOutputSpecified(symbols.create("outputSpecified"))
|
2017-06-28 16:11:01 +00:00
|
|
|
|
, repair(NoRepair)
|
2022-01-04 18:23:11 +00:00
|
|
|
|
, emptyBindings(0)
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
|
, store(store)
|
2021-06-29 19:09:48 +00:00
|
|
|
|
, buildStore(buildStore ? buildStore : store)
|
2022-05-20 16:33:50 +00:00
|
|
|
|
, debugRepl(0)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
, debugStop(false)
|
2022-02-15 16:49:25 +00:00
|
|
|
|
, debugQuit(false)
|
2020-09-21 16:22:45 +00:00
|
|
|
|
, regexCache(makeRegexCache())
|
2022-01-22 20:17:35 +00:00
|
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
|
, valueAllocCache(std::allocate_shared<void *>(traceable_allocator<void *>(), nullptr))
|
2021-12-26 18:32:08 +00:00
|
|
|
|
, env1AllocCache(std::allocate_shared<void *>(traceable_allocator<void *>(), nullptr))
|
2022-01-22 20:17:35 +00:00
|
|
|
|
#else
|
|
|
|
|
, valueAllocCache(std::make_shared<void *>(nullptr))
|
2021-12-26 18:32:08 +00:00
|
|
|
|
, env1AllocCache(std::make_shared<void *>(nullptr))
|
2022-01-22 20:17:35 +00:00
|
|
|
|
#endif
|
2010-04-14 14:42:32 +00:00
|
|
|
|
, baseEnv(allocEnv(128))
|
2022-05-05 10:29:14 +00:00
|
|
|
|
, staticBaseEnv{std::make_shared<StaticEnv>(false, nullptr)}
|
2010-03-29 14:37:56 +00:00
|
|
|
|
{
|
2019-11-22 15:06:44 +00:00
|
|
|
|
countCalls = getEnv("NIX_COUNT_CALLS").value_or("0") != "0";
|
2010-03-29 14:37:56 +00:00
|
|
|
|
|
2015-03-19 19:02:37 +00:00
|
|
|
|
assert(gcInitialised);
|
2011-08-06 16:05:24 +00:00
|
|
|
|
|
2021-10-22 20:27:04 +00:00
|
|
|
|
static_assert(sizeof(Env) <= 16, "environment must be <= 16 bytes");
|
2018-05-22 14:02:32 +00:00
|
|
|
|
|
2011-08-06 16:05:24 +00:00
|
|
|
|
/* Initialise the Nix expression search path. */
|
2018-03-27 17:02:22 +00:00
|
|
|
|
if (!evalSettings.pureEval) {
|
2018-01-16 17:50:38 +00:00
|
|
|
|
for (auto & i : _searchPath) addToSearchPath(i);
|
2019-11-22 22:07:35 +00:00
|
|
|
|
for (auto & i : evalSettings.nixPath.get()) addToSearchPath(i);
|
2018-01-16 17:50:38 +00:00
|
|
|
|
}
|
2012-01-03 14:01:47 +00:00
|
|
|
|
|
2018-03-27 17:02:22 +00:00
|
|
|
|
if (evalSettings.restrictEval || evalSettings.pureEval) {
|
2018-01-16 17:50:38 +00:00
|
|
|
|
allowedPaths = PathSet();
|
2018-05-09 13:45:05 +00:00
|
|
|
|
|
2018-01-16 17:50:38 +00:00
|
|
|
|
for (auto & i : searchPath) {
|
|
|
|
|
auto r = resolveSearchPathElem(i);
|
|
|
|
|
if (!r.first) continue;
|
2018-05-09 13:45:05 +00:00
|
|
|
|
|
|
|
|
|
auto path = r.second;
|
|
|
|
|
|
|
|
|
|
if (store->isInStore(r.second)) {
|
2020-08-24 17:15:17 +00:00
|
|
|
|
try {
|
|
|
|
|
StorePathSet closure;
|
|
|
|
|
store->computeFSClosure(store->toStorePath(r.second).first, closure);
|
|
|
|
|
for (auto & path : closure)
|
2021-10-07 12:07:51 +00:00
|
|
|
|
allowPath(path);
|
2020-08-24 17:15:17 +00:00
|
|
|
|
} catch (InvalidPath &) {
|
2021-10-07 10:11:00 +00:00
|
|
|
|
allowPath(r.second);
|
2020-08-24 17:15:17 +00:00
|
|
|
|
}
|
2018-05-09 13:45:05 +00:00
|
|
|
|
} else
|
2021-10-07 10:11:00 +00:00
|
|
|
|
allowPath(r.second);
|
2018-01-16 17:50:38 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-03 14:01:47 +00:00
|
|
|
|
createBaseEnv();
|
2004-02-04 16:03:29 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-09 12:00:49 +00:00
|
|
|
|
EvalState::~EvalState()
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2021-10-07 10:11:00 +00:00
|
|
|
|
void EvalState::allowPath(const Path & path)
|
|
|
|
|
{
|
|
|
|
|
if (allowedPaths)
|
|
|
|
|
allowedPaths->insert(path);
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-07 12:07:51 +00:00
|
|
|
|
void EvalState::allowPath(const StorePath & storePath)
|
|
|
|
|
{
|
|
|
|
|
if (allowedPaths)
|
|
|
|
|
allowedPaths->insert(store->toRealPath(storePath));
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-05 10:29:14 +00:00
|
|
|
|
void EvalState::allowAndSetStorePathString(const StorePath & storePath, Value & v)
|
2022-02-27 14:59:34 +00:00
|
|
|
|
{
|
|
|
|
|
allowPath(storePath);
|
|
|
|
|
|
|
|
|
|
auto path = store->printStorePath(storePath);
|
|
|
|
|
v.mkString(path, PathSet({path}));
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-23 13:41:53 +00:00
|
|
|
|
Path EvalState::checkSourcePath(const Path & path_)
|
|
|
|
|
{
|
2018-01-16 17:50:38 +00:00
|
|
|
|
if (!allowedPaths) return path_;
|
|
|
|
|
|
2018-05-22 11:02:14 +00:00
|
|
|
|
auto i = resolvedPaths.find(path_);
|
|
|
|
|
if (i != resolvedPaths.end())
|
|
|
|
|
return i->second;
|
|
|
|
|
|
2018-01-16 17:50:38 +00:00
|
|
|
|
bool found = false;
|
|
|
|
|
|
2018-08-03 04:24:57 +00:00
|
|
|
|
/* First canonicalize the path without symlinks, so we make sure an
|
|
|
|
|
* attacker can't append ../../... to a path that would be in allowedPaths
|
|
|
|
|
* and thus leak symlink targets.
|
|
|
|
|
*/
|
|
|
|
|
Path abspath = canonPath(path_);
|
|
|
|
|
|
2020-12-22 13:43:20 +00:00
|
|
|
|
if (hasPrefix(abspath, corepkgsPrefix)) return abspath;
|
|
|
|
|
|
2018-01-16 17:50:38 +00:00
|
|
|
|
for (auto & i : *allowedPaths) {
|
2018-08-03 04:24:57 +00:00
|
|
|
|
if (isDirOrInDir(abspath, i)) {
|
2018-01-16 17:50:38 +00:00
|
|
|
|
found = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-11-25 13:48:01 +00:00
|
|
|
|
if (!found) {
|
|
|
|
|
auto modeInformation = evalSettings.pureEval
|
|
|
|
|
? "in pure eval mode (use '--impure' to override)"
|
|
|
|
|
: "in restricted mode";
|
|
|
|
|
throw RestrictedPathError("access to absolute path '%1%' is forbidden %2%", abspath, modeInformation);
|
|
|
|
|
}
|
2015-02-23 13:41:53 +00:00
|
|
|
|
|
|
|
|
|
/* Resolve symlinks. */
|
2018-08-03 04:24:57 +00:00
|
|
|
|
debug(format("checking access to '%s'") % abspath);
|
|
|
|
|
Path path = canonPath(abspath, true);
|
2015-02-23 13:41:53 +00:00
|
|
|
|
|
2018-01-16 17:50:38 +00:00
|
|
|
|
for (auto & i : *allowedPaths) {
|
2018-05-22 11:02:14 +00:00
|
|
|
|
if (isDirOrInDir(path, i)) {
|
|
|
|
|
resolvedPaths[path_] = path;
|
2015-02-23 13:41:53 +00:00
|
|
|
|
return path;
|
2018-05-22 11:02:14 +00:00
|
|
|
|
}
|
2016-04-14 13:32:24 +00:00
|
|
|
|
}
|
2015-02-23 13:41:53 +00:00
|
|
|
|
|
2021-11-20 04:52:52 +00:00
|
|
|
|
throw RestrictedPathError("access to canonical path '%1%' is forbidden in restricted mode", path);
|
2015-02-23 13:41:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-10-30 11:39:59 +00:00
|
|
|
|
void EvalState::checkURI(const std::string & uri)
|
|
|
|
|
{
|
2018-03-27 17:02:22 +00:00
|
|
|
|
if (!evalSettings.restrictEval) return;
|
2017-10-30 11:39:59 +00:00
|
|
|
|
|
|
|
|
|
/* 'uri' should be equal to a prefix, or in a subdirectory of a
|
|
|
|
|
prefix. Thus, the prefix https://github.co does not permit
|
|
|
|
|
access to https://github.com. Note: this allows 'http://' and
|
|
|
|
|
'https://' as prefixes for any http/https URI. */
|
2018-03-27 17:02:22 +00:00
|
|
|
|
for (auto & prefix : evalSettings.allowedUris.get())
|
2017-10-30 11:39:59 +00:00
|
|
|
|
if (uri == prefix ||
|
|
|
|
|
(uri.size() > prefix.size()
|
|
|
|
|
&& prefix.size() > 0
|
|
|
|
|
&& hasPrefix(uri, prefix)
|
|
|
|
|
&& (prefix[prefix.size() - 1] == '/' || uri[prefix.size()] == '/')))
|
|
|
|
|
return;
|
|
|
|
|
|
2018-02-06 13:35:14 +00:00
|
|
|
|
/* If the URI is a path, then check it against allowedPaths as
|
|
|
|
|
well. */
|
|
|
|
|
if (hasPrefix(uri, "/")) {
|
|
|
|
|
checkSourcePath(uri);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (hasPrefix(uri, "file://")) {
|
|
|
|
|
checkSourcePath(std::string(uri, 7));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-30 11:39:59 +00:00
|
|
|
|
throw RestrictedPathError("access to URI '%s' is forbidden in restricted mode", uri);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-01-12 16:31:08 +00:00
|
|
|
|
Path EvalState::toRealPath(const Path & path, const PathSet & context)
|
|
|
|
|
{
|
|
|
|
|
// FIXME: check whether 'path' is in 'context'.
|
|
|
|
|
return
|
|
|
|
|
!context.empty() && store->isInStore(path)
|
|
|
|
|
? store->toRealPath(path)
|
|
|
|
|
: path;
|
2019-11-10 16:23:35 +00:00
|
|
|
|
}
|
2018-01-12 16:31:08 +00:00
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
Value * EvalState::addConstant(const std::string & name, Value & v)
|
2010-03-30 14:39:27 +00:00
|
|
|
|
{
|
2010-10-22 14:47:42 +00:00
|
|
|
|
Value * v2 = allocValue();
|
|
|
|
|
*v2 = v;
|
2020-03-02 17:15:06 +00:00
|
|
|
|
addConstant(name, v2);
|
2018-02-08 18:00:53 +00:00
|
|
|
|
return v2;
|
2010-03-30 14:39:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
void EvalState::addConstant(const std::string & name, Value * v)
|
2020-03-02 17:15:06 +00:00
|
|
|
|
{
|
2021-11-30 21:15:02 +00:00
|
|
|
|
staticBaseEnv->vars.emplace_back(symbols.create(name), baseEnvDispl);
|
2020-03-02 17:15:06 +00:00
|
|
|
|
baseEnv.values[baseEnvDispl++] = v;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto name2 = name.substr(0, 2) == "__" ? name.substr(2) : name;
|
2020-03-02 17:15:06 +00:00
|
|
|
|
baseEnv.values[0]->attrs->push_back(Attr(symbols.create(name2), v));
|
2010-03-30 14:39:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
Value * EvalState::addPrimOp(const std::string & name,
|
2018-05-02 11:56:34 +00:00
|
|
|
|
size_t arity, PrimOpFun primOp)
|
2004-02-04 16:03:29 +00:00
|
|
|
|
{
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto name2 = name.substr(0, 2) == "__" ? name.substr(2) : name;
|
2022-03-05 13:40:24 +00:00
|
|
|
|
auto sym = symbols.create(name2);
|
2018-11-29 15:28:43 +00:00
|
|
|
|
|
|
|
|
|
/* Hack to make constants lazy: turn them into a application of
|
|
|
|
|
the primop to a dummy value. */
|
2018-02-08 18:00:53 +00:00
|
|
|
|
if (arity == 0) {
|
2018-11-29 15:28:43 +00:00
|
|
|
|
auto vPrimOp = allocValue();
|
2022-03-05 18:26:36 +00:00
|
|
|
|
vPrimOp->mkPrimOp(new PrimOp { .fun = primOp, .arity = 1, .name = name2 });
|
2018-02-08 18:00:53 +00:00
|
|
|
|
Value v;
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkApp(vPrimOp, vPrimOp);
|
2018-02-08 18:00:53 +00:00
|
|
|
|
return addConstant(name, v);
|
|
|
|
|
}
|
2018-11-29 15:28:43 +00:00
|
|
|
|
|
2010-10-22 14:47:42 +00:00
|
|
|
|
Value * v = allocValue();
|
2022-03-05 18:26:36 +00:00
|
|
|
|
v->mkPrimOp(new PrimOp { .fun = primOp, .arity = arity, .name = name2 });
|
2021-11-25 15:53:59 +00:00
|
|
|
|
staticBaseEnv->vars.emplace_back(symbols.create(name), baseEnvDispl);
|
2010-10-22 15:51:52 +00:00
|
|
|
|
baseEnv.values[baseEnvDispl++] = v;
|
2010-10-24 19:52:33 +00:00
|
|
|
|
baseEnv.values[0]->attrs->push_back(Attr(sym, v));
|
2018-01-16 17:50:38 +00:00
|
|
|
|
return v;
|
2003-10-31 17:09:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2020-08-24 11:11:56 +00:00
|
|
|
|
Value * EvalState::addPrimOp(PrimOp && primOp)
|
|
|
|
|
{
|
|
|
|
|
/* Hack to make constants lazy: turn them into a application of
|
|
|
|
|
the primop to a dummy value. */
|
|
|
|
|
if (primOp.arity == 0) {
|
|
|
|
|
primOp.arity = 1;
|
|
|
|
|
auto vPrimOp = allocValue();
|
2022-03-05 18:26:36 +00:00
|
|
|
|
vPrimOp->mkPrimOp(new PrimOp(primOp));
|
2020-08-24 11:11:56 +00:00
|
|
|
|
Value v;
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkApp(vPrimOp, vPrimOp);
|
2020-08-24 11:11:56 +00:00
|
|
|
|
return addConstant(primOp.name, v);
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
|
auto envName = symbols.create(primOp.name);
|
2020-08-24 11:11:56 +00:00
|
|
|
|
if (hasPrefix(primOp.name, "__"))
|
2022-03-05 18:26:36 +00:00
|
|
|
|
primOp.name = primOp.name.substr(2);
|
2020-08-24 11:11:56 +00:00
|
|
|
|
|
|
|
|
|
Value * v = allocValue();
|
2022-03-05 18:26:36 +00:00
|
|
|
|
v->mkPrimOp(new PrimOp(primOp));
|
2021-11-25 15:53:59 +00:00
|
|
|
|
staticBaseEnv->vars.emplace_back(envName, baseEnvDispl);
|
2020-08-24 11:11:56 +00:00
|
|
|
|
baseEnv.values[baseEnvDispl++] = v;
|
2022-03-05 18:26:36 +00:00
|
|
|
|
baseEnv.values[0]->attrs->push_back(Attr(symbols.create(primOp.name), v));
|
2020-08-24 11:11:56 +00:00
|
|
|
|
return v;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
Value & EvalState::getBuiltin(const std::string & name)
|
2013-09-03 13:45:32 +00:00
|
|
|
|
{
|
2016-08-23 15:11:19 +00:00
|
|
|
|
return *baseEnv.values[0]->attrs->find(symbols.create(name))->value;
|
2013-09-03 13:45:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2020-08-25 11:31:11 +00:00
|
|
|
|
std::optional<EvalState::Doc> EvalState::getDoc(Value & v)
|
|
|
|
|
{
|
2021-03-03 16:52:57 +00:00
|
|
|
|
if (v.isPrimOp()) {
|
2020-08-25 11:31:11 +00:00
|
|
|
|
auto v2 = &v;
|
|
|
|
|
if (v2->primOp->doc)
|
|
|
|
|
return Doc {
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.pos = {},
|
2020-08-25 11:31:11 +00:00
|
|
|
|
.name = v2->primOp->name,
|
|
|
|
|
.arity = v2->primOp->arity,
|
|
|
|
|
.args = v2->primOp->args,
|
|
|
|
|
.doc = v2->primOp->doc,
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-31 15:37:36 +00:00
|
|
|
|
|
|
|
|
|
// just for the current level of StaticEnv, not the whole chain.
|
2022-05-05 10:29:14 +00:00
|
|
|
|
void printStaticEnvBindings(const SymbolTable & st, const StaticEnv & se)
|
2021-10-02 19:47:36 +00:00
|
|
|
|
{
|
2022-03-31 15:37:36 +00:00
|
|
|
|
std::cout << ANSI_MAGENTA;
|
2022-05-05 10:29:14 +00:00
|
|
|
|
for (auto & i : se.vars)
|
|
|
|
|
std::cout << st[i.first] << " ";
|
2022-03-31 15:37:36 +00:00
|
|
|
|
std::cout << ANSI_NORMAL;
|
|
|
|
|
std::cout << std::endl;
|
|
|
|
|
}
|
2022-01-05 19:28:31 +00:00
|
|
|
|
|
2022-03-31 15:37:36 +00:00
|
|
|
|
// just for the current level of Env, not the whole chain.
|
2022-05-05 10:29:14 +00:00
|
|
|
|
void printWithBindings(const SymbolTable & st, const Env & env)
|
2022-03-31 15:37:36 +00:00
|
|
|
|
{
|
2022-05-05 10:29:14 +00:00
|
|
|
|
if (env.type == Env::HasWithAttrs) {
|
2022-04-29 17:24:54 +00:00
|
|
|
|
std::cout << "with: ";
|
2022-01-05 19:28:31 +00:00
|
|
|
|
std::cout << ANSI_MAGENTA;
|
2022-03-31 15:37:36 +00:00
|
|
|
|
Bindings::iterator j = env.values[0]->attrs->begin();
|
|
|
|
|
while (j != env.values[0]->attrs->end()) {
|
2022-04-29 16:02:17 +00:00
|
|
|
|
std::cout << st[j->name] << " ";
|
2022-03-31 15:37:36 +00:00
|
|
|
|
++j;
|
2022-01-04 01:29:43 +00:00
|
|
|
|
}
|
2022-01-05 19:28:31 +00:00
|
|
|
|
std::cout << ANSI_NORMAL;
|
2022-01-04 01:29:43 +00:00
|
|
|
|
std::cout << std::endl;
|
2022-03-31 15:37:36 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-05 10:29:14 +00:00
|
|
|
|
void printEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env, int lvl)
|
2022-03-31 15:37:36 +00:00
|
|
|
|
{
|
|
|
|
|
std::cout << "Env level " << lvl << std::endl;
|
2022-01-04 01:29:43 +00:00
|
|
|
|
|
2022-03-31 15:37:36 +00:00
|
|
|
|
if (se.up && env.up) {
|
2022-04-29 17:24:54 +00:00
|
|
|
|
std::cout << "static: ";
|
2022-04-29 16:02:17 +00:00
|
|
|
|
printStaticEnvBindings(st, se);
|
|
|
|
|
printWithBindings(st, env);
|
2022-03-31 15:37:36 +00:00
|
|
|
|
std::cout << std::endl;
|
2022-04-29 16:02:17 +00:00
|
|
|
|
printEnvBindings(st, *se.up, *env.up, ++lvl);
|
2022-05-05 10:29:14 +00:00
|
|
|
|
} else {
|
2022-01-05 19:28:31 +00:00
|
|
|
|
std::cout << ANSI_MAGENTA;
|
2022-05-05 10:29:14 +00:00
|
|
|
|
// for the top level, don't print the double underscore ones;
|
|
|
|
|
// they are in builtins.
|
|
|
|
|
for (auto & i : se.vars)
|
|
|
|
|
if (!hasPrefix(st[i.first], "__"))
|
|
|
|
|
std::cout << st[i.first] << " ";
|
2022-01-05 19:28:31 +00:00
|
|
|
|
std::cout << ANSI_NORMAL;
|
2022-01-04 01:29:43 +00:00
|
|
|
|
std::cout << std::endl;
|
2022-04-29 16:02:17 +00:00
|
|
|
|
printWithBindings(st, env); // probably nothing there for the top level.
|
2022-01-04 01:29:43 +00:00
|
|
|
|
std::cout << std::endl;
|
|
|
|
|
|
|
|
|
|
}
|
2021-10-02 19:47:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 16:48:10 +00:00
|
|
|
|
void printEnvBindings(const EvalState &es, const Expr & expr, const Env & env)
|
2021-10-02 19:47:36 +00:00
|
|
|
|
{
|
2021-11-25 15:23:07 +00:00
|
|
|
|
// just print the names for now
|
2022-05-19 16:48:10 +00:00
|
|
|
|
auto se = es.getStaticEnv(expr);
|
|
|
|
|
if (se)
|
|
|
|
|
printEnvBindings(es.symbols, *se, env, 0);
|
2022-05-05 10:29:14 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-05 21:43:23 +00:00
|
|
|
|
void mapStaticEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env, ValMap & vm)
|
2022-05-05 10:29:14 +00:00
|
|
|
|
{
|
|
|
|
|
// add bindings for the next level up first, so that the bindings for this level
|
|
|
|
|
// override the higher levels.
|
|
|
|
|
// The top level bindings (builtins) are skipped since they are added for us by initEnv()
|
|
|
|
|
if (env.up && se.up) {
|
|
|
|
|
mapStaticEnvBindings(st, *se.up, *env.up, vm);
|
|
|
|
|
|
|
|
|
|
if (env.type == Env::HasWithAttrs) {
|
|
|
|
|
// add 'with' bindings.
|
|
|
|
|
Bindings::iterator j = env.values[0]->attrs->begin();
|
|
|
|
|
while (j != env.values[0]->attrs->end()) {
|
|
|
|
|
vm[st[j->name]] = j->value;
|
|
|
|
|
++j;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
// iterate through staticenv bindings and add them.
|
|
|
|
|
for (auto & i : se.vars)
|
|
|
|
|
vm[st[i.first]] = env.values[i.second];
|
|
|
|
|
}
|
2021-11-25 15:23:07 +00:00
|
|
|
|
}
|
2021-10-02 19:47:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-05 21:43:23 +00:00
|
|
|
|
std::unique_ptr<ValMap> mapStaticEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env)
|
2022-05-05 10:29:14 +00:00
|
|
|
|
{
|
2022-05-05 21:43:23 +00:00
|
|
|
|
auto vm = std::make_unique<ValMap>();
|
2022-04-29 16:02:17 +00:00
|
|
|
|
mapStaticEnvBindings(st, se, env, *vm);
|
2021-10-11 22:32:43 +00:00
|
|
|
|
return vm;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-20 16:33:50 +00:00
|
|
|
|
void EvalState::runDebugRepl(const Error * error, const Env & env, const Expr & expr)
|
2022-05-19 23:01:23 +00:00
|
|
|
|
{
|
2022-05-23 03:45:24 +00:00
|
|
|
|
// double check we've got the debugRepl function pointer.
|
2022-05-20 16:33:50 +00:00
|
|
|
|
if (!debugRepl)
|
|
|
|
|
return;
|
2022-05-25 10:32:22 +00:00
|
|
|
|
|
2022-05-19 23:01:23 +00:00
|
|
|
|
auto dts =
|
|
|
|
|
error && expr.getPos()
|
|
|
|
|
? std::make_unique<DebugTraceStacker>(
|
|
|
|
|
*this,
|
|
|
|
|
DebugTrace {
|
|
|
|
|
.pos = error->info().errPos ? *error->info().errPos : positions[expr.getPos()],
|
|
|
|
|
.expr = expr,
|
|
|
|
|
.env = env,
|
|
|
|
|
.hint = error->info().msg,
|
|
|
|
|
.isError = true
|
|
|
|
|
})
|
|
|
|
|
: nullptr;
|
|
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
|
printError("%s\n\n" ANSI_BOLD "Starting REPL to allow you to inspect the current state of the evaluator.\n" ANSI_NORMAL, error->what());
|
|
|
|
|
|
|
|
|
|
auto se = getStaticEnv(expr);
|
|
|
|
|
if (se) {
|
|
|
|
|
auto vm = mapStaticEnvBindings(symbols, *se.get(), env);
|
2022-05-25 16:21:20 +00:00
|
|
|
|
(debugRepl)(ref<EvalState>(shared_from_this()), *vm);
|
2022-05-19 23:01:23 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-02-27 19:10:45 +00:00
|
|
|
|
/* 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. */
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwEvalError(const PosIdx pos, const char * s, Env & env, Expr & expr)
|
2022-03-07 20:02:17 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(EvalError({
|
2022-03-07 20:02:17 +00:00
|
|
|
|
.msg = hintfmt(s),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2022-03-07 20:02:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwEvalError(const PosIdx pos, const char * s)
|
2022-03-07 20:02:17 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrowLastTrace(EvalError({
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.msg = hintfmt(s),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}));
|
2022-03-07 20:02:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwEvalError(const char * s, const std::string & s2)
|
2007-02-27 19:10:45 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrowLastTrace(EvalError(s, s2));
|
2007-02-27 19:10:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::throwEvalError(const PosIdx pos, const Suggestions & suggestions, const char * s,
|
2022-05-19 18:44:40 +00:00
|
|
|
|
const std::string & s2, Env & env, Expr & expr)
|
2022-02-10 23:01:49 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(EvalError(ErrorInfo{
|
2022-03-08 05:16:51 +00:00
|
|
|
|
.msg = hintfmt(s, s2),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos],
|
2022-03-08 05:16:51 +00:00
|
|
|
|
.suggestions = suggestions,
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2022-02-10 23:01:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2)
|
2014-04-04 20:19:33 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrowLastTrace(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(s, s2),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}));
|
2014-04-04 20:19:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2, Env & env, Expr & expr)
|
2010-04-09 12:00:49 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(EvalError({
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.msg = hintfmt(s, s2),
|
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2022-04-29 16:02:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void EvalState::throwEvalError(const char * s, const std::string & s2,
|
2022-05-19 18:44:40 +00:00
|
|
|
|
const std::string & s3)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrowLastTrace(EvalError({
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.msg = hintfmt(s, s2),
|
|
|
|
|
.errPos = positions[noPos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}));
|
2022-04-29 16:02:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2,
|
2022-05-19 18:44:40 +00:00
|
|
|
|
const std::string & s3)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrowLastTrace(EvalError({
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.msg = hintfmt(s, s2),
|
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}));
|
2010-04-09 12:00:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2,
|
2022-05-19 18:44:40 +00:00
|
|
|
|
const std::string & s3, Env & env, Expr & expr)
|
2010-04-09 12:00:49 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(EvalError({
|
2022-02-10 22:05:38 +00:00
|
|
|
|
.msg = hintfmt(s, s2),
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2010-04-09 12:00:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwEvalError(const PosIdx p1, const char * s, const Symbol sym, const PosIdx p2, Env & env, Expr & expr)
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
{
|
2020-05-12 16:52:26 +00:00
|
|
|
|
// p1 is where the error occurred; p2 is a position mentioned in the message.
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(EvalError({
|
2022-03-05 13:40:24 +00:00
|
|
|
|
.msg = hintfmt(s, symbols[sym], positions[p2]),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[p1]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwTypeError(const PosIdx pos, const char * s, const Value & v)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrowLastTrace(TypeError({
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.msg = hintfmt(s, showType(v)),
|
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}));
|
2022-04-29 16:02:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwTypeError(const PosIdx pos, const char * s, const Value & v, Env & env, Expr & expr)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(TypeError({
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.msg = hintfmt(s, showType(v)),
|
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2022-04-29 16:02:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwTypeError(const PosIdx pos, const char * s)
|
2014-04-04 20:19:33 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrowLastTrace(TypeError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(s),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}));
|
2021-05-11 00:36:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::throwTypeError(const PosIdx pos, const char * s, const ExprLambda & fun,
|
2022-05-19 18:44:40 +00:00
|
|
|
|
const Symbol s2, Env & env, Expr &expr)
|
2021-05-11 00:36:57 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(TypeError({
|
2022-03-05 13:40:24 +00:00
|
|
|
|
.msg = hintfmt(s, fun.showNamePos(*this), symbols[s2]),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2014-04-04 20:19:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::throwTypeError(const PosIdx pos, const Suggestions & suggestions, const char * s,
|
2022-05-19 18:44:40 +00:00
|
|
|
|
const ExprLambda & fun, const Symbol s2, Env & env, Expr &expr)
|
2013-11-07 17:04:36 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(TypeError(ErrorInfo {
|
2022-03-05 13:40:24 +00:00
|
|
|
|
.msg = hintfmt(s, fun.showNamePos(*this), symbols[s2]),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos],
|
2022-03-08 15:20:01 +00:00
|
|
|
|
.suggestions = suggestions,
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2013-11-07 17:04:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwTypeError(const char * s, const Value & v, Env & env, Expr &expr)
|
2022-02-03 23:31:33 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(TypeError({
|
2022-04-29 16:02:17 +00:00
|
|
|
|
.msg = hintfmt(s, showType(v)),
|
|
|
|
|
.errPos = positions[expr.getPos()],
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2022-02-03 23:31:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwAssertionError(const PosIdx pos, const char * s, const std::string & s1, Env & env, Expr &expr)
|
2010-04-09 12:00:49 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(AssertionError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(s, s1),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2010-04-09 12:00:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1, Env & env, Expr &expr)
|
2013-10-08 12:45:36 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(UndefinedVarError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(s, s1),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2013-10-08 12:45:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-19 18:44:40 +00:00
|
|
|
|
void EvalState::throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1, Env & env, Expr &expr)
|
2020-11-11 16:29:32 +00:00
|
|
|
|
{
|
2022-05-25 10:32:22 +00:00
|
|
|
|
debugThrow(MissingArgumentError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(s, s1),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-05-25 10:32:22 +00:00
|
|
|
|
}), env, expr);
|
2013-10-08 12:45:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-03-07 20:02:17 +00:00
|
|
|
|
void EvalState::addErrorTrace(Error & e, const char * s, const std::string & s2) const
|
2007-02-27 19:10:45 +00:00
|
|
|
|
{
|
2020-06-24 19:46:25 +00:00
|
|
|
|
e.addTrace(std::nullopt, s, s2);
|
2007-02-27 19:10:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::addErrorTrace(Error & e, const PosIdx pos, const char * s, const std::string & s2) const
|
2013-11-12 11:51:59 +00:00
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
|
e.addTrace(positions[pos], s, s2);
|
2010-05-07 12:11:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-05 10:29:14 +00:00
|
|
|
|
static std::unique_ptr<DebugTraceStacker> makeDebugTraceStacker(
|
|
|
|
|
EvalState & state,
|
|
|
|
|
Expr & expr,
|
|
|
|
|
Env & env,
|
|
|
|
|
std::optional<ErrPos> pos,
|
|
|
|
|
const char * s,
|
|
|
|
|
const std::string & s2)
|
2021-12-23 16:08:41 +00:00
|
|
|
|
{
|
2022-05-05 10:29:14 +00:00
|
|
|
|
return std::make_unique<DebugTraceStacker>(state,
|
|
|
|
|
DebugTrace {
|
|
|
|
|
.pos = pos,
|
|
|
|
|
.expr = expr,
|
|
|
|
|
.env = env,
|
|
|
|
|
.hint = hintfmt(s, s2),
|
|
|
|
|
.isError = false
|
|
|
|
|
});
|
2021-12-23 16:08:41 +00:00
|
|
|
|
}
|
2021-12-22 22:38:49 +00:00
|
|
|
|
|
2022-05-05 10:29:14 +00:00
|
|
|
|
DebugTraceStacker::DebugTraceStacker(EvalState & evalState, DebugTrace t)
|
|
|
|
|
: evalState(evalState)
|
|
|
|
|
, trace(std::move(t))
|
2022-01-08 18:03:48 +00:00
|
|
|
|
{
|
2022-05-05 10:29:14 +00:00
|
|
|
|
evalState.debugTraces.push_front(trace);
|
2022-05-23 03:45:24 +00:00
|
|
|
|
if (evalState.debugStop && evalState.debugRepl)
|
2022-05-20 16:33:50 +00:00
|
|
|
|
evalState.runDebugRepl(nullptr, trace.env, trace.expr);
|
2022-01-08 18:03:48 +00:00
|
|
|
|
}
|
2021-12-22 22:38:49 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
void Value::mkString(std::string_view s)
|
2010-03-30 18:05:54 +00:00
|
|
|
|
{
|
2022-02-27 11:50:18 +00:00
|
|
|
|
mkString(makeImmutableString(s));
|
2010-03-30 18:05:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
|
2021-12-27 01:04:49 +00:00
|
|
|
|
static void copyContextToValue(Value & v, const PathSet & context)
|
2010-03-30 18:05:54 +00:00
|
|
|
|
{
|
2010-03-31 19:52:29 +00:00
|
|
|
|
if (!context.empty()) {
|
2018-05-02 11:56:34 +00:00
|
|
|
|
size_t n = 0;
|
2010-10-28 12:50:01 +00:00
|
|
|
|
v.string.context = (const char * *)
|
2015-03-19 13:11:35 +00:00
|
|
|
|
allocBytes((context.size() + 1) * sizeof(char *));
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : context)
|
|
|
|
|
v.string.context[n++] = dupString(i.c_str());
|
2010-03-31 19:52:29 +00:00
|
|
|
|
v.string.context[n] = 0;
|
|
|
|
|
}
|
2010-03-30 18:05:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-12-27 01:04:49 +00:00
|
|
|
|
void Value::mkString(std::string_view s, const PathSet & context)
|
|
|
|
|
{
|
|
|
|
|
mkString(s);
|
|
|
|
|
copyContextToValue(*this, context);
|
|
|
|
|
}
|
2010-03-30 18:05:54 +00:00
|
|
|
|
|
2021-12-27 01:04:49 +00:00
|
|
|
|
void Value::mkStringMove(const char * s, const PathSet & context)
|
2010-03-30 18:05:54 +00:00
|
|
|
|
{
|
2021-12-27 01:04:49 +00:00
|
|
|
|
mkString(s);
|
|
|
|
|
copyContextToValue(*this, context);
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-30 18:05:54 +00:00
|
|
|
|
|
2022-01-04 17:45:16 +00:00
|
|
|
|
void Value::mkPath(std::string_view s)
|
2010-03-30 18:05:54 +00:00
|
|
|
|
{
|
2022-02-27 11:50:18 +00:00
|
|
|
|
mkPath(makeImmutableString(s));
|
2010-03-30 18:05:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-10-08 12:24:53 +00:00
|
|
|
|
inline Value * EvalState::lookupVar(Env * env, const ExprVar & var, bool noEval)
|
2010-03-29 14:37:56 +00:00
|
|
|
|
{
|
2020-02-24 13:33:01 +00:00
|
|
|
|
for (auto l = var.level; l; --l, env = env->up) ;
|
2013-07-31 10:44:21 +00:00
|
|
|
|
|
|
|
|
|
if (!var.fromWith) return env->values[var.displ];
|
|
|
|
|
|
|
|
|
|
while (1) {
|
2018-05-22 14:02:32 +00:00
|
|
|
|
if (env->type == Env::HasWithExpr) {
|
2013-07-31 10:44:21 +00:00
|
|
|
|
if (noEval) return 0;
|
2013-10-02 13:24:45 +00:00
|
|
|
|
Value * v = allocValue();
|
|
|
|
|
evalAttrs(*env->up, (Expr *) env->values[0], *v);
|
|
|
|
|
env->values[0] = v;
|
2018-05-22 14:02:32 +00:00
|
|
|
|
env->type = Env::HasWithAttrs;
|
2010-04-22 15:08:09 +00:00
|
|
|
|
}
|
2013-07-31 10:44:21 +00:00
|
|
|
|
Bindings::iterator j = env->values[0]->attrs->find(var.name);
|
|
|
|
|
if (j != env->values[0]->attrs->end()) {
|
2022-03-04 18:31:59 +00:00
|
|
|
|
if (countCalls) attrSelects[j->pos]++;
|
2013-07-31 10:44:21 +00:00
|
|
|
|
return j->value;
|
|
|
|
|
}
|
|
|
|
|
if (!env->prevWith)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwUndefinedVarError(var.pos, "undefined variable '%1%'", symbols[var.name], *env, const_cast<ExprVar&>(var));
|
2018-05-02 11:56:34 +00:00
|
|
|
|
for (size_t l = env->prevWith; l; --l, env = env->up) ;
|
2013-07-31 10:44:21 +00:00
|
|
|
|
}
|
2010-03-29 14:37:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-02 11:56:34 +00:00
|
|
|
|
void EvalState::mkList(Value & v, size_t size)
|
2010-03-30 14:39:27 +00:00
|
|
|
|
{
|
2020-12-18 13:38:49 +00:00
|
|
|
|
v.mkList(size);
|
|
|
|
|
if (size > 2)
|
|
|
|
|
v.bigList.elems = (Value * *) allocBytes(size * sizeof(Value *));
|
2015-07-23 20:05:09 +00:00
|
|
|
|
nrListElems += size;
|
2010-03-30 14:39:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-10-24 14:20:02 +00:00
|
|
|
|
unsigned long nrThunks = 0;
|
|
|
|
|
|
|
|
|
|
static inline void mkThunk(Value & v, Env & env, Expr * expr)
|
|
|
|
|
{
|
2020-12-18 13:38:49 +00:00
|
|
|
|
v.mkThunk(&env, expr);
|
2010-10-24 14:20:02 +00:00
|
|
|
|
nrThunks++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void EvalState::mkThunk_(Value & v, Expr * expr)
|
2010-04-07 15:47:06 +00:00
|
|
|
|
{
|
|
|
|
|
mkThunk(v, baseEnv, expr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::mkPos(Value & v, PosIdx p)
|
2013-11-18 21:22:35 +00:00
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
|
auto pos = positions[p];
|
2022-03-05 16:31:50 +00:00
|
|
|
|
if (!pos.file.empty()) {
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = buildBindings(3);
|
2022-03-04 18:31:59 +00:00
|
|
|
|
attrs.alloc(sFile).mkString(pos.file);
|
|
|
|
|
attrs.alloc(sLine).mkInt(pos.line);
|
|
|
|
|
attrs.alloc(sColumn).mkInt(pos.column);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
v.mkAttrs(attrs);
|
2013-11-18 21:22:35 +00:00
|
|
|
|
} else
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkNull();
|
2013-11-18 21:22:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-10-24 14:20:02 +00:00
|
|
|
|
/* 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. */
|
2012-01-04 21:24:11 +00:00
|
|
|
|
Value * Expr::maybeThunk(EvalState & state, Env & env)
|
|
|
|
|
{
|
|
|
|
|
Value * v = state.allocValue();
|
|
|
|
|
mkThunk(*v, env, this);
|
|
|
|
|
return v;
|
|
|
|
|
}
|
2010-10-24 14:20:02 +00:00
|
|
|
|
|
|
|
|
|
|
2012-01-04 21:24:11 +00:00
|
|
|
|
Value * ExprVar::maybeThunk(EvalState & state, Env & env)
|
|
|
|
|
{
|
2013-10-08 12:24:53 +00:00
|
|
|
|
Value * v = state.lookupVar(&env, *this, true);
|
2013-07-16 12:43:54 +00:00
|
|
|
|
/* The value might not be initialised in the environment yet.
|
|
|
|
|
In that case, ignore it. */
|
2021-07-21 22:31:08 +00:00
|
|
|
|
if (v) { state.nrAvoided++; return v; }
|
2012-01-04 21:24:11 +00:00
|
|
|
|
return Expr::maybeThunk(state, env);
|
2010-10-24 14:20:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
|
Value * ExprString::maybeThunk(EvalState & state, Env & env)
|
|
|
|
|
{
|
2021-07-21 22:31:08 +00:00
|
|
|
|
state.nrAvoided++;
|
2012-01-07 17:26:33 +00:00
|
|
|
|
return &v;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Value * ExprInt::maybeThunk(EvalState & state, Env & env)
|
|
|
|
|
{
|
2021-07-21 22:31:08 +00:00
|
|
|
|
state.nrAvoided++;
|
2012-01-07 17:26:33 +00:00
|
|
|
|
return &v;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-04 23:40:40 +00:00
|
|
|
|
Value * ExprFloat::maybeThunk(EvalState & state, Env & env)
|
|
|
|
|
{
|
2021-07-21 22:31:08 +00:00
|
|
|
|
state.nrAvoided++;
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return &v;
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-07 17:26:33 +00:00
|
|
|
|
Value * ExprPath::maybeThunk(EvalState & state, Env & env)
|
|
|
|
|
{
|
2021-07-21 22:31:08 +00:00
|
|
|
|
state.nrAvoided++;
|
2012-01-07 17:26:33 +00:00
|
|
|
|
return &v;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2019-09-09 15:34:38 +00:00
|
|
|
|
void EvalState::evalFile(const Path & path_, Value & v, bool mustBeTrivial)
|
2010-03-30 09:22:33 +00:00
|
|
|
|
{
|
2018-01-16 17:50:38 +00:00
|
|
|
|
auto path = checkSourcePath(path_);
|
|
|
|
|
|
2013-10-23 11:16:46 +00:00
|
|
|
|
FileEvalCache::iterator i;
|
|
|
|
|
if ((i = fileEvalCache.find(path)) != fileEvalCache.end()) {
|
|
|
|
|
v = i->second;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2013-09-03 10:56:33 +00:00
|
|
|
|
|
2021-09-13 12:41:28 +00:00
|
|
|
|
Path resolvedPath = resolveExprPath(path);
|
|
|
|
|
if ((i = fileEvalCache.find(resolvedPath)) != fileEvalCache.end()) {
|
2011-08-06 19:45:43 +00:00
|
|
|
|
v = i->second;
|
2013-09-03 10:56:33 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2021-09-13 12:41:28 +00:00
|
|
|
|
printTalkative("evaluating file '%1%'", resolvedPath);
|
2018-06-11 14:06:01 +00:00
|
|
|
|
Expr * e = nullptr;
|
|
|
|
|
|
2021-09-13 12:41:28 +00:00
|
|
|
|
auto j = fileParseCache.find(resolvedPath);
|
2018-06-11 14:06:01 +00:00
|
|
|
|
if (j != fileParseCache.end())
|
|
|
|
|
e = j->second;
|
|
|
|
|
|
|
|
|
|
if (!e)
|
2021-09-13 12:41:28 +00:00
|
|
|
|
e = parseExprFromFile(checkSourcePath(resolvedPath));
|
|
|
|
|
|
|
|
|
|
cacheFile(path, resolvedPath, e, v, mustBeTrivial);
|
|
|
|
|
}
|
2018-06-11 14:06:01 +00:00
|
|
|
|
|
2021-09-13 12:41:28 +00:00
|
|
|
|
|
|
|
|
|
void EvalState::resetFileCache()
|
|
|
|
|
{
|
|
|
|
|
fileEvalCache.clear();
|
|
|
|
|
fileParseCache.clear();
|
|
|
|
|
}
|
2018-06-11 14:06:01 +00:00
|
|
|
|
|
2021-12-22 22:38:49 +00:00
|
|
|
|
|
2021-09-13 12:41:28 +00:00
|
|
|
|
void EvalState::cacheFile(
|
|
|
|
|
const Path & path,
|
|
|
|
|
const Path & resolvedPath,
|
|
|
|
|
Expr * e,
|
|
|
|
|
Value & v,
|
|
|
|
|
bool mustBeTrivial)
|
|
|
|
|
{
|
|
|
|
|
fileParseCache[resolvedPath] = e;
|
2018-06-11 14:06:01 +00:00
|
|
|
|
|
2013-09-03 10:56:33 +00:00
|
|
|
|
try {
|
2022-05-23 03:45:24 +00:00
|
|
|
|
auto dts = debugRepl
|
2022-05-05 10:29:14 +00:00
|
|
|
|
? makeDebugTraceStacker(
|
|
|
|
|
*this,
|
|
|
|
|
*e,
|
|
|
|
|
this->baseEnv,
|
|
|
|
|
e->getPos() ? std::optional(ErrPos(positions[e->getPos()])) : std::nullopt,
|
|
|
|
|
"while evaluating the file '%1%':", resolvedPath)
|
|
|
|
|
: nullptr;
|
2021-12-22 22:38:49 +00:00
|
|
|
|
|
2019-09-09 15:34:38 +00:00
|
|
|
|
// Enforce that 'flake.nix' is a direct attrset, not a
|
|
|
|
|
// computation.
|
|
|
|
|
if (mustBeTrivial &&
|
|
|
|
|
!(dynamic_cast<ExprAttrs *>(e)))
|
2021-06-29 21:28:43 +00:00
|
|
|
|
throw EvalError("file '%s' must be an attribute set", path);
|
2013-09-03 10:56:33 +00:00
|
|
|
|
eval(e, v);
|
|
|
|
|
} catch (Error & e) {
|
2021-09-13 12:41:28 +00:00
|
|
|
|
addErrorTrace(e, "while evaluating the file '%1%':", resolvedPath);
|
2013-09-03 10:56:33 +00:00
|
|
|
|
throw;
|
|
|
|
|
}
|
2013-10-23 11:16:46 +00:00
|
|
|
|
|
2021-09-13 12:41:28 +00:00
|
|
|
|
fileEvalCache[resolvedPath] = v;
|
|
|
|
|
if (path != resolvedPath) fileEvalCache[path] = v;
|
2013-09-02 16:34:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void EvalState::eval(Expr * e, Value & v)
|
|
|
|
|
{
|
2012-02-04 13:50:25 +00:00
|
|
|
|
e->eval(*this, baseEnv, v);
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
2010-03-29 14:37:56 +00:00
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
|
2014-03-05 15:18:13 +00:00
|
|
|
|
inline bool EvalState::evalBool(Env & env, Expr * e)
|
2010-04-12 18:30:11 +00:00
|
|
|
|
{
|
2014-03-05 15:18:13 +00:00
|
|
|
|
Value v;
|
2012-02-04 13:50:25 +00:00
|
|
|
|
e->eval(*this, env, v);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nBool)
|
2022-02-15 22:46:45 +00:00
|
|
|
|
throwTypeError(noPos, "value is %1% while a Boolean was expected", v, env, *e);
|
2010-04-12 18:30:11 +00:00
|
|
|
|
return v.boolean;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
inline bool EvalState::evalBool(Env & env, Expr * e, const PosIdx pos)
|
2014-04-04 20:43:52 +00:00
|
|
|
|
{
|
|
|
|
|
Value v;
|
|
|
|
|
e->eval(*this, env, v);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nBool)
|
2022-02-15 22:46:45 +00:00
|
|
|
|
throwTypeError(pos, "value is %1% while a Boolean was expected", v, env, *e);
|
2014-04-04 20:43:52 +00:00
|
|
|
|
return v.boolean;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-02-04 13:50:25 +00:00
|
|
|
|
inline void EvalState::evalAttrs(Env & env, Expr * e, Value & v)
|
2010-04-16 15:13:47 +00:00
|
|
|
|
{
|
2012-02-04 13:50:25 +00:00
|
|
|
|
e->eval(*this, env, v);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nAttrs)
|
2022-02-15 22:46:45 +00:00
|
|
|
|
throwTypeError(noPos, "value is %1% while a set was expected", v, env, *e);
|
2010-04-16 15:13:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 22:03:27 +00:00
|
|
|
|
void Expr::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
|
|
|
|
abort();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprInt::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2012-01-07 17:26:33 +00:00
|
|
|
|
v = this->v;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2016-01-04 23:40:40 +00:00
|
|
|
|
void ExprFloat::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
|
|
|
|
v = this->v;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprString::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2012-01-07 17:26:33 +00:00
|
|
|
|
v = this->v;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprPath::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2012-01-07 17:26:33 +00:00
|
|
|
|
v = this->v;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2022-01-04 19:29:17 +00:00
|
|
|
|
v.mkAttrs(state.buildBindings(attrs.size() + dynamicAttrs.size()).finish());
|
|
|
|
|
auto dynamicEnv = &env;
|
2010-04-14 23:25:05 +00:00
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
if (recursive) {
|
|
|
|
|
/* Create a new environment that contains the attributes in
|
|
|
|
|
this `rec'. */
|
2010-10-24 19:52:33 +00:00
|
|
|
|
Env & env2(state.allocEnv(attrs.size()));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
env2.up = &env;
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
dynamicEnv = &env2;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
|
2010-10-24 19:52:33 +00:00
|
|
|
|
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. */
|
2020-02-24 13:33:01 +00:00
|
|
|
|
Displacement displ = 0;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : attrs) {
|
2013-07-15 21:10:18 +00:00
|
|
|
|
Value * vAttr;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
if (hasOverrides && !i.second.inherited) {
|
2013-07-15 21:10:18 +00:00
|
|
|
|
vAttr = state.allocValue();
|
2015-07-17 17:24:28 +00:00
|
|
|
|
mkThunk(*vAttr, env2, i.second.e);
|
2013-07-15 21:10:18 +00:00
|
|
|
|
} else
|
2015-07-17 17:24:28 +00:00
|
|
|
|
vAttr = i.second.e->maybeThunk(state, i.second.inherited ? env : env2);
|
2013-07-15 21:10:18 +00:00
|
|
|
|
env2.values[displ++] = vAttr;
|
2022-03-04 18:31:59 +00:00
|
|
|
|
v.attrs->push_back(Attr(i.first, vAttr, i.second.pos));
|
2013-07-15 21:10:18 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-05-15 08:10:12 +00:00
|
|
|
|
/* 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.) */
|
2010-10-24 19:52:33 +00:00
|
|
|
|
if (hasOverrides) {
|
|
|
|
|
Value * vOverrides = (*v.attrs)[overrides->second.displ].value;
|
2022-02-03 23:31:33 +00:00
|
|
|
|
state.forceAttrs(*vOverrides, [&]() { return vOverrides->determinePos(noPos); });
|
2019-11-25 12:37:14 +00:00
|
|
|
|
Bindings * newBnds = state.allocBindings(v.attrs->capacity() + vOverrides->attrs->size());
|
2014-09-19 14:49:41 +00:00
|
|
|
|
for (auto & i : *v.attrs)
|
|
|
|
|
newBnds->push_back(i);
|
|
|
|
|
for (auto & i : *vOverrides->attrs) {
|
|
|
|
|
AttrDefs::iterator j = attrs.find(i.name);
|
2010-10-24 19:52:33 +00:00
|
|
|
|
if (j != attrs.end()) {
|
2014-09-19 14:49:41 +00:00
|
|
|
|
(*newBnds)[j->second.displ] = i;
|
|
|
|
|
env2.values[j->second.displ] = i.value;
|
2010-10-24 19:52:33 +00:00
|
|
|
|
} else
|
2014-09-19 14:49:41 +00:00
|
|
|
|
newBnds->push_back(i);
|
2010-05-15 08:10:12 +00:00
|
|
|
|
}
|
2014-09-19 14:49:41 +00:00
|
|
|
|
newBnds->sort();
|
|
|
|
|
v.attrs = newBnds;
|
2010-05-15 08:10:12 +00:00
|
|
|
|
}
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
else
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : attrs)
|
2022-03-04 18:31:59 +00:00
|
|
|
|
v.attrs->push_back(Attr(i.first, i.second.e->maybeThunk(state, env), i.second.pos));
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
|
2014-04-04 20:19:33 +00:00
|
|
|
|
/* Dynamic attrs apply *after* rec and __overrides. */
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : dynamicAttrs) {
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
Value nameVal;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
i.nameExpr->eval(state, *dynamicEnv, nameVal);
|
2015-07-31 15:32:25 +00:00
|
|
|
|
state.forceValue(nameVal, i.pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (nameVal.type() == nNull)
|
2014-10-04 23:04:58 +00:00
|
|
|
|
continue;
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
state.forceStringNoCtx(nameVal);
|
2022-03-05 13:40:24 +00:00
|
|
|
|
auto nameSym = state.symbols.create(nameVal.string.s);
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
Bindings::iterator j = v.attrs->find(nameSym);
|
|
|
|
|
if (j != v.attrs->end())
|
2022-04-28 18:32:57 +00:00
|
|
|
|
state.throwEvalError(i.pos, "dynamic attribute '%1%' already defined at %2%", nameSym, j->pos, env, *this);
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
i.valueExpr->setName(nameSym);
|
Dynamic attrs
This adds new syntax for attribute names:
* attrs."${name}" => getAttr name attrs
* attrs ? "${name}" => isAttrs attrs && hasAttr attrs name
* attrs."${name}" or def => if attrs ? "${name}" then attrs."${name}" else def
* { "${name}" = value; } => listToAttrs [{ inherit name value; }]
Of course, it's a bit more complicated than that. The attribute chains
can be arbitrarily long and contain combinations of static and dynamic
parts (e.g. attrs."${foo}".bar."${baz}" or qux), which is relatively
straightforward for the getAttrs/hasAttrs cases but is more complex for
the listToAttrs case due to rules about duplicate attribute definitions.
For attribute sets with dynamic attribute names, duplicate static
attributes are detected at parse time while duplicate dynamic attributes
are detected when the attribute set is forced. So, for example, { a =
null; a.b = null; "${"c"}" = true; } will be a parse-time error, while
{ a = {}; "${"a"}".b = null; c = true; } will be an eval-time error
(technically that case could theoretically be detected at parse time,
but the general case would require full evaluation). Moreover, duplicate
dynamic attributes are not allowed even in cases where they would be
with static attributes ({ a.b.d = true; a.b.c = false; } is legal, but {
a."${"b"}".d = true; a."${"b"}".c = false; } is not). This restriction
might be relaxed in the future in cases where the static variant would
not be an error, but it is not obvious that that is desirable.
Finally, recursive attribute sets with dynamic attributes have the
static attributes in scope but not the dynamic ones. So rec { a = true;
"${"b"}" = a; } is equivalent to { a = true; b = true; } but rec {
"${"a"}" = true; b = a; } would be an error or use a from the
surrounding scope if it exists.
Note that the getAttr, getAttr or default, and hasAttr are all
implemented purely in the parser as syntactic sugar, while attribute
sets with dynamic attribute names required changes to the AST to be
implemented cleanly.
This is an alternative solution to and closes #167
Signed-off-by: Shea Levy <shea@shealevy.com>
2013-09-21 03:25:30 +00:00
|
|
|
|
/* Keep sorted order so find can catch duplicates */
|
2022-03-04 18:31:59 +00:00
|
|
|
|
v.attrs->push_back(Attr(nameSym, i.valueExpr->maybeThunk(state, *dynamicEnv), i.pos));
|
2014-09-19 14:49:41 +00:00
|
|
|
|
v.attrs->sort(); // FIXME: inefficient
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
2021-01-08 21:27:00 +00:00
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
v.attrs->pos = pos;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-13 13:42:25 +00:00
|
|
|
|
void ExprLet::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
|
|
|
|
/* Create a new environment that contains the attributes in this
|
|
|
|
|
`let'. */
|
2010-10-24 19:52:33 +00:00
|
|
|
|
Env & env2(state.allocEnv(attrs->attrs.size()));
|
2010-04-13 13:42:25 +00:00
|
|
|
|
env2.up = &env;
|
2010-04-14 14:42:32 +00:00
|
|
|
|
|
2010-10-24 19:52:33 +00:00
|
|
|
|
/* The recursive attributes are evaluated in the new environment,
|
|
|
|
|
while the inherited attributes are evaluated in the original
|
2010-04-13 13:42:25 +00:00
|
|
|
|
environment. */
|
2020-02-24 13:33:01 +00:00
|
|
|
|
Displacement displ = 0;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : attrs->attrs)
|
|
|
|
|
env2.values[displ++] = i.second.e->maybeThunk(state, i.second.inherited ? env : env2);
|
2010-04-13 13:42:25 +00:00
|
|
|
|
|
2012-02-04 13:50:25 +00:00
|
|
|
|
body->eval(state, env2, v);
|
2010-04-13 13:42:25 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprList::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.mkList(v, elems.size());
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto [n, v2] : enumerate(v.listItems()))
|
|
|
|
|
const_cast<Value * &>(v2) = elems[n]->maybeThunk(state, env);
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprVar::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2013-10-08 12:24:53 +00:00
|
|
|
|
Value * v2 = state.lookupVar(&env, *this, false);
|
2015-07-31 15:32:25 +00:00
|
|
|
|
state.forceValue(*v2, pos);
|
2010-04-14 15:14:23 +00:00
|
|
|
|
v = *v2;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
static std::string showAttrPath(EvalState & state, Env & env, const AttrPath & attrPath)
|
2015-03-06 13:24:08 +00:00
|
|
|
|
{
|
|
|
|
|
std::ostringstream out;
|
|
|
|
|
bool first = true;
|
|
|
|
|
for (auto & i : attrPath) {
|
|
|
|
|
if (!first) out << '.'; else first = false;
|
|
|
|
|
try {
|
2022-03-05 13:40:24 +00:00
|
|
|
|
out << state.symbols[getName(i, state, env)];
|
2015-03-06 13:24:08 +00:00
|
|
|
|
} catch (Error & e) {
|
2022-03-05 13:40:24 +00:00
|
|
|
|
assert(!i.symbol);
|
|
|
|
|
out << "\"${";
|
|
|
|
|
i.expr->show(state.symbols, out);
|
|
|
|
|
out << "}\"";
|
2015-03-06 13:24:08 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return out.str();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprSelect::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2011-07-06 12:28:57 +00:00
|
|
|
|
Value vTmp;
|
2022-03-04 18:31:59 +00:00
|
|
|
|
PosIdx pos2;
|
2011-07-06 12:28:57 +00:00
|
|
|
|
Value * vAttrs = &vTmp;
|
|
|
|
|
|
2012-02-04 13:50:25 +00:00
|
|
|
|
e->eval(state, env, vTmp);
|
2011-07-06 12:28:57 +00:00
|
|
|
|
|
|
|
|
|
try {
|
2022-05-23 03:45:24 +00:00
|
|
|
|
auto dts = state.debugRepl
|
2022-05-05 10:29:14 +00:00
|
|
|
|
? makeDebugTraceStacker(
|
|
|
|
|
state,
|
|
|
|
|
*this,
|
|
|
|
|
env,
|
|
|
|
|
state.positions[pos2],
|
|
|
|
|
"while evaluating the attribute '%1%'",
|
|
|
|
|
showAttrPath(state, env, attrPath))
|
2022-04-08 21:46:12 +00:00
|
|
|
|
: nullptr;
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : attrPath) {
|
2021-07-21 22:31:08 +00:00
|
|
|
|
state.nrLookups++;
|
2011-07-06 12:28:57 +00:00
|
|
|
|
Bindings::iterator j;
|
2022-03-05 13:40:24 +00:00
|
|
|
|
auto name = getName(i, state, env);
|
2011-07-13 12:19:57 +00:00
|
|
|
|
if (def) {
|
2015-07-31 15:32:25 +00:00
|
|
|
|
state.forceValue(*vAttrs, pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (vAttrs->type() != nAttrs ||
|
2013-12-31 23:56:26 +00:00
|
|
|
|
(j = vAttrs->attrs->find(name)) == vAttrs->attrs->end())
|
2011-07-13 12:19:57 +00:00
|
|
|
|
{
|
2012-02-04 13:50:25 +00:00
|
|
|
|
def->eval(state, env, v);
|
2011-07-13 12:19:57 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2014-04-04 20:52:14 +00:00
|
|
|
|
state.forceAttrs(*vAttrs, pos);
|
2022-03-08 05:16:51 +00:00
|
|
|
|
if ((j = vAttrs->attrs->find(name)) == vAttrs->attrs->end()) {
|
|
|
|
|
std::set<std::string> allAttrNames;
|
|
|
|
|
for (auto & attr : *vAttrs->attrs)
|
2022-03-05 13:40:24 +00:00
|
|
|
|
allAttrNames.insert(state.symbols[attr.name]);
|
2022-03-07 20:02:17 +00:00
|
|
|
|
state.throwEvalError(
|
2022-03-08 05:16:51 +00:00
|
|
|
|
pos,
|
2022-03-05 13:40:24 +00:00
|
|
|
|
Suggestions::bestMatches(allAttrNames, state.symbols[name]),
|
2022-04-28 18:32:57 +00:00
|
|
|
|
"attribute '%1%' missing", state.symbols[name], env, *this);
|
2022-03-08 05:16:51 +00:00
|
|
|
|
}
|
2011-07-13 12:19:57 +00:00
|
|
|
|
}
|
2011-07-06 12:28:57 +00:00
|
|
|
|
vAttrs = j->value;
|
2014-04-04 20:52:14 +00:00
|
|
|
|
pos2 = j->pos;
|
2022-03-04 18:31:59 +00:00
|
|
|
|
if (state.countCalls) state.attrSelects[pos2]++;
|
2011-07-06 12:28:57 +00:00
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
state.forceValue(*vAttrs, (pos2 ? pos2 : this->pos ) );
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
} catch (Error & e) {
|
2022-03-04 18:31:59 +00:00
|
|
|
|
auto pos2r = state.positions[pos2];
|
2022-03-05 16:31:50 +00:00
|
|
|
|
if (pos2 && pos2r.file != state.derivationNixPath)
|
2022-03-04 18:31:59 +00:00
|
|
|
|
state.addErrorTrace(e, pos2, "while evaluating the attribute '%1%'",
|
2020-06-19 19:44:08 +00:00
|
|
|
|
showAttrPath(state, env, attrPath));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
throw;
|
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2011-07-06 12:28:57 +00:00
|
|
|
|
v = *vAttrs;
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
|
void ExprOpHasAttr::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2011-07-06 10:58:17 +00:00
|
|
|
|
Value vTmp;
|
|
|
|
|
Value * vAttrs = &vTmp;
|
|
|
|
|
|
2012-02-04 13:50:25 +00:00
|
|
|
|
e->eval(state, env, vTmp);
|
2011-07-06 10:58:17 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : attrPath) {
|
2022-01-21 16:44:19 +00:00
|
|
|
|
state.forceValue(*vAttrs, noPos);
|
2011-07-06 10:58:17 +00:00
|
|
|
|
Bindings::iterator j;
|
2022-03-05 13:40:24 +00:00
|
|
|
|
auto name = getName(i, state, env);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (vAttrs->type() != nAttrs ||
|
2013-12-31 23:56:26 +00:00
|
|
|
|
(j = vAttrs->attrs->find(name)) == vAttrs->attrs->end())
|
2011-07-06 10:58:17 +00:00
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(false);
|
2011-07-06 10:58:17 +00:00
|
|
|
|
return;
|
|
|
|
|
} else {
|
|
|
|
|
vAttrs = j->value;
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(true);
|
2010-04-12 21:21:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprLambda::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2020-12-18 13:38:49 +00:00
|
|
|
|
v.mkLambda(&env, this);
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const PosIdx pos)
|
2010-04-12 18:30:11 +00:00
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
|
auto trace = evalSettings.traceFunctionCalls
|
|
|
|
|
? std::make_unique<FunctionCallTrace>(positions[pos])
|
|
|
|
|
: nullptr;
|
2013-11-07 17:04:36 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
forceValue(fun, pos);
|
2013-11-07 17:04:36 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
Value vCur(fun);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
auto makeAppChain = [&]()
|
|
|
|
|
{
|
|
|
|
|
vRes = vCur;
|
|
|
|
|
for (size_t i = 0; i < nrArgs; ++i) {
|
|
|
|
|
auto fun2 = allocValue();
|
|
|
|
|
*fun2 = vRes;
|
|
|
|
|
vRes.mkPrimOpApp(fun2, args[i]);
|
|
|
|
|
}
|
|
|
|
|
};
|
2020-08-05 19:26:17 +00:00
|
|
|
|
|
2021-11-16 16:44:19 +00:00
|
|
|
|
Attr * functor;
|
2019-04-12 16:31:33 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
while (nrArgs > 0) {
|
2018-07-06 21:49:51 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
if (vCur.isLambda()) {
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
ExprLambda & lambda(*vCur.lambda.fun);
|
2014-10-16 02:04:48 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
auto size =
|
2022-03-05 13:40:24 +00:00
|
|
|
|
(!lambda.arg ? 0 : 1) +
|
2020-02-24 00:32:01 +00:00
|
|
|
|
(lambda.hasFormals() ? lambda.formals->formals.size() : 0);
|
|
|
|
|
Env & env2(allocEnv(size));
|
|
|
|
|
env2.up = vCur.lambda.env;
|
2010-03-30 13:47:59 +00:00
|
|
|
|
|
2020-02-24 13:33:01 +00:00
|
|
|
|
Displacement displ = 0;
|
2013-11-12 11:51:59 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
if (!lambda.hasFormals())
|
|
|
|
|
env2.values[displ++] = args[0];
|
|
|
|
|
else {
|
|
|
|
|
forceAttrs(*args[0], pos);
|
2010-03-30 13:47:59 +00:00
|
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
|
if (lambda.arg)
|
2020-02-24 00:32:01 +00:00
|
|
|
|
env2.values[displ++] = args[0];
|
2010-04-14 14:42:32 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
/* 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. */
|
|
|
|
|
size_t attrsUsed = 0;
|
|
|
|
|
for (auto & i : lambda.formals->formals) {
|
|
|
|
|
auto j = args[0]->attrs->get(i.name);
|
|
|
|
|
if (!j) {
|
|
|
|
|
if (!i.def) throwTypeError(pos, "%1% called without required argument '%2%'",
|
2022-02-15 22:46:45 +00:00
|
|
|
|
lambda, i.name, *fun.lambda.env, lambda);
|
2020-02-24 00:32:01 +00:00
|
|
|
|
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 != args[0]->attrs->size()) {
|
|
|
|
|
/* Nope, so show the first unexpected argument to the
|
|
|
|
|
user. */
|
|
|
|
|
for (auto & i : *args[0]->attrs)
|
2022-03-08 15:20:01 +00:00
|
|
|
|
if (!lambda.formals->has(i.name)) {
|
|
|
|
|
std::set<std::string> formalNames;
|
|
|
|
|
for (auto & formal : lambda.formals->formals)
|
2022-03-05 13:40:24 +00:00
|
|
|
|
formalNames.insert(symbols[formal.name]);
|
2022-03-08 15:20:01 +00:00
|
|
|
|
throwTypeError(
|
|
|
|
|
pos,
|
2022-03-05 13:40:24 +00:00
|
|
|
|
Suggestions::bestMatches(formalNames, symbols[i.name]),
|
2022-03-08 15:20:01 +00:00
|
|
|
|
"%1% called with unexpected argument '%2%'",
|
2022-02-15 22:46:45 +00:00
|
|
|
|
lambda, i.name, *fun.lambda.env, lambda);
|
2022-03-08 15:20:01 +00:00
|
|
|
|
}
|
2020-02-24 00:32:01 +00:00
|
|
|
|
abort(); // can't happen
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-04-14 14:42:32 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
nrFunctionCalls++;
|
|
|
|
|
if (countCalls) incrFunctionCall(&lambda);
|
|
|
|
|
|
|
|
|
|
/* Evaluate the body. */
|
|
|
|
|
try {
|
2022-05-23 03:45:24 +00:00
|
|
|
|
auto dts = debugRepl
|
2022-05-05 10:29:14 +00:00
|
|
|
|
? makeDebugTraceStacker(
|
|
|
|
|
*this, *lambda.body, env2, positions[lambda.pos],
|
|
|
|
|
"while evaluating %s",
|
|
|
|
|
lambda.name
|
|
|
|
|
? concatStrings("'", symbols[lambda.name], "'")
|
|
|
|
|
: "anonymous lambda")
|
|
|
|
|
: nullptr;
|
2021-12-23 02:40:08 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
lambda.body->eval(*this, env2, vCur);
|
|
|
|
|
} catch (Error & e) {
|
|
|
|
|
if (loggerSettings.showTrace.get()) {
|
|
|
|
|
addErrorTrace(e, lambda.pos, "while evaluating %s",
|
2022-03-05 13:40:24 +00:00
|
|
|
|
(lambda.name
|
|
|
|
|
? concatStrings("'", symbols[lambda.name], "'")
|
2020-02-24 00:32:01 +00:00
|
|
|
|
: "anonymous lambda"));
|
|
|
|
|
addErrorTrace(e, pos, "from call site%s", "");
|
|
|
|
|
}
|
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
nrArgs--;
|
|
|
|
|
args += 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else if (vCur.isPrimOp()) {
|
|
|
|
|
|
|
|
|
|
size_t argsLeft = vCur.primOp->arity;
|
|
|
|
|
|
|
|
|
|
if (nrArgs < argsLeft) {
|
|
|
|
|
/* We don't have enough arguments, so create a tPrimOpApp chain. */
|
|
|
|
|
makeAppChain();
|
|
|
|
|
return;
|
2021-08-25 19:18:27 +00:00
|
|
|
|
} else {
|
2020-02-24 00:32:01 +00:00
|
|
|
|
/* We have all the arguments, so call the primop. */
|
|
|
|
|
nrPrimOpCalls++;
|
|
|
|
|
if (countCalls) primOpCalls[vCur.primOp->name]++;
|
|
|
|
|
vCur.primOp->fun(*this, pos, args, vCur);
|
|
|
|
|
|
|
|
|
|
nrArgs -= argsLeft;
|
|
|
|
|
args += argsLeft;
|
2021-08-06 17:09:27 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-30 13:47:59 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
else if (vCur.isPrimOpApp()) {
|
|
|
|
|
/* Figure out the number of arguments still needed. */
|
|
|
|
|
size_t argsDone = 0;
|
|
|
|
|
Value * primOp = &vCur;
|
|
|
|
|
while (primOp->isPrimOpApp()) {
|
|
|
|
|
argsDone++;
|
|
|
|
|
primOp = primOp->primOpApp.left;
|
|
|
|
|
}
|
|
|
|
|
assert(primOp->isPrimOp());
|
|
|
|
|
auto arity = primOp->primOp->arity;
|
|
|
|
|
auto argsLeft = arity - argsDone;
|
|
|
|
|
|
|
|
|
|
if (nrArgs < argsLeft) {
|
|
|
|
|
/* We still don't have enough arguments, so extend the tPrimOpApp chain. */
|
|
|
|
|
makeAppChain();
|
|
|
|
|
return;
|
|
|
|
|
} else {
|
|
|
|
|
/* We have all the arguments, so call the primop with
|
|
|
|
|
the previous and new arguments. */
|
|
|
|
|
|
|
|
|
|
Value * vArgs[arity];
|
|
|
|
|
auto n = argsDone;
|
|
|
|
|
for (Value * arg = &vCur; arg->isPrimOpApp(); arg = arg->primOpApp.left)
|
|
|
|
|
vArgs[--n] = arg->primOpApp.right;
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < argsLeft; ++i)
|
|
|
|
|
vArgs[argsDone + i] = args[i];
|
|
|
|
|
|
|
|
|
|
nrPrimOpCalls++;
|
|
|
|
|
if (countCalls) primOpCalls[primOp->primOp->name]++;
|
|
|
|
|
primOp->primOp->fun(*this, pos, vArgs, vCur);
|
|
|
|
|
|
|
|
|
|
nrArgs -= argsLeft;
|
|
|
|
|
args += argsLeft;
|
|
|
|
|
}
|
2013-05-16 15:56:14 +00:00
|
|
|
|
}
|
2021-08-25 19:18:27 +00:00
|
|
|
|
|
2021-11-16 16:44:19 +00:00
|
|
|
|
else if (vCur.type() == nAttrs && (functor = vCur.attrs->get(sFunctor))) {
|
2021-11-16 21:34:17 +00:00
|
|
|
|
/* 'vCur' may be allocated on the stack of the calling
|
2021-11-16 16:44:19 +00:00
|
|
|
|
function, but for functors we may keep a reference, so
|
|
|
|
|
heap-allocate a copy and use that instead. */
|
2021-11-16 21:34:17 +00:00
|
|
|
|
Value * args2[] = {allocValue(), args[0]};
|
2021-11-16 16:44:19 +00:00
|
|
|
|
*args2[0] = vCur;
|
|
|
|
|
/* !!! Should we use the attr pos here? */
|
2021-11-16 21:34:17 +00:00
|
|
|
|
callFunction(*functor->value, 2, args2, vCur, pos);
|
|
|
|
|
nrArgs--;
|
|
|
|
|
args++;
|
2013-05-16 15:56:14 +00:00
|
|
|
|
}
|
2020-02-24 00:32:01 +00:00
|
|
|
|
|
|
|
|
|
else
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "attempt to call something which is not a function but %1%", vCur);
|
2010-03-30 13:47:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
vRes = vCur;
|
|
|
|
|
}
|
2013-11-12 11:51:59 +00:00
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
|
|
|
|
|
|
void ExprCall::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
|
|
|
|
Value vFun;
|
|
|
|
|
fun->eval(state, env, vFun);
|
|
|
|
|
|
|
|
|
|
Value * vArgs[args.size()];
|
|
|
|
|
for (size_t i = 0; i < args.size(); ++i)
|
|
|
|
|
vArgs[i] = args[i]->maybeThunk(state, env);
|
|
|
|
|
|
|
|
|
|
state.callFunction(vFun, args.size(), vArgs, v, pos);
|
2013-11-07 17:04:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Lifted out of callFunction() because it creates a temporary that
|
|
|
|
|
// prevents tail-call optimisation.
|
|
|
|
|
void EvalState::incrFunctionCall(ExprLambda * fun)
|
|
|
|
|
{
|
|
|
|
|
functionCalls[fun]++;
|
2010-03-30 13:47:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-10-22 14:47:42 +00:00
|
|
|
|
void EvalState::autoCallFunction(Bindings & args, Value & fun, Value & res)
|
2010-04-07 15:47:06 +00:00
|
|
|
|
{
|
2022-02-03 23:31:33 +00:00
|
|
|
|
auto pos = fun.determinePos(noPos);
|
|
|
|
|
|
2021-11-27 17:40:24 +00:00
|
|
|
|
forceValue(fun, pos);
|
2010-04-07 15:47:06 +00:00
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (fun.type() == nAttrs) {
|
2015-11-25 16:56:14 +00:00
|
|
|
|
auto found = fun.attrs->find(sFunctor);
|
|
|
|
|
if (found != fun.attrs->end()) {
|
|
|
|
|
Value * v = allocValue();
|
2021-11-27 17:40:24 +00:00
|
|
|
|
callFunction(*found->value, fun, *v, pos);
|
|
|
|
|
forceValue(*v, pos);
|
2015-11-25 16:56:14 +00:00
|
|
|
|
return autoCallFunction(args, *v, res);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-10-06 15:08:08 +00:00
|
|
|
|
if (!fun.isLambda() || !fun.lambda.fun->hasFormals()) {
|
2010-04-07 15:47:06 +00:00
|
|
|
|
res = fun;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = buildBindings(std::max(static_cast<uint32_t>(fun.lambda.fun->formals->formals.size()), args.size()));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
|
2020-08-27 16:28:12 +00:00
|
|
|
|
if (fun.lambda.fun->formals->ellipsis) {
|
|
|
|
|
// If the formals have an ellipsis (eg the function accepts extra args) pass
|
|
|
|
|
// all available automatic arguments (which includes arguments specified on
|
|
|
|
|
// the command line via --arg/--argstr)
|
2022-01-04 16:39:16 +00:00
|
|
|
|
for (auto & v : args)
|
|
|
|
|
attrs.insert(v);
|
2020-08-27 16:28:12 +00:00
|
|
|
|
} else {
|
|
|
|
|
// Otherwise, only pass the arguments that the function accepts
|
|
|
|
|
for (auto & i : fun.lambda.fun->formals->formals) {
|
|
|
|
|
Bindings::iterator j = args.find(i.name);
|
|
|
|
|
if (j != args.end()) {
|
2022-01-04 16:39:16 +00:00
|
|
|
|
attrs.insert(*j);
|
2020-08-27 16:28:12 +00:00
|
|
|
|
} else if (!i.def) {
|
2021-06-09 00:37:28 +00:00
|
|
|
|
throwMissingArgumentError(i.pos, R"(cannot evaluate a function that has an argument without a value ('%1%')
|
2020-11-11 18:05:21 +00:00
|
|
|
|
|
2021-02-22 14:24:14 +00:00
|
|
|
|
Nix attempted to evaluate a function as a top level expression; in
|
|
|
|
|
this case it must have its arguments supplied either by default
|
|
|
|
|
values, or passed explicitly with '--arg' or '--argstr'. See
|
2022-05-09 15:30:44 +00:00
|
|
|
|
https://nixos.org/manual/nix/stable/expressions/language-constructs.html#functions.)", symbols[i.name],
|
2022-02-15 22:46:45 +00:00
|
|
|
|
*fun.lambda.env, *fun.lambda.fun);
|
2020-08-27 16:28:12 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2010-04-07 15:47:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
callFunction(fun, allocValue()->mkAttrs(attrs), res, noPos);
|
2010-04-07 15:47:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprWith::eval(EvalState & state, Env & env, Value & v)
|
2010-03-29 14:37:56 +00:00
|
|
|
|
{
|
2010-04-14 15:01:04 +00:00
|
|
|
|
Env & env2(state.allocEnv(1));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
env2.up = &env;
|
2010-04-22 15:08:09 +00:00
|
|
|
|
env2.prevWith = prevWith;
|
2018-05-22 14:02:32 +00:00
|
|
|
|
env2.type = Env::HasWithExpr;
|
2021-10-22 20:34:50 +00:00
|
|
|
|
env2.values[0] = (Value *) attrs;
|
2021-11-09 20:14:49 +00:00
|
|
|
|
|
2012-02-04 13:50:25 +00:00
|
|
|
|
body->eval(state, env2, v);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprIf::eval(EvalState & state, Env & env, Value & v)
|
2010-03-29 14:37:56 +00:00
|
|
|
|
{
|
2020-04-09 07:45:15 +00:00
|
|
|
|
(state.evalBool(env, cond, pos) ? then : else_)->eval(state, env, v);
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
|
void ExprAssert::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2020-01-11 14:06:57 +00:00
|
|
|
|
if (!state.evalBool(env, cond, pos)) {
|
|
|
|
|
std::ostringstream out;
|
2022-03-05 13:40:24 +00:00
|
|
|
|
cond->show(state.symbols, out);
|
2022-04-28 18:32:57 +00:00
|
|
|
|
state.throwAssertionError(pos, "assertion '%1%' failed", out.str(), env, *this);
|
2020-01-11 14:06:57 +00:00
|
|
|
|
}
|
2012-02-04 13:50:25 +00:00
|
|
|
|
body->eval(state, env, v);
|
2010-04-12 21:21:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
|
void ExprOpNot::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(!state.evalBool(env, e));
|
2010-04-12 21:21:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
|
void ExprOpEq::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2012-02-04 13:50:25 +00:00
|
|
|
|
Value v1; e1->eval(state, env, v1);
|
|
|
|
|
Value v2; e2->eval(state, env, v2);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(state.eqValues(v1, v2));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprOpNEq::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2012-02-04 13:50:25 +00:00
|
|
|
|
Value v1; e1->eval(state, env, v1);
|
|
|
|
|
Value v2; e2->eval(state, env, v2);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(!state.eqValues(v1, v2));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprOpAnd::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(state.evalBool(env, e1, pos) && state.evalBool(env, e2, pos));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprOpOr::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(state.evalBool(env, e1, pos) || state.evalBool(env, e2, pos));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprOpImpl::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(!state.evalBool(env, e1, pos) || state.evalBool(env, e2, pos));
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprOpUpdate::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2010-08-02 16:31:05 +00:00
|
|
|
|
Value v1, v2;
|
|
|
|
|
state.evalAttrs(env, e1, v1);
|
2010-04-16 15:13:47 +00:00
|
|
|
|
state.evalAttrs(env, e2, v2);
|
2010-08-02 16:31:05 +00:00
|
|
|
|
|
2010-10-20 15:48:00 +00:00
|
|
|
|
state.nrOpUpdates++;
|
|
|
|
|
|
2010-08-02 16:31:05 +00:00
|
|
|
|
if (v1.attrs->size() == 0) { v = v2; return; }
|
|
|
|
|
if (v2.attrs->size() == 0) { v = v1; return; }
|
|
|
|
|
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto attrs = state.buildBindings(v1.attrs->size() + v2.attrs->size());
|
2010-10-24 19:52:33 +00:00
|
|
|
|
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* Merge the sets, preferring values from the second set. Make
|
|
|
|
|
sure to keep the resulting vector in sorted order. */
|
2010-10-24 19:52:33 +00:00
|
|
|
|
Bindings::iterator i = v1.attrs->begin();
|
|
|
|
|
Bindings::iterator j = v2.attrs->begin();
|
2010-08-02 16:31:05 +00:00
|
|
|
|
|
2010-10-24 19:52:33 +00:00
|
|
|
|
while (i != v1.attrs->end() && j != v2.attrs->end()) {
|
|
|
|
|
if (i->name == j->name) {
|
2022-01-04 19:29:17 +00:00
|
|
|
|
attrs.insert(*j);
|
2010-10-24 19:52:33 +00:00
|
|
|
|
++i; ++j;
|
|
|
|
|
}
|
|
|
|
|
else if (i->name < j->name)
|
2022-01-04 19:29:17 +00:00
|
|
|
|
attrs.insert(*i++);
|
2010-10-24 19:52:33 +00:00
|
|
|
|
else
|
2022-01-04 19:29:17 +00:00
|
|
|
|
attrs.insert(*j++);
|
2010-10-24 19:52:33 +00:00
|
|
|
|
}
|
2010-10-20 15:48:00 +00:00
|
|
|
|
|
2022-01-04 19:29:17 +00:00
|
|
|
|
while (i != v1.attrs->end()) attrs.insert(*i++);
|
|
|
|
|
while (j != v2.attrs->end()) attrs.insert(*j++);
|
|
|
|
|
|
|
|
|
|
v.mkAttrs(attrs.alreadySorted());
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-10-20 15:48:00 +00:00
|
|
|
|
state.nrOpUpdateValuesCopied += v.attrs->size();
|
2010-04-12 18:30:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ExprOpConcatLists::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2012-02-04 13:50:25 +00:00
|
|
|
|
Value v1; e1->eval(state, env, v1);
|
|
|
|
|
Value v2; e2->eval(state, env, v2);
|
2012-08-13 05:53:10 +00:00
|
|
|
|
Value * lists[2] = { &v1, &v2 };
|
2014-04-04 20:43:52 +00:00
|
|
|
|
state.concatLists(v, 2, lists, pos);
|
2012-08-13 05:53:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::concatLists(Value & v, size_t nrLists, Value * * lists, const PosIdx pos)
|
2012-08-13 05:53:10 +00:00
|
|
|
|
{
|
|
|
|
|
nrListConcats++;
|
2012-08-13 18:58:54 +00:00
|
|
|
|
|
|
|
|
|
Value * nonEmpty = 0;
|
2018-05-02 11:56:34 +00:00
|
|
|
|
size_t len = 0;
|
|
|
|
|
for (size_t n = 0; n < nrLists; ++n) {
|
2014-04-04 20:43:52 +00:00
|
|
|
|
forceList(*lists[n], pos);
|
2018-05-02 11:56:34 +00:00
|
|
|
|
auto l = lists[n]->listSize();
|
2012-08-13 18:58:54 +00:00
|
|
|
|
len += l;
|
|
|
|
|
if (l) nonEmpty = lists[n];
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
if (nonEmpty && len == nonEmpty->listSize()) {
|
2012-08-13 18:58:54 +00:00
|
|
|
|
v = *nonEmpty;
|
|
|
|
|
return;
|
2012-08-13 05:53:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mkList(v, len);
|
2015-07-23 20:05:09 +00:00
|
|
|
|
auto out = v.listElems();
|
2018-05-02 11:56:34 +00:00
|
|
|
|
for (size_t n = 0, pos = 0; n < nrLists; ++n) {
|
|
|
|
|
auto l = lists[n]->listSize();
|
2018-03-15 03:44:02 +00:00
|
|
|
|
if (l)
|
|
|
|
|
memcpy(out + pos, lists[n]->listElems(), l * sizeof(Value *));
|
2012-08-13 05:53:10 +00:00
|
|
|
|
pos += l;
|
|
|
|
|
}
|
2010-03-29 14:37:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-12 21:21:24 +00:00
|
|
|
|
void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
std::vector<BackedStringView> s;
|
2021-12-27 01:04:49 +00:00
|
|
|
|
size_t sSize = 0;
|
2013-08-19 10:35:03 +00:00
|
|
|
|
NixInt n = 0;
|
2016-01-04 23:40:40 +00:00
|
|
|
|
NixFloat nf = 0;
|
2013-08-02 15:21:17 +00:00
|
|
|
|
|
2013-10-16 22:39:59 +00:00
|
|
|
|
bool first = !forceString;
|
2020-12-17 13:42:52 +00:00
|
|
|
|
ValueType firstType = nString;
|
2010-04-12 21:21:24 +00:00
|
|
|
|
|
2021-12-27 01:04:49 +00:00
|
|
|
|
const auto str = [&] {
|
|
|
|
|
std::string result;
|
|
|
|
|
result.reserve(sSize);
|
2022-01-21 15:20:54 +00:00
|
|
|
|
for (const auto & part : s) result += *part;
|
2021-12-27 01:04:49 +00:00
|
|
|
|
return result;
|
|
|
|
|
};
|
|
|
|
|
/* c_str() is not str().c_str() because we want to create a string
|
|
|
|
|
Value. allocating a GC'd string directly and moving it into a
|
|
|
|
|
Value lets us avoid an allocation and copy. */
|
|
|
|
|
const auto c_str = [&] {
|
|
|
|
|
char * result = allocString(sSize + 1);
|
|
|
|
|
char * tmp = result;
|
|
|
|
|
for (const auto & part : s) {
|
2022-01-21 15:20:54 +00:00
|
|
|
|
memcpy(tmp, part->data(), part->size());
|
|
|
|
|
tmp += part->size();
|
2021-12-27 01:04:49 +00:00
|
|
|
|
}
|
|
|
|
|
*tmp = 0;
|
|
|
|
|
return result;
|
|
|
|
|
};
|
|
|
|
|
|
2022-01-21 15:20:54 +00:00
|
|
|
|
Value values[es->size()];
|
|
|
|
|
Value * vTmpP = values;
|
|
|
|
|
|
2021-09-23 02:30:31 +00:00
|
|
|
|
for (auto & [i_pos, i] : *es) {
|
2022-01-21 15:20:54 +00:00
|
|
|
|
Value & vTmp = *vTmpP++;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
i->eval(state, env, vTmp);
|
2010-04-12 21:21:24 +00:00
|
|
|
|
|
|
|
|
|
/* 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) {
|
2020-12-17 13:45:45 +00:00
|
|
|
|
firstType = vTmp.type();
|
2010-04-12 21:21:24 +00:00
|
|
|
|
}
|
2012-08-13 19:10:29 +00:00
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
if (firstType == nInt) {
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (vTmp.type() == nInt) {
|
2016-01-04 23:40:40 +00:00
|
|
|
|
n += vTmp.integer;
|
2020-12-17 13:45:45 +00:00
|
|
|
|
} else if (vTmp.type() == nFloat) {
|
2016-01-04 23:40:40 +00:00
|
|
|
|
// Upgrade the type from int to float;
|
2020-12-12 01:09:10 +00:00
|
|
|
|
firstType = nFloat;
|
2016-01-04 23:40:40 +00:00
|
|
|
|
nf = n;
|
|
|
|
|
nf += vTmp.fpoint;
|
|
|
|
|
} else
|
2022-04-28 18:32:57 +00:00
|
|
|
|
state.throwEvalError(i_pos, "cannot add %1% to an integer", showType(vTmp), env, *this);
|
2020-12-12 01:09:10 +00:00
|
|
|
|
} else if (firstType == nFloat) {
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (vTmp.type() == nInt) {
|
2016-01-04 23:40:40 +00:00
|
|
|
|
nf += vTmp.integer;
|
2020-12-17 13:45:45 +00:00
|
|
|
|
} else if (vTmp.type() == nFloat) {
|
2016-01-04 23:40:40 +00:00
|
|
|
|
nf += vTmp.fpoint;
|
|
|
|
|
} else
|
2022-04-28 18:32:57 +00:00
|
|
|
|
state.throwEvalError(i_pos, "cannot add %1% to a float", showType(vTmp), env, *this);
|
2021-12-27 01:04:49 +00:00
|
|
|
|
} else {
|
|
|
|
|
if (s.empty()) s.reserve(es->size());
|
2021-07-29 16:03:07 +00:00
|
|
|
|
/* skip canonization of first path, which would only be not
|
|
|
|
|
canonized in the first place if it's coming from a ./${foo} type
|
|
|
|
|
path */
|
2022-01-21 15:20:54 +00:00
|
|
|
|
auto part = state.coerceToString(i_pos, vTmp, context, false, firstType == nString, !first);
|
|
|
|
|
sSize += part->size();
|
|
|
|
|
s.emplace_back(std::move(part));
|
2021-12-27 01:04:49 +00:00
|
|
|
|
}
|
2021-07-29 16:03:07 +00:00
|
|
|
|
|
|
|
|
|
first = false;
|
2010-04-12 21:21:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
if (firstType == nInt)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(n);
|
2020-12-12 01:09:10 +00:00
|
|
|
|
else if (firstType == nFloat)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkFloat(nf);
|
2020-12-12 01:09:10 +00:00
|
|
|
|
else if (firstType == nPath) {
|
2013-08-02 15:21:17 +00:00
|
|
|
|
if (!context.empty())
|
2022-04-29 16:02:17 +00:00
|
|
|
|
state.throwEvalError(pos, "a string that refers to a store path cannot be appended to a path", env, *this);
|
2021-12-27 01:04:49 +00:00
|
|
|
|
v.mkPath(canonPath(str()));
|
2013-08-02 15:21:17 +00:00
|
|
|
|
} else
|
2021-12-27 01:04:49 +00:00
|
|
|
|
v.mkStringMove(c_str(), context);
|
2010-04-12 21:21:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-11-18 19:14:54 +00:00
|
|
|
|
void ExprPos::eval(EvalState & state, Env & env, Value & v)
|
|
|
|
|
{
|
2022-03-04 18:31:59 +00:00
|
|
|
|
state.mkPos(v, pos);
|
2013-11-18 19:14:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-09-22 13:03:59 +00:00
|
|
|
|
void EvalState::forceValueDeep(Value & v)
|
2010-04-07 13:55:46 +00:00
|
|
|
|
{
|
2014-09-22 13:16:09 +00:00
|
|
|
|
std::set<const Value *> seen;
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2014-09-22 13:16:09 +00:00
|
|
|
|
std::function<void(Value & v)> recurse;
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2014-09-22 13:16:09 +00:00
|
|
|
|
recurse = [&](Value & v) {
|
2019-10-09 13:51:52 +00:00
|
|
|
|
if (!seen.insert(&v).second) return;
|
2014-09-22 13:16:09 +00:00
|
|
|
|
|
2022-02-03 23:31:33 +00:00
|
|
|
|
forceValue(v, [&]() { return v.determinePos(noPos); });
|
2014-09-22 13:16:09 +00:00
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() == nAttrs) {
|
2015-03-06 14:10:12 +00:00
|
|
|
|
for (auto & i : *v.attrs)
|
|
|
|
|
try {
|
2022-05-05 10:29:14 +00:00
|
|
|
|
// If the value is a thunk, we're evaling. Otherwise no trace necessary.
|
2022-05-23 03:45:24 +00:00
|
|
|
|
auto dts = debugRepl && i.value->isThunk()
|
2022-05-15 18:05:51 +00:00
|
|
|
|
? makeDebugTraceStacker(*this, *i.value->thunk.expr, *i.value->thunk.env, positions[i.pos],
|
2022-05-05 10:29:14 +00:00
|
|
|
|
"while evaluating the attribute '%1%'", symbols[i.name])
|
2022-04-08 21:46:12 +00:00
|
|
|
|
: nullptr;
|
2021-12-23 02:40:08 +00:00
|
|
|
|
|
2015-03-06 14:10:12 +00:00
|
|
|
|
recurse(*i.value);
|
|
|
|
|
} catch (Error & e) {
|
2022-03-05 13:40:24 +00:00
|
|
|
|
addErrorTrace(e, i.pos, "while evaluating the attribute '%1%'", symbols[i.name]);
|
2015-03-06 14:10:12 +00:00
|
|
|
|
throw;
|
|
|
|
|
}
|
2014-09-22 13:16:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
else if (v.isList()) {
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto v2 : v.listItems())
|
|
|
|
|
recurse(*v2);
|
2014-09-22 13:16:09 +00:00
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
recurse(v);
|
2010-04-07 13:55:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
NixInt EvalState::forceInt(Value & v, const PosIdx pos)
|
2010-03-29 14:37:56 +00:00
|
|
|
|
{
|
2015-07-31 15:32:25 +00:00
|
|
|
|
forceValue(v, pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nInt)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "value is %1% while an integer was expected", v);
|
2022-02-10 22:05:38 +00:00
|
|
|
|
|
2010-03-29 14:37:56 +00:00
|
|
|
|
return v.integer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
NixFloat EvalState::forceFloat(Value & v, const PosIdx pos)
|
2016-01-04 23:40:40 +00:00
|
|
|
|
{
|
|
|
|
|
forceValue(v, pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() == nInt)
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v.integer;
|
2020-12-17 13:45:45 +00:00
|
|
|
|
else if (v.type() != nFloat)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "value is %1% while a float was expected", v);
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v.fpoint;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
bool EvalState::forceBool(Value & v, const PosIdx pos)
|
2010-03-31 15:38:03 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
forceValue(v, pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nBool)
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "value is %1% while a Boolean was expected", v);
|
2010-03-31 15:38:03 +00:00
|
|
|
|
return v.boolean;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-10-08 11:22:11 +00:00
|
|
|
|
bool EvalState::isFunctor(Value & fun)
|
|
|
|
|
{
|
2020-12-17 13:45:45 +00:00
|
|
|
|
return fun.type() == nAttrs && fun.attrs->find(sFunctor) != fun.attrs->end();
|
2015-10-08 11:22:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
void EvalState::forceFunction(Value & v, const PosIdx pos)
|
2010-03-30 13:47:59 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
forceValue(v, pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nFunction && !isFunctor(v))
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "value is %1% while a function was expected", v);
|
2010-03-30 13:47:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
std::string_view EvalState::forceString(Value & v, const PosIdx pos)
|
2010-03-30 18:05:54 +00:00
|
|
|
|
{
|
2015-07-31 15:32:25 +00:00
|
|
|
|
forceValue(v, pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nString) {
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "value is %1% while a string was expected", v);
|
2014-04-04 19:14:11 +00:00
|
|
|
|
}
|
2022-01-21 13:44:00 +00:00
|
|
|
|
return v.string.s;
|
2010-03-31 15:38:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2020-06-29 17:08:37 +00:00
|
|
|
|
/* Decode a context string ‘!<name>!<path>’ into a pair <path,
|
|
|
|
|
name>. */
|
2022-03-12 00:28:00 +00:00
|
|
|
|
NixStringContextElem decodeContext(const Store & store, std::string_view s)
|
2020-06-29 17:08:37 +00:00
|
|
|
|
{
|
|
|
|
|
if (s.at(0) == '!') {
|
|
|
|
|
size_t index = s.find("!", 1);
|
2022-03-12 00:28:00 +00:00
|
|
|
|
return {
|
|
|
|
|
store.parseStorePath(s.substr(index + 1)),
|
|
|
|
|
std::string(s.substr(1, index - 1)),
|
|
|
|
|
};
|
2020-06-29 17:08:37 +00:00
|
|
|
|
} else
|
2022-03-12 00:28:00 +00:00
|
|
|
|
return {
|
|
|
|
|
store.parseStorePath(
|
|
|
|
|
s.at(0) == '/'
|
|
|
|
|
? s
|
|
|
|
|
: s.substr(1)),
|
|
|
|
|
"",
|
|
|
|
|
};
|
2020-06-29 17:08:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-06-10 10:29:50 +00:00
|
|
|
|
void copyContext(const Value & v, PathSet & context)
|
2010-03-31 19:52:29 +00:00
|
|
|
|
{
|
2010-04-09 12:00:49 +00:00
|
|
|
|
if (v.string.context)
|
2013-09-02 14:29:15 +00:00
|
|
|
|
for (const char * * p = v.string.context; *p; ++p)
|
2010-03-31 19:52:29 +00:00
|
|
|
|
context.insert(*p);
|
2010-06-10 10:29:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-12 00:28:00 +00:00
|
|
|
|
NixStringContext Value::getContext(const Store & store)
|
2020-06-29 17:08:37 +00:00
|
|
|
|
{
|
2021-03-10 02:20:32 +00:00
|
|
|
|
NixStringContext res;
|
2020-12-17 13:42:52 +00:00
|
|
|
|
assert(internalType == tString);
|
2020-06-29 17:08:37 +00:00
|
|
|
|
if (string.context)
|
|
|
|
|
for (const char * * p = string.context; *p; ++p)
|
2022-03-12 00:28:00 +00:00
|
|
|
|
res.push_back(decodeContext(store, *p));
|
2020-06-29 17:08:37 +00:00
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
std::string_view EvalState::forceString(Value & v, PathSet & context, const PosIdx pos)
|
2010-06-10 10:29:50 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto s = forceString(v, pos);
|
2010-06-10 10:29:50 +00:00
|
|
|
|
copyContext(v, context);
|
2010-03-31 19:52:29 +00:00
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
std::string_view EvalState::forceStringNoCtx(Value & v, const PosIdx pos)
|
2010-03-31 15:38:03 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto s = forceString(v, pos);
|
2014-04-04 19:14:11 +00:00
|
|
|
|
if (v.string.context) {
|
|
|
|
|
if (pos)
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throwEvalError(pos, "the string '%1%' is not allowed to refer to a store path (such as '%2%')",
|
2022-04-29 16:02:17 +00:00
|
|
|
|
v.string.s, v.string.context[0]);
|
2014-04-04 19:14:11 +00:00
|
|
|
|
else
|
2017-07-30 11:27:57 +00:00
|
|
|
|
throwEvalError("the string '%1%' is not allowed to refer to a store path (such as '%2%')",
|
2022-04-29 16:02:17 +00:00
|
|
|
|
v.string.s, v.string.context[0]);
|
2014-04-04 19:14:11 +00:00
|
|
|
|
}
|
2010-03-31 15:38:03 +00:00
|
|
|
|
return s;
|
2010-03-30 18:05:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-04-07 13:55:46 +00:00
|
|
|
|
bool EvalState::isDerivation(Value & v)
|
|
|
|
|
{
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() != nAttrs) return false;
|
2010-04-13 12:25:42 +00:00
|
|
|
|
Bindings::iterator i = v.attrs->find(sType);
|
2011-10-27 19:06:23 +00:00
|
|
|
|
if (i == v.attrs->end()) return false;
|
2022-03-04 18:31:59 +00:00
|
|
|
|
forceValue(*i->value, i->pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (i->value->type() != nString) return false;
|
2013-10-24 01:08:34 +00:00
|
|
|
|
return strcmp(i->value->string.s, "derivation") == 0;
|
2010-04-07 13:55:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
std::optional<std::string> EvalState::tryAttrsToString(const PosIdx pos, Value & v,
|
2019-10-27 09:15:51 +00:00
|
|
|
|
PathSet & context, bool coerceMore, bool copyToStore)
|
|
|
|
|
{
|
|
|
|
|
auto i = v.attrs->find(sToString);
|
|
|
|
|
if (i != v.attrs->end()) {
|
|
|
|
|
Value v1;
|
|
|
|
|
callFunction(*i->value, v, v1, pos);
|
2022-01-21 15:20:54 +00:00
|
|
|
|
return coerceToString(pos, v1, context, coerceMore, copyToStore).toOwned();
|
2019-10-27 09:15:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return {};
|
|
|
|
|
}
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
BackedStringView EvalState::coerceToString(const PosIdx pos, Value & v, PathSet & context,
|
2021-08-31 12:02:04 +00:00
|
|
|
|
bool coerceMore, bool copyToStore, bool canonicalizePath)
|
2010-03-30 09:22:33 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
forceValue(v, pos);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() == nString) {
|
2010-06-10 10:29:50 +00:00
|
|
|
|
copyContext(v, context);
|
2022-01-21 15:20:54 +00:00
|
|
|
|
return std::string_view(v.string.s);
|
2010-03-31 19:52:29 +00:00
|
|
|
|
}
|
2010-03-30 09:22:33 +00:00
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() == nPath) {
|
2022-01-21 15:20:54 +00:00
|
|
|
|
BackedStringView path(PathView(v.path));
|
|
|
|
|
if (canonicalizePath)
|
|
|
|
|
path = canonPath(*path);
|
|
|
|
|
if (copyToStore)
|
|
|
|
|
path = copyPathToStore(context, std::move(path).toOwned());
|
|
|
|
|
return path;
|
2010-03-30 09:22:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() == nAttrs) {
|
2019-10-27 09:15:51 +00:00
|
|
|
|
auto maybeString = tryAttrsToString(pos, v, context, coerceMore, copyToStore);
|
2022-01-21 15:20:54 +00:00
|
|
|
|
if (maybeString)
|
|
|
|
|
return std::move(*maybeString);
|
2019-10-27 09:15:51 +00:00
|
|
|
|
auto i = v.attrs->find(sOutPath);
|
2021-05-11 00:36:57 +00:00
|
|
|
|
if (i == v.attrs->end())
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "cannot coerce a set to a string");
|
2014-04-04 20:19:33 +00:00
|
|
|
|
return coerceToString(pos, *i->value, context, coerceMore, copyToStore);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() == nExternal)
|
2022-03-04 18:31:59 +00:00
|
|
|
|
return v.external->coerceToString(positions[pos], context, coerceMore, copyToStore);
|
2014-11-30 18:16:19 +00:00
|
|
|
|
|
2010-03-30 09:22:33 +00:00
|
|
|
|
if (coerceMore) {
|
|
|
|
|
/* Note that `false' is represented as an empty string for
|
|
|
|
|
shell scripting convenience, just like `null'. */
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v.type() == nBool && v.boolean) return "1";
|
|
|
|
|
if (v.type() == nBool && !v.boolean) return "";
|
|
|
|
|
if (v.type() == nInt) return std::to_string(v.integer);
|
|
|
|
|
if (v.type() == nFloat) return std::to_string(v.fpoint);
|
|
|
|
|
if (v.type() == nNull) return "";
|
2010-03-30 09:22:33 +00:00
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
if (v.isList()) {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string result;
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto [n, v2] : enumerate(v.listItems())) {
|
2022-01-21 15:20:54 +00:00
|
|
|
|
result += *coerceToString(pos, *v2, context, coerceMore, copyToStore);
|
2015-07-23 20:05:09 +00:00
|
|
|
|
if (n < v.listSize() - 1
|
2010-04-01 14:35:03 +00:00
|
|
|
|
/* !!! not quite correct */
|
2021-11-24 19:21:34 +00:00
|
|
|
|
&& (!v2->isList() || v2->listSize() != 0))
|
2010-04-01 14:35:03 +00:00
|
|
|
|
result += " ";
|
2010-03-30 09:22:33 +00:00
|
|
|
|
}
|
2022-01-21 15:20:54 +00:00
|
|
|
|
return std::move(result);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwTypeError(pos, "cannot coerce %1% to a string", v);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string EvalState::copyPathToStore(PathSet & context, const Path & path)
|
2013-11-18 23:03:11 +00:00
|
|
|
|
{
|
|
|
|
|
if (nix::isDerivation(path))
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwEvalError("file names are not allowed to end in '%1%'", drvExtension);
|
2013-11-18 23:03:11 +00:00
|
|
|
|
|
|
|
|
|
Path dstPath;
|
2019-12-05 18:11:09 +00:00
|
|
|
|
auto i = srcToStore.find(path);
|
|
|
|
|
if (i != srcToStore.end())
|
|
|
|
|
dstPath = store->printStorePath(i->second);
|
2013-11-18 23:03:11 +00:00
|
|
|
|
else {
|
2019-12-05 18:11:09 +00:00
|
|
|
|
auto p = settings.readOnlyMode
|
|
|
|
|
? store->computeStorePathForPath(std::string(baseNameOf(path)), checkSourcePath(path)).first
|
2020-03-29 05:04:55 +00:00
|
|
|
|
: store->addToStore(std::string(baseNameOf(path)), checkSourcePath(path), FileIngestionMethod::Recursive, htSHA256, defaultPathFilter, repair);
|
2019-12-05 18:11:09 +00:00
|
|
|
|
dstPath = store->printStorePath(p);
|
2021-10-07 12:07:51 +00:00
|
|
|
|
allowPath(p);
|
2019-12-05 18:11:09 +00:00
|
|
|
|
srcToStore.insert_or_assign(path, std::move(p));
|
|
|
|
|
printMsg(lvlChatty, "copied source '%1%' -> '%2%'", path, dstPath);
|
2013-11-18 23:03:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
context.insert(dstPath);
|
|
|
|
|
return dstPath;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
Path EvalState::coerceToPath(const PosIdx pos, Value & v, PathSet & context)
|
2010-03-30 09:22:33 +00:00
|
|
|
|
{
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto path = coerceToString(pos, v, context, false, false).toOwned();
|
2010-03-30 09:22:33 +00:00
|
|
|
|
if (path == "" || path[0] != '/')
|
2022-04-29 16:02:17 +00:00
|
|
|
|
throwEvalError(pos, "string '%1%' doesn't represent an absolute path", path);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
|
StorePath EvalState::coerceToStorePath(const PosIdx pos, Value & v, PathSet & context)
|
2022-03-02 09:57:19 +00:00
|
|
|
|
{
|
|
|
|
|
auto path = coerceToString(pos, v, context, false, false).toOwned();
|
|
|
|
|
if (auto storePath = store->maybeParseStorePath(path))
|
|
|
|
|
return *storePath;
|
|
|
|
|
throw EvalError({
|
|
|
|
|
.msg = hintfmt("path '%1%' is not in the Nix store", path),
|
2022-03-04 18:31:59 +00:00
|
|
|
|
.errPos = positions[pos]
|
2022-03-02 09:57:19 +00:00
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-03-29 14:37:56 +00:00
|
|
|
|
bool EvalState::eqValues(Value & v1, Value & v2)
|
|
|
|
|
{
|
2022-01-21 16:44:19 +00:00
|
|
|
|
forceValue(v1, noPos);
|
|
|
|
|
forceValue(v2, noPos);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
|
2010-04-12 09:50:20 +00:00
|
|
|
|
/* !!! Hack to support some old broken code that relies on pointer
|
2013-10-24 14:41:04 +00:00
|
|
|
|
equality tests between sets. (Specifically, builderDefs calls
|
|
|
|
|
uniqList on a list of sets.) Will remove this eventually. */
|
2010-04-12 09:50:20 +00:00
|
|
|
|
if (&v1 == &v2) return true;
|
|
|
|
|
|
2016-01-04 23:40:40 +00:00
|
|
|
|
// Special case type-compatibility between float and int
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v1.type() == nInt && v2.type() == nFloat)
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v1.integer == v2.fpoint;
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v1.type() == nFloat && v2.type() == nInt)
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v1.fpoint == v2.integer;
|
|
|
|
|
|
|
|
|
|
// All other types are not compatible with each other.
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v1.type() != v2.type()) return false;
|
2010-04-12 09:50:20 +00:00
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
switch (v1.type()) {
|
2010-03-29 14:37:56 +00:00
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nInt:
|
2010-03-29 14:37:56 +00:00
|
|
|
|
return v1.integer == v2.integer;
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nBool:
|
2010-03-29 14:37:56 +00:00
|
|
|
|
return v1.boolean == v2.boolean;
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nString:
|
2014-06-10 12:02:56 +00:00
|
|
|
|
return strcmp(v1.string.s, v2.string.s) == 0;
|
2010-03-29 14:37:56 +00:00
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nPath:
|
2010-03-31 20:09:20 +00:00
|
|
|
|
return strcmp(v1.path, v2.path) == 0;
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nNull:
|
2010-03-31 09:54:12 +00:00
|
|
|
|
return true;
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nList:
|
2015-07-23 20:05:09 +00:00
|
|
|
|
if (v1.listSize() != v2.listSize()) return false;
|
2018-05-02 11:56:34 +00:00
|
|
|
|
for (size_t n = 0; n < v1.listSize(); ++n)
|
2015-07-23 20:05:09 +00:00
|
|
|
|
if (!eqValues(*v1.listElems()[n], *v2.listElems()[n])) return false;
|
2010-03-29 14:37:56 +00:00
|
|
|
|
return true;
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nAttrs: {
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* If both sets denote a derivation (type = "derivation"),
|
|
|
|
|
then compare their outPaths. */
|
2012-01-19 23:08:47 +00:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-16 13:51:01 +00:00
|
|
|
|
if (v1.attrs->size() != v2.attrs->size()) return false;
|
2012-01-19 23:08:47 +00:00
|
|
|
|
|
|
|
|
|
/* 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)
|
2010-10-24 00:41:29 +00:00
|
|
|
|
if (i->name != j->name || !eqValues(*i->value, *j->value))
|
2010-05-07 12:11:05 +00:00
|
|
|
|
return false;
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-03-29 14:37:56 +00:00
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-01 10:55:36 +00:00
|
|
|
|
/* Functions are incomparable. */
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nFunction:
|
2010-04-01 10:55:36 +00:00
|
|
|
|
return false;
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nExternal:
|
2014-11-30 18:16:19 +00:00
|
|
|
|
return *v1.external == *v2.external;
|
|
|
|
|
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nFloat:
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v1.fpoint == v2.fpoint;
|
|
|
|
|
|
2010-03-29 14:37:56 +00:00
|
|
|
|
default:
|
2021-06-09 00:37:28 +00:00
|
|
|
|
throwEvalError("cannot compare %1% with %2%",
|
|
|
|
|
showType(v1),
|
2022-04-29 16:02:17 +00:00
|
|
|
|
showType(v2));
|
2010-03-29 14:37:56 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-30 15:18:20 +00:00
|
|
|
|
void EvalState::printStats()
|
2003-10-31 17:09:31 +00:00
|
|
|
|
{
|
2019-11-22 15:06:44 +00:00
|
|
|
|
bool showStats = getEnv("NIX_SHOW_STATS").value_or("0") != "0";
|
2012-02-04 13:27:11 +00:00
|
|
|
|
|
|
|
|
|
struct rusage buf;
|
|
|
|
|
getrusage(RUSAGE_SELF, &buf);
|
|
|
|
|
float cpuTime = buf.ru_utime.tv_sec + ((float) buf.ru_utime.tv_usec / 1000000);
|
|
|
|
|
|
2014-10-04 22:39:28 +00:00
|
|
|
|
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);
|
|
|
|
|
|
2015-03-18 15:24:54 +00:00
|
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
|
GC_word heapSize, totalBytes;
|
|
|
|
|
GC_get_heap_usage_safe(&heapSize, 0, 0, 0, &totalBytes);
|
|
|
|
|
#endif
|
2018-09-02 21:20:18 +00:00
|
|
|
|
if (showStats) {
|
2019-11-22 15:06:44 +00:00
|
|
|
|
auto outPath = getEnv("NIX_SHOW_STATS_PATH").value_or("-");
|
2018-09-01 22:50:22 +00:00
|
|
|
|
std::fstream fs;
|
2018-09-05 19:35:58 +00:00
|
|
|
|
if (outPath != "-")
|
2018-09-01 22:50:22 +00:00
|
|
|
|
fs.open(outPath, std::fstream::out);
|
2018-09-05 19:35:58 +00:00
|
|
|
|
JSONObject topObj(outPath == "-" ? std::cerr : fs, true);
|
2018-09-01 22:50:22 +00:00
|
|
|
|
topObj.attr("cpuTime",cpuTime);
|
|
|
|
|
{
|
|
|
|
|
auto envs = topObj.object("envs");
|
|
|
|
|
envs.attr("number", nrEnvs);
|
2018-09-02 21:20:18 +00:00
|
|
|
|
envs.attr("elements", nrValuesInEnvs);
|
2018-09-01 22:50:22 +00:00
|
|
|
|
envs.attr("bytes", bEnvs);
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto lists = topObj.object("list");
|
|
|
|
|
lists.attr("elements", nrListElems);
|
|
|
|
|
lists.attr("bytes", bLists);
|
|
|
|
|
lists.attr("concats", nrListConcats);
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto values = topObj.object("values");
|
|
|
|
|
values.attr("number", nrValues);
|
|
|
|
|
values.attr("bytes", bValues);
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto syms = topObj.object("symbols");
|
|
|
|
|
syms.attr("number", symbols.size());
|
|
|
|
|
syms.attr("bytes", symbols.totalSize());
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto sets = topObj.object("sets");
|
|
|
|
|
sets.attr("number", nrAttrsets);
|
|
|
|
|
sets.attr("bytes", bAttrsets);
|
2018-09-02 21:20:18 +00:00
|
|
|
|
sets.attr("elements", nrAttrsInAttrsets);
|
2018-09-01 22:50:22 +00:00
|
|
|
|
}
|
|
|
|
|
{
|
2018-09-05 19:57:54 +00:00
|
|
|
|
auto sizes = topObj.object("sizes");
|
2018-09-01 22:50:22 +00:00
|
|
|
|
sizes.attr("Env", sizeof(Env));
|
|
|
|
|
sizes.attr("Value", sizeof(Value));
|
|
|
|
|
sizes.attr("Bindings", sizeof(Bindings));
|
|
|
|
|
sizes.attr("Attr", sizeof(Attr));
|
|
|
|
|
}
|
|
|
|
|
topObj.attr("nrOpUpdates", nrOpUpdates);
|
|
|
|
|
topObj.attr("nrOpUpdateValuesCopied", nrOpUpdateValuesCopied);
|
|
|
|
|
topObj.attr("nrThunks", nrThunks);
|
|
|
|
|
topObj.attr("nrAvoided", nrAvoided);
|
|
|
|
|
topObj.attr("nrLookups", nrLookups);
|
|
|
|
|
topObj.attr("nrPrimOpCalls", nrPrimOpCalls);
|
|
|
|
|
topObj.attr("nrFunctionCalls", nrFunctionCalls);
|
|
|
|
|
#if HAVE_BOEHMGC
|
2018-09-05 19:57:54 +00:00
|
|
|
|
{
|
|
|
|
|
auto gc = topObj.object("gc");
|
|
|
|
|
gc.attr("heapSize", heapSize);
|
|
|
|
|
gc.attr("totalBytes", totalBytes);
|
|
|
|
|
}
|
2018-09-01 22:50:22 +00:00
|
|
|
|
#endif
|
2019-04-11 21:04:13 +00:00
|
|
|
|
|
2018-09-05 19:57:54 +00:00
|
|
|
|
if (countCalls) {
|
|
|
|
|
{
|
|
|
|
|
auto obj = topObj.object("primops");
|
|
|
|
|
for (auto & i : primOpCalls)
|
|
|
|
|
obj.attr(i.first, i.second);
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto list = topObj.list("functions");
|
|
|
|
|
for (auto & i : functionCalls) {
|
|
|
|
|
auto obj = list.object();
|
2022-03-05 13:40:24 +00:00
|
|
|
|
if (i.first->name)
|
2022-02-25 15:00:00 +00:00
|
|
|
|
obj.attr("name", (const std::string &) i.first->name);
|
2018-09-05 19:57:54 +00:00
|
|
|
|
else
|
|
|
|
|
obj.attr("name", nullptr);
|
2022-03-04 18:31:59 +00:00
|
|
|
|
if (auto pos = positions[i.first->pos]) {
|
|
|
|
|
obj.attr("file", (const std::string &) pos.file);
|
|
|
|
|
obj.attr("line", pos.line);
|
|
|
|
|
obj.attr("column", pos.column);
|
2018-09-05 19:57:54 +00:00
|
|
|
|
}
|
|
|
|
|
obj.attr("count", i.second);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
auto list = topObj.list("attributes");
|
|
|
|
|
for (auto & i : attrSelects) {
|
|
|
|
|
auto obj = list.object();
|
2022-03-04 18:31:59 +00:00
|
|
|
|
if (auto pos = positions[i.first]) {
|
|
|
|
|
obj.attr("file", (const std::string &) pos.file);
|
|
|
|
|
obj.attr("line", pos.line);
|
|
|
|
|
obj.attr("column", pos.column);
|
2018-09-05 19:57:54 +00:00
|
|
|
|
}
|
|
|
|
|
obj.attr("count", i.second);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-04-11 21:04:13 +00:00
|
|
|
|
|
2019-11-22 15:06:44 +00:00
|
|
|
|
if (getEnv("NIX_SHOW_SYMBOLS").value_or("0") != "0") {
|
2019-04-11 21:04:13 +00:00
|
|
|
|
auto list = topObj.list("symbols");
|
|
|
|
|
symbols.dump([&](const std::string & s) { list.elem(s); });
|
|
|
|
|
}
|
2012-08-13 03:29:28 +00:00
|
|
|
|
}
|
2003-10-31 17:09:31 +00:00
|
|
|
|
}
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
2010-04-07 13:55:46 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string ExternalValueBase::coerceToString(const Pos & pos, PathSet & context, bool copyMore, bool copyToStore) const
|
2014-11-30 18:16:19 +00:00
|
|
|
|
{
|
2020-06-15 12:06:58 +00:00
|
|
|
|
throw TypeError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("cannot coerce %1% to a string", showType()),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2020-06-15 12:06:58 +00:00
|
|
|
|
});
|
2014-11-30 18:16:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-12-02 15:02:03 +00:00
|
|
|
|
bool ExternalValueBase::operator==(const ExternalValueBase & b) const
|
2014-11-30 18:16:19 +00:00
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-12-02 15:02:03 +00:00
|
|
|
|
std::ostream & operator << (std::ostream & str, const ExternalValueBase & v) {
|
2014-11-30 18:16:19 +00:00
|
|
|
|
return v.print(str);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2019-11-22 22:07:35 +00:00
|
|
|
|
EvalSettings::EvalSettings()
|
|
|
|
|
{
|
|
|
|
|
auto var = getEnv("NIX_PATH");
|
|
|
|
|
if (var) nixPath = parseNixPath(*var);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Strings EvalSettings::getDefaultNixPath()
|
|
|
|
|
{
|
|
|
|
|
Strings res;
|
2020-11-12 15:46:08 +00:00
|
|
|
|
auto add = [&](const Path & p, const std::string & s = std::string()) {
|
|
|
|
|
if (pathExists(p)) {
|
|
|
|
|
if (s.empty()) {
|
|
|
|
|
res.push_back(p);
|
|
|
|
|
} else {
|
|
|
|
|
res.push_back(s + "=" + p);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2021-04-12 16:36:14 +00:00
|
|
|
|
if (!evalSettings.restrictEval && !evalSettings.pureEval) {
|
|
|
|
|
add(getHome() + "/.nix-defexpr/channels");
|
|
|
|
|
add(settings.nixStateDir + "/profiles/per-user/root/channels/nixpkgs", "nixpkgs");
|
|
|
|
|
add(settings.nixStateDir + "/profiles/per-user/root/channels");
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-22 22:07:35 +00:00
|
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-27 17:02:22 +00:00
|
|
|
|
EvalSettings evalSettings;
|
|
|
|
|
|
2020-10-06 11:36:55 +00:00
|
|
|
|
static GlobalConfig::Register rEvalSettings(&evalSettings);
|
2018-03-27 17:02:22 +00:00
|
|
|
|
|
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
}
|