blokyk
f91bdc9367
frames manually added with `addErrorContext` are generally a lot more useful/informative to the average user than other frames, esp. in the module system, which can create much better error messages than we can. however, before this change, frames from addErrorContext were truncated by default if they weren't in the first 3 frames, so they were basically useless (with `--show-trace`, you're dredging through 250 frames of module shenanigans just to spot one singular line). this change also removes the frames for _the call to_ `addErrorContext`, which is just pure noise. the way this change is done hopefully leaves a bit of space for future similar changes to error printing, by introducing a new `TraceKind` enum that can be used to categorize traces (i haven't done that in this CL because that would be a pretty herculean task, given all the calls to `BaseError::addTrace` in the codebase, and we probably want to be careful about what categories we choose). the actual printing code could definitely be improved tho... (e.g. by iterating twice through the trace stack instead to first pick out the most important traces and _then_ printing less "important" traces if there's space left) Change-Id: I52acc52f231991a9f2309d9cecae362397c6888c
3254 lines
120 KiB
C++
3254 lines
120 KiB
C++
#include "libutil/error-trace.hh"
|
||
#include "lix/libutil/archive.hh"
|
||
#include "lix/libstore/derivations.hh"
|
||
#include "lix/libexpr/eval.hh"
|
||
#include "lix/libexpr/eval-settings.hh"
|
||
#include "lix/libexpr/extra-primops.hh"
|
||
#include "lix/libexpr/gc-small-vector.hh"
|
||
#include "lix/libstore/globals.hh"
|
||
#include "lix/libexpr/json-to-value.hh"
|
||
#include "lix/libstore/names.hh"
|
||
#include "lix/libstore/path-references.hh"
|
||
#include "lix/libutil/async.hh"
|
||
#include "lix/libutil/json.hh"
|
||
#include "lix/libutil/processes.hh"
|
||
#include "lix/libstore/store-api.hh"
|
||
#include "lix/libexpr/value-to-json.hh"
|
||
#include "lix/libexpr/value-to-xml.hh"
|
||
#include "lix/libexpr/primops.hh"
|
||
#include "lix/libfetchers/fetch-to-store.hh"
|
||
#include "lix/libutil/c-calls.hh"
|
||
#include "lix/libutil/regex.hh"
|
||
#include "lix/libutil/types.hh"
|
||
#include "value.hh"
|
||
|
||
#include <boost/container/small_vector.hpp>
|
||
#include <kj/async.h>
|
||
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <tuple>
|
||
#include <unistd.h>
|
||
|
||
#include <algorithm>
|
||
#include <cstring>
|
||
#include <sstream>
|
||
#include <regex>
|
||
#include <dlfcn.h>
|
||
|
||
#include <cmath>
|
||
#include <cfenv>
|
||
|
||
namespace nix {
|
||
|
||
/*************************************************************
|
||
* Miscellaneous
|
||
*************************************************************/
|
||
|
||
StringMap EvalState::realiseContext(const NixStringContext & context)
|
||
{
|
||
std::vector<DerivedPath::Built> drvs;
|
||
StringMap res;
|
||
|
||
for (auto & c : context) {
|
||
auto ensureValid = [&](const StorePath & p) {
|
||
if (!aio.blockOn(ctx.store->isValidPath(p)))
|
||
ctx.errors.make<InvalidPathError>(ctx.store->printStorePath(p)).debugThrow(always_progresses);
|
||
};
|
||
std::visit(overloaded {
|
||
[&](const NixStringContextElem::Built & b) {
|
||
drvs.push_back(DerivedPath::Built {
|
||
.drvPath = b.drvPath,
|
||
.outputs = OutputsSpec::Names { b.output },
|
||
});
|
||
return ensureValid(b.drvPath.path);
|
||
},
|
||
[&](const NixStringContextElem::Opaque & o) {
|
||
auto ctxS = ctx.store->printStorePath(o.path);
|
||
res.insert_or_assign(ctxS, ctxS);
|
||
return ensureValid(o.path);
|
||
},
|
||
[&](const NixStringContextElem::DrvDeep & d) {
|
||
/* Treat same as Opaque */
|
||
auto ctxS = ctx.store->printStorePath(d.drvPath);
|
||
res.insert_or_assign(ctxS, ctxS);
|
||
return ensureValid(d.drvPath);
|
||
},
|
||
}, c.raw);
|
||
}
|
||
|
||
if (drvs.empty()) return StringMap{};
|
||
|
||
if (!evalSettings.enableImportFromDerivation)
|
||
ctx.errors.make<EvalError>(
|
||
"cannot build '%1%' during evaluation because the option 'allow-import-from-derivation' is disabled",
|
||
drvs.begin()->to_string(*ctx.store)
|
||
).debugThrow();
|
||
|
||
if (evalSettings.warnImportFromDerivation) {
|
||
printTaggedWarning(
|
||
"building '%1%' during evaluation due to the use of import from derivation",
|
||
drvs.begin()->to_string(*ctx.store)
|
||
);
|
||
}
|
||
|
||
/* Build/substitute the context. */
|
||
std::vector<DerivedPath> buildReqs;
|
||
for (auto & d : drvs) buildReqs.emplace_back(DerivedPath { d });
|
||
aio.blockOn(ctx.buildStore->buildPaths(buildReqs, bmNormal, ctx.store));
|
||
|
||
StorePathSet outputsToCopyAndAllow;
|
||
|
||
for (auto & drv : drvs) {
|
||
auto outputs = aio.blockOn(resolveDerivedPath(*ctx.buildStore, drv, &*ctx.store));
|
||
for (auto & [outputName, outputPath] : outputs) {
|
||
outputsToCopyAndAllow.insert(outputPath);
|
||
}
|
||
}
|
||
|
||
if (ctx.store != ctx.buildStore) {
|
||
aio.blockOn(copyClosure(*ctx.buildStore, *ctx.store, outputsToCopyAndAllow));
|
||
}
|
||
for (auto & outputPath : outputsToCopyAndAllow) {
|
||
/* Add the output of this derivations to the allowed
|
||
paths. */
|
||
ctx.paths.allowPath(outputPath);
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
static auto realisePath(EvalState & state, Value & v, auto checkFn)
|
||
{
|
||
NixStringContext context;
|
||
|
||
auto path = state.coerceToPath(noPos, v, context, "while realising the context of a path");
|
||
|
||
try {
|
||
StringMap rewrites = state.realiseContext(context);
|
||
|
||
return checkFn(SourcePath(CanonPath(
|
||
state.ctx.paths.toRealPath(rewriteStrings(path.canonical().abs(), rewrites), context)
|
||
)));
|
||
} catch (Error & e) {
|
||
e.addTrace(nullptr, "while realising the context of path '%s'", path);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
static CheckedSourcePath realisePath(EvalState & state, Value & v)
|
||
{
|
||
return realisePath(state, v, [&](auto p) { return state.ctx.paths.checkSourcePath(p); });
|
||
}
|
||
|
||
/**
|
||
* Add and attribute to the given attribute map from the output name to
|
||
* the output path, or a placeholder.
|
||
*
|
||
* Where possible the path is used, but for floating CA derivations we
|
||
* may not know it. For sake of determinism we always assume we don't
|
||
* and instead put in a place holder. In either case, however, the
|
||
* string context will contain the drv path and output name, so
|
||
* downstream derivations will have the proper dependency, and in
|
||
* addition, before building, the placeholder will be rewritten to be
|
||
* the actual path.
|
||
*
|
||
* The 'drv' and 'drvPath' outputs must correspond.
|
||
*/
|
||
static void mkOutputString(
|
||
EvalState & state,
|
||
BindingsBuilder & attrs,
|
||
const StorePath & drvPath,
|
||
const std::pair<std::string, DerivationOutput> & o)
|
||
{
|
||
attrs.insert(
|
||
o.first,
|
||
state.mkOutputString(
|
||
SingleDerivedPath::Built{
|
||
.drvPath = makeConstantStorePath(drvPath),
|
||
.output = o.first,
|
||
},
|
||
o.second.path(*state.ctx.store, Derivation::nameFromPath(drvPath), o.first)
|
||
)
|
||
);
|
||
}
|
||
|
||
/* Load and evaluate an expression from path specified by the
|
||
argument. */
|
||
static Value import(EvalState & state, Value & vPath, Value * vScope)
|
||
{
|
||
auto path = realisePath(state, vPath);
|
||
auto path2 = path.canonical().abs();
|
||
|
||
// FIXME
|
||
auto isValidDerivationInStore = [&]() -> std::optional<StorePath> {
|
||
if (!state.ctx.store->isStorePath(path2))
|
||
return std::nullopt;
|
||
auto storePath = state.ctx.store->parseStorePath(path2);
|
||
if (!(state.aio.blockOn(state.ctx.store->isValidPath(storePath)) && isDerivation(path2)))
|
||
return std::nullopt;
|
||
return storePath;
|
||
};
|
||
|
||
if (auto storePath = isValidDerivationInStore()) {
|
||
Derivation drv = state.aio.blockOn(state.ctx.store->readDerivation(*storePath));
|
||
auto attrs = state.ctx.buildBindings(3 + drv.outputs.size());
|
||
attrs.insert(
|
||
state.ctx.symbols.sym_drvPath,
|
||
{NewValueAs::string,
|
||
path2,
|
||
{
|
||
NixStringContextElem::DrvDeep{.drvPath = *storePath},
|
||
}}
|
||
);
|
||
attrs.insert(state.ctx.symbols.sym_name, {NewValueAs::string, drv.env["name"]});
|
||
auto outputsList = state.ctx.mem.newList(drv.outputs.size());
|
||
attrs.insert(state.ctx.symbols.sym_outputs, {NewValueAs::list, outputsList});
|
||
|
||
for (const auto & [i, o] : enumerate(drv.outputs)) {
|
||
mkOutputString(state, attrs, *storePath, o);
|
||
outputsList->elems[i] = {NewValueAs::string, o.first};
|
||
}
|
||
|
||
Value w{NewValueAs::attrs, attrs.finish()};
|
||
|
||
if (!state.ctx.caches.vImportedDrvToDerivation) {
|
||
state.ctx.caches.vImportedDrvToDerivation =
|
||
allocRootValue(state.eval(state.ctx.parseExprFromString(
|
||
#include "imported-drv-to-derivation.nix.gen.hh"
|
||
, CanonPath::root
|
||
)));
|
||
}
|
||
|
||
state.forceFunction(
|
||
*state.ctx.caches.vImportedDrvToDerivation,
|
||
noPos,
|
||
"while evaluating imported-drv-to-derivation.nix.gen.hh"
|
||
);
|
||
Value v = {NewValueAs::app, state.ctx.mem, *state.ctx.caches.vImportedDrvToDerivation, w};
|
||
state.forceAttrs(v, noPos, "while calling imported-drv-to-derivation.nix.gen.hh");
|
||
return v;
|
||
}
|
||
|
||
else if (path2 == corepkgsPrefix + "fetchurl.nix") {
|
||
return state.eval(state.ctx.parseExprFromString(
|
||
#include "fetchurl.nix.gen.hh"
|
||
, CanonPath::root
|
||
));
|
||
}
|
||
|
||
else {
|
||
if (!vScope)
|
||
return state.evalFile(path);
|
||
else {
|
||
state.forceAttrs(*vScope, noPos, "while evaluating the first argument passed to builtins.scopedImport");
|
||
|
||
Env * env = &state.ctx.mem.allocEnv(vScope->attrs()->size());
|
||
env->up = &state.ctx.builtins.env;
|
||
|
||
auto staticEnv = std::make_shared<StaticEnv>(
|
||
nullptr, state.ctx.builtins.staticEnv.get(), vScope->attrs()->size()
|
||
);
|
||
|
||
staticEnv->vars.unsafe_insert_bulk([&] (auto & map) {
|
||
unsigned int displ = 0;
|
||
for (auto & attr : *vScope->attrs()) {
|
||
// safety: args[0]->attrs is already sorted.
|
||
map.emplace_back(attr.name, displ);
|
||
env->values[displ++] = attr.value;
|
||
}
|
||
});
|
||
|
||
debug("evaluating file '%1%'", path);
|
||
Expr & e = state.ctx.parseExprFromFile(state.ctx.paths.resolveExprPath(path), staticEnv);
|
||
|
||
return e.eval(state, *env);
|
||
}
|
||
}
|
||
}
|
||
|
||
static Value prim_import(EvalState & state, Value ** args)
|
||
{
|
||
return import(state, *args[0], nullptr);
|
||
}
|
||
|
||
/* Want reasonable symbol names, so extern C */
|
||
/* !!! Should we pass the Pos or the file name too? */
|
||
extern "C" typedef void (*ValueInitializer)(EvalState & state, Value & v);
|
||
|
||
/* Load a ValueInitializer from a DSO and return whatever it initializes */
|
||
Value prim_importNative(EvalState & state, Value ** args)
|
||
{
|
||
# if LIX_MAJOR > 2 || (LIX_MAJOR == 2 && LIX_MINOR >= 97)
|
||
#pragma message ("Folks, we need to rip this out since we've reached 2.97 See fj#796 for more details")
|
||
# endif
|
||
printTaggedWarning("builtins.importNative is deprecated and will be removed in Lix 2.97, please migrate away from it. You can browse issue #795 for more details.");
|
||
|
||
auto path = realisePath(state, *args[0]);
|
||
|
||
std::string sym(state.forceStringNoCtx(*args[1], noPos, "while evaluating the second argument passed to builtins.importNative"));
|
||
|
||
void * handle = dlopen(requireCString(path.canonical().abs()), RTLD_LAZY | RTLD_LOCAL);
|
||
if (!handle)
|
||
state.ctx.errors.make<EvalError>("could not open '%1%': %2%", path, dlerror()).debugThrow();
|
||
|
||
dlerror();
|
||
ValueInitializer func = reinterpret_cast<ValueInitializer>(dlsym(handle, requireCString(sym)));
|
||
if(!func) {
|
||
char *message = dlerror();
|
||
if (message)
|
||
state.ctx.errors.make<EvalError>("could not load symbol '%1%' from '%2%': %3%", sym, path, message).debugThrow();
|
||
else
|
||
state.ctx.errors.make<EvalError>("symbol '%1%' from '%2%' resolved to NULL when a function pointer was expected", sym, path).debugThrow();
|
||
}
|
||
|
||
// Default construction of `Value` is deprecated, and uses of `Value&` out parameters
|
||
// have mostly been removed in favor of returning a `Value` instead. However in this
|
||
// particular case, this signature (ValueInitializer defined above) is externally visible,
|
||
// changing it would be an API breaking change, so for this one instance we just suppress
|
||
// the warning instead.
|
||
#pragma clang diagnostic push
|
||
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
|
||
Value v;
|
||
(func)(state, v);
|
||
#pragma clang diagnostic pop
|
||
|
||
/* We don't dlclose because v may be a primop referencing a function in the shared object file */
|
||
return v;
|
||
}
|
||
|
||
|
||
/* Execute a program and parse its output */
|
||
Value prim_exec(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[0], noPos, "while evaluating the first argument passed to builtins.exec");
|
||
auto elems = args[0]->listElems();
|
||
auto count = args[0]->listSize();
|
||
if (count == 0)
|
||
state.ctx.errors.make<EvalError>("at least one argument to 'exec' required").debugThrow();
|
||
NixStringContext context;
|
||
auto program =
|
||
state
|
||
.coerceToString(
|
||
noPos,
|
||
elems[0],
|
||
context,
|
||
"while evaluating the first element of the argument passed to builtins.exec",
|
||
StringCoercionMode::Strict,
|
||
false
|
||
)
|
||
.toOwned();
|
||
Strings commandArgs;
|
||
for (size_t i = 1; i < count; ++i) {
|
||
commandArgs.push_back(
|
||
state
|
||
.coerceToString(
|
||
noPos,
|
||
elems[i],
|
||
context,
|
||
"while evaluating an element of the argument passed to builtins.exec",
|
||
StringCoercionMode::Strict,
|
||
false
|
||
)
|
||
.toOwned()
|
||
);
|
||
}
|
||
try {
|
||
auto _ = state.realiseContext(context); // FIXME: Handle CA derivations
|
||
} catch (InvalidPathError & e) {
|
||
e.addTrace(nullptr, "while realising the context for builtins.exec");
|
||
throw;
|
||
}
|
||
|
||
auto output = state.aio.blockOn(runProgram(program, true, commandArgs));
|
||
Expr * parsed;
|
||
try {
|
||
parsed = &state.ctx.parseExprFromString(std::move(output), CanonPath::root);
|
||
} catch (Error & e) {
|
||
e.addTrace(nullptr, "while parsing the output from '%1%'", program);
|
||
throw;
|
||
}
|
||
try {
|
||
return state.eval(*parsed);
|
||
} catch (Error & e) {
|
||
e.addTrace(nullptr, "while evaluating the output from '%1%'", program);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
/* Return a string representing the type of the expression. */
|
||
static Value prim_typeOf(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
std::string t;
|
||
switch (args[0]->type()) {
|
||
case nInt: t = "int"; break;
|
||
case nBool: t = "bool"; break;
|
||
case nString: t = "string"; break;
|
||
case nPath: t = "path"; break;
|
||
case nNull: t = "null"; break;
|
||
case nAttrs: t = "set"; break;
|
||
case nList: t = "list"; break;
|
||
case nFunction: t = "lambda"; break;
|
||
case nExternal:
|
||
t = args[0]->external()->typeOf();
|
||
break;
|
||
case nFloat: t = "float"; break;
|
||
case nThunk: abort();
|
||
}
|
||
return {NewValueAs::string, t};
|
||
}
|
||
|
||
/* Determine whether the argument is the null value. */
|
||
static Value prim_isNull(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nNull};
|
||
}
|
||
|
||
/* Determine whether the argument is a function. */
|
||
static Value prim_isFunction(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nFunction};
|
||
}
|
||
|
||
/* Determine whether the argument is an integer. */
|
||
static Value prim_isInt(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nInt};
|
||
}
|
||
|
||
/* Determine whether the argument is a float. */
|
||
static Value prim_isFloat(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nFloat};
|
||
}
|
||
|
||
/* Determine whether the argument is a string. */
|
||
static Value prim_isString(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nString};
|
||
}
|
||
|
||
/* Determine whether the argument is a Boolean. */
|
||
static Value prim_isBool(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nBool};
|
||
}
|
||
|
||
/* Determine whether the argument is a path. */
|
||
static Value prim_isPath(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nPath};
|
||
}
|
||
|
||
template<typename Callable>
|
||
static inline void withExceptionContext(Trace trace, Callable&& func)
|
||
{
|
||
try
|
||
{
|
||
func();
|
||
}
|
||
catch(Error & e)
|
||
{
|
||
e.pushTrace(trace);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
struct CompareValues : NeverAsync
|
||
{
|
||
EvalState & state;
|
||
const std::string_view errorCtx;
|
||
|
||
CompareValues(EvalState & state, const std::string_view && errorCtx) : state(state), errorCtx(errorCtx) { };
|
||
|
||
bool operator()(Value * v1, Value * v2) const
|
||
{
|
||
return (*this)(*v1, *v2, errorCtx);
|
||
}
|
||
|
||
bool operator()(Value & v1, Value & v2) const
|
||
{
|
||
return (*this)(v1, v2, errorCtx);
|
||
}
|
||
|
||
bool operator()(Value const & v1, Value const & v2) const
|
||
{
|
||
return (*this)(v1, v2, errorCtx);
|
||
}
|
||
|
||
bool operator()(Value const & v1, Value const & v2, std::string_view errorCtx) const
|
||
{
|
||
try {
|
||
if (v1.type() == nFloat && v2.type() == nInt) {
|
||
return v1.fpoint() < v2.integer().value;
|
||
}
|
||
if (v1.type() == nInt && v2.type() == nFloat) {
|
||
return v1.integer().value < v2.fpoint();
|
||
}
|
||
if (v1.type() != v2.type()) {
|
||
state.ctx.errors
|
||
.make<EvalError>("cannot compare %s with %s", showType(v1), showType(v2))
|
||
.debugThrow();
|
||
}
|
||
// Allow selecting a subset of enum values
|
||
#pragma GCC diagnostic push
|
||
#pragma GCC diagnostic ignored "-Wswitch-enum"
|
||
switch (v1.type()) {
|
||
case nInt:
|
||
return v1.integer() < v2.integer();
|
||
case nFloat:
|
||
return v1.fpoint() < v2.fpoint();
|
||
case nString:
|
||
return v1.str() < v2.str();
|
||
case nPath:
|
||
return v1.string().content->str() < v2.string().content->str();
|
||
case nList:
|
||
// Lexicographic comparison
|
||
for (size_t i = 0;; i++) {
|
||
if (i == v2.listSize()) {
|
||
return false;
|
||
} else if (i == v1.listSize()) {
|
||
return true;
|
||
} else if (!state.eqValues(
|
||
v1.listElems()[i], v2.listElems()[i], noPos, errorCtx
|
||
))
|
||
{
|
||
return (*this)(
|
||
v1.listElems()[i],
|
||
v2.listElems()[i],
|
||
"while comparing two list elements"
|
||
);
|
||
}
|
||
}
|
||
default:
|
||
state.ctx.errors
|
||
.make<EvalError>(
|
||
"cannot compare %s with %s; values of that type are incomparable",
|
||
showType(v1),
|
||
showType(v2)
|
||
)
|
||
.debugThrow();
|
||
#pragma GCC diagnostic pop
|
||
}
|
||
} catch (Error & e) {
|
||
if (!errorCtx.empty())
|
||
e.addTrace(nullptr, errorCtx);
|
||
throw;
|
||
}
|
||
}
|
||
};
|
||
|
||
/// NOTE: this type must NEVER be outside of GC-scanned memory.
|
||
#if HAVE_BOEHMGC
|
||
using UnsafeValueList = std::list<Value, gc_allocator<Value>>;
|
||
#else
|
||
using UnsafeValueList = std::list<Value>;
|
||
#endif
|
||
|
||
static const Attr *
|
||
getAttr(EvalState & state, Symbol attrSym, Bindings * attrSet, std::string_view errorCtx)
|
||
{
|
||
auto value = attrSet->get(attrSym);
|
||
if (!value) {
|
||
state.ctx.errors.make<TypeError>("attribute '%s' missing", state.ctx.symbols[attrSym]).withTrace(noPos, errorCtx).debugThrow();
|
||
}
|
||
return value;
|
||
}
|
||
|
||
static Value prim_genericClosure(EvalState & state, Value ** args)
|
||
{
|
||
state.forceAttrs(*args[0], noPos, "while evaluating the first argument passed to builtins.genericClosure");
|
||
|
||
/* Get the start set. */
|
||
auto startSet = getAttr(
|
||
state,
|
||
state.ctx.symbols.sym_startSet,
|
||
args[0]->attrs(),
|
||
"in the attrset passed as argument to builtins.genericClosure"
|
||
);
|
||
|
||
state.forceList(
|
||
startSet->value,
|
||
noPos,
|
||
"while evaluating the 'startSet' attribute passed as argument to builtins.genericClosure"
|
||
);
|
||
|
||
UnsafeValueList workSet;
|
||
for (auto & elem : startSet->value.listItems()) {
|
||
workSet.push_back(elem);
|
||
}
|
||
|
||
if (startSet->value.listSize() == 0) {
|
||
return startSet->value;
|
||
}
|
||
|
||
/* Get the operator. */
|
||
auto op = getAttr(
|
||
state,
|
||
state.ctx.symbols.sym_operator,
|
||
args[0]->attrs(),
|
||
"in the attrset passed as argument to builtins.genericClosure"
|
||
);
|
||
state.forceFunction(
|
||
op->value,
|
||
noPos,
|
||
"while evaluating the 'operator' attribute passed as argument to builtins.genericClosure"
|
||
);
|
||
|
||
/* Construct the closure by applying the operator to elements of
|
||
`workSet', adding the result to `workSet', continuing until
|
||
no new elements are found. */
|
||
UnsafeValueList res;
|
||
// `doneKeys' doesn't need to be a GC root, because its values are
|
||
// reachable from res.
|
||
auto cmp = CompareValues(state, "while comparing the `key` attributes of two genericClosure elements");
|
||
std::set<Value, decltype(cmp)> doneKeys(cmp);
|
||
while (!workSet.empty()) {
|
||
Value e = *(workSet.begin());
|
||
workSet.pop_front();
|
||
|
||
state.forceAttrs(
|
||
e,
|
||
noPos,
|
||
"while evaluating one of the elements generated by (or initially passed to) "
|
||
"builtins.genericClosure"
|
||
);
|
||
|
||
auto key = getAttr(
|
||
state,
|
||
state.ctx.symbols.sym_key,
|
||
e.attrs(),
|
||
"in one of the attrsets generated by (or initially passed to) builtins.genericClosure"
|
||
);
|
||
state.forceValue(key->value, noPos);
|
||
|
||
if (!doneKeys.insert(key->value).second) {
|
||
continue;
|
||
}
|
||
res.push_back(e);
|
||
|
||
/* Call the `operator' function with `e' as argument. */
|
||
Value newElements = state.callFunction(op->value, {&e, 1}, noPos);
|
||
state.forceList(newElements, noPos, "while evaluating the return value of the `operator` passed to builtins.genericClosure");
|
||
|
||
/* Add the values returned by the operator to the work set. */
|
||
for (auto & elem : newElements.listItems()) {
|
||
state.forceValue(elem, noPos); // "while evaluating one one of the elements returned by
|
||
// the `operator` passed to builtins.genericClosure");
|
||
workSet.push_back(elem);
|
||
}
|
||
}
|
||
|
||
/* Create the result list. */
|
||
auto result = state.ctx.mem.newList(res.size());
|
||
unsigned int n = 0;
|
||
for (auto & i : res)
|
||
result->elems[n++] = i;
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
static Value prim_break(EvalState & state, Value ** args)
|
||
{
|
||
if (auto const trace = state.ctx.nextDebugTrace()) {
|
||
auto error = EvalError(ErrorInfo {
|
||
.level = lvlInfo,
|
||
.msg = HintFmt("breakpoint reached"),
|
||
});
|
||
|
||
state.ctx.debug->onEvalError(&error, (*trace)->env, (*trace)->expr);
|
||
}
|
||
|
||
// Return the value we were passed.
|
||
state.forceValue(*args[0], noPos);
|
||
return *args[0];
|
||
}
|
||
|
||
static Value prim_abort(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
auto s = state.coerceToString(noPos, *args[0], context,
|
||
"while evaluating the error message passed to builtins.abort").toOwned();
|
||
state.ctx.errors.make<Abort>("evaluation aborted with the following error message: '%1%'", s).debugThrow();
|
||
}
|
||
|
||
static Value prim_throw(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
auto s = state
|
||
.coerceToString(
|
||
noPos, *args[0], context, "while evaluating the error message passed to builtin.throw"
|
||
)
|
||
.toOwned();
|
||
state.ctx.errors.make<ThrownError>(s).debugThrow();
|
||
}
|
||
|
||
static Value prim_addErrorContext(EvalState & state, Value ** args)
|
||
{
|
||
try {
|
||
state.forceValue(*args[1], noPos);
|
||
return *args[1];
|
||
} catch (Error & e) {
|
||
NixStringContext context;
|
||
auto message = state.coerceToString(noPos, *args[0], context,
|
||
"while evaluating the error message passed to builtins.addErrorContext",
|
||
StringCoercionMode::Strict, false).toOwned();
|
||
e.addTrace(nullptr, HintFmt(message), TraceKind::UserTrace);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
static std::optional<NixInt> floatToIntChecked(NixFloat f)
|
||
{
|
||
// Required to detect overflows when converting floats to integers
|
||
#pragma STDC FENV_ACCESS ON
|
||
|
||
std::feclearexcept(FE_ALL_EXCEPT);
|
||
auto converted = llrint(f);
|
||
if (std::fetestexcept(FE_ALL_EXCEPT)) {
|
||
return std::nullopt;
|
||
}
|
||
return NixInt{converted};
|
||
}
|
||
|
||
/*
|
||
Note [floor/ceil corrupt integers]:
|
||
Integers above 2**54 that aren't a power of two get corrupted when passed
|
||
through floor/ceil.
|
||
|
||
Corrupting integers would become impossible if we just passed through integer
|
||
inputs, since the corruption actually happens when casting from int to float,
|
||
*not* from float to int, which is the one we actually safely cast.
|
||
|
||
Floats generate an error as intended if they are out of range.
|
||
|
||
In a future release, we'd like to pass through all integers, but it would be
|
||
an eval semantics change, so it's safer to error first before relaxing the
|
||
semantics again.
|
||
*/
|
||
|
||
using FloorCeilFunc = auto (*)(NixFloat) -> NixFloat;
|
||
|
||
static Value
|
||
floorCeil(std::string_view const which, FloorCeilFunc f, EvalState & state, NixFloat value, Value * arg0)
|
||
{
|
||
bool isInt = arg0->type() == nInt;
|
||
|
||
NixFloat result = f(value);
|
||
|
||
if (auto checked = floatToIntChecked(result); checked.has_value()) {
|
||
// See Note [floor/ceil corrupt integers].
|
||
if (isInt && *checked != arg0->integer()
|
||
&& !featureSettings.isEnabled(DeprecatedFeature::FloorCeilCorruptIntegers))
|
||
{
|
||
state.ctx.errors
|
||
.make<EvalError>(
|
||
"%s was corrupting your integer (was %d, became %d) in previous versions due to a "
|
||
"historical Nix bug (https://github.com/NixOS/nix/issues/12899).\n"
|
||
"This may be changed in the future to pass through integers as-is, which will change the "
|
||
"semantics of this code.\n"
|
||
"To suppress this error, use %s",
|
||
which,
|
||
arg0->integer(),
|
||
*checked,
|
||
"--extra-deprecated-features floor-ceil-corrupt-integers"
|
||
)
|
||
.debugThrow();
|
||
}
|
||
return {NewValueAs::integer, NixInt::Inner(*checked)};
|
||
} else {
|
||
state.ctx.errors.make<EvalError>("%s result %f is out of range for Nix integer (i64)", which, result)
|
||
.debugThrow();
|
||
}
|
||
}
|
||
|
||
static Value prim_ceil(EvalState & state, Value ** args)
|
||
{
|
||
auto value = state.forceFloat(*args[0], noPos, "while evaluating the argument passed to builtins.ceil");
|
||
return floorCeil("builtins.ceil", ceil, state, value, args[0]);
|
||
}
|
||
|
||
static Value prim_floor(EvalState & state, Value ** args)
|
||
{
|
||
auto value = state.forceFloat(*args[0], noPos, "while evaluating the argument passed to builtins.floor");
|
||
return floorCeil("builtins.floor", floor, state, value, args[0]);
|
||
}
|
||
|
||
/* Try evaluating the argument. Success => {success=true; value=something;},
|
||
* else => {success=false; value=false;} */
|
||
static Value prim_tryEval(EvalState & state, Value ** args)
|
||
{
|
||
auto attrs = state.ctx.buildBindings(2);
|
||
|
||
const bool success = [&] {
|
||
std::optional<MaintainCount<int>> trylevel;
|
||
DebugState * savedDebug = nullptr;
|
||
KJ_DEFER({
|
||
if (savedDebug) {
|
||
state.ctx.errors.debug = savedDebug;
|
||
}
|
||
});
|
||
if (state.ctx.errors.debug != nullptr) {
|
||
trylevel.emplace(state.ctx.errors.debug->trylevel);
|
||
if (evalSettings.ignoreExceptionsDuringTry) {
|
||
/* to prevent starting the repl from exceptions within a tryEval, null it. */
|
||
savedDebug = state.ctx.errors.debug;
|
||
state.ctx.errors.debug = nullptr;
|
||
}
|
||
}
|
||
|
||
try {
|
||
state.forceValue(*args[0], noPos);
|
||
} catch (AssertionError & e) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}();
|
||
if (success)
|
||
attrs.insert(state.ctx.symbols.sym_value, *args[0]);
|
||
else
|
||
attrs.insert(state.ctx.symbols.sym_value, {NewValueAs::boolean, false});
|
||
attrs.insert("success", {NewValueAs::boolean, success});
|
||
|
||
return {NewValueAs::attrs, attrs};
|
||
}
|
||
|
||
/* Return an environment variable. Use with care. */
|
||
static Value prim_getEnv(EvalState & state, Value ** args)
|
||
{
|
||
std::string name(state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.getEnv"));
|
||
return {
|
||
NewValueAs::string,
|
||
evalSettings.restrictEval || evalSettings.pureEval ? "" : getEnv(name).value_or("")
|
||
};
|
||
}
|
||
|
||
/* Evaluate the first argument, then return the second argument. */
|
||
static Value prim_seq(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
state.forceValue(*args[1], noPos);
|
||
return *args[1];
|
||
}
|
||
|
||
/* Evaluate the first argument deeply (i.e. recursing into lists and
|
||
attrsets), then return the second argument. */
|
||
static Value prim_deepSeq(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValueDeep(*args[0]);
|
||
state.forceValue(*args[1], noPos);
|
||
return *args[1];
|
||
}
|
||
|
||
/* Evaluate the first expression and print it on standard error. Then
|
||
return the second expression. Useful for debugging. */
|
||
static Value prim_trace(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
if (args[0]->type() == nString)
|
||
printError("trace: %1%", Uncolored(args[0]->str()));
|
||
else
|
||
printError("trace: %1%", Uncolored(ValuePrinter(state, *args[0])));
|
||
|
||
if (evalSettings.debuggerOnTrace) {
|
||
if (auto const trace = state.ctx.nextDebugTrace()) {
|
||
state.ctx.debug->onEvalError(nullptr, (*trace)->env, (*trace)->expr);
|
||
}
|
||
}
|
||
|
||
state.forceValue(*args[1], noPos);
|
||
return *args[1];
|
||
}
|
||
|
||
static Value prim_warn(EvalState & state, Value ** args)
|
||
{
|
||
// We only accept a string argument for now. The use case for pretty printing a value is covered
|
||
// by `trace`. By rejecting non-strings we allow future versions to add more features without
|
||
// breaking existing code.
|
||
auto const msg =
|
||
state.forceString(*args[0], noPos, "while evaluating message for builtins.warn");
|
||
|
||
printTaggedWarning("%s", Uncolored(msg));
|
||
|
||
if (evalSettings.abortOnWarn) {
|
||
state.ctx.errors.make<Abort>("evaluation aborted (abort-on-warn)")
|
||
.debugThrow();
|
||
}
|
||
|
||
if (evalSettings.debuggerOnWarn) {
|
||
if (auto const trace = state.ctx.nextDebugTrace()) {
|
||
auto const error = EvalError(ErrorInfo{
|
||
.level = lvlWarn,
|
||
.msg = HintFmt("builtins.warn reached"),
|
||
});
|
||
|
||
state.ctx.debug->onEvalError(&error, (*trace)->env, (*trace)->expr);
|
||
}
|
||
}
|
||
|
||
state.forceValue(*args[1], noPos);
|
||
return *args[1];
|
||
}
|
||
|
||
/* Takes two arguments and evaluates to the second one. Used as the
|
||
* builtins.traceVerbose implementation when --trace-verbose is not enabled
|
||
*/
|
||
static Value prim_second(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[1], noPos);
|
||
return *args[1];
|
||
}
|
||
|
||
/*************************************************************
|
||
* Derivations
|
||
*************************************************************/
|
||
|
||
static Value derivationStrictInternal(EvalState & state, const std::string & name, Bindings * attrs);
|
||
|
||
/* Construct (as a unobservable side effect) a Nix derivation
|
||
expression that performs the derivation described by the argument
|
||
set. Returns the original set extended with the following
|
||
attributes: `outPath' containing the primary output path of the
|
||
derivation; `drvPath' containing the path of the Nix expression;
|
||
and `type' set to `derivation' to indicate that this is a
|
||
derivation. */
|
||
static Value prim_derivationStrict(EvalState & state, Value ** args)
|
||
{
|
||
state.forceAttrs(*args[0], noPos, "while evaluating the argument passed to builtins.derivationStrict");
|
||
|
||
Bindings * attrs = args[0]->attrs();
|
||
|
||
/* Figure out the name first (for stack backtraces). */
|
||
auto nameAttr = getAttr(
|
||
state,
|
||
state.ctx.symbols.sym_name,
|
||
attrs,
|
||
"in the attrset passed as argument to builtins.derivationStrict"
|
||
);
|
||
|
||
std::string drvName;
|
||
try {
|
||
drvName = state.forceStringNoCtx(
|
||
nameAttr->value,
|
||
noPos,
|
||
"while evaluating the `name` attribute passed to builtins.derivationStrict"
|
||
);
|
||
} catch (Error & e) {
|
||
e.addTrace(
|
||
state.ctx.positions[nameAttr->pos], "while evaluating the derivation attribute 'name'"
|
||
);
|
||
throw;
|
||
}
|
||
|
||
try {
|
||
return derivationStrictInternal(state, drvName, attrs);
|
||
} catch (Error & e) {
|
||
Pos pos = state.ctx.positions[nameAttr->pos];
|
||
/*
|
||
* Here we make two abuses of the error system
|
||
*
|
||
* 1. We print the location as a string to avoid a code snippet being
|
||
* printed. While the location of the name attribute is a good hint, the
|
||
* exact code there is irrelevant.
|
||
*
|
||
* 2. We mark this trace as a frame trace, meaning that we stop printing
|
||
* less important traces from now on. In particular, this prevents the
|
||
* display of the automatic "while calling builtins.derivationStrict"
|
||
* trace, which is of little use for the public we target here.
|
||
*
|
||
* Please keep in mind that error reporting is done on a best-effort
|
||
* basis in nix. There is no accurate location for a derivation, as it
|
||
* often results from the composition of several functions
|
||
* (derivationStrict, derivation, mkDerivation, mkPythonModule, etc.)
|
||
*/
|
||
|
||
e.pushTrace(Trace::fromDrv(
|
||
state.ctx.positions[nameAttr->pos],
|
||
drvName
|
||
));
|
||
|
||
throw;
|
||
}
|
||
}
|
||
|
||
static Value derivationStrictInternal(EvalState & state, const std::string & drvName, Bindings * attrs)
|
||
{
|
||
/* Check whether attributes should be passed as a JSON file. */
|
||
std::optional<JSON> jsonObject;
|
||
auto attr = attrs->get(state.ctx.symbols.sym___structuredAttrs);
|
||
if (attr
|
||
&& state.forceBool(
|
||
attr->value,
|
||
attr->pos,
|
||
"while evaluating the `__structuredAttrs` "
|
||
"attribute passed to builtins.derivationStrict"
|
||
))
|
||
{
|
||
if (attrs->get(state.ctx.symbols.sym___json)) {
|
||
state.ctx.errors
|
||
.make<EvalError>(
|
||
"a `__json` attribute cannot be passed to builtins.derivationStrict when structured "
|
||
"attributes are enabled"
|
||
)
|
||
.debugThrow();
|
||
}
|
||
jsonObject = JSON::object();
|
||
}
|
||
|
||
/* Check whether null attributes should be ignored. */
|
||
bool ignoreNulls = false;
|
||
attr = attrs->get(state.ctx.symbols.sym___ignoreNulls);
|
||
if (attr) {
|
||
ignoreNulls = state.forceBool(
|
||
attr->value,
|
||
attr->pos,
|
||
"while evaluating the `__ignoreNulls` attribute "
|
||
"passed to builtins.derivationStrict"
|
||
);
|
||
}
|
||
|
||
/* Build the derivation expression by processing the attributes. */
|
||
Derivation drv;
|
||
drv.name = drvName;
|
||
|
||
NixStringContext context;
|
||
|
||
std::optional<std::string> outputHash;
|
||
std::string outputHashAlgo;
|
||
std::optional<ContentAddressMethod> ingestionMethod;
|
||
|
||
StringSet outputs;
|
||
outputs.insert("out");
|
||
|
||
for (auto & i : attrs->lexicographicOrder(state.ctx.symbols)) {
|
||
if (i->name == state.ctx.symbols.sym___ignoreNulls) {
|
||
continue;
|
||
}
|
||
auto & key = state.ctx.symbols[i->name];
|
||
vomit("processing attribute '%1%'", key);
|
||
|
||
auto handleHashMode = [&](const std::string_view s, NeverAsync = {}) {
|
||
if (s == "recursive") ingestionMethod = FileIngestionMethod::Recursive;
|
||
else if (s == "flat") ingestionMethod = FileIngestionMethod::Flat;
|
||
else
|
||
state.ctx.errors.make<EvalError>(
|
||
"invalid value '%s' for 'outputHashMode' attribute", s
|
||
).debugThrow();
|
||
};
|
||
|
||
auto handleOutputs = [&](const Strings & ss, NeverAsync = {}) {
|
||
outputs.clear();
|
||
for (auto & j : ss) {
|
||
if (outputs.find(j) != outputs.end())
|
||
state.ctx.errors.make<EvalError>("duplicate derivation output '%1%'", j)
|
||
.debugThrow();
|
||
/* !!! Check whether j is a valid attribute
|
||
name. */
|
||
/* Derivations cannot be named ‘drv’, because
|
||
then we'd have an attribute ‘drvPath’ in
|
||
the resulting set. */
|
||
if (j == "drv")
|
||
state.ctx.errors.make<EvalError>("invalid derivation output name 'drv'")
|
||
.debugThrow();
|
||
outputs.insert(j);
|
||
}
|
||
if (outputs.empty())
|
||
state.ctx.errors.make<EvalError>("derivation cannot have an empty set of outputs")
|
||
.debugThrow();
|
||
};
|
||
|
||
try {
|
||
// This try-catch block adds context for most errors.
|
||
// Use this empty error context to signify that we defer to it.
|
||
const std::string_view context_below("");
|
||
|
||
if (ignoreNulls) {
|
||
state.forceValue(i->value, noPos);
|
||
if (i->value.type() == nNull) {
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (i->name == state.ctx.symbols.sym___contentAddressed
|
||
&& state.forceBool(i->value, noPos, context_below))
|
||
{
|
||
state.ctx.errors.make<EvalError>("ca derivations are not supported in Lix")
|
||
.debugThrow();
|
||
}
|
||
|
||
else if (i->name == state.ctx.symbols.sym___impure
|
||
&& state.forceBool(i->value, noPos, context_below))
|
||
{
|
||
state.ctx.errors.make<EvalError>("impure derivations are not supported in Lix")
|
||
.debugThrow();
|
||
}
|
||
|
||
/* The `args' attribute is special: it supplies the
|
||
command-line arguments to the builder. */
|
||
else if (i->name == state.ctx.symbols.sym_args)
|
||
{
|
||
state.forceList(i->value, noPos, context_below);
|
||
for (auto & elem : i->value.listItems()) {
|
||
auto s = state
|
||
.coerceToString(
|
||
noPos,
|
||
elem,
|
||
context,
|
||
"while evaluating an element of the argument list",
|
||
StringCoercionMode::ToString
|
||
)
|
||
.toOwned();
|
||
drv.args.push_back(s);
|
||
}
|
||
}
|
||
|
||
/* All other attributes are passed to the builder through
|
||
the environment. */
|
||
else {
|
||
|
||
if (jsonObject) {
|
||
|
||
if (i->name == state.ctx.symbols.sym___structuredAttrs) {
|
||
continue;
|
||
}
|
||
|
||
(*jsonObject)[std::string(key)] =
|
||
printValueAsJSON(state, true, i->value, noPos, context);
|
||
|
||
if (i->name == state.ctx.symbols.sym_builder) {
|
||
drv.builder = state.forceString(i->value, context, noPos, context_below);
|
||
} else if (i->name == state.ctx.symbols.sym_system) {
|
||
drv.platform = state.forceStringNoCtx(i->value, noPos, context_below);
|
||
} else if (i->name == state.ctx.symbols.sym_outputHash) {
|
||
outputHash = state.forceStringNoCtx(i->value, noPos, context_below);
|
||
} else if (i->name == state.ctx.symbols.sym_outputHashAlgo) {
|
||
outputHashAlgo = state.forceStringNoCtx(i->value, noPos, context_below);
|
||
} else if (i->name == state.ctx.symbols.sym_outputHashMode) {
|
||
handleHashMode(state.forceStringNoCtx(i->value, noPos, context_below));
|
||
} else if (i->name == state.ctx.symbols.sym_outputs) {
|
||
/* Require ‘outputs’ to be a list of strings. */
|
||
state.forceList(i->value, noPos, context_below);
|
||
Strings ss;
|
||
for (auto & elem : i->value.listItems()) {
|
||
ss.emplace_back(state.forceStringNoCtx(elem, noPos, context_below));
|
||
}
|
||
handleOutputs(ss);
|
||
}
|
||
|
||
if (i->name == state.ctx.symbols.sym_allowedReferences) {
|
||
printTaggedWarning(
|
||
"In a derivation named '%s', 'structuredAttrs' disables the effect of "
|
||
"the derivation attribute 'allowedReferences'; use "
|
||
"'outputChecks.<output>.allowedReferences' instead",
|
||
drvName
|
||
);
|
||
}
|
||
if (i->name == state.ctx.symbols.sym_allowedRequisites) {
|
||
printTaggedWarning(
|
||
"In a derivation named '%s', 'structuredAttrs' disables the effect of "
|
||
"the derivation attribute 'allowedRequisites'; use "
|
||
"'outputChecks.<output>.allowedRequisites' instead",
|
||
drvName
|
||
);
|
||
}
|
||
if (i->name == state.ctx.symbols.sym_disallowedReferences) {
|
||
printTaggedWarning(
|
||
"In a derivation named '%s', 'structuredAttrs' disables the effect of "
|
||
"the derivation attribute 'disallowedReferences'; use "
|
||
"'outputChecks.<output>.disallowedReferences' instead",
|
||
drvName
|
||
);
|
||
}
|
||
if (i->name == state.ctx.symbols.sym_disallowedRequisites) {
|
||
printTaggedWarning(
|
||
"In a derivation named '%s', 'structuredAttrs' disables the effect of "
|
||
"the derivation attribute 'disallowedRequisites'; use "
|
||
"'outputChecks.<output>.disallowedRequisites' instead",
|
||
drvName
|
||
);
|
||
}
|
||
if (i->name == state.ctx.symbols.sym_maxSize) {
|
||
printTaggedWarning(
|
||
"In a derivation named '%s', 'structuredAttrs' disables the effect of "
|
||
"the derivation attribute 'maxSize'; use "
|
||
"'outputChecks.<output>.maxSize' instead",
|
||
drvName
|
||
);
|
||
}
|
||
if (i->name == state.ctx.symbols.sym_maxClosureSize) {
|
||
printTaggedWarning(
|
||
"In a derivation named '%s', 'structuredAttrs' disables the effect of "
|
||
"the derivation attribute 'maxClosureSize'; use "
|
||
"'outputChecks.<output>.maxClosureSize' instead",
|
||
drvName
|
||
);
|
||
}
|
||
|
||
} else {
|
||
auto s = state
|
||
.coerceToString(
|
||
noPos,
|
||
i->value,
|
||
context,
|
||
context_below,
|
||
StringCoercionMode::ToString
|
||
)
|
||
.toOwned();
|
||
drv.env.emplace(key, s);
|
||
if (i->name == state.ctx.symbols.sym_builder) {
|
||
drv.builder = std::move(s);
|
||
} else if (i->name == state.ctx.symbols.sym_system) {
|
||
drv.platform = std::move(s);
|
||
} else if (i->name == state.ctx.symbols.sym_outputHash) {
|
||
outputHash = std::move(s);
|
||
} else if (i->name == state.ctx.symbols.sym_outputHashAlgo) {
|
||
outputHashAlgo = std::move(s);
|
||
} else if (i->name == state.ctx.symbols.sym_outputHashMode) {
|
||
handleHashMode(s);
|
||
} else if (i->name == state.ctx.symbols.sym_outputs) {
|
||
handleOutputs(tokenizeString<Strings>(s));
|
||
}
|
||
}
|
||
}
|
||
|
||
} catch (Error & e) {
|
||
e.pushTrace(Trace::fromDrvAttr(
|
||
state.ctx.positions[i->pos],
|
||
std::string(drvName),
|
||
std::string(key)
|
||
));
|
||
throw;
|
||
}
|
||
}
|
||
|
||
if (jsonObject) {
|
||
drv.env.emplace("__json", jsonObject->dump());
|
||
jsonObject.reset();
|
||
}
|
||
|
||
/* Everything in the context of the strings in the derivation
|
||
attributes should be added as dependencies of the resulting
|
||
derivation. */
|
||
for (auto & c : context) {
|
||
std::visit(overloaded {
|
||
/* Since this allows the builder to gain access to every
|
||
path in the dependency graph of the derivation (including
|
||
all outputs), all paths in the graph must be added to
|
||
this derivation's list of inputs to ensure that they are
|
||
available when the builder runs. */
|
||
[&](const NixStringContextElem::DrvDeep & d) {
|
||
/* !!! This doesn't work if readOnlyMode is set. */
|
||
StorePathSet refs;
|
||
state.aio.blockOn(state.ctx.store->computeFSClosure(d.drvPath, refs));
|
||
for (auto & j : refs) {
|
||
drv.inputSrcs.insert(j);
|
||
if (j.isDerivation()) {
|
||
drv.inputDrvs[j] =
|
||
state.aio.blockOn(state.ctx.store->readDerivation(j)).outputNames();
|
||
}
|
||
}
|
||
},
|
||
[&](const NixStringContextElem::Built & b) {
|
||
drv.inputDrvs[b.drvPath.path].insert(b.output);
|
||
},
|
||
[&](const NixStringContextElem::Opaque & o) {
|
||
drv.inputSrcs.insert(o.path);
|
||
},
|
||
}, c.raw);
|
||
}
|
||
|
||
/* Do we have all required attributes? */
|
||
if (drv.builder == "")
|
||
state.ctx.errors.make<EvalError>("required attribute 'builder' missing")
|
||
.debugThrow();
|
||
|
||
if (drv.platform == "")
|
||
state.ctx.errors.make<EvalError>("required attribute 'system' missing")
|
||
.debugThrow();
|
||
|
||
/* Check whether the derivation name is valid. */
|
||
if (isDerivation(drvName)) {
|
||
state.ctx.errors
|
||
.make<EvalError>("derivation names are not allowed to end in '%s'", drvExtension)
|
||
.debugThrow();
|
||
}
|
||
|
||
if (outputHash) {
|
||
/* Handle fixed-output derivations.
|
||
|
||
Ignore `__contentAddressed` because fixed output derivations are
|
||
already content addressed. */
|
||
if (outputs.size() != 1 || *(outputs.begin()) != "out")
|
||
state.ctx.errors.make<EvalError>(
|
||
"multiple outputs are not supported in fixed-output derivations"
|
||
).debugThrow();
|
||
|
||
auto h = newHashAllowEmpty(*outputHash, parseHashTypeOpt(outputHashAlgo));
|
||
|
||
auto method = ingestionMethod.value_or(FileIngestionMethod::Flat);
|
||
|
||
DerivationOutput::CAFixed dof {
|
||
.ca = ContentAddress {
|
||
.method = std::move(method),
|
||
.hash = std::move(h),
|
||
},
|
||
};
|
||
|
||
drv.env["out"] = state.ctx.store->printStorePath(dof.path(*state.ctx.store, drvName, "out"));
|
||
drv.outputs.insert_or_assign("out", std::move(dof));
|
||
}
|
||
|
||
else {
|
||
/* Compute a hash over the "masked" store derivation, which is
|
||
the final one except that in the list of outputs, the
|
||
output paths are empty strings, and the corresponding
|
||
environment variables have an empty value. This ensures
|
||
that changes in the set of output names do get reflected in
|
||
the hash. */
|
||
for (auto & i : outputs) {
|
||
drv.env[i] = "";
|
||
drv.outputs.insert_or_assign(i,
|
||
DerivationOutput::InputAddressed { .path = StorePath::dummy });
|
||
}
|
||
|
||
auto hashModulo =
|
||
state.aio.blockOn(hashDerivationModulo(*state.ctx.store, Derivation(drv), true));
|
||
for (auto & i : outputs) {
|
||
auto h = get(hashModulo.hashes, i);
|
||
if (!h)
|
||
state.ctx.errors.make<AssertionError>(
|
||
"derivation produced no hash for output '%s'",
|
||
i
|
||
).debugThrow();
|
||
auto outPath = state.ctx.store->makeOutputPath(i, *h, drvName);
|
||
drv.env[i] = state.ctx.store->printStorePath(outPath);
|
||
drv.outputs.insert_or_assign(
|
||
i,
|
||
DerivationOutput::InputAddressed {
|
||
.path = std::move(outPath),
|
||
});
|
||
}
|
||
}
|
||
|
||
/* Write the resulting term into the Nix store directory. */
|
||
auto drvPath = state.aio.blockOn(writeDerivation(*state.ctx.store, drv, state.ctx.repair));
|
||
auto drvPathS = state.ctx.store->printStorePath(drvPath);
|
||
|
||
printMsg(lvlChatty, "instantiated '%1%' -> '%2%'", drvName, drvPathS);
|
||
|
||
/* Optimisation, but required in read-only mode! because in that
|
||
case we don't actually write store derivations, so we can't
|
||
read them later. */
|
||
{
|
||
auto h = state.aio.blockOn(hashDerivationModulo(*state.ctx.store, drv, false));
|
||
drvHashes.lock()->insert_or_assign(drvPath, h);
|
||
}
|
||
|
||
auto result = state.ctx.buildBindings(1 + drv.outputs.size());
|
||
result.insert(
|
||
state.ctx.symbols.sym_drvPath,
|
||
{NewValueAs::string,
|
||
drvPathS,
|
||
{
|
||
NixStringContextElem::DrvDeep{.drvPath = drvPath},
|
||
}}
|
||
);
|
||
for (auto & i : drv.outputs)
|
||
mkOutputString(state, result, drvPath, i);
|
||
|
||
return {NewValueAs::attrs, result};
|
||
}
|
||
|
||
/* Return a placeholder string for the specified output that will be
|
||
substituted by the corresponding output path at build time. For
|
||
example, 'placeholder "out"' returns the string
|
||
/1rz4g4znpzjwh1xymhjpm42vipw92pr73vdgl6xs1hycac8kf2n9. At build
|
||
time, any occurrence of this string in an derivation attribute will
|
||
be replaced with the concrete path in the Nix store of the output
|
||
‘out’. */
|
||
static Value prim_placeholder(EvalState & state, Value ** args)
|
||
{
|
||
return {
|
||
NewValueAs::string,
|
||
hashPlaceholder(state.forceStringNoCtx(
|
||
*args[0], noPos, "while evaluating the first argument passed to builtins.placeholder"
|
||
))
|
||
};
|
||
}
|
||
|
||
|
||
/*************************************************************
|
||
* Paths
|
||
*************************************************************/
|
||
|
||
|
||
/* Convert the argument to a path. !!! obsolete? */
|
||
static Value prim_toPath(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
auto path = state.coerceToPath(noPos, *args[0], context, "while evaluating the first argument passed to builtins.toPath");
|
||
return {NewValueAs::string, path.to_string(), context};
|
||
}
|
||
|
||
/* Allow a valid store path to be used in an expression. This is
|
||
useful in some generated expressions such as in nix-push, which
|
||
generates a call to a function with an already existing store path
|
||
as argument. You don't want to use `toPath' here because it copies
|
||
the path to the Nix store, which yields a copy like
|
||
/nix/store/newhash-oldhash-oldname. In the past, `toPath' had
|
||
special case behaviour for store paths, but that created weird
|
||
corner cases. */
|
||
static Value prim_storePath(EvalState & state, Value ** args)
|
||
{
|
||
if (evalSettings.pureEval)
|
||
state.ctx.errors.make<EvalError>(
|
||
"'%s' is not allowed in pure evaluation mode",
|
||
"builtins.storePath"
|
||
).debugThrow();
|
||
|
||
NixStringContext context;
|
||
auto path = state.ctx.paths.checkSourcePath(state.coerceToPath(noPos, *args[0], context, "while evaluating the first argument passed to builtins.storePath")).canonical();
|
||
/* Resolve symlinks in ‘path’, unless ‘path’ itself is a symlink
|
||
directly in the store. The latter condition is necessary so
|
||
e.g. nix-push does the right thing. */
|
||
if (!state.ctx.store->isStorePath(path.abs()))
|
||
path = CanonPath(canonPath(path.abs(), true));
|
||
if (!state.ctx.store->isInStore(path.abs()))
|
||
state.ctx.errors.make<EvalError>("path '%1%' is not in the Nix store", path)
|
||
.debugThrow();
|
||
auto path2 = state.ctx.store->toStorePath(path.abs()).first;
|
||
if (!settings.readOnlyMode)
|
||
state.aio.blockOn(state.ctx.store->ensurePath(path2));
|
||
context.insert(NixStringContextElem::Opaque { .path = path2 });
|
||
return {NewValueAs::string, path.abs(), context};
|
||
}
|
||
|
||
static Value prim_pathExists(EvalState & state, Value ** args)
|
||
{
|
||
auto & arg = *args[0];
|
||
|
||
/* We don’t check the path right now, because we don’t want to
|
||
throw if the path isn’t allowed, but just return false (and we
|
||
can’t just catch the exception here because we still want to
|
||
throw if something in the evaluation of `arg` tries to
|
||
access an unauthorized path). */
|
||
auto path = realisePath(state, arg, std::identity{});
|
||
|
||
/* SourcePath doesn't know about trailing slash. */
|
||
auto mustBeDir = arg.type() == nString
|
||
&& (arg.str().ends_with("/")
|
||
|| arg.str().ends_with("/."));
|
||
|
||
try {
|
||
auto checked = state.ctx.paths.checkSourcePath(path);
|
||
|
||
// previously we fully resolved symlinks in the mustBeDir case or in pure eval
|
||
// mode (by accident, since checkSourcePath does this in that case), and up to
|
||
// the last component otherwise. this is equivalent to calling stat and lstat,
|
||
// respectively. (in neither case do intermediate symlinks affect the result.)
|
||
auto st = mustBeDir ? checked.maybeStat() : checked.maybeLstat();
|
||
auto exists = st && (!mustBeDir || st->type == InputAccessor::tDirectory);
|
||
return {NewValueAs::boolean, exists};
|
||
} catch (SysError & e) {
|
||
/* Don't give away info from errors while canonicalising
|
||
‘path’ in restricted mode. */
|
||
return {NewValueAs::boolean, false};
|
||
} catch (RestrictedPathError & e) {
|
||
return {NewValueAs::boolean, false};
|
||
}
|
||
}
|
||
|
||
/* Return the base name of the given string, i.e., everything
|
||
following the last slash. */
|
||
static Value prim_baseNameOf(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
return {
|
||
NewValueAs::string,
|
||
baseNameOf(*state.coerceToString(
|
||
noPos,
|
||
*args[0],
|
||
context,
|
||
"while evaluating the first argument passed to builtins.baseNameOf",
|
||
StringCoercionMode::Strict,
|
||
false
|
||
)),
|
||
context
|
||
};
|
||
}
|
||
|
||
/* Return the directory of the given path, i.e., everything before the
|
||
last slash. Return either a path or a string depending on the type
|
||
of the argument. */
|
||
static Value prim_dirOf(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
if (args[0]->type() == nPath) {
|
||
auto path = args[0]->path();
|
||
return {NewValueAs::path, path.canonical().isRoot() ? path : path.parent()};
|
||
} else {
|
||
NixStringContext context;
|
||
auto path = state.coerceToString(noPos, *args[0], context,
|
||
"while evaluating the first argument passed to 'builtins.dirOf'",
|
||
StringCoercionMode::Strict, false);
|
||
auto dir = dirOf(*path);
|
||
return {NewValueAs::string, dir, context};
|
||
}
|
||
}
|
||
|
||
/* Return the contents of a file as a string. */
|
||
static Value prim_readFile(EvalState & state, Value ** args)
|
||
{
|
||
auto path = realisePath(state, *args[0]);
|
||
auto s = path.readFile();
|
||
StorePathSet refs;
|
||
if (state.ctx.store->isInStore(path.canonical().abs())) {
|
||
try {
|
||
refs = state.aio
|
||
.blockOn(state.ctx.store->queryPathInfo(
|
||
state.ctx.store->toStorePath(path.canonical().abs()).first
|
||
))
|
||
->references;
|
||
} catch (Error &) { // FIXME: should be InvalidPathError
|
||
}
|
||
// Re-scan references to filter down to just the ones that actually occur in the file.
|
||
auto refsSink = PathRefScanSink::fromPaths(refs);
|
||
refsSink << s;
|
||
refs = refsSink.getResultPaths();
|
||
}
|
||
NixStringContext context;
|
||
for (auto && p : std::move(refs)) {
|
||
context.insert(NixStringContextElem::Opaque {
|
||
.path = std::move((StorePath &&)p),
|
||
});
|
||
}
|
||
return {NewValueAs::string, s, context};
|
||
}
|
||
|
||
/* Find a file in the Nix search path. Used to implement <x> paths,
|
||
which are desugared to 'findFile __nixPath "x"'. */
|
||
static Value prim_findFile(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[0], noPos, "while evaluating the first argument passed to builtins.findFile");
|
||
|
||
SearchPath searchPath;
|
||
|
||
for (auto & v2 : args[0]->listItems()) {
|
||
state.forceAttrs(
|
||
v2, noPos, "while evaluating an element of the list passed to builtins.findFile"
|
||
);
|
||
|
||
std::string prefix;
|
||
auto i = v2.attrs()->get(state.ctx.symbols.sym_prefix);
|
||
if (i) {
|
||
prefix = state.forceStringNoCtx(
|
||
i->value,
|
||
noPos,
|
||
"while evaluating the `prefix` attribute of an element of the list passed to "
|
||
"builtins.findFile"
|
||
);
|
||
}
|
||
|
||
i = getAttr(state, state.ctx.symbols.sym_path, v2.attrs(), "in an element of the __nixPath");
|
||
|
||
NixStringContext context;
|
||
auto path = state
|
||
.coerceToString(
|
||
noPos,
|
||
i->value,
|
||
context,
|
||
"while evaluating the `path` attribute of an element of the list "
|
||
"passed to builtins.findFile",
|
||
StringCoercionMode::Strict,
|
||
false
|
||
)
|
||
.toOwned();
|
||
|
||
try {
|
||
auto rewrites = state.realiseContext(context);
|
||
path = rewriteStrings(path, rewrites);
|
||
} catch (InvalidPathError & e) {
|
||
state.ctx.errors.make<EvalError>(
|
||
"cannot find '%1%', since path '%2%' is not valid",
|
||
path,
|
||
e.path
|
||
).debugThrow();
|
||
}
|
||
|
||
searchPath.elements.emplace_back(SearchPath::Elem {
|
||
.prefix = SearchPath::Prefix { .s = prefix },
|
||
.path = SearchPath::Path { .s = path },
|
||
});
|
||
}
|
||
|
||
auto path = state.forceStringNoCtx(*args[1], noPos, "while evaluating the second argument passed to builtins.findFile");
|
||
|
||
return {
|
||
NewValueAs::path,
|
||
state.ctx.paths.checkSourcePath(
|
||
state.aio.blockOn(state.ctx.paths.findFile(searchPath, path, noPos)).unwrap()
|
||
)
|
||
};
|
||
}
|
||
|
||
/* Return the cryptographic hash of a file in base-16. */
|
||
static Value prim_hashFile(EvalState & state, Value ** args)
|
||
{
|
||
auto type = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.hashFile");
|
||
std::optional<HashType> ht = parseHashType(type);
|
||
if (!ht)
|
||
state.ctx.errors.make<EvalError>("unknown hash type '%1%'", type).debugThrow();
|
||
|
||
auto path = realisePath(state, *args[1]);
|
||
|
||
return {NewValueAs::string, hashString(*ht, path.readFile()).to_string(HashFormat::Base16, false)};
|
||
}
|
||
|
||
static std::string_view fileTypeToString(InputAccessor::Type type)
|
||
{
|
||
return
|
||
type == InputAccessor::Type::tRegular ? "regular" :
|
||
type == InputAccessor::Type::tDirectory ? "directory" :
|
||
type == InputAccessor::Type::tSymlink ? "symlink" :
|
||
"unknown";
|
||
}
|
||
|
||
static Value prim_readFileType(EvalState & state, Value ** args)
|
||
{
|
||
auto path = realisePath(state, *args[0]);
|
||
/* Retrieve the directory entry type and stringize it. */
|
||
return {NewValueAs::string, fileTypeToString(path.lstat().type)};
|
||
}
|
||
|
||
/* Read a directory (without . or ..) */
|
||
static Value prim_readDir(EvalState & state, Value ** args)
|
||
{
|
||
auto path = realisePath(state, *args[0]);
|
||
|
||
// Retrieve directory entries for all nodes in a directory.
|
||
// This is similar to `getFileType` but is optimized to reduce system calls
|
||
// on many systems.
|
||
auto entries = path.readDirectory();
|
||
auto attrs = state.ctx.buildBindings(entries.size());
|
||
|
||
// If we hit unknown directory entry types we may need to fallback to
|
||
// using `getFileType` on some systems.
|
||
// In order to reduce system calls we make each lookup lazy by using
|
||
// `builtins.readFileType` application.
|
||
Value * readFileType = nullptr;
|
||
|
||
for (auto & [name, type] : entries) {
|
||
if (!type) {
|
||
// Some filesystems or operating systems may not be able to return
|
||
// detailed node info quickly in this case we produce a thunk to
|
||
// query the file type lazily.
|
||
Value epath = {NewValueAs::path, path + name};
|
||
if (!readFileType)
|
||
readFileType = &state.ctx.builtins.get("readFileType");
|
||
Value attr = {NewValueAs::app, state.ctx.mem, *readFileType, epath};
|
||
attrs.insert(name, attr);
|
||
} else {
|
||
// This branch of the conditional is much more likely.
|
||
// Here we just stringize the directory entry type.
|
||
Value attr = {NewValueAs::string, fileTypeToString(*type)};
|
||
attrs.insert(name, attr);
|
||
}
|
||
}
|
||
|
||
return {NewValueAs::attrs, attrs};
|
||
}
|
||
|
||
/*************************************************************
|
||
* Creating files
|
||
*************************************************************/
|
||
|
||
|
||
/* Convert the argument (which can be any Nix expression) to an XML
|
||
representation returned in a string. Not all Nix expressions can
|
||
be sensibly or completely represented (e.g., functions). */
|
||
static Value prim_toXML(EvalState & state, Value ** args)
|
||
{
|
||
std::ostringstream out;
|
||
NixStringContext context;
|
||
printValueAsXML(state, true, false, *args[0], out, context, noPos);
|
||
return {NewValueAs::string, out.str(), context};
|
||
}
|
||
|
||
/* Convert the argument (which can be any Nix expression) to a JSON
|
||
string. Not all Nix expressions can be sensibly or completely
|
||
represented (e.g., functions). */
|
||
static Value prim_toJSON(EvalState & state, Value ** args)
|
||
{
|
||
std::ostringstream out;
|
||
NixStringContext context;
|
||
printValueAsJSON(state, true, *args[0], noPos, out, context);
|
||
return {NewValueAs::string, out.str(), context};
|
||
}
|
||
|
||
/* Parse a JSON string to a value. */
|
||
static Value prim_fromJSON(EvalState & state, Value ** args)
|
||
{
|
||
auto s = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.fromJSON");
|
||
try {
|
||
return parseJSON(state, s);
|
||
} catch (JSONParseError &e) {
|
||
e.addTrace(nullptr, "while decoding a JSON string");
|
||
throw;
|
||
}
|
||
}
|
||
|
||
/* Store a string in the Nix store as a source file that can be used
|
||
as an input by derivations. */
|
||
static Value prim_toFile(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
std::string name(state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.toFile"));
|
||
std::string contents(state.forceString(*args[1], context, noPos, "while evaluating the second argument passed to builtins.toFile"));
|
||
|
||
StorePathSet refs;
|
||
|
||
for (auto c : context) {
|
||
if (auto p = std::get_if<NixStringContextElem::Opaque>(&c.raw))
|
||
refs.insert(p->path);
|
||
else
|
||
state.ctx.errors.make<EvalError>(
|
||
"files created by %1% may not reference derivations, but %2% references %3%",
|
||
"builtins.toFile",
|
||
name,
|
||
c.to_string()
|
||
).debugThrow();
|
||
}
|
||
|
||
auto storePath = settings.readOnlyMode
|
||
? state.ctx.store->computeStorePathForText(name, contents, refs)
|
||
: state.aio.blockOn(state.ctx.store->addTextToStore(name, contents, refs, state.ctx.repair));
|
||
|
||
/* Note: we don't need to add `context' to the context of the
|
||
result, since `storePath' itself has references to the paths
|
||
used in args[1]. */
|
||
|
||
/* Add the output of this to the allowed paths. */
|
||
return state.ctx.paths.allowAndSetStorePathString(storePath);
|
||
}
|
||
|
||
static Value addPath(
|
||
EvalState & state,
|
||
std::string_view name,
|
||
Path path,
|
||
Value * filterFun,
|
||
FileIngestionMethod method,
|
||
const std::optional<Hash> expectedHash,
|
||
const NixStringContext & context
|
||
)
|
||
{
|
||
try {
|
||
// FIXME: handle CA derivation outputs (where path needs to
|
||
// be rewritten to the actual output).
|
||
auto rewrites = state.realiseContext(context);
|
||
path = rewriteStrings(path, rewrites);
|
||
|
||
Path realPath = path;
|
||
|
||
StorePathSet refs;
|
||
|
||
// If the path is in the store, it can mean either a physical path or a logical path in a
|
||
// chroot store. Query the chroot store for its presence to find out which is the case.
|
||
if (state.ctx.store->isInStore(path)) {
|
||
try {
|
||
auto [storePath, subPath] = state.ctx.store->toStorePath(path);
|
||
// FIXME: we should scanForReferences on the path before adding it
|
||
refs = state.aio.blockOn(state.ctx.store->queryPathInfo(storePath))->references;
|
||
realPath = state.ctx.store->toRealPath(path);
|
||
} catch (Error &) { // FIXME: should be InvalidPathError
|
||
}
|
||
}
|
||
|
||
realPath = evalSettings.pureEval && expectedHash
|
||
? realPath
|
||
: state.ctx.paths.checkSourcePath(CanonPath(realPath)).canonical().abs();
|
||
|
||
PathFilter filter = filterFun ? ([&](const Path & p) {
|
||
auto st = lstat(p);
|
||
|
||
/* Call the filter function. The first argument is the path,
|
||
the second is a string indicating the type of the file. */
|
||
Value arg1 = {
|
||
NewValueAs::string,
|
||
isInDir(p, realPath) ? path + "/" + std::string(p, realPath.size() + 1) : p
|
||
};
|
||
|
||
Value arg2 =
|
||
{NewValueAs::string,
|
||
S_ISREG(st.st_mode) ? "regular"
|
||
: S_ISDIR(st.st_mode) ? "directory"
|
||
: S_ISLNK(st.st_mode) ? "symlink"
|
||
: "unknown" /* not supported, will fail! */};
|
||
|
||
Value args[]{arg1, arg2};
|
||
Value res = state.callFunction(*filterFun, args, noPos);
|
||
|
||
return state.forceBool(res, noPos, "while evaluating the return value of the path filter function");
|
||
}) : defaultPathFilter;
|
||
|
||
std::optional<StorePath> expectedStorePath;
|
||
if (expectedHash)
|
||
expectedStorePath = state.ctx.store->makeFixedOutputPath(name, FixedOutputInfo {
|
||
.method = method,
|
||
.hash = *expectedHash,
|
||
.references = {},
|
||
});
|
||
|
||
if (!expectedHash || !state.aio.blockOn(state.ctx.store->isValidPath(*expectedStorePath))) {
|
||
auto checkedPath = state.ctx.paths.checkSourcePath(CanonPath(realPath));
|
||
auto dstPath = state.aio.blockOn(
|
||
method == FileIngestionMethod::Flat
|
||
? fetchToStoreFlat(*state.ctx.store, checkedPath, name, state.ctx.repair)
|
||
: fetchToStoreRecursive(
|
||
*state.ctx.store,
|
||
*prepareDump(checkedPath.canonical().abs(), filter),
|
||
name,
|
||
state.ctx.repair
|
||
)
|
||
);
|
||
if (expectedHash && expectedStorePath != dstPath)
|
||
state.ctx.errors.make<EvalError>(
|
||
"store path mismatch in (possibly filtered) path added from '%s'",
|
||
path
|
||
).debugThrow();
|
||
return state.ctx.paths.allowAndSetStorePathString(dstPath);
|
||
} else
|
||
return state.ctx.paths.allowAndSetStorePathString(*expectedStorePath);
|
||
} catch (Error & e) {
|
||
e.addTrace(nullptr, "while adding path '%s'", path);
|
||
throw;
|
||
}
|
||
}
|
||
|
||
static Value prim_filterSource(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
auto path = state.coerceToPath(noPos, *args[1], context,
|
||
"while evaluating the second argument (the path to filter) passed to builtins.filterSource");
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.filterSource");
|
||
return addPath(
|
||
state,
|
||
path.baseName(),
|
||
path.canonical().abs(),
|
||
args[0],
|
||
FileIngestionMethod::Recursive,
|
||
std::nullopt,
|
||
context
|
||
);
|
||
}
|
||
|
||
static Value prim_path(EvalState & state, Value ** args)
|
||
{
|
||
std::optional<SourcePath> path;
|
||
std::string name;
|
||
Value * filterFun = nullptr;
|
||
auto method = FileIngestionMethod::Recursive;
|
||
std::optional<Hash> expectedHash;
|
||
NixStringContext context;
|
||
|
||
state.forceAttrs(*args[0], noPos, "while evaluating the argument passed to 'builtins.path'");
|
||
|
||
for (auto & attr : *args[0]->attrs()) {
|
||
auto & n = state.ctx.symbols[attr.name];
|
||
if (n == "path") {
|
||
path.emplace(state.coerceToPath(
|
||
attr.pos,
|
||
attr.value,
|
||
context,
|
||
"while evaluating the 'path' attribute passed to 'builtins.path'"
|
||
));
|
||
} else if (attr.name == state.ctx.symbols.sym_name) {
|
||
name = state.forceStringNoCtx(
|
||
attr.value,
|
||
attr.pos,
|
||
"while evaluating the `name` attribute passed to builtins.path"
|
||
);
|
||
} else if (n == "filter") {
|
||
state.forceFunction(
|
||
*(filterFun = &attr.value),
|
||
attr.pos,
|
||
"while evaluating the `filter` parameter passed to builtins.path"
|
||
);
|
||
} else if (n == "recursive") {
|
||
method = FileIngestionMethod{state.forceBool(
|
||
attr.value,
|
||
attr.pos,
|
||
"while evaluating the `recursive` attribute passed to builtins.path"
|
||
)};
|
||
} else if (n == "sha256") {
|
||
expectedHash = newHashAllowEmpty(
|
||
state.forceStringNoCtx(
|
||
attr.value,
|
||
attr.pos,
|
||
"while evaluating the `sha256` attribute passed to builtins.path"
|
||
),
|
||
HashType::SHA256
|
||
);
|
||
} else {
|
||
state.ctx.errors
|
||
.make<EvalError>(
|
||
"unsupported argument '%1%' to 'addPath'", state.ctx.symbols[attr.name]
|
||
)
|
||
.atPos(attr.pos)
|
||
.debugThrow();
|
||
}
|
||
}
|
||
if (!path)
|
||
state.ctx.errors.make<EvalError>(
|
||
"missing required 'path' attribute in the first argument to builtins.path"
|
||
).debugThrow();
|
||
if (name.empty())
|
||
name = path->baseName();
|
||
|
||
return addPath(state, name, path->canonical().abs(), filterFun, method, expectedHash, context);
|
||
}
|
||
|
||
|
||
/*************************************************************
|
||
* Sets
|
||
*************************************************************/
|
||
|
||
|
||
/* Return the names of the attributes in a set as a sorted list of
|
||
strings. */
|
||
static Value prim_attrNames(EvalState & state, Value ** args)
|
||
{
|
||
state.forceAttrs(*args[0], noPos, "while evaluating the argument passed to builtins.attrNames");
|
||
|
||
auto result = state.ctx.mem.newList(args[0]->attrs()->size());
|
||
|
||
size_t n = 0;
|
||
for (auto & i : *args[0]->attrs())
|
||
result->elems[n++] = state.ctx.symbols[i.name].toValue();
|
||
|
||
std::sort(result->elems, result->elems + n, [](Value & v1, Value & v2) {
|
||
return v1.str() < v2.str();
|
||
});
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
/* Return the values of the attributes in a set as a list, in the same
|
||
order as attrNames. */
|
||
static Value prim_attrValues(EvalState & state, Value ** args)
|
||
{
|
||
state.forceAttrs(*args[0], noPos, "while evaluating the argument passed to builtins.attrValues");
|
||
|
||
auto result = state.ctx.mem.newList(args[0]->attrs()->size());
|
||
|
||
boost::container::small_vector<const Attr *, 128> tmp;
|
||
tmp.reserve(args[0]->attrs()->size());
|
||
|
||
for (auto & i : *args[0]->attrs())
|
||
tmp.push_back(&i);
|
||
|
||
std::sort(tmp.begin(), tmp.end(), [&](const Attr * v1, const Attr * v2) {
|
||
std::string_view s1 = state.ctx.symbols[v1->name], s2 = state.ctx.symbols[v2->name];
|
||
return s1 < s2;
|
||
});
|
||
|
||
for (auto [i, attr] : enumerate(tmp)) {
|
||
result->elems[i] = attr->value;
|
||
}
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
/* Dynamic version of the `.' operator. */
|
||
Value prim_getAttr(EvalState & state, Value ** args)
|
||
{
|
||
auto attr = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.getAttr");
|
||
state.forceAttrs(*args[1], noPos, "while evaluating the second argument passed to builtins.getAttr");
|
||
auto i = getAttr(
|
||
state,
|
||
state.ctx.symbols.create(attr),
|
||
args[1]->attrs(),
|
||
"in the attribute set under consideration"
|
||
);
|
||
// !!! add to stack trace?
|
||
if (state.ctx.stats.countCalls && i->pos) state.ctx.stats.attrSelects[i->pos]++;
|
||
state.forceValue(i->value, noPos);
|
||
return i->value;
|
||
}
|
||
|
||
/* Return position information of the specified attribute. */
|
||
static Value prim_unsafeGetAttrPos(EvalState & state, Value ** args)
|
||
{
|
||
auto attr = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.unsafeGetAttrPos");
|
||
state.forceAttrs(*args[1], noPos, "while evaluating the second argument passed to builtins.unsafeGetAttrPos");
|
||
auto i = args[1]->attrs()->get(state.ctx.symbols.create(attr));
|
||
if (!i) {
|
||
return Value::VNULL;
|
||
} else {
|
||
return state.mkPos(i->pos);
|
||
}
|
||
}
|
||
|
||
// access to exact position information (ie, line and colum numbers) is deferred
|
||
// due to the cost associated with calculating that information and how rarely
|
||
// it is used in practice. this is achieved by creating thunks to otherwise
|
||
// inaccessible primops that are not exposed as __op or under builtins to turn
|
||
// the internal PosIdx back into a line and column number, respectively. exposing
|
||
// these primops in any way would at best be not useful and at worst create wildly
|
||
// indeterministic eval results depending on parse order of files.
|
||
//
|
||
// in a simpler world this would instead be implemented as another kind of thunk,
|
||
// but each type of thunk has an associated runtime cost in the current evaluator.
|
||
// as with black holes this cost is too high to justify another thunk type to check
|
||
// for in the very hot path that is forceValue.
|
||
static struct LazyPosAcessors {
|
||
PrimOp primop_lineOfPos{
|
||
{.arity = 1, .fun = [](EvalState & state, Value ** args) -> Value {
|
||
return {NewValueAs::integer, state.ctx.positions[PosIdx(args[0]->integer().value)].line};
|
||
}}
|
||
};
|
||
PrimOp primop_columnOfPos{
|
||
{.arity = 1, .fun = [](EvalState & state, Value ** args) -> Value {
|
||
return {NewValueAs::integer, state.ctx.positions[PosIdx(args[0]->integer().value)].column};
|
||
}}
|
||
};
|
||
|
||
Value lineOfPos = {NewValueAs::primop, primop_lineOfPos},
|
||
columnOfPos = {NewValueAs::primop, primop_columnOfPos};
|
||
|
||
std::tuple<Value, Value> operator()(EvalState & state, const PosIdx pos)
|
||
{
|
||
Value posV{NewValueAs::integer, NixInt{pos.id}};
|
||
Value line = {NewValueAs::app, state.ctx.mem, lineOfPos, posV};
|
||
Value column = {NewValueAs::app, state.ctx.mem, columnOfPos, posV};
|
||
return std::make_tuple(line, column);
|
||
}
|
||
} makeLazyPosAccessors;
|
||
|
||
std::tuple<Value, Value> makePositionThunks(EvalState & state, const PosIdx pos)
|
||
{
|
||
return makeLazyPosAccessors(state, pos);
|
||
}
|
||
|
||
/* Dynamic version of the `?' operator. */
|
||
static Value prim_hasAttr(EvalState & state, Value ** args)
|
||
{
|
||
auto attr = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.hasAttr");
|
||
state.forceAttrs(*args[1], noPos, "while evaluating the second argument passed to builtins.hasAttr");
|
||
return {NewValueAs::boolean, bool(args[1]->attrs()->get(state.ctx.symbols.create(attr)))};
|
||
}
|
||
|
||
/* Determine whether the argument is a set. */
|
||
static Value prim_isAttrs(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nAttrs};
|
||
}
|
||
|
||
static Value prim_removeAttrs(EvalState & state, Value ** args)
|
||
{
|
||
state.forceAttrs(*args[0], noPos, "while evaluating the first argument passed to builtins.removeAttrs");
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.removeAttrs");
|
||
|
||
/* Get the attribute names to be removed.
|
||
We keep them as Attrs instead of Symbols so std::set_difference
|
||
can be used to remove them from attrs[0]. */
|
||
// 64: large enough to fit the attributes of a derivation
|
||
boost::container::small_vector<Symbol, 64> names;
|
||
names.reserve(args[1]->listSize());
|
||
for (auto & elem : args[1]->listItems()) {
|
||
state.forceStringNoCtx(
|
||
elem,
|
||
noPos,
|
||
"while evaluating the values of the second argument passed to builtins.removeAttrs"
|
||
);
|
||
names.push_back(state.ctx.symbols.create(elem.str()));
|
||
}
|
||
std::sort(names.begin(), names.end());
|
||
|
||
/* Copy all attributes not in that set. Note that we don't need
|
||
to sort v.attrs because it's a subset of an already sorted
|
||
vector. */
|
||
auto attrs = state.ctx.buildBindings(args[0]->attrs()->size());
|
||
std::set_difference(
|
||
args[0]->attrs()->begin(),
|
||
args[0]->attrs()->end(),
|
||
names.begin(),
|
||
names.end(),
|
||
std::back_inserter(attrs),
|
||
overloaded{
|
||
[](const Attr & a, const Symbol & s) { return a.name < s; },
|
||
[](const Symbol & s, const Attr & a) { return s < a.name; }
|
||
}
|
||
);
|
||
return {NewValueAs::attrs, attrs.alreadySorted()};
|
||
}
|
||
|
||
/* Builds a set from a list specifying (name, value) pairs. To be
|
||
precise, a list [{name = "name1"; value = value1;} ... {name =
|
||
"nameN"; value = valueN;}] is transformed to {name1 = value1;
|
||
... nameN = valueN;}. In case of duplicate occurrences of the same
|
||
name, the first takes precedence. */
|
||
static Value prim_listToAttrs(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[0], noPos, "while evaluating the argument passed to builtins.listToAttrs");
|
||
|
||
auto attrs = state.ctx.buildBindings(args[0]->listSize());
|
||
|
||
std::set<Symbol> seen;
|
||
|
||
for (auto & v2 : args[0]->listItems()) {
|
||
state.forceAttrs(
|
||
v2, noPos, "while evaluating an element of the list passed to builtins.listToAttrs"
|
||
);
|
||
|
||
auto j = getAttr(state, state.ctx.symbols.sym_name, v2.attrs(), "in a {name=...; value=...;} pair");
|
||
|
||
auto name = state.forceStringNoCtx(
|
||
j->value,
|
||
j->pos,
|
||
"while evaluating the `name` attribute of an element of the list passed to "
|
||
"builtins.listToAttrs"
|
||
);
|
||
|
||
auto sym = state.ctx.symbols.create(name);
|
||
if (seen.insert(sym).second) {
|
||
auto j2 =
|
||
getAttr(state, state.ctx.symbols.sym_value, v2.attrs(), "in a {name=...; value=...;} pair");
|
||
attrs.insert(sym, j2->value, j2->pos);
|
||
}
|
||
}
|
||
|
||
return {NewValueAs::attrs, attrs};
|
||
}
|
||
|
||
static Value prim_intersectAttrs(EvalState & state, Value ** args)
|
||
{
|
||
state.forceAttrs(*args[0], noPos, "while evaluating the first argument passed to builtins.intersectAttrs");
|
||
state.forceAttrs(*args[1], noPos, "while evaluating the second argument passed to builtins.intersectAttrs");
|
||
|
||
Bindings &left = *args[0]->attrs();
|
||
Bindings &right = *args[1]->attrs();
|
||
|
||
auto attrs = state.ctx.buildBindings(std::min(left.size(), right.size()));
|
||
|
||
// The current implementation has good asymptotic complexity and is reasonably
|
||
// simple. Further optimization may be possible, but does not seem productive,
|
||
// considering the state of eval performance in 2022.
|
||
//
|
||
// I have looked for reusable and/or standard solutions and these are my
|
||
// findings:
|
||
//
|
||
// STL
|
||
// ===
|
||
// std::set_intersection is not suitable, as it only performs a simultaneous
|
||
// linear scan; not taking advantage of random access. This is O(n + m), so
|
||
// linear in the largest set, which is not acceptable for callPackage in Nixpkgs.
|
||
//
|
||
// Simultaneous scan, with alternating simple binary search
|
||
// ===
|
||
// One alternative algorithm scans the attrsets simultaneously, jumping
|
||
// forward using `lower_bound` in case of inequality. This should perform
|
||
// well on very similar sets, having a local and predictable access pattern.
|
||
// On dissimilar sets, it seems to need more comparisons than the current
|
||
// algorithm, as few consecutive attrs match. `lower_bound` could take
|
||
// advantage of the decreasing remaining search space, but this causes
|
||
// the medians to move, which can mean that they don't stay in the cache
|
||
// like they would with the current naive `find`.
|
||
//
|
||
// Double binary search
|
||
// ===
|
||
// The optimal algorithm may be "Double binary search", which doesn't
|
||
// scan at all, but rather divides both sets simultaneously.
|
||
// See "Fast Intersection Algorithms for Sorted Sequences" by Baeza-Yates et al.
|
||
// https://cs.uwaterloo.ca/~ajsaling/papers/intersection_alg_app10.pdf
|
||
// The only downsides I can think of are not having a linear access pattern
|
||
// for similar sets, and having to maintain a more intricate algorithm.
|
||
//
|
||
// Adaptive
|
||
// ===
|
||
// Finally one could run try a simultaneous scan, count misses and fall back
|
||
// to double binary search when the counter hit some threshold and/or ratio.
|
||
|
||
if (left.size() < right.size()) {
|
||
for (auto & l : left) {
|
||
auto r = right.get(l.name);
|
||
if (r) {
|
||
attrs.insert(*r);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (auto & r : right) {
|
||
auto l = left.get(r.name);
|
||
if (l) {
|
||
attrs.insert(r);
|
||
}
|
||
}
|
||
}
|
||
|
||
return {NewValueAs::attrs, attrs.alreadySorted()};
|
||
}
|
||
|
||
static Value prim_catAttrs(EvalState & state, Value ** args)
|
||
{
|
||
auto attrName = state.ctx.symbols.create(state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.catAttrs"));
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.catAttrs");
|
||
|
||
SmallValueVector<nonRecursiveStackReservation> res;
|
||
res.reserve(args[1]->listSize());
|
||
|
||
for (auto & v2 : args[1]->listItems()) {
|
||
state.forceAttrs(
|
||
v2,
|
||
noPos,
|
||
"while evaluating an element in the list passed as second argument to builtins.catAttrs"
|
||
);
|
||
auto i = v2.attrs()->get(attrName);
|
||
if (i) {
|
||
res.push_back(i->value);
|
||
}
|
||
}
|
||
|
||
auto result = state.ctx.mem.newList(res.size());
|
||
std::copy(res.cbegin(), res.cend(), result->elems);
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
static Value prim_functionArgs(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
if (args[0]->isPrimOpApp() || args[0]->isPrimOp()) {
|
||
return {NewValueAs::attrs, &Bindings::EMPTY};
|
||
}
|
||
if (!args[0]->isLambda())
|
||
state.ctx.errors.make<TypeError>("'functionArgs' requires a function").debugThrow();
|
||
|
||
AttrsPattern * formals = dynamic_cast<AttrsPattern *>(args[0]->lambda().fun->pattern.get());
|
||
if (!formals) {
|
||
return {NewValueAs::attrs, &Bindings::EMPTY};
|
||
}
|
||
|
||
auto attrs = state.ctx.buildBindings(formals->formals.size());
|
||
for (auto & i : formals->formals)
|
||
attrs.insert(i.name, {NewValueAs::boolean, i.def != nullptr}, i.pos);
|
||
return {NewValueAs::attrs, attrs};
|
||
}
|
||
|
||
/* */
|
||
static Value prim_mapAttrs(EvalState & state, Value ** args)
|
||
{
|
||
state.forceAttrs(*args[1], noPos, "while evaluating the second argument passed to builtins.mapAttrs");
|
||
|
||
auto attrs = state.ctx.buildBindings(args[1]->attrs()->size());
|
||
|
||
for (auto & i : *args[1]->attrs()) {
|
||
auto vName = state.ctx.symbols[i.name].toValue();
|
||
Value appArgs[] = {vName, i.value};
|
||
attrs.insert(i.name, {NewValueAs::app, state.ctx.mem, *args[0], appArgs});
|
||
}
|
||
|
||
return {NewValueAs::attrs, attrs.alreadySorted()};
|
||
}
|
||
|
||
static Value prim_zipAttrsWith(EvalState & state, Value ** args)
|
||
{
|
||
// we will first count how many values are present for each given key.
|
||
// we then allocate a single attrset and pre-populate it with lists of
|
||
// appropriate sizes, stash the pointers to the list elements of each,
|
||
// and populate the lists. after that we replace the list in the every
|
||
// attribute with the merge function application. this way we need not
|
||
// use (slightly slower) temporary storage the GC does not know about.
|
||
|
||
std::map<Symbol, std::pair<size_t, Value *>> attrsSeen;
|
||
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.zipAttrsWith");
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.zipAttrsWith");
|
||
const auto listSize = args[1]->listSize();
|
||
const auto listElems = args[1]->listElems();
|
||
|
||
for (unsigned int n = 0; n < listSize; ++n) {
|
||
Value & vElem = listElems[n];
|
||
state.forceAttrs(
|
||
vElem,
|
||
noPos,
|
||
"while evaluating a value of the list passed as second argument to "
|
||
"builtins.zipAttrsWith"
|
||
);
|
||
for (auto & attr : *vElem.attrs()) {
|
||
attrsSeen[attr.name].first++;
|
||
}
|
||
}
|
||
|
||
auto attrs = state.ctx.buildBindings(attrsSeen.size());
|
||
for (auto & [sym, elem] : attrsSeen) {
|
||
/* Take care of the returned lists. */
|
||
auto content = state.ctx.mem.newList(elem.first);
|
||
Value list{NewValueAs::list, content};
|
||
elem.second = content->elems;
|
||
|
||
/* Construct a `fn name list` function call value. */
|
||
auto name = state.ctx.symbols[sym].toValue();
|
||
Value callArgs[] = {name, list};
|
||
Value call{NewValueAs::app, state.ctx.mem, *args[0], callArgs};
|
||
|
||
/* Insert it inside the returned attribute set. */
|
||
attrs.insert(sym, call);
|
||
}
|
||
|
||
/* Populate the lists inside the attribute set */
|
||
for (unsigned int n = 0; n < listSize; ++n) {
|
||
Value & vElem = listElems[n];
|
||
for (auto & attr : *vElem.attrs()) {
|
||
*attrsSeen[attr.name].second++ = attr.value;
|
||
}
|
||
}
|
||
|
||
return {NewValueAs::attrs, attrs.alreadySorted()};
|
||
}
|
||
|
||
|
||
/*************************************************************
|
||
* Lists
|
||
*************************************************************/
|
||
|
||
|
||
/* Determine whether the argument is a list. */
|
||
static Value prim_isList(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
return {NewValueAs::boolean, args[0]->type() == nList};
|
||
}
|
||
|
||
static Value elemAt(EvalState & state, Value & list, NixInt::Inner n)
|
||
{
|
||
state.forceList(list, noPos, "while evaluating the first argument passed to builtins.elemAt");
|
||
if (n < 0 || std::make_unsigned_t<NixInt::Inner>(n) >= list.listSize()) {
|
||
state.ctx.errors.make<EvalError>("list index %1% is out of bounds", n).debugThrow();
|
||
}
|
||
state.forceValue(list.listElems()[n], noPos);
|
||
return list.listElems()[n];
|
||
}
|
||
|
||
/* Return the n-1'th element of a list. */
|
||
static Value prim_elemAt(EvalState & state, Value ** args)
|
||
{
|
||
NixInt::Inner elem = state.forceInt(*args[1], noPos, "while evaluating the second argument passed to builtins.elemAt").value;
|
||
return elemAt(state, *args[0], elem);
|
||
}
|
||
|
||
/* Return the first element of a list. */
|
||
static Value prim_head(EvalState & state, Value ** args)
|
||
{
|
||
return elemAt(state, *args[0], 0);
|
||
}
|
||
|
||
/* Return a list consisting of everything but the first element of
|
||
a list. Warning: this function takes O(n) time, so you probably
|
||
don't want to use it! */
|
||
static Value prim_tail(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[0], noPos, "while evaluating the first argument passed to builtins.tail");
|
||
if (args[0]->listSize() == 0)
|
||
state.ctx.errors.make<EvalError>("'tail' called on an empty list").debugThrow();
|
||
|
||
auto result = state.ctx.mem.newList(args[0]->listSize() - 1);
|
||
for (unsigned int n = 0; n < result->size; ++n) {
|
||
result->elems[n] = args[0]->listElems()[n + 1];
|
||
}
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
/* Apply a function to every element of a list. */
|
||
static Value prim_map(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.map");
|
||
|
||
if (args[1]->listSize() == 0) {
|
||
return *args[1];
|
||
}
|
||
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.map");
|
||
|
||
auto result = state.ctx.mem.newList(args[1]->listSize());
|
||
for (unsigned int n = 0; n < result->size; ++n) {
|
||
result->elems[n] = {NewValueAs::app, state.ctx.mem, *args[0], args[1]->listElems()[n]};
|
||
}
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
/* Filter a list using a predicate; that is, return a list containing
|
||
every element from the list for which the predicate function
|
||
returns true. */
|
||
static Value prim_filter(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.filter");
|
||
|
||
if (args[1]->listSize() == 0) {
|
||
return *args[1];
|
||
}
|
||
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.filter");
|
||
|
||
auto len = args[1]->listSize();
|
||
SmallValueVector<nonRecursiveStackReservation> vs;
|
||
vs.reserve(len);
|
||
|
||
bool same = true;
|
||
for (size_t n = 0; n < len; ++n) {
|
||
Value res = state.callFunction(*args[0], args[1]->listElems()[n], noPos);
|
||
if (state.forceBool(
|
||
res,
|
||
noPos,
|
||
"while evaluating the return value of the filtering function passed to builtins.filter"
|
||
))
|
||
{
|
||
vs.push_back(args[1]->listElems()[n]);
|
||
} else {
|
||
same = false;
|
||
}
|
||
}
|
||
|
||
if (same)
|
||
return *args[1];
|
||
else {
|
||
auto result = state.ctx.mem.newList(vs.size());
|
||
std::copy(vs.cbegin(), vs.cend(), result->elems);
|
||
return {NewValueAs::list, result};
|
||
}
|
||
}
|
||
|
||
/* Return true if a list contains a given element. */
|
||
static Value prim_elem(EvalState & state, Value ** args)
|
||
{
|
||
bool res = false;
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.elem");
|
||
for (auto & elem : args[1]->listItems()) {
|
||
if (state.eqValues(
|
||
*args[0],
|
||
elem,
|
||
noPos,
|
||
"while searching for the presence of the given element in the list"
|
||
))
|
||
{
|
||
res = true;
|
||
break;
|
||
}
|
||
}
|
||
return {NewValueAs::boolean, res};
|
||
}
|
||
|
||
/* Concatenate a list of lists. */
|
||
static Value prim_concatLists(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[0], noPos, "while evaluating the first argument passed to builtins.concatLists");
|
||
return state.concatLists(
|
||
std::span{args[0]->listElems(), args[0]->listSize()},
|
||
noPos,
|
||
"while evaluating a value of the list passed to builtins.concatLists"
|
||
);
|
||
}
|
||
|
||
/* Return the length of a list. This is an O(1) time operation. */
|
||
static Value prim_length(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[0], noPos, "while evaluating the first argument passed to builtins.length");
|
||
return {NewValueAs::integer, NixInt::Inner(args[0]->listSize())};
|
||
}
|
||
|
||
/* Reduce a list by applying a binary operator, from left to
|
||
right. The operator is applied strictly. */
|
||
static Value prim_foldlStrict(EvalState & state, Value ** args)
|
||
{
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.foldlStrict");
|
||
state.forceList(*args[2], noPos, "while evaluating the third argument passed to builtins.foldlStrict");
|
||
|
||
if (args[2]->listSize()) {
|
||
Value vCur = *args[1];
|
||
|
||
for (auto && [n, elem] : enumerate(args[2]->listItems())) {
|
||
Value vs[]{vCur, elem};
|
||
vCur = state.callFunction(*args[0], vs, noPos);
|
||
}
|
||
state.forceValue(vCur, noPos);
|
||
return vCur;
|
||
} else {
|
||
state.forceValue(*args[1], noPos);
|
||
return *args[1];
|
||
}
|
||
}
|
||
|
||
static Value anyOrAll(bool any, EvalState & state, Value ** args)
|
||
{
|
||
state.forceFunction(*args[0], noPos, std::string("while evaluating the first argument passed to builtins.") + (any ? "any" : "all"));
|
||
state.forceList(*args[1], noPos, std::string("while evaluating the second argument passed to builtins.") + (any ? "any" : "all"));
|
||
|
||
std::string_view errorCtx = any
|
||
? "while evaluating the return value of the function passed to builtins.any"
|
||
: "while evaluating the return value of the function passed to builtins.all";
|
||
|
||
for (auto & elem : args[1]->listItems()) {
|
||
Value vTmp = state.callFunction(*args[0], elem, noPos);
|
||
bool res = state.forceBool(vTmp, noPos, errorCtx);
|
||
if (res == any) {
|
||
return {NewValueAs::boolean, any};
|
||
}
|
||
}
|
||
|
||
return {NewValueAs::boolean, !any};
|
||
}
|
||
|
||
static Value prim_any(EvalState & state, Value ** args)
|
||
{
|
||
return anyOrAll(true, state, args);
|
||
}
|
||
|
||
static Value prim_all(EvalState & state, Value ** args)
|
||
{
|
||
return anyOrAll(false, state, args);
|
||
}
|
||
|
||
static Value prim_genList(EvalState & state, Value ** args)
|
||
{
|
||
auto len_ = state.forceInt(*args[1], noPos, "while evaluating the second argument passed to builtins.genList").value;
|
||
|
||
if (len_ < 0 || std::make_unsigned_t<NixInt::Inner>(len_) > std::numeric_limits<size_t>::max())
|
||
{
|
||
state.ctx.errors.make<EvalError>("cannot create list of size %1%", len_).debugThrow();
|
||
}
|
||
|
||
size_t len = len_;
|
||
|
||
// More strict than striclty (!) necessary, but acceptable
|
||
// as evaluating map without accessing any values makes little sense.
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.genList");
|
||
|
||
auto result = state.ctx.mem.newList(len);
|
||
for (size_t n = 0; n < len; ++n) {
|
||
Value arg{NewValueAs::integer, NixInt{ssize_t(n)}};
|
||
result->elems[n] = {NewValueAs::app, state.ctx.mem, *args[0], arg};
|
||
}
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
static Value prim_lessThan(EvalState & state, Value ** args);
|
||
|
||
static Value prim_sort(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.sort");
|
||
|
||
auto len = args[1]->listSize();
|
||
if (len == 0) {
|
||
return *args[1];
|
||
}
|
||
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.sort");
|
||
|
||
auto list = state.ctx.mem.newList(len);
|
||
for (unsigned int n = 0; n < len; ++n) {
|
||
state.forceValue(args[1]->listElems()[n], noPos);
|
||
list->elems[n] = args[1]->listElems()[n];
|
||
}
|
||
|
||
auto comparator = [&](Value a, Value b) {
|
||
/* Optimization: if the comparator is lessThan, bypass
|
||
callFunction. */
|
||
/* TODO: (layus) this is absurd. An optimisation like this
|
||
should be outside the lambda creation */
|
||
if (args[0]->isPrimOp()) {
|
||
auto ptr = args[0]->primOp()->fun.target<decltype(&prim_lessThan)>();
|
||
if (ptr && *ptr == prim_lessThan)
|
||
return CompareValues(state, "while evaluating the ordering function passed to builtins.sort")(a, b);
|
||
}
|
||
|
||
Value vs[] = {a, b};
|
||
Value vBool = state.callFunction(*args[0], vs, noPos);
|
||
return state.forceBool(vBool, noPos, "while evaluating the return value of the sorting function passed to builtins.sort");
|
||
};
|
||
|
||
/* FIXME: std::sort can segfault if the comparator is not a strict
|
||
weak ordering. What to do? std::stable_sort() seems more
|
||
resilient, but no guarantees... */
|
||
std::stable_sort(list->elems, list->elems + len, comparator);
|
||
|
||
return {NewValueAs::list, list};
|
||
}
|
||
|
||
static Value prim_partition(EvalState & state, Value ** args)
|
||
{
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.partition");
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.partition");
|
||
|
||
auto len = args[1]->listSize();
|
||
auto elems = args[1]->listElems();
|
||
|
||
std::vector<size_t> right, wrong;
|
||
|
||
for (size_t n = 0; n < len; ++n) {
|
||
auto & vElem = args[1]->listElems()[n];
|
||
state.forceValue(vElem, noPos);
|
||
Value res = state.callFunction(*args[0], vElem, noPos);
|
||
if (state.forceBool(res, noPos, "while evaluating the return value of the partition function passed to builtins.partition"))
|
||
right.push_back(n);
|
||
else
|
||
wrong.push_back(n);
|
||
}
|
||
|
||
auto attrs = state.ctx.buildBindings(2);
|
||
|
||
auto rsize = right.size();
|
||
auto rlist = state.ctx.mem.newList(rsize);
|
||
attrs.insert(state.ctx.symbols.sym_right, {NewValueAs::list, rlist});
|
||
for (auto [i, idx] : enumerate(right)) {
|
||
rlist->elems[i] = elems[idx];
|
||
}
|
||
|
||
auto wsize = wrong.size();
|
||
auto wlist = state.ctx.mem.newList(wsize);
|
||
attrs.insert(state.ctx.symbols.sym_wrong, {NewValueAs::list, wlist});
|
||
for (auto [i, idx] : enumerate(wrong)) {
|
||
wlist->elems[i] = elems[idx];
|
||
}
|
||
|
||
return {NewValueAs::attrs, attrs};
|
||
}
|
||
|
||
static Value prim_groupBy(EvalState & state, Value ** args)
|
||
{
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.groupBy");
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.groupBy");
|
||
|
||
std::map<Symbol, std::vector<size_t>> attrs;
|
||
|
||
auto elems = args[1]->listElems();
|
||
|
||
for (auto [i, vElem] : enumerate(args[1]->listItems())) {
|
||
Value res = state.callFunction(*args[0], vElem, noPos);
|
||
auto name = state.forceStringNoCtx(res, noPos, "while evaluating the return value of the grouping function passed to builtins.groupBy");
|
||
auto sym = state.ctx.symbols.create(name);
|
||
auto vector = attrs.try_emplace(sym, std::vector<size_t>()).first;
|
||
vector->second.push_back(i);
|
||
}
|
||
|
||
auto attrs2 = state.ctx.buildBindings(attrs.size());
|
||
|
||
for (auto & i : attrs) {
|
||
auto size = i.second.size();
|
||
auto content = state.ctx.mem.newList(size);
|
||
attrs2.insert(i.first, {NewValueAs::list, content});
|
||
for (auto [i, idx] : enumerate(i.second)) {
|
||
content->elems[i] = elems[idx];
|
||
}
|
||
}
|
||
|
||
return {NewValueAs::attrs, attrs2.alreadySorted()};
|
||
}
|
||
|
||
static Value prim_concatMap(EvalState & state, Value ** args)
|
||
{
|
||
state.forceFunction(*args[0], noPos, "while evaluating the first argument passed to builtins.concatMap");
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.concatMap");
|
||
auto nrLists = args[1]->listSize();
|
||
|
||
// List of returned lists before concatenation. References to these Values must NOT be persisted.
|
||
SmallTemporaryValueVector<conservativeStackReservation> lists;
|
||
lists.reserve(nrLists);
|
||
size_t len = 0;
|
||
|
||
for (size_t n = 0; n < nrLists; ++n) {
|
||
Value & vElem = args[1]->listElems()[n];
|
||
lists.push_back(state.callFunction(*args[0], vElem, noPos));
|
||
state.forceList(lists[n], noPos, "while evaluating the return value of the function passed to builtins.concatMap");
|
||
len += lists[n].listSize();
|
||
}
|
||
|
||
auto result = state.ctx.mem.newList(len);
|
||
auto out = result->elems;
|
||
for (unsigned int n = 0, pos = 0; n < nrLists; ++n) {
|
||
auto l = lists[n].listSize();
|
||
if (l) {
|
||
std::copy(lists[n].listItems().begin(), lists[n].listItems().end(), out + pos);
|
||
}
|
||
pos += l;
|
||
}
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
|
||
/*************************************************************
|
||
* Integer arithmetic
|
||
*************************************************************/
|
||
|
||
static Value prim_add(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
state.forceValue(*args[1], noPos);
|
||
if (args[0]->type() == nFloat || args[1]->type() == nFloat)
|
||
return {
|
||
NewValueAs::floating,
|
||
state.forceFloat(*args[0], noPos, "while evaluating the first argument of the addition")
|
||
+ state.forceFloat(*args[1], noPos, "while evaluating the second argument of the addition")
|
||
};
|
||
else {
|
||
auto i1 = state.forceInt(*args[0], noPos, "while evaluating the first argument of the addition");
|
||
auto i2 = state.forceInt(*args[1], noPos, "while evaluating the second argument of the addition");
|
||
|
||
auto result_ = i1 + i2;
|
||
if (auto result = result_.valueChecked(); result.has_value()) {
|
||
return {NewValueAs::integer, *result};
|
||
} else {
|
||
state.ctx.errors.make<EvalError>("integer overflow in adding %1% + %2%", i1, i2).debugThrow();
|
||
}
|
||
}
|
||
}
|
||
|
||
static Value prim_sub(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
state.forceValue(*args[1], noPos);
|
||
if (args[0]->type() == nFloat || args[1]->type() == nFloat)
|
||
return {
|
||
NewValueAs::floating,
|
||
state.forceFloat(*args[0], noPos, "while evaluating the first argument of the subtraction")
|
||
- state.forceFloat(*args[1], noPos, "while evaluating the second argument of the subtraction")
|
||
};
|
||
else {
|
||
auto i1 = state.forceInt(*args[0], noPos, "while evaluating the first argument of the subtraction");
|
||
auto i2 = state.forceInt(*args[1], noPos, "while evaluating the second argument of the subtraction");
|
||
|
||
auto result_ = i1 - i2;
|
||
|
||
if (auto result = result_.valueChecked(); result.has_value()) {
|
||
return {NewValueAs::integer, *result};
|
||
} else {
|
||
state.ctx.errors.make<EvalError>("integer overflow in subtracting %1% - %2%", i1, i2).debugThrow();
|
||
}
|
||
}
|
||
}
|
||
|
||
static Value prim_mul(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
state.forceValue(*args[1], noPos);
|
||
if (args[0]->type() == nFloat || args[1]->type() == nFloat)
|
||
return {
|
||
NewValueAs::floating,
|
||
state.forceFloat(*args[0], noPos, "while evaluating the first of the multiplication")
|
||
* state.forceFloat(
|
||
*args[1], noPos, "while evaluating the second argument of the multiplication"
|
||
)
|
||
};
|
||
else {
|
||
auto i1 = state.forceInt(*args[0], noPos, "while evaluating the first argument of the multiplication");
|
||
auto i2 = state.forceInt(*args[1], noPos, "while evaluating the second argument of the multiplication");
|
||
|
||
auto result_ = i1 * i2;
|
||
|
||
if (auto result = result_.valueChecked(); result.has_value()) {
|
||
return {NewValueAs::integer, *result};
|
||
} else {
|
||
state.ctx.errors.make<EvalError>("integer overflow in multiplying %1% * %2%", i1, i2).debugThrow();
|
||
}
|
||
}
|
||
}
|
||
|
||
static Value prim_div(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
state.forceValue(*args[1], noPos);
|
||
|
||
NixFloat f2 = state.forceFloat(*args[1], noPos, "while evaluating the second operand of the division");
|
||
if (f2 == 0)
|
||
state.ctx.errors.make<EvalError>("division by zero").debugThrow();
|
||
|
||
if (args[0]->type() == nFloat || args[1]->type() == nFloat) {
|
||
return {
|
||
NewValueAs::floating,
|
||
state.forceFloat(*args[0], noPos, "while evaluating the first operand of the division") / f2
|
||
};
|
||
} else {
|
||
NixInt i1 = state.forceInt(*args[0], noPos, "while evaluating the first operand of the division");
|
||
NixInt i2 = state.forceInt(*args[1], noPos, "while evaluating the second operand of the division");
|
||
/* Avoid division overflow as it might raise SIGFPE. */
|
||
auto result_ = i1 / i2;
|
||
if (auto result = result_.valueChecked(); result.has_value()) {
|
||
return {NewValueAs::integer, *result};
|
||
} else {
|
||
state.ctx.errors.make<EvalError>("integer overflow in dividing %1% / %2%", i1, i2).debugThrow();
|
||
}
|
||
}
|
||
}
|
||
|
||
static Value prim_bitAnd(EvalState & state, Value ** args)
|
||
{
|
||
auto i1 = state.forceInt(*args[0], noPos, "while evaluating the first argument passed to builtins.bitAnd");
|
||
auto i2 = state.forceInt(*args[1], noPos, "while evaluating the second argument passed to builtins.bitAnd");
|
||
return {NewValueAs::integer, i1.value & i2.value};
|
||
}
|
||
|
||
static Value prim_bitOr(EvalState & state, Value ** args)
|
||
{
|
||
auto i1 = state.forceInt(*args[0], noPos, "while evaluating the first argument passed to builtins.bitOr");
|
||
auto i2 = state.forceInt(*args[1], noPos, "while evaluating the second argument passed to builtins.bitOr");
|
||
|
||
return {NewValueAs::integer, i1.value | i2.value};
|
||
}
|
||
|
||
static Value prim_bitXor(EvalState & state, Value ** args)
|
||
{
|
||
auto i1 = state.forceInt(*args[0], noPos, "while evaluating the first argument passed to builtins.bitXor");
|
||
auto i2 = state.forceInt(*args[1], noPos, "while evaluating the second argument passed to builtins.bitXor");
|
||
|
||
return {NewValueAs::integer, i1.value ^ i2.value};
|
||
}
|
||
|
||
static Value prim_lessThan(EvalState & state, Value ** args)
|
||
{
|
||
state.forceValue(*args[0], noPos);
|
||
state.forceValue(*args[1], noPos);
|
||
CompareValues comp(state, "");
|
||
return {NewValueAs::boolean, comp(*args[0], *args[1])};
|
||
}
|
||
|
||
|
||
/*************************************************************
|
||
* String manipulation
|
||
*************************************************************/
|
||
|
||
|
||
/* Convert the argument to a string. Paths are *not* copied to the
|
||
store, so `toString /foo/bar' yields `"/foo/bar"', not
|
||
`"/nix/store/whatever..."'. */
|
||
static Value prim_toString(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
auto s = state.coerceToString(noPos, *args[0], context,
|
||
"while evaluating the first argument passed to builtins.toString",
|
||
StringCoercionMode::ToString, false);
|
||
return {NewValueAs::string, *s, context};
|
||
}
|
||
|
||
/* `substring start len str' returns the substring of `str' starting
|
||
at character position `min(start, stringLength str)' inclusive and
|
||
ending at `min(start + len, stringLength str)'. `start' must be
|
||
non-negative. */
|
||
static Value prim_substring(EvalState & state, Value ** args)
|
||
{
|
||
using NixUInt = std::make_unsigned_t<NixInt::Inner>;
|
||
NixInt::Inner start = state.forceInt(*args[0], noPos, "while evaluating the first argument (the start offset) passed to builtins.substring").value;
|
||
|
||
if (start < 0)
|
||
state.ctx.errors.make<EvalError>("negative start position in 'substring'").debugThrow();
|
||
|
||
NixInt::Inner len_arg = state
|
||
.forceInt(
|
||
*args[1],
|
||
noPos,
|
||
"while evaluating the second argument (the substring length) "
|
||
"passed to builtins.substring"
|
||
)
|
||
.value;
|
||
|
||
// Special-case on empty substring to avoid O(n) strlen
|
||
// This allows for the use of empty substrings to efficiently capture string context
|
||
if (len_arg == 0) {
|
||
state.forceValue(*args[2], noPos);
|
||
if (args[2]->type() == nString) {
|
||
return Value{NewValueAs::string, "", args[2]->string().context};
|
||
}
|
||
}
|
||
|
||
NixStringContext context;
|
||
auto s = state.coerceToString(noPos, *args[2], context, "while evaluating the third argument (the string) passed to builtins.substring");
|
||
|
||
// Negative length may be idiomatically passed to builtins.substring to get
|
||
// the tail of the string.
|
||
// Otherwise, clamp it to the size of the string or the length argument if it's smaller.
|
||
// This is notably useful on 32 bits platforms where max(size_t) (32 bits) < max(NixUInt) (64
|
||
// bits), because then the `len` argument fits a `size_t`.
|
||
static_assert(
|
||
sizeof(size_t) <= sizeof(NixUInt),
|
||
"std::size_t's size must be smaller or equal to Nix's unsigned int type's size (NixUInt)"
|
||
);
|
||
auto len = len_arg >= 0 ? std::min(static_cast<NixUInt>(s->size()), NixUInt(len_arg))
|
||
: std::numeric_limits<std::string::size_type>::max();
|
||
|
||
return {NewValueAs::string, NixUInt(start) >= s->size() ? "" : s->substr(start, len), context};
|
||
}
|
||
|
||
static Value prim_stringLength(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
auto s = state.coerceToString(noPos, *args[0], context, "while evaluating the argument passed to builtins.stringLength");
|
||
return {NewValueAs::integer, NixInt::Inner(s->size())};
|
||
}
|
||
|
||
/* Return the cryptographic hash of a string in base-16. */
|
||
static Value prim_hashString(EvalState & state, Value ** args)
|
||
{
|
||
auto type = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.hashString");
|
||
std::optional<HashType> ht = parseHashType(type);
|
||
if (!ht)
|
||
state.ctx.errors.make<EvalError>("unknown hash algorithm '%1%'", type).debugThrow();
|
||
|
||
NixStringContext context; // discarded
|
||
auto s = state.forceString(*args[1], context, noPos, "while evaluating the second argument passed to builtins.hashString");
|
||
|
||
return {NewValueAs::string, hashString(*ht, s).to_string(HashFormat::Base16, false)};
|
||
}
|
||
|
||
struct RegexCache
|
||
{
|
||
// TODO use C++20 transparent comparison when available
|
||
std::unordered_map<std::string_view, std::regex> cache;
|
||
std::list<std::string> keys;
|
||
|
||
std::regex get(std::string_view re)
|
||
{
|
||
auto it = cache.find(re);
|
||
if (it != cache.end())
|
||
return it->second;
|
||
keys.emplace_back(re);
|
||
return cache.emplace(keys.back(), regex::parse(keys.back(), std::regex::extended)).first->second;
|
||
}
|
||
};
|
||
|
||
static RegexCache & regexCacheOf(EvalState & state)
|
||
{
|
||
if (!state.ctx.caches.regexes) {
|
||
state.ctx.caches.regexes = std::make_shared<RegexCache>();
|
||
}
|
||
return *state.ctx.caches.regexes;
|
||
}
|
||
|
||
Value prim_match(EvalState & state, Value ** args)
|
||
{
|
||
auto re = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.match");
|
||
|
||
try {
|
||
|
||
auto regex = regexCacheOf(state).get(re);
|
||
|
||
NixStringContext context;
|
||
const auto str = state.forceString(*args[1], context, noPos, "while evaluating the second argument passed to builtins.match");
|
||
|
||
std::cmatch match;
|
||
if (!std::regex_match(str.begin(), str.end(), match, regex)) {
|
||
return Value::VNULL;
|
||
}
|
||
|
||
// the first match is the whole string
|
||
const size_t len = match.size() - 1;
|
||
auto result = state.ctx.mem.newList(len);
|
||
for (size_t i = 0; i < len; ++i) {
|
||
if (!match[i+1].matched)
|
||
result->elems[i] = Value::VNULL;
|
||
else
|
||
result->elems[i] = {NewValueAs::string, match[i + 1].str()};
|
||
}
|
||
|
||
return {NewValueAs::list, result};
|
||
} catch (regex::Error & e) {
|
||
state.ctx.errors.make<EvalError>(e.info()).debugThrow();
|
||
}
|
||
}
|
||
|
||
/* Split a string with a regular expression, and return a list of the
|
||
non-matching parts interleaved by the lists of the matching groups. */
|
||
Value prim_split(EvalState & state, Value ** args)
|
||
{
|
||
auto re = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.split");
|
||
|
||
try {
|
||
|
||
auto regex = regexCacheOf(state).get(re);
|
||
|
||
NixStringContext context;
|
||
const auto str = state.forceString(*args[1], context, noPos, "while evaluating the second argument passed to builtins.split");
|
||
|
||
auto begin = std::cregex_iterator(str.begin(), str.end(), regex);
|
||
auto end = std::cregex_iterator();
|
||
|
||
// Any matches results are surrounded by non-matching results.
|
||
const size_t len = std::distance(begin, end);
|
||
auto result = state.ctx.mem.newList(2 * len + 1);
|
||
Value v = {NewValueAs::list, result};
|
||
size_t idx = 0;
|
||
|
||
if (len == 0) {
|
||
result->elems[idx++] = *args[1];
|
||
return v;
|
||
}
|
||
|
||
for (auto i = begin; i != end; ++i) {
|
||
assert(idx <= 2 * len + 1 - 3);
|
||
auto match = *i;
|
||
|
||
// Add a string for non-matched characters.
|
||
result->elems[idx++] = {NewValueAs::string, match.prefix().str()};
|
||
|
||
// Add a list for matched substrings.
|
||
const size_t slen = match.size() - 1;
|
||
auto & elem = result->elems[idx++];
|
||
|
||
// Start at 1, beacause the first match is the whole string.
|
||
auto content = state.ctx.mem.newList(slen);
|
||
elem = {NewValueAs::list, content};
|
||
for (size_t si = 0; si < slen; ++si) {
|
||
if (!match[si + 1].matched)
|
||
content->elems[si] = Value::VNULL;
|
||
else
|
||
content->elems[si] = {NewValueAs::string, match[si + 1].str()};
|
||
}
|
||
|
||
// Add a string for non-matched suffix characters.
|
||
if (idx == 2 * len) {
|
||
result->elems[idx++] = {NewValueAs::string, match.suffix().str()};
|
||
}
|
||
}
|
||
|
||
assert(idx == 2 * len + 1);
|
||
|
||
return v;
|
||
} catch (regex::Error & e) {
|
||
state.ctx.errors.make<EvalError>(e.info()).debugThrow();
|
||
}
|
||
}
|
||
|
||
static Value prim_concatStringsSep(EvalState & state, Value ** args)
|
||
{
|
||
NixStringContext context;
|
||
|
||
auto sep = state.forceString(*args[0], context, noPos, "while evaluating the first argument (the separator string) passed to builtins.concatStringsSep");
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument (the list of strings to concat) passed to builtins.concatStringsSep");
|
||
|
||
std::string res;
|
||
res.reserve((args[1]->listSize() + 32) * sep.size());
|
||
bool first = true;
|
||
|
||
for (auto & elem : args[1]->listItems()) {
|
||
if (first) first = false; else res += sep;
|
||
res += *state.coerceToString(
|
||
noPos,
|
||
elem,
|
||
context,
|
||
"while evaluating one element of the list of strings to concat passed to "
|
||
"builtins.concatStringsSep"
|
||
);
|
||
}
|
||
|
||
return {NewValueAs::string, res, context};
|
||
}
|
||
|
||
static Value prim_replaceStrings(EvalState & state, Value ** args)
|
||
{
|
||
state.forceList(*args[0], noPos, "while evaluating the first argument passed to builtins.replaceStrings");
|
||
state.forceList(*args[1], noPos, "while evaluating the second argument passed to builtins.replaceStrings");
|
||
if (args[0]->listSize() != args[1]->listSize())
|
||
state.ctx.errors.make<EvalError>(
|
||
"'from' and 'to' arguments passed to builtins.replaceStrings have different lengths"
|
||
).debugThrow();
|
||
|
||
std::vector<std::string> from;
|
||
from.reserve(args[0]->listSize());
|
||
for (auto & elem : args[0]->listItems()) {
|
||
from.emplace_back(state.forceString(
|
||
elem,
|
||
noPos,
|
||
"while evaluating one of the strings to replace passed to builtins.replaceStrings"
|
||
));
|
||
}
|
||
|
||
std::unordered_map<size_t, std::string> cache;
|
||
auto to = args[1]->listItems();
|
||
|
||
NixStringContext context;
|
||
auto s = state.forceString(*args[2], context, noPos, "while evaluating the third argument passed to builtins.replaceStrings");
|
||
|
||
std::string res;
|
||
// Loops one past last character to handle the case where 'from' contains an empty string.
|
||
for (size_t p = 0; p <= s.size(); ) {
|
||
bool found = false;
|
||
auto i = from.begin();
|
||
auto j = to.begin();
|
||
size_t j_index = 0;
|
||
for (; i != from.end(); ++i, ++j, ++j_index)
|
||
if (s.compare(p, i->size(), *i) == 0) {
|
||
found = true;
|
||
auto v = cache.find(j_index);
|
||
if (v == cache.end()) {
|
||
NixStringContext ctx;
|
||
auto ts = state.forceString(
|
||
*j,
|
||
ctx,
|
||
noPos,
|
||
"while evaluating one of the replacement strings passed to "
|
||
"builtins.replaceStrings"
|
||
);
|
||
v = (cache.emplace(j_index, ts)).first;
|
||
for (auto & path : ctx) {
|
||
context.insert(path);
|
||
}
|
||
}
|
||
res += v->second;
|
||
if (i->empty()) {
|
||
if (p < s.size())
|
||
res += s[p];
|
||
p++;
|
||
} else {
|
||
p += i->size();
|
||
}
|
||
break;
|
||
}
|
||
if (!found) {
|
||
if (p < s.size())
|
||
res += s[p];
|
||
p++;
|
||
}
|
||
}
|
||
|
||
return {NewValueAs::string, res, context};
|
||
}
|
||
|
||
|
||
/*************************************************************
|
||
* Versions
|
||
*************************************************************/
|
||
|
||
static Value prim_parseDrvName(EvalState & state, Value ** args)
|
||
{
|
||
auto name = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.parseDrvName");
|
||
DrvName parsed(name);
|
||
auto attrs = state.ctx.buildBindings(2);
|
||
attrs.insert(state.ctx.symbols.sym_name, {NewValueAs::string, parsed.name});
|
||
attrs.insert("version", {NewValueAs::string, parsed.version});
|
||
return {NewValueAs::attrs, attrs};
|
||
}
|
||
|
||
static Value prim_compareVersions(EvalState & state, Value ** args)
|
||
{
|
||
auto version1 = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.compareVersions");
|
||
auto version2 = state.forceStringNoCtx(*args[1], noPos, "while evaluating the second argument passed to builtins.compareVersions");
|
||
auto result = compareVersions(version1, version2);
|
||
return {NewValueAs::integer, result < 0 ? -1 : result > 0 ? 1 : 0};
|
||
}
|
||
|
||
static Value prim_splitVersion(EvalState & state, Value ** args)
|
||
{
|
||
auto version = state.forceStringNoCtx(*args[0], noPos, "while evaluating the first argument passed to builtins.splitVersion");
|
||
auto iter = version.cbegin();
|
||
Strings components;
|
||
while (iter != version.cend()) {
|
||
auto component = nextComponent(iter, version.cend());
|
||
if (component.empty())
|
||
break;
|
||
components.emplace_back(component);
|
||
}
|
||
auto result = state.ctx.mem.newList(components.size());
|
||
for (const auto & [n, component] : enumerate(components))
|
||
result->elems[n] = {NewValueAs::string, component};
|
||
return {NewValueAs::list, result};
|
||
}
|
||
|
||
|
||
/*************************************************************
|
||
* Primop registration
|
||
*************************************************************/
|
||
|
||
PluginPrimOps::PrimOps * PluginPrimOps::primOps;
|
||
|
||
void PluginPrimOps::add(PrimOpDetails && primOp)
|
||
{
|
||
if (!primOps) primOps = new PrimOps;
|
||
primOps->emplace_back(std::move(primOp));
|
||
}
|
||
|
||
|
||
Value EvalBuiltins::prepareNixPath(const SearchPath & searchPath)
|
||
{
|
||
auto v = mem.newList(searchPath.elements.size());
|
||
int n = 0;
|
||
for (auto & i : searchPath.elements) {
|
||
auto attrs = mem.buildBindings(symbols, 2);
|
||
attrs.insert("path", {NewValueAs::string, i.path.s});
|
||
attrs.insert("prefix", {NewValueAs::string, i.prefix.s});
|
||
v->elems[n++] = {NewValueAs::attrs, attrs};
|
||
}
|
||
return {NewValueAs::list, v};
|
||
}
|
||
|
||
void EvalBuiltins::createBaseEnv(const SearchPath & searchPath, const Path & storeDir)
|
||
{
|
||
env.up = 0;
|
||
|
||
// constants include the magic `builtins` which must come first
|
||
#include "register-builtin-constants.gen.inc"
|
||
#include "register-builtins.gen.inc"
|
||
|
||
// Miscellaneous
|
||
if (evalSettings.enableNativeCode) {
|
||
addPrimOp({
|
||
.name = "__importNative",
|
||
.arity = 2,
|
||
.fun = prim_importNative,
|
||
});
|
||
addPrimOp({
|
||
.name = "__exec",
|
||
.arity = 1,
|
||
.fun = prim_exec,
|
||
});
|
||
}
|
||
|
||
if (PluginPrimOps::primOps) {
|
||
for (auto & primOp : *PluginPrimOps::primOps) {
|
||
if (experimentalFeatureSettings.isEnabled(primOp.experimentalFeature))
|
||
{
|
||
auto primOpAdjusted = primOp;
|
||
primOpAdjusted.arity = std::max(primOp.args.size(), primOp.arity);
|
||
addPrimOp(std::move(primOpAdjusted));
|
||
}
|
||
}
|
||
}
|
||
|
||
static PrimOp prim_initializeDerivation{
|
||
{
|
||
.arity = 1,
|
||
.fun = [](EvalState & state, Value ** args) -> Value {
|
||
char code[] =
|
||
#include "primops/derivation.nix.gen.hh"
|
||
;
|
||
auto & expr = *state.ctx.parse(
|
||
code, sizeof(code), Pos::Hidden{}, {CanonPath::root}, state.ctx.builtins.staticEnv
|
||
);
|
||
return state.eval(expr);
|
||
},
|
||
}
|
||
};
|
||
static Value initializeDerivation{NewValueAs::primop, prim_initializeDerivation};
|
||
|
||
/* Add a wrapper around the derivation primop that computes the
|
||
`drvPath' and `outPath' attributes lazily.
|
||
|
||
Null docs because it is documented separately.
|
||
App instead of PrimopApp to have eval immediately force it when accessed.
|
||
*/
|
||
addConstant(
|
||
"derivation",
|
||
{NewValueAs::app, mem, initializeDerivation, initializeDerivation},
|
||
{.type = nFunction}
|
||
);
|
||
|
||
/* Now that we've added all primops, sort the `builtins' set,
|
||
because attribute lookups expect it to be sorted. */
|
||
env.values[0].attrs()->sort();
|
||
|
||
staticEnv->isRoot = true;
|
||
}
|
||
|
||
|
||
}
|