Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
|
#include "archive.hh"
|
|
|
|
|
#include "derivations.hh"
|
|
|
|
|
#include "eval-inline.hh"
|
2004-08-04 10:59:20 +00:00
|
|
|
|
#include "eval.hh"
|
2003-10-31 17:09:31 +00:00
|
|
|
|
#include "globals.hh"
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
|
#include "json-to-value.hh"
|
|
|
|
|
#include "names.hh"
|
2006-11-30 17:43:04 +00:00
|
|
|
|
#include "store-api.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
#include "util.hh"
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
#include "json.hh"
|
2013-11-18 23:03:11 +00:00
|
|
|
|
#include "value-to-json.hh"
|
Eliminate the "store" global variable
Also, move a few free-standing functions into StoreAPI and Derivation.
Also, introduce a non-nullable smart pointer, ref<T>, which is just a
wrapper around std::shared_ptr ensuring that the pointer is never
null. (For reference-counted values, this is better than passing a
"T&", because the latter doesn't maintain the refcount. Usually, the
caller will have a shared_ptr keeping the value alive, but that's not
always the case, e.g., when passing a reference to a std::thread via
std::bind.)
2016-02-04 13:28:26 +00:00
|
|
|
|
#include "value-to-xml.hh"
|
2016-04-13 09:15:45 +00:00
|
|
|
|
#include "primops.hh"
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
2022-01-01 23:41:21 +00:00
|
|
|
|
#include <boost/container/small_vector.hpp>
|
|
|
|
|
|
2007-01-15 08:54:51 +00:00
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <sys/stat.h>
|
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
#include <algorithm>
|
2010-03-30 09:22:33 +00:00
|
|
|
|
#include <cstring>
|
2016-10-18 18:21:21 +00:00
|
|
|
|
#include <regex>
|
2014-06-01 14:42:56 +00:00
|
|
|
|
#include <dlfcn.h>
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
2021-05-10 14:41:10 +00:00
|
|
|
|
#include <cmath>
|
2021-05-10 09:47:00 +00:00
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
|
|
|
|
namespace nix {
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Miscellaneous
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
|
2014-10-18 02:15:09 +00:00
|
|
|
|
InvalidPathError::InvalidPathError(const Path & path) :
|
2019-12-05 18:11:09 +00:00
|
|
|
|
EvalError("path '%s' is not valid", path), path(path) {}
|
2014-05-30 19:43:31 +00:00
|
|
|
|
|
2021-12-20 18:46:55 +00:00
|
|
|
|
StringMap EvalState::realiseContext(const PathSet & context)
|
2014-05-30 19:43:31 +00:00
|
|
|
|
{
|
2021-04-05 13:48:18 +00:00
|
|
|
|
std::vector<DerivedPath::Built> drvs;
|
2021-12-20 18:46:55 +00:00
|
|
|
|
StringMap res;
|
2018-02-06 14:38:45 +00:00
|
|
|
|
|
2014-05-30 19:04:17 +00:00
|
|
|
|
for (auto & i : context) {
|
2022-03-12 00:28:00 +00:00
|
|
|
|
auto [ctx, outputName] = decodeContext(*store, i);
|
|
|
|
|
auto ctxS = store->printStorePath(ctx);
|
2012-01-26 13:13:00 +00:00
|
|
|
|
if (!store->isValidPath(ctx))
|
2022-02-11 21:14:25 +00:00
|
|
|
|
debug_throw(InvalidPathError(store->printStorePath(ctx)));
|
2020-06-18 11:44:40 +00:00
|
|
|
|
if (!outputName.empty() && ctx.isDerivation()) {
|
2021-03-02 03:50:41 +00:00
|
|
|
|
drvs.push_back({ctx, {outputName}});
|
2021-12-20 18:46:55 +00:00
|
|
|
|
} else {
|
|
|
|
|
res.insert_or_assign(ctxS, ctxS);
|
2018-02-06 14:38:45 +00:00
|
|
|
|
}
|
2014-05-30 19:04:17 +00:00
|
|
|
|
}
|
2018-02-06 14:38:45 +00:00
|
|
|
|
|
2021-12-20 18:46:55 +00:00
|
|
|
|
if (drvs.empty()) return {};
|
2018-02-06 14:38:45 +00:00
|
|
|
|
|
2018-03-27 17:02:22 +00:00
|
|
|
|
if (!evalSettings.enableImportFromDerivation)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
debug_throw(Error(
|
2021-09-22 12:00:56 +00:00
|
|
|
|
"cannot build '%1%' during evaluation because the option 'allow-import-from-derivation' is disabled",
|
2022-02-11 21:14:25 +00:00
|
|
|
|
store->printStorePath(drvs.begin()->drvPath)));
|
2018-02-06 14:38:45 +00:00
|
|
|
|
|
2021-10-07 11:15:01 +00:00
|
|
|
|
/* Build/substitute the context. */
|
2021-04-05 13:48:18 +00:00
|
|
|
|
std::vector<DerivedPath> buildReqs;
|
|
|
|
|
for (auto & d : drvs) buildReqs.emplace_back(DerivedPath { d });
|
2021-03-02 03:50:41 +00:00
|
|
|
|
store->buildPaths(buildReqs);
|
2020-08-07 19:09:26 +00:00
|
|
|
|
|
2021-12-20 18:46:55 +00:00
|
|
|
|
/* Get all the output paths corresponding to the placeholders we had */
|
|
|
|
|
for (auto & [drvPath, outputs] : drvs) {
|
|
|
|
|
auto outputPaths = store->queryDerivationOutputMap(drvPath);
|
|
|
|
|
for (auto & outputName : outputs) {
|
|
|
|
|
if (outputPaths.count(outputName) == 0)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
debug_throw(Error("derivation '%s' does not have an output named '%s'",
|
|
|
|
|
store->printStorePath(drvPath), outputName));
|
2021-12-20 18:46:55 +00:00
|
|
|
|
res.insert_or_assign(
|
|
|
|
|
downstreamPlaceholder(*store, drvPath, outputName),
|
|
|
|
|
store->printStorePath(outputPaths.at(outputName))
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-07 19:09:26 +00:00
|
|
|
|
/* Add the output of this derivations to the allowed
|
|
|
|
|
paths. */
|
|
|
|
|
if (allowedPaths) {
|
2021-12-20 18:46:55 +00:00
|
|
|
|
for (auto & [_placeholder, outputPath] : res) {
|
2021-12-29 17:42:02 +00:00
|
|
|
|
allowPath(store->toRealPath(outputPath));
|
2020-08-07 19:09:26 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2021-12-20 18:46:55 +00:00
|
|
|
|
|
|
|
|
|
return res;
|
2014-05-30 19:43:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-12-23 09:35:09 +00:00
|
|
|
|
struct RealisePathFlags {
|
|
|
|
|
// Whether to check that the path is allowed in pure eval mode
|
|
|
|
|
bool checkForPureEval = true;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static Path realisePath(EvalState & state, const Pos & pos, Value & v, const RealisePathFlags flags = {})
|
2021-12-21 07:42:19 +00:00
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
|
|
|
|
|
2022-01-21 12:51:05 +00:00
|
|
|
|
auto path = [&]()
|
|
|
|
|
{
|
|
|
|
|
try {
|
2022-01-27 14:32:14 +00:00
|
|
|
|
return state.coerceToPath(pos, v, context);
|
2022-01-21 12:51:05 +00:00
|
|
|
|
} catch (Error & e) {
|
|
|
|
|
e.addTrace(pos, "while realising the context of a path");
|
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
}();
|
2021-12-21 07:42:19 +00:00
|
|
|
|
|
2022-01-21 12:51:05 +00:00
|
|
|
|
try {
|
|
|
|
|
StringMap rewrites = state.realiseContext(context);
|
2021-12-21 07:42:19 +00:00
|
|
|
|
|
2022-01-21 12:51:05 +00:00
|
|
|
|
auto realPath = state.toRealPath(rewriteStrings(path, rewrites), context);
|
2021-12-23 09:35:09 +00:00
|
|
|
|
|
2022-01-21 12:51:05 +00:00
|
|
|
|
return flags.checkForPureEval
|
|
|
|
|
? state.checkSourcePath(realPath)
|
|
|
|
|
: realPath;
|
|
|
|
|
} catch (Error & e) {
|
|
|
|
|
e.addTrace(pos, "while realising the context of path '%s'", path);
|
|
|
|
|
throw;
|
|
|
|
|
}
|
2014-05-30 19:43:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-09-04 15:58:42 +00:00
|
|
|
|
/* 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. */
|
2022-01-04 16:39:16 +00:00
|
|
|
|
static void mkOutputString(
|
|
|
|
|
EvalState & state,
|
|
|
|
|
BindingsBuilder & attrs,
|
|
|
|
|
const StorePath & drvPath,
|
|
|
|
|
const BasicDerivation & drv,
|
2022-02-25 15:00:00 +00:00
|
|
|
|
const std::pair<std::string, DerivationOutput> & o)
|
2020-08-07 19:09:26 +00:00
|
|
|
|
{
|
2020-09-15 15:21:39 +00:00
|
|
|
|
auto optOutputPath = o.second.path(*state.store, drv.name, o.first);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
attrs.alloc(o.first).mkString(
|
2020-08-21 19:35:35 +00:00
|
|
|
|
optOutputPath
|
|
|
|
|
? state.store->printStorePath(*optOutputPath)
|
2020-08-07 19:09:26 +00:00
|
|
|
|
/* Downstream we would substitute this for an actual path once
|
|
|
|
|
we build the floating CA derivation */
|
|
|
|
|
/* FIXME: we need to depend on the basic derivation, not
|
|
|
|
|
derivation */
|
2020-08-21 19:35:35 +00:00
|
|
|
|
: downstreamPlaceholder(*state.store, drvPath, o.first),
|
2020-08-07 19:09:26 +00:00
|
|
|
|
{"!" + o.first + "!" + state.store->printStorePath(drvPath)});
|
|
|
|
|
}
|
2014-05-30 19:43:31 +00:00
|
|
|
|
|
|
|
|
|
/* Load and evaluate an expression from path specified by the
|
|
|
|
|
argument. */
|
2020-08-25 12:06:01 +00:00
|
|
|
|
static void import(EvalState & state, const Pos & pos, Value & vPath, Value * vScope, Value & v)
|
2014-05-30 19:43:31 +00:00
|
|
|
|
{
|
2022-01-21 12:51:05 +00:00
|
|
|
|
auto path = realisePath(state, pos, vPath);
|
2006-09-24 17:48:41 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
// FIXME
|
2020-07-12 02:38:03 +00:00
|
|
|
|
auto isValidDerivationInStore = [&]() -> std::optional<StorePath> {
|
|
|
|
|
if (!state.store->isStorePath(path))
|
|
|
|
|
return std::nullopt;
|
|
|
|
|
auto storePath = state.store->parseStorePath(path);
|
|
|
|
|
if (!(state.store->isValidPath(storePath) && isDerivation(path)))
|
|
|
|
|
return std::nullopt;
|
|
|
|
|
return storePath;
|
|
|
|
|
};
|
2020-08-25 12:06:01 +00:00
|
|
|
|
|
2020-07-12 02:38:03 +00:00
|
|
|
|
if (auto optStorePath = isValidDerivationInStore()) {
|
|
|
|
|
auto storePath = *optStorePath;
|
2020-08-01 19:38:35 +00:00
|
|
|
|
Derivation drv = state.store->readDerivation(storePath);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = state.buildBindings(3 + drv.outputs.size());
|
|
|
|
|
attrs.alloc(state.sDrvPath).mkString(path, {"=" + path});
|
|
|
|
|
attrs.alloc(state.sName).mkString(drv.env["name"]);
|
|
|
|
|
auto & outputsVal = attrs.alloc(state.sOutputs);
|
|
|
|
|
state.mkList(outputsVal, drv.outputs.size());
|
|
|
|
|
|
|
|
|
|
for (const auto & [i, o] : enumerate(drv.outputs)) {
|
|
|
|
|
mkOutputString(state, attrs, storePath, drv, o);
|
|
|
|
|
(outputsVal.listElems()[i] = state.allocValue())->mkString(o.first);
|
import: If the path is a valid .drv file, parse it and generate a derivation attrset.
The generated attrset has drvPath and outPath with the right string context, type 'derivation', outputName with
the right name, all with a list of outputs, and an attribute for each output.
I see three uses for this (though certainly there may be more):
* Using derivations generated by something besides nix-instantiate (e.g. guix)
* Allowing packages provided by channels to be used in nix expressions. If a channel installed a valid deriver
for each package it provides into the store, then those could be imported and used as dependencies or installed
in environment.systemPackages, for example.
* Enable hydra to be consistent in how it treats inputs that are outputs of another build. Right now, if an
input is passed as an argument to the job, it is passed as a derivation, but if it is accessed via NIX_PATH
(i.e. through the <> syntax), then it is a path that can be imported. This is problematic because the build
being depended upon may have been built with non-obvious arguments passed to its jobset file. With this
feature, hydra can just set the name of that input to the path to its drv file in NIX_PATH
2012-07-23 17:41:28 +00:00
|
|
|
|
}
|
2022-01-04 16:39:16 +00:00
|
|
|
|
|
|
|
|
|
auto w = state.allocValue();
|
|
|
|
|
w->mkAttrs(attrs);
|
2020-03-11 15:41:22 +00:00
|
|
|
|
|
2021-08-29 17:31:52 +00:00
|
|
|
|
if (!state.vImportedDrvToDerivation) {
|
|
|
|
|
state.vImportedDrvToDerivation = allocRootValue(state.allocValue());
|
2020-03-11 15:41:22 +00:00
|
|
|
|
state.eval(state.parseExprFromString(
|
|
|
|
|
#include "imported-drv-to-derivation.nix.gen.hh"
|
2021-08-29 17:31:52 +00:00
|
|
|
|
, "/"), **state.vImportedDrvToDerivation);
|
2020-03-11 15:41:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-08-29 17:31:52 +00:00
|
|
|
|
state.forceFunction(**state.vImportedDrvToDerivation, pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkApp(*state.vImportedDrvToDerivation, w);
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(v, pos);
|
2020-12-22 13:43:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else if (path == corepkgsPrefix + "fetchurl.nix") {
|
|
|
|
|
state.eval(state.parseExprFromString(
|
|
|
|
|
#include "fetchurl.nix.gen.hh"
|
|
|
|
|
, "/"), v);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else {
|
2020-08-25 12:06:01 +00:00
|
|
|
|
if (!vScope)
|
2021-12-21 07:42:19 +00:00
|
|
|
|
state.evalFile(path, v);
|
2014-05-30 19:04:17 +00:00
|
|
|
|
else {
|
2022-01-21 15:43:16 +00:00
|
|
|
|
state.forceAttrs(*vScope, pos);
|
2020-08-25 12:06:01 +00:00
|
|
|
|
|
|
|
|
|
Env * env = &state.allocEnv(vScope->attrs->size());
|
2014-05-30 19:04:17 +00:00
|
|
|
|
env->up = &state.baseEnv;
|
|
|
|
|
|
2021-11-25 15:53:59 +00:00
|
|
|
|
auto staticEnv = std::shared_ptr<StaticEnv>(new StaticEnv(false, state.staticBaseEnv.get(), vScope->attrs->size()));
|
2014-05-30 19:04:17 +00:00
|
|
|
|
|
|
|
|
|
unsigned int displ = 0;
|
2020-08-25 12:06:01 +00:00
|
|
|
|
for (auto & attr : *vScope->attrs) {
|
2021-11-30 21:15:02 +00:00
|
|
|
|
staticEnv->vars.emplace_back(attr.name, displ);
|
2014-05-30 19:04:17 +00:00
|
|
|
|
env->values[displ++] = attr.value;
|
|
|
|
|
}
|
Add primop ‘scopedImport’
‘scopedImport’ works like ‘import’, except that it takes a set of
attributes to be added to the lexical scope of the expression,
essentially extending or overriding the builtin variables. For
instance, the expression
scopedImport { x = 1; } ./foo.nix
where foo.nix contains ‘x’, will evaluate to 1.
This has a few applications:
* It allows getting rid of function argument specifications in package
expressions. For instance, a package expression like:
{ stdenv, fetchurl, libfoo }:
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
can now we written as just
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
and imported in all-packages.nix as:
bar = scopedImport pkgs ./bar.nix;
So whereas we once had dependencies listed in three places
(buildInputs, the function, and the call site), they now only need
to appear in one place.
* It allows overriding builtin functions. For instance, to trace all
calls to ‘map’:
let
overrides = {
map = f: xs: builtins.trace "map called!" (map f xs);
# Ensure that our override gets propagated by calls to
# import/scopedImport.
import = fn: scopedImport overrides fn;
scopedImport = attrs: fn: scopedImport (overrides // attrs) fn;
# Also update ‘builtins’.
builtins = builtins // overrides;
};
in scopedImport overrides ./bla.nix
* Similarly, it allows extending the set of builtin functions. For
instance, during Nixpkgs/NixOS evaluation, the Nixpkgs library
functions could be added to the default scope.
There is a downside: calls to scopedImport are not memoized, unlike
import. So importing a file multiple times leads to multiple parsings
/ evaluations. It would be possible to construct the AST only once,
but that would require careful handling of variables/environments.
2014-05-26 11:46:11 +00:00
|
|
|
|
|
2020-02-21 17:31:16 +00:00
|
|
|
|
// No need to call staticEnv.sort(), because
|
|
|
|
|
// args[0]->attrs is already sorted.
|
|
|
|
|
|
2021-12-21 07:42:19 +00:00
|
|
|
|
printTalkative("evaluating file '%1%'", path);
|
|
|
|
|
Expr * e = state.parseExprFromFile(resolveExprPath(path), staticEnv);
|
Add primop ‘scopedImport’
‘scopedImport’ works like ‘import’, except that it takes a set of
attributes to be added to the lexical scope of the expression,
essentially extending or overriding the builtin variables. For
instance, the expression
scopedImport { x = 1; } ./foo.nix
where foo.nix contains ‘x’, will evaluate to 1.
This has a few applications:
* It allows getting rid of function argument specifications in package
expressions. For instance, a package expression like:
{ stdenv, fetchurl, libfoo }:
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
can now we written as just
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
and imported in all-packages.nix as:
bar = scopedImport pkgs ./bar.nix;
So whereas we once had dependencies listed in three places
(buildInputs, the function, and the call site), they now only need
to appear in one place.
* It allows overriding builtin functions. For instance, to trace all
calls to ‘map’:
let
overrides = {
map = f: xs: builtins.trace "map called!" (map f xs);
# Ensure that our override gets propagated by calls to
# import/scopedImport.
import = fn: scopedImport overrides fn;
scopedImport = attrs: fn: scopedImport (overrides // attrs) fn;
# Also update ‘builtins’.
builtins = builtins // overrides;
};
in scopedImport overrides ./bla.nix
* Similarly, it allows extending the set of builtin functions. For
instance, during Nixpkgs/NixOS evaluation, the Nixpkgs library
functions could be added to the default scope.
There is a downside: calls to scopedImport are not memoized, unlike
import. So importing a file multiple times leads to multiple parsings
/ evaluations. It would be possible to construct the AST only once,
but that would require careful handling of variables/environments.
2014-05-26 11:46:11 +00:00
|
|
|
|
|
2014-05-30 19:04:17 +00:00
|
|
|
|
e->eval(state, *env, v);
|
|
|
|
|
}
|
Add primop ‘scopedImport’
‘scopedImport’ works like ‘import’, except that it takes a set of
attributes to be added to the lexical scope of the expression,
essentially extending or overriding the builtin variables. For
instance, the expression
scopedImport { x = 1; } ./foo.nix
where foo.nix contains ‘x’, will evaluate to 1.
This has a few applications:
* It allows getting rid of function argument specifications in package
expressions. For instance, a package expression like:
{ stdenv, fetchurl, libfoo }:
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
can now we written as just
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
and imported in all-packages.nix as:
bar = scopedImport pkgs ./bar.nix;
So whereas we once had dependencies listed in three places
(buildInputs, the function, and the call site), they now only need
to appear in one place.
* It allows overriding builtin functions. For instance, to trace all
calls to ‘map’:
let
overrides = {
map = f: xs: builtins.trace "map called!" (map f xs);
# Ensure that our override gets propagated by calls to
# import/scopedImport.
import = fn: scopedImport overrides fn;
scopedImport = attrs: fn: scopedImport (overrides // attrs) fn;
# Also update ‘builtins’.
builtins = builtins // overrides;
};
in scopedImport overrides ./bla.nix
* Similarly, it allows extending the set of builtin functions. For
instance, during Nixpkgs/NixOS evaluation, the Nixpkgs library
functions could be added to the default scope.
There is a downside: calls to scopedImport are not memoized, unlike
import. So importing a file multiple times leads to multiple parsings
/ evaluations. It would be possible to construct the AST only once,
but that would require careful handling of variables/environments.
2014-05-26 11:46:11 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 12:06:01 +00:00
|
|
|
|
static RegisterPrimOp primop_scopedImport(RegisterPrimOp::Info {
|
|
|
|
|
.name = "scopedImport",
|
|
|
|
|
.arity = 2,
|
|
|
|
|
.fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
import(state, pos, *args[1], args[0], v);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
static RegisterPrimOp primop_import({
|
|
|
|
|
.name = "import",
|
|
|
|
|
.args = {"path"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Load, parse and return the Nix expression in the file *path*. If
|
|
|
|
|
*path* is a directory, the file ` default.nix ` in that directory
|
|
|
|
|
is loaded. Evaluation aborts if the file doesn’t exist or contains
|
|
|
|
|
an incorrect Nix expression. `import` implements Nix’s module
|
|
|
|
|
system: you can put any Nix expression (such as a set or a
|
|
|
|
|
function) in a separate file, and use it from Nix expressions in
|
|
|
|
|
other files.
|
|
|
|
|
|
|
|
|
|
> **Note**
|
|
|
|
|
>
|
|
|
|
|
> Unlike some languages, `import` is a regular function in Nix.
|
|
|
|
|
> Paths using the angle bracket syntax (e.g., `import` *\<foo\>*)
|
|
|
|
|
> are [normal path values](language-values.md).
|
|
|
|
|
|
|
|
|
|
A Nix expression loaded by `import` must not contain any *free
|
|
|
|
|
variables* (identifiers that are not defined in the Nix expression
|
|
|
|
|
itself and are not built-in). Therefore, it cannot refer to
|
|
|
|
|
variables that are in scope at the call site. For instance, if you
|
|
|
|
|
have a calling expression
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
rec {
|
|
|
|
|
x = 123;
|
|
|
|
|
y = import ./foo.nix;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
then the following `foo.nix` will give an error:
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
x + 456
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
since `x` is not in scope in `foo.nix`. If you want `x` to be
|
|
|
|
|
available in `foo.nix`, you should pass it as a function argument:
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
rec {
|
|
|
|
|
x = 123;
|
|
|
|
|
y = import ./foo.nix x;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
and
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
x: x + 456
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
(The function argument doesn’t have to be called `x` in `foo.nix`;
|
|
|
|
|
any name would work.)
|
|
|
|
|
)",
|
|
|
|
|
.fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
import(state, pos, *args[0], nullptr, v);
|
|
|
|
|
}
|
|
|
|
|
});
|
Add primop ‘scopedImport’
‘scopedImport’ works like ‘import’, except that it takes a set of
attributes to be added to the lexical scope of the expression,
essentially extending or overriding the builtin variables. For
instance, the expression
scopedImport { x = 1; } ./foo.nix
where foo.nix contains ‘x’, will evaluate to 1.
This has a few applications:
* It allows getting rid of function argument specifications in package
expressions. For instance, a package expression like:
{ stdenv, fetchurl, libfoo }:
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
can now we written as just
stdenv.mkDerivation { ... buildInputs = [ libfoo ]; }
and imported in all-packages.nix as:
bar = scopedImport pkgs ./bar.nix;
So whereas we once had dependencies listed in three places
(buildInputs, the function, and the call site), they now only need
to appear in one place.
* It allows overriding builtin functions. For instance, to trace all
calls to ‘map’:
let
overrides = {
map = f: xs: builtins.trace "map called!" (map f xs);
# Ensure that our override gets propagated by calls to
# import/scopedImport.
import = fn: scopedImport overrides fn;
scopedImport = attrs: fn: scopedImport (overrides // attrs) fn;
# Also update ‘builtins’.
builtins = builtins // overrides;
};
in scopedImport overrides ./bla.nix
* Similarly, it allows extending the set of builtin functions. For
instance, during Nixpkgs/NixOS evaluation, the Nixpkgs library
functions could be added to the default scope.
There is a downside: calls to scopedImport are not memoized, unlike
import. So importing a file multiple times leads to multiple parsings
/ evaluations. It would be possible to construct the AST only once,
but that would require careful handling of variables/environments.
2014-05-26 11:46:11 +00:00
|
|
|
|
|
2014-06-01 14:42:56 +00:00
|
|
|
|
/* 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);
|
|
|
|
|
|
2015-02-23 13:41:53 +00:00
|
|
|
|
/* Load a ValueInitializer from a DSO and return whatever it initializes */
|
2018-04-09 14:26:50 +00:00
|
|
|
|
void prim_importNative(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2014-06-01 14:42:56 +00:00
|
|
|
|
{
|
2022-01-21 12:51:05 +00:00
|
|
|
|
auto path = realisePath(state, pos, *args[0]);
|
2014-06-01 14:42:56 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string sym(state.forceStringNoCtx(*args[1], pos));
|
2014-06-01 14:42:56 +00:00
|
|
|
|
|
|
|
|
|
void *handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);
|
|
|
|
|
if (!handle)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError("could not open '%1%': %2%", path, dlerror()));
|
2014-06-01 14:42:56 +00:00
|
|
|
|
|
|
|
|
|
dlerror();
|
|
|
|
|
ValueInitializer func = (ValueInitializer) dlsym(handle, sym.c_str());
|
|
|
|
|
if(!func) {
|
|
|
|
|
char *message = dlerror();
|
|
|
|
|
if (message)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError("could not load symbol '%1%' from '%2%': %3%", sym, path, message));
|
2014-06-01 14:42:56 +00:00
|
|
|
|
else
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError("symbol '%1%' from '%2%' resolved to NULL when a function pointer was expected",
|
|
|
|
|
sym, path));
|
2014-06-01 14:42:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
(func)(state, v);
|
|
|
|
|
|
|
|
|
|
/* We don't dlclose because v may be a primop referencing a function in the shared object file */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-03-30 12:04:21 +00:00
|
|
|
|
/* Execute a program and parse its output */
|
2018-04-09 14:26:50 +00:00
|
|
|
|
void prim_exec(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2017-03-30 12:04:21 +00:00
|
|
|
|
{
|
2017-03-31 15:58:41 +00:00
|
|
|
|
state.forceList(*args[0], pos);
|
|
|
|
|
auto elems = args[0]->listElems();
|
|
|
|
|
auto count = args[0]->listSize();
|
|
|
|
|
if (count == 0) {
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("at least one argument to 'exec' required"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2017-03-31 15:58:41 +00:00
|
|
|
|
}
|
2017-03-30 12:04:21 +00:00
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
auto program = state.coerceToString(pos, *elems[0], context, false, false).toOwned();
|
2017-03-30 12:04:21 +00:00
|
|
|
|
Strings commandArgs;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
for (unsigned int i = 1; i < args[0]->listSize(); ++i) {
|
|
|
|
|
commandArgs.push_back(state.coerceToString(pos, *elems[i], context, false, false).toOwned());
|
|
|
|
|
}
|
2017-03-30 12:04:21 +00:00
|
|
|
|
try {
|
2021-12-20 18:46:55 +00:00
|
|
|
|
auto _ = state.realiseContext(context); // FIXME: Handle CA derivations
|
2017-03-30 12:04:21 +00:00
|
|
|
|
} catch (InvalidPathError & e) {
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("cannot execute '%1%', since path '%2%' is not valid",
|
2020-06-15 12:06:58 +00:00
|
|
|
|
program, e.path),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-06-15 12:06:58 +00:00
|
|
|
|
}
|
2017-03-30 12:04:21 +00:00
|
|
|
|
|
|
|
|
|
auto output = runProgram(program, true, commandArgs);
|
|
|
|
|
Expr * parsed;
|
|
|
|
|
try {
|
2021-12-21 12:56:57 +00:00
|
|
|
|
parsed = state.parseExprFromString(std::move(output), pos.file);
|
2017-03-30 12:04:21 +00:00
|
|
|
|
} catch (Error & e) {
|
2020-06-24 19:46:25 +00:00
|
|
|
|
e.addTrace(pos, "While parsing the output from '%1%'", program);
|
2017-03-30 12:04:21 +00:00
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
try {
|
|
|
|
|
state.eval(parsed, v);
|
|
|
|
|
} catch (Error & e) {
|
2020-06-24 19:46:25 +00:00
|
|
|
|
e.addTrace(pos, "While evaluating the output from '%1%'", program);
|
2017-03-30 12:04:21 +00:00
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-10-24 00:49:13 +00:00
|
|
|
|
/* Return a string representing the type of the expression. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_typeOf(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2013-10-24 00:49:13 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string t;
|
2020-12-17 13:45:45 +00:00
|
|
|
|
switch (args[0]->type()) {
|
2020-12-12 01:09:10 +00:00
|
|
|
|
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:
|
2014-11-30 18:16:19 +00:00
|
|
|
|
t = args[0]->external->typeOf();
|
|
|
|
|
break;
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nFloat: t = "float"; break;
|
|
|
|
|
case nThunk: abort();
|
2013-10-24 00:49:13 +00:00
|
|
|
|
}
|
2022-01-04 18:09:40 +00:00
|
|
|
|
v.mkString(state.symbols.create(t));
|
2013-10-24 00:49:13 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_typeOf({
|
|
|
|
|
.name = "__typeOf",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a string representing the type of the value *e*, namely
|
|
|
|
|
`"int"`, `"bool"`, `"string"`, `"path"`, `"null"`, `"set"`,
|
|
|
|
|
`"list"`, `"lambda"` or `"float"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_typeOf,
|
|
|
|
|
});
|
2013-10-24 00:49:13 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/* Determine whether the argument is the null value. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_isNull(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 15:11:32 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nNull);
|
2007-01-29 15:11:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isNull({
|
|
|
|
|
.name = "isNull",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to `null`, and `false` otherwise.
|
|
|
|
|
|
|
|
|
|
> **Warning**
|
2021-09-22 18:58:21 +00:00
|
|
|
|
>
|
2020-08-24 12:31:10 +00:00
|
|
|
|
> This function is *deprecated*; just write `e == null` instead.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isNull,
|
|
|
|
|
});
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2007-05-16 16:17:04 +00:00
|
|
|
|
/* Determine whether the argument is a function. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_isFunction(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-05-16 16:17:04 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nFunction);
|
2007-05-16 16:17:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isFunction({
|
|
|
|
|
.name = "__isFunction",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to a function, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isFunction,
|
|
|
|
|
});
|
2010-03-30 22:39:48 +00:00
|
|
|
|
|
2013-10-24 00:49:13 +00:00
|
|
|
|
/* Determine whether the argument is an integer. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_isInt(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2009-02-05 19:35:40 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nInt);
|
2009-02-05 19:35:40 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isInt({
|
|
|
|
|
.name = "__isInt",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to an integer, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isInt,
|
|
|
|
|
});
|
|
|
|
|
|
2016-01-04 23:40:40 +00:00
|
|
|
|
/* Determine whether the argument is a float. */
|
|
|
|
|
static void prim_isFloat(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nFloat);
|
2016-01-04 23:40:40 +00:00
|
|
|
|
}
|
2010-03-30 22:39:48 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isFloat({
|
|
|
|
|
.name = "__isFloat",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to a float, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isFloat,
|
|
|
|
|
});
|
|
|
|
|
|
2013-10-24 00:49:13 +00:00
|
|
|
|
/* Determine whether the argument is a string. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_isString(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2009-02-05 19:35:40 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nString);
|
2009-02-05 19:35:40 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isString({
|
|
|
|
|
.name = "__isString",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to a string, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isString,
|
|
|
|
|
});
|
2010-03-30 22:39:48 +00:00
|
|
|
|
|
2013-10-24 00:49:13 +00:00
|
|
|
|
/* Determine whether the argument is a Boolean. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_isBool(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2009-02-05 19:35:40 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nBool);
|
2009-02-05 19:35:40 +00:00
|
|
|
|
}
|
2007-05-16 16:17:04 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isBool({
|
|
|
|
|
.name = "__isBool",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to a bool, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isBool,
|
|
|
|
|
});
|
|
|
|
|
|
2018-01-29 12:36:59 +00:00
|
|
|
|
/* Determine whether the argument is a path. */
|
|
|
|
|
static void prim_isPath(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nPath);
|
2018-01-29 12:36:59 +00:00
|
|
|
|
}
|
2010-03-30 22:39:48 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isPath({
|
|
|
|
|
.name = "__isPath",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to a path, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isPath,
|
|
|
|
|
});
|
|
|
|
|
|
2010-04-21 15:57:11 +00:00
|
|
|
|
struct CompareValues
|
|
|
|
|
{
|
2021-11-22 22:56:40 +00:00
|
|
|
|
EvalState & state;
|
|
|
|
|
|
|
|
|
|
CompareValues(EvalState & state) : state(state) { };
|
|
|
|
|
|
|
|
|
|
bool operator () (Value * v1, Value * v2) const
|
2010-04-21 15:57:11 +00:00
|
|
|
|
{
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v1->type() == nFloat && v2->type() == nInt)
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v1->fpoint < v2->integer;
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v1->type() == nInt && v2->type() == nFloat)
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v1->integer < v2->fpoint;
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (v1->type() != v2->type())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError("cannot compare %1% with %2%", showType(*v1), showType(*v2)));
|
2020-12-17 13:45:45 +00:00
|
|
|
|
switch (v1->type()) {
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nInt:
|
2013-10-28 17:50:58 +00:00
|
|
|
|
return v1->integer < v2->integer;
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nFloat:
|
2016-01-04 23:40:40 +00:00
|
|
|
|
return v1->fpoint < v2->fpoint;
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nString:
|
2013-10-28 17:50:58 +00:00
|
|
|
|
return strcmp(v1->string.s, v2->string.s) < 0;
|
2020-12-12 01:09:10 +00:00
|
|
|
|
case nPath:
|
2013-10-28 17:50:58 +00:00
|
|
|
|
return strcmp(v1->path, v2->path) < 0;
|
2021-11-22 22:56:40 +00:00
|
|
|
|
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])) {
|
|
|
|
|
return (*this)(v1->listElems()[i], v2->listElems()[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-04-21 15:57:11 +00:00
|
|
|
|
default:
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError("cannot compare %1% with %2%", showType(*v1), showType(*v2)));
|
|
|
|
|
return false;
|
2010-04-21 15:57:11 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
2013-10-28 17:50:58 +00:00
|
|
|
|
#if HAVE_BOEHMGC
|
2022-02-21 15:25:12 +00:00
|
|
|
|
typedef std::list<Value *, gc_allocator<Value *> > ValueList;
|
2013-10-28 17:50:58 +00:00
|
|
|
|
#else
|
2022-02-21 15:25:12 +00:00
|
|
|
|
typedef std::list<Value *> ValueList;
|
2013-10-28 17:50:58 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
2021-04-13 21:08:59 +00:00
|
|
|
|
static Bindings::iterator getAttr(
|
|
|
|
|
EvalState & state,
|
2022-01-12 17:08:48 +00:00
|
|
|
|
std::string_view funcName,
|
|
|
|
|
Symbol attrSym,
|
2021-04-13 21:08:59 +00:00
|
|
|
|
Bindings * attrSet,
|
|
|
|
|
const Pos & pos)
|
|
|
|
|
{
|
2022-01-12 17:08:48 +00:00
|
|
|
|
Bindings::iterator value = attrSet->find(attrSym);
|
2021-04-11 10:14:05 +00:00
|
|
|
|
if (value == attrSet->end()) {
|
2021-04-11 11:55:07 +00:00
|
|
|
|
hintformat errorMsg = hintfmt(
|
|
|
|
|
"attribute '%s' missing for call to '%s'",
|
2022-01-12 17:08:48 +00:00
|
|
|
|
attrSym,
|
2021-04-11 11:55:07 +00:00
|
|
|
|
funcName
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
Pos aPos = *attrSet->pos;
|
|
|
|
|
if (aPos == noPos) {
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(TypeError({
|
2021-04-11 11:55:07 +00:00
|
|
|
|
.msg = errorMsg,
|
|
|
|
|
.errPos = pos,
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2021-04-11 11:55:07 +00:00
|
|
|
|
} else {
|
|
|
|
|
auto e = TypeError({
|
|
|
|
|
.msg = errorMsg,
|
|
|
|
|
.errPos = aPos,
|
|
|
|
|
});
|
2021-04-11 10:14:05 +00:00
|
|
|
|
|
2021-04-11 11:55:07 +00:00
|
|
|
|
// Adding another trace for the function name to make it clear
|
|
|
|
|
// which call received wrong arguments.
|
|
|
|
|
e.addTrace(pos, hintfmt("while invoking '%s'", funcName));
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(e);
|
2021-04-11 11:55:07 +00:00
|
|
|
|
}
|
2021-04-11 10:14:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return value;
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 15:11:32 +00:00
|
|
|
|
{
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[0], pos);
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
|
|
|
|
/* Get the start set. */
|
2021-04-13 21:08:59 +00:00
|
|
|
|
Bindings::iterator startSet = getAttr(
|
2021-04-11 10:14:05 +00:00
|
|
|
|
state,
|
|
|
|
|
"genericClosure",
|
2022-01-12 17:08:48 +00:00
|
|
|
|
state.sStartSet,
|
2021-04-11 10:14:05 +00:00
|
|
|
|
args[0]->attrs,
|
|
|
|
|
pos
|
|
|
|
|
);
|
|
|
|
|
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*startSet->value, pos);
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2013-10-28 21:51:12 +00:00
|
|
|
|
ValueList workSet;
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : startSet->value->listItems())
|
|
|
|
|
workSet.push_back(elem);
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2008-07-11 13:29:04 +00:00
|
|
|
|
/* Get the operator. */
|
2021-04-13 21:08:59 +00:00
|
|
|
|
Bindings::iterator op = getAttr(
|
2021-04-11 10:14:05 +00:00
|
|
|
|
state,
|
|
|
|
|
"genericClosure",
|
2022-01-12 17:08:48 +00:00
|
|
|
|
state.sOperator,
|
2021-04-11 10:14:05 +00:00
|
|
|
|
args[0]->attrs,
|
|
|
|
|
pos
|
|
|
|
|
);
|
|
|
|
|
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*op->value, pos);
|
2010-04-21 15:57:11 +00:00
|
|
|
|
|
2008-07-11 13:29:04 +00:00
|
|
|
|
/* Construct the closure by applying the operator to element of
|
|
|
|
|
`workSet', adding the result to `workSet', continuing until
|
|
|
|
|
no new elements are found. */
|
2013-10-28 21:51:12 +00:00
|
|
|
|
ValueList res;
|
2013-10-28 17:50:58 +00:00
|
|
|
|
// `doneKeys' doesn't need to be a GC root, because its values are
|
|
|
|
|
// reachable from res.
|
2021-11-22 22:56:40 +00:00
|
|
|
|
auto cmp = CompareValues(state);
|
2022-02-21 15:28:23 +00:00
|
|
|
|
std::set<Value *, decltype(cmp)> doneKeys(cmp);
|
2007-01-29 15:11:32 +00:00
|
|
|
|
while (!workSet.empty()) {
|
2013-08-02 16:53:02 +00:00
|
|
|
|
Value * e = *(workSet.begin());
|
|
|
|
|
workSet.pop_front();
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*e, pos);
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2010-04-21 15:57:11 +00:00
|
|
|
|
Bindings::iterator key =
|
2022-01-12 17:08:48 +00:00
|
|
|
|
e->attrs->find(state.sKey);
|
2010-04-21 15:57:11 +00:00
|
|
|
|
if (key == e->attrs->end())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("attribute 'key' required"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*key->value, pos);
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2019-10-09 13:51:52 +00:00
|
|
|
|
if (!doneKeys.insert(key->value).second) continue;
|
2013-10-28 17:50:58 +00:00
|
|
|
|
res.push_back(e);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2008-07-11 13:29:04 +00:00
|
|
|
|
/* Call the `operator' function with `e' as argument. */
|
2010-04-21 15:57:11 +00:00
|
|
|
|
Value call;
|
2022-01-04 17:40:39 +00:00
|
|
|
|
call.mkApp(op->value, e);
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(call, pos);
|
2010-04-21 15:57:11 +00:00
|
|
|
|
|
|
|
|
|
/* Add the values returned by the operator to the work set. */
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : call.listItems()) {
|
|
|
|
|
state.forceValue(*elem, pos);
|
|
|
|
|
workSet.push_back(elem);
|
2010-04-21 15:57:11 +00:00
|
|
|
|
}
|
2007-01-29 15:11:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-04-21 15:57:11 +00:00
|
|
|
|
/* Create the result list. */
|
|
|
|
|
state.mkList(v, res.size());
|
|
|
|
|
unsigned int n = 0;
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : res)
|
2015-07-23 20:05:09 +00:00
|
|
|
|
v.listElems()[n++] = i;
|
2007-01-29 15:11:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:25:01 +00:00
|
|
|
|
static RegisterPrimOp primop_genericClosure(RegisterPrimOp::Info {
|
|
|
|
|
.name = "__genericClosure",
|
2022-03-24 02:54:43 +00:00
|
|
|
|
.args = {"attrset"},
|
2020-08-25 09:25:01 +00:00
|
|
|
|
.arity = 1,
|
2022-03-24 02:54:43 +00:00
|
|
|
|
.doc = R"(
|
|
|
|
|
Take an *attrset* with values named `startSet` and `operator` in order to
|
|
|
|
|
return a *list of attrsets* by starting with the `startSet`, recursively
|
|
|
|
|
applying the `operator` function to each element. The *attrsets* in the
|
|
|
|
|
`startSet` and produced by the `operator` must each contain value named
|
|
|
|
|
`key` which are comparable to each other. The result is produced by
|
|
|
|
|
repeatedly calling the operator for each element encountered with a
|
|
|
|
|
unique key, terminating when no new elements are produced. For example,
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
builtins.genericClosure {
|
|
|
|
|
startSet = [ {key = 5;} ];
|
|
|
|
|
operator = item: [{
|
|
|
|
|
key = if (item.key / 2 ) * 2 == item.key
|
|
|
|
|
then item.key / 2
|
|
|
|
|
else 3 * item.key + 1;
|
|
|
|
|
}];
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
evaluates to
|
|
|
|
|
```
|
|
|
|
|
[ { key = 5; } { key = 16; } { key = 8; } { key = 4; } { key = 2; } { key = 1; } ]
|
|
|
|
|
```
|
|
|
|
|
)",
|
2020-08-25 09:25:01 +00:00
|
|
|
|
.fun = prim_genericClosure,
|
|
|
|
|
});
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2022-02-14 21:04:34 +00:00
|
|
|
|
|
2022-02-03 20:15:21 +00:00
|
|
|
|
static RegisterPrimOp primop_break({
|
|
|
|
|
.name = "break",
|
2022-02-04 21:50:25 +00:00
|
|
|
|
.args = {"v"},
|
2022-02-03 20:15:21 +00:00
|
|
|
|
.doc = R"(
|
|
|
|
|
In debug mode, pause Nix expression evaluation and enter the repl.
|
|
|
|
|
)",
|
|
|
|
|
.fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2022-02-14 21:04:34 +00:00
|
|
|
|
auto error = Error(ErrorInfo{
|
|
|
|
|
.level = lvlInfo,
|
|
|
|
|
.msg = hintfmt("breakpoint reached; value was %1%", *args[0]),
|
|
|
|
|
.errPos = pos,
|
|
|
|
|
});
|
2022-02-03 20:15:21 +00:00
|
|
|
|
if (debuggerHook && !state.debugTraces.empty())
|
|
|
|
|
{
|
2022-03-16 18:09:47 +00:00
|
|
|
|
auto &dt = state.debugTraces.front();
|
|
|
|
|
debuggerHook(&error, dt.env, dt.expr);
|
|
|
|
|
|
|
|
|
|
if (state.debugQuit) {
|
|
|
|
|
// if the user elects to quit the repl, throw an exception.
|
|
|
|
|
throw Error(ErrorInfo{
|
|
|
|
|
.level = lvlInfo,
|
|
|
|
|
.msg = hintfmt("quit from debugger"),
|
|
|
|
|
.errPos = noPos,
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// returning the value we were passed.
|
|
|
|
|
v = *args[0];
|
2022-02-03 20:15:21 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2020-08-24 11:11:56 +00:00
|
|
|
|
static RegisterPrimOp primop_abort({
|
|
|
|
|
.name = "abort",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Abort Nix expression evaluation and print the error message *s*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto s = state.coerceToString(pos, *args[0], context).toOwned();
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Abort("evaluation aborted with the following error message: '%1%'", s));
|
2020-08-24 11:11:56 +00:00
|
|
|
|
}
|
|
|
|
|
});
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_throw({
|
|
|
|
|
.name = "throw",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Throw an error message *s*. This usually aborts Nix expression
|
|
|
|
|
evaluation, but in `nix-env -qa` and other commands that try to
|
|
|
|
|
evaluate a set of derivations to get information about those
|
|
|
|
|
derivations, a derivation that throws an error is silently skipped
|
|
|
|
|
(which is not the case for `abort`).
|
|
|
|
|
)",
|
|
|
|
|
.fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto s = state.coerceToString(pos, *args[0], context).toOwned();
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(ThrownError(s));
|
2020-08-24 12:31:10 +00:00
|
|
|
|
}
|
|
|
|
|
});
|
2007-04-16 15:03:19 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_addErrorContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2009-01-27 14:36:44 +00:00
|
|
|
|
{
|
|
|
|
|
try {
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[1], pos);
|
2010-05-07 12:33:14 +00:00
|
|
|
|
v = *args[1];
|
2009-01-27 14:36:44 +00:00
|
|
|
|
} catch (Error & e) {
|
2010-05-07 12:33:14 +00:00
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
e.addTrace(std::nullopt, state.coerceToString(pos, *args[0], context).toOwned());
|
2009-01-27 14:36:44 +00:00
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:25:01 +00:00
|
|
|
|
static RegisterPrimOp primop_addErrorContext(RegisterPrimOp::Info {
|
|
|
|
|
.name = "__addErrorContext",
|
|
|
|
|
.arity = 2,
|
|
|
|
|
.fun = prim_addErrorContext,
|
|
|
|
|
});
|
2010-05-07 12:33:14 +00:00
|
|
|
|
|
2021-05-10 09:47:00 +00:00
|
|
|
|
static void prim_ceil(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
auto value = state.forceFloat(*args[0], args[0]->determinePos(pos));
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(ceil(value));
|
2021-05-10 09:47:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static RegisterPrimOp primop_ceil({
|
|
|
|
|
.name = "__ceil",
|
|
|
|
|
.args = {"double"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Converts an IEEE-754 double-precision floating-point number (*double*) to
|
|
|
|
|
the next higher integer.
|
|
|
|
|
|
|
|
|
|
If the datatype is neither an integer nor a "float", an evaluation error will be
|
|
|
|
|
thrown.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_ceil,
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
static void prim_floor(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
auto value = state.forceFloat(*args[0], args[0]->determinePos(pos));
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(floor(value));
|
2021-05-10 09:47:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static RegisterPrimOp primop_floor({
|
|
|
|
|
.name = "__floor",
|
|
|
|
|
.args = {"double"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Converts an IEEE-754 double-precision floating-point number (*double*) to
|
|
|
|
|
the next lower integer.
|
|
|
|
|
|
|
|
|
|
If the datatype is neither an integer nor a "float", an evaluation error will be
|
|
|
|
|
thrown.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_floor,
|
|
|
|
|
});
|
|
|
|
|
|
2013-09-02 14:29:15 +00:00
|
|
|
|
/* Try evaluating the argument. Success => {success=true; value=something;},
|
2009-08-25 16:06:46 +00:00
|
|
|
|
* else => {success=false; value=false;} */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_tryEval(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2009-08-25 16:06:46 +00:00
|
|
|
|
{
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = state.buildBindings(2);
|
2009-08-25 16:06:46 +00:00
|
|
|
|
try {
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
attrs.insert(state.sValue, args[0]);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
attrs.alloc("success").mkBool(true);
|
2009-09-23 19:19:26 +00:00
|
|
|
|
} catch (AssertionError & e) {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
attrs.alloc(state.sValue).mkBool(false);
|
|
|
|
|
attrs.alloc("success").mkBool(false);
|
2009-08-25 16:06:46 +00:00
|
|
|
|
}
|
2022-01-04 16:39:16 +00:00
|
|
|
|
v.mkAttrs(attrs);
|
2009-08-25 16:06:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_tryEval({
|
|
|
|
|
.name = "__tryEval",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Try to shallowly evaluate *e*. Return a set containing the
|
|
|
|
|
attributes `success` (`true` if *e* evaluated successfully,
|
|
|
|
|
`false` if an error was thrown) and `value`, equalling *e* if
|
2021-02-02 22:04:36 +00:00
|
|
|
|
successful and `false` otherwise. `tryEval` will only prevent
|
|
|
|
|
errors created by `throw` or `assert` from being thrown.
|
|
|
|
|
Errors `tryEval` will not catch are for example those created
|
|
|
|
|
by `abort` and type errors generated by builtins. Also note that
|
|
|
|
|
this doesn't evaluate *e* deeply, so `let e = { x = throw ""; };
|
|
|
|
|
in (builtins.tryEval e).success` will be `true`. Using
|
|
|
|
|
`builtins.deepSeq` one can get the expected result:
|
|
|
|
|
`let e = { x = throw ""; }; in
|
2020-08-24 12:31:10 +00:00
|
|
|
|
(builtins.tryEval (builtins.deepSeq e e)).success` will be
|
|
|
|
|
`false`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_tryEval,
|
|
|
|
|
});
|
2009-01-27 14:36:44 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/* Return an environment variable. Use with care. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_getEnv(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 15:11:32 +00:00
|
|
|
|
{
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string name(state.forceStringNoCtx(*args[0], pos));
|
2022-01-04 16:39:16 +00:00
|
|
|
|
v.mkString(evalSettings.restrictEval || evalSettings.pureEval ? "" : getEnv(name).value_or(""));
|
2007-01-29 15:11:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_getEnv({
|
|
|
|
|
.name = "__getEnv",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
`getEnv` returns the value of the environment variable *s*, or an
|
|
|
|
|
empty string if the variable doesn’t exist. This function should be
|
|
|
|
|
used with care, as it can introduce all sorts of nasty environment
|
|
|
|
|
dependencies in your Nix expression.
|
|
|
|
|
|
|
|
|
|
`getEnv` is used in Nix Packages to locate the file
|
|
|
|
|
`~/.nixpkgs/config.nix`, which contains user-local settings for Nix
|
|
|
|
|
Packages. (That is, it does a `getEnv "HOME"` to locate the user’s
|
|
|
|
|
home directory.)
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_getEnv,
|
|
|
|
|
});
|
2007-10-26 18:25:50 +00:00
|
|
|
|
|
2014-09-22 12:53:21 +00:00
|
|
|
|
/* Evaluate the first argument, then return the second argument. */
|
2014-09-23 13:08:27 +00:00
|
|
|
|
static void prim_seq(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2014-09-22 12:53:21 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
|
|
|
|
state.forceValue(*args[1], pos);
|
2014-09-22 12:53:21 +00:00
|
|
|
|
v = *args[1];
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_seq({
|
|
|
|
|
.name = "__seq",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Evaluate *e1*, then evaluate and return *e2*. This ensures that a
|
|
|
|
|
computation is strict in the value of *e1*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_seq,
|
|
|
|
|
});
|
2014-09-22 12:53:21 +00:00
|
|
|
|
|
2014-09-22 14:03:55 +00:00
|
|
|
|
/* Evaluate the first argument deeply (i.e. recursing into lists and
|
|
|
|
|
attrsets), then return the second argument. */
|
2014-09-23 13:08:27 +00:00
|
|
|
|
static void prim_deepSeq(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2014-09-22 14:03:55 +00:00
|
|
|
|
{
|
|
|
|
|
state.forceValueDeep(*args[0]);
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[1], pos);
|
2014-09-22 14:03:55 +00:00
|
|
|
|
v = *args[1];
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_deepSeq({
|
|
|
|
|
.name = "__deepSeq",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
This is like `seq e1 e2`, except that *e1* is evaluated *deeply*:
|
|
|
|
|
if it’s a list or set, its elements or attributes are also
|
|
|
|
|
evaluated recursively.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_deepSeq,
|
|
|
|
|
});
|
2014-09-22 14:03:55 +00:00
|
|
|
|
|
2010-03-31 20:09:20 +00:00
|
|
|
|
/* Evaluate the first expression and print it on standard error. Then
|
|
|
|
|
return the second expression. Useful for debugging. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_trace(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-08-18 22:12:00 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (args[0]->type() == nString)
|
2020-04-21 23:07:07 +00:00
|
|
|
|
printError("trace: %1%", args[0]->string.s);
|
2009-10-22 08:10:12 +00:00
|
|
|
|
else
|
2020-04-21 23:07:07 +00:00
|
|
|
|
printError("trace: %1%", *args[0]);
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[1], pos);
|
2010-03-31 20:09:20 +00:00
|
|
|
|
v = *args[1];
|
2007-08-18 22:12:00 +00:00
|
|
|
|
}
|
2007-01-29 15:11:32 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_trace({
|
|
|
|
|
.name = "__trace",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Evaluate *e1* and print its abstract syntax representation on
|
|
|
|
|
standard error. Then return *e2*. This function is useful for
|
|
|
|
|
debugging.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_trace,
|
|
|
|
|
});
|
|
|
|
|
|
2007-10-26 18:25:50 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Derivations
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
|
/* 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. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2003-10-31 17:09:31 +00:00
|
|
|
|
{
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[0], pos);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
2010-03-31 15:38:03 +00:00
|
|
|
|
/* Figure out the name first (for stack backtraces). */
|
2021-04-13 21:08:59 +00:00
|
|
|
|
Bindings::iterator attr = getAttr(
|
2021-04-11 11:55:07 +00:00
|
|
|
|
state,
|
|
|
|
|
"derivationStrict",
|
|
|
|
|
state.sName,
|
|
|
|
|
args[0]->attrs,
|
|
|
|
|
pos
|
|
|
|
|
);
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string drvName;
|
2010-10-24 00:41:29 +00:00
|
|
|
|
Pos & posDrvName(*attr->pos);
|
2012-11-27 14:01:32 +00:00
|
|
|
|
try {
|
2014-04-04 19:14:11 +00:00
|
|
|
|
drvName = state.forceStringNoCtx(*attr->value, pos);
|
2006-10-23 16:45:19 +00:00
|
|
|
|
} catch (Error & e) {
|
2020-06-24 19:46:25 +00:00
|
|
|
|
e.addTrace(posDrvName, "while evaluating the derivation attribute 'name'");
|
2006-10-23 16:45:19 +00:00
|
|
|
|
throw;
|
|
|
|
|
}
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
/* Check whether attributes should be passed as a JSON file. */
|
|
|
|
|
std::ostringstream jsonBuf;
|
|
|
|
|
std::unique_ptr<JSONObject> jsonObject;
|
|
|
|
|
attr = args[0]->attrs->find(state.sStructuredAttrs);
|
|
|
|
|
if (attr != args[0]->attrs->end() && state.forceBool(*attr->value, pos))
|
|
|
|
|
jsonObject = std::make_unique<JSONObject>(jsonBuf);
|
|
|
|
|
|
2012-11-27 14:01:32 +00:00
|
|
|
|
/* Check whether null attributes should be ignored. */
|
|
|
|
|
bool ignoreNulls = false;
|
|
|
|
|
attr = args[0]->attrs->find(state.sIgnoreNulls);
|
|
|
|
|
if (attr != args[0]->attrs->end())
|
2016-08-29 15:56:35 +00:00
|
|
|
|
ignoreNulls = state.forceBool(*attr->value, pos);
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
2003-10-31 17:09:31 +00:00
|
|
|
|
/* Build the derivation expression by processing the attributes. */
|
2005-01-19 11:16:11 +00:00
|
|
|
|
Derivation drv;
|
2020-07-12 03:03:12 +00:00
|
|
|
|
drv.name = drvName;
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
|
|
|
|
|
2020-07-22 23:59:25 +00:00
|
|
|
|
bool contentAddressed = false;
|
2022-03-30 14:31:01 +00:00
|
|
|
|
bool isImpure = false;
|
2019-02-12 12:43:32 +00:00
|
|
|
|
std::optional<std::string> outputHash;
|
2017-05-15 16:44:58 +00:00
|
|
|
|
std::string outputHashAlgo;
|
2022-03-31 14:56:44 +00:00
|
|
|
|
std::optional<FileIngestionMethod> ingestionMethod;
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
* Support multiple outputs. A derivation can declare multiple outputs
by setting the ‘outputs’ attribute. For example:
stdenv.mkDerivation {
name = "aterm-2.5";
src = ...;
outputs = [ "out" "tools" "dev" ];
configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include";
}
This derivation creates three outputs, named like this:
/nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5
/nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools
/nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev
That is, the symbolic name of the output is suffixed to the store
path (except for the ‘out’ output). Each path is passed to the
builder through the corresponding environment variable, e.g.,
${tools}.
The main reason for multiple outputs is to allow parts of a package
to be distributed and garbage-collected separately. For instance,
most packages depend on Glibc for its libraries, but don't need its
header files. If these are separated into different store paths,
then a package that depends on the Glibc libraries only causes the
libraries and not the headers to be downloaded.
The main problem with multiple outputs is that if one output exists
while the others have been garbage-collected (or never downloaded in
the first place), and we want to rebuild the other outputs, then
this isn't possible because we can't clobber a valid output (it
might be in active use). This currently gives an error message
like:
error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths
There are two solutions: 1) Do the build in a chroot. Then we don't
need to overwrite the existing path. 2) Use hash rewriting (see the
ASE-2005 paper). Scary but it should work.
This is not finished yet. There is not yet an easy way to refer to
non-default outputs in Nix expressions. Also, mutually recursive
outputs aren't detected yet and cause the garbage collector to
crash.
2011-07-18 23:31:03 +00:00
|
|
|
|
StringSet outputs;
|
|
|
|
|
outputs.insert("out");
|
|
|
|
|
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
for (auto & i : args[0]->attrs->lexicographicOrder()) {
|
|
|
|
|
if (i->name == state.sIgnoreNulls) continue;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
const std::string & key = i->name;
|
2017-07-30 11:27:57 +00:00
|
|
|
|
vomit("processing attribute '%1%'", key);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto handleHashMode = [&](const std::string_view s) {
|
2020-03-30 22:36:15 +00:00
|
|
|
|
if (s == "recursive") ingestionMethod = FileIngestionMethod::Recursive;
|
|
|
|
|
else if (s == "flat") ingestionMethod = FileIngestionMethod::Flat;
|
2020-06-15 12:06:58 +00:00
|
|
|
|
else
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("invalid value '%s' for 'outputHashMode' attribute", s),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
auto handleOutputs = [&](const Strings & ss) {
|
|
|
|
|
outputs.clear();
|
|
|
|
|
for (auto & j : ss) {
|
|
|
|
|
if (outputs.find(j) != outputs.end())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("duplicate derivation output '%1%'", j),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
/* !!! 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")
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("invalid derivation output name 'drv'" ),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
outputs.insert(j);
|
|
|
|
|
}
|
|
|
|
|
if (outputs.empty())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("derivation cannot have an empty set of outputs"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
};
|
|
|
|
|
|
2004-04-02 10:49:37 +00:00
|
|
|
|
try {
|
2006-08-28 13:31:06 +00:00
|
|
|
|
|
2012-11-27 14:01:32 +00:00
|
|
|
|
if (ignoreNulls) {
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*i->value, pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (i->value->type() == nNull) continue;
|
2012-11-27 14:01:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-27 17:56:36 +00:00
|
|
|
|
if (i->name == state.sContentAddressed) {
|
2020-07-22 23:59:25 +00:00
|
|
|
|
contentAddressed = state.forceBool(*i->value, pos);
|
2021-10-26 14:55:57 +00:00
|
|
|
|
if (contentAddressed)
|
|
|
|
|
settings.requireExperimentalFeature(Xp::CaDerivations);
|
2020-07-27 17:56:36 +00:00
|
|
|
|
}
|
2020-07-22 23:59:25 +00:00
|
|
|
|
|
2022-03-30 14:31:01 +00:00
|
|
|
|
else if (i->name == state.sImpure) {
|
|
|
|
|
isImpure = state.forceBool(*i->value, pos);
|
|
|
|
|
if (isImpure)
|
|
|
|
|
settings.requireExperimentalFeature(Xp::ImpureDerivations);
|
|
|
|
|
}
|
|
|
|
|
|
2006-08-28 13:31:06 +00:00
|
|
|
|
/* The `args' attribute is special: it supplies the
|
|
|
|
|
command-line arguments to the builder. */
|
2020-08-05 15:05:46 +00:00
|
|
|
|
else if (i->name == state.sArgs) {
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
state.forceList(*i->value, pos);
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : i->value->listItems()) {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto s = state.coerceToString(posDrvName, *elem, context, true).toOwned();
|
2006-08-28 13:31:06 +00:00
|
|
|
|
drv.args.push_back(s);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* All other attributes are passed to the builder through
|
|
|
|
|
the environment. */
|
|
|
|
|
else {
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
|
|
|
|
|
if (jsonObject) {
|
|
|
|
|
|
|
|
|
|
if (i->name == state.sStructuredAttrs) continue;
|
|
|
|
|
|
|
|
|
|
auto placeholder(jsonObject->placeholder(key));
|
2021-10-25 21:13:35 +00:00
|
|
|
|
printValueAsJSON(state, true, *i->value, pos, placeholder, context);
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
|
|
|
|
|
if (i->name == state.sBuilder)
|
|
|
|
|
drv.builder = state.forceString(*i->value, context, posDrvName);
|
|
|
|
|
else if (i->name == state.sSystem)
|
|
|
|
|
drv.platform = state.forceStringNoCtx(*i->value, posDrvName);
|
2017-03-04 13:24:06 +00:00
|
|
|
|
else if (i->name == state.sOutputHash)
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
outputHash = state.forceStringNoCtx(*i->value, posDrvName);
|
2017-03-04 13:24:06 +00:00
|
|
|
|
else if (i->name == state.sOutputHashAlgo)
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
outputHashAlgo = state.forceStringNoCtx(*i->value, posDrvName);
|
2017-03-04 13:24:06 +00:00
|
|
|
|
else if (i->name == state.sOutputHashMode)
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
handleHashMode(state.forceStringNoCtx(*i->value, posDrvName));
|
2017-03-04 13:24:06 +00:00
|
|
|
|
else if (i->name == state.sOutputs) {
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
/* Require ‘outputs’ to be a list of strings. */
|
|
|
|
|
state.forceList(*i->value, posDrvName);
|
|
|
|
|
Strings ss;
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : i->value->listItems())
|
|
|
|
|
ss.emplace_back(state.forceStringNoCtx(*elem, posDrvName));
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
handleOutputs(ss);
|
* Support multiple outputs. A derivation can declare multiple outputs
by setting the ‘outputs’ attribute. For example:
stdenv.mkDerivation {
name = "aterm-2.5";
src = ...;
outputs = [ "out" "tools" "dev" ];
configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include";
}
This derivation creates three outputs, named like this:
/nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5
/nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools
/nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev
That is, the symbolic name of the output is suffixed to the store
path (except for the ‘out’ output). Each path is passed to the
builder through the corresponding environment variable, e.g.,
${tools}.
The main reason for multiple outputs is to allow parts of a package
to be distributed and garbage-collected separately. For instance,
most packages depend on Glibc for its libraries, but don't need its
header files. If these are separated into different store paths,
then a package that depends on the Glibc libraries only causes the
libraries and not the headers to be downloaded.
The main problem with multiple outputs is that if one output exists
while the others have been garbage-collected (or never downloaded in
the first place), and we want to rebuild the other outputs, then
this isn't possible because we can't clobber a valid output (it
might be in active use). This currently gives an error message
like:
error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths
There are two solutions: 1) Do the build in a chroot. Then we don't
need to overwrite the existing path. 2) Use hash rewriting (see the
ASE-2005 paper). Scary but it should work.
This is not finished yet. There is not yet an easy way to refer to
non-default outputs in Nix expressions. Also, mutually recursive
outputs aren't detected yet and cause the garbage collector to
crash.
2011-07-18 23:31:03 +00:00
|
|
|
|
}
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
|
|
|
|
|
} else {
|
2022-01-21 15:20:54 +00:00
|
|
|
|
auto s = state.coerceToString(*i->pos, *i->value, context, true).toOwned();
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
drv.env.emplace(key, s);
|
2022-01-01 23:30:57 +00:00
|
|
|
|
if (i->name == state.sBuilder) drv.builder = std::move(s);
|
|
|
|
|
else if (i->name == state.sSystem) drv.platform = std::move(s);
|
|
|
|
|
else if (i->name == state.sOutputHash) outputHash = std::move(s);
|
|
|
|
|
else if (i->name == state.sOutputHashAlgo) outputHashAlgo = std::move(s);
|
2017-03-04 13:24:06 +00:00
|
|
|
|
else if (i->name == state.sOutputHashMode) handleHashMode(s);
|
|
|
|
|
else if (i->name == state.sOutputs)
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
handleOutputs(tokenizeString<Strings>(s));
|
* Support multiple outputs. A derivation can declare multiple outputs
by setting the ‘outputs’ attribute. For example:
stdenv.mkDerivation {
name = "aterm-2.5";
src = ...;
outputs = [ "out" "tools" "dev" ];
configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include";
}
This derivation creates three outputs, named like this:
/nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5
/nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools
/nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev
That is, the symbolic name of the output is suffixed to the store
path (except for the ‘out’ output). Each path is passed to the
builder through the corresponding environment variable, e.g.,
${tools}.
The main reason for multiple outputs is to allow parts of a package
to be distributed and garbage-collected separately. For instance,
most packages depend on Glibc for its libraries, but don't need its
header files. If these are separated into different store paths,
then a package that depends on the Glibc libraries only causes the
libraries and not the headers to be downloaded.
The main problem with multiple outputs is that if one output exists
while the others have been garbage-collected (or never downloaded in
the first place), and we want to rebuild the other outputs, then
this isn't possible because we can't clobber a valid output (it
might be in active use). This currently gives an error message
like:
error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths
There are two solutions: 1) Do the build in a chroot. Then we don't
need to overwrite the existing path. 2) Use hash rewriting (see the
ASE-2005 paper). Scary but it should work.
This is not finished yet. There is not yet an easy way to refer to
non-default outputs in Nix expressions. Also, mutually recursive
outputs aren't detected yet and cause the garbage collector to
crash.
2011-07-18 23:31:03 +00:00
|
|
|
|
}
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
|
2006-08-28 13:31:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2004-04-02 10:49:37 +00:00
|
|
|
|
} catch (Error & e) {
|
2020-07-22 23:59:25 +00:00
|
|
|
|
e.addTrace(posDrvName,
|
2020-06-24 19:46:25 +00:00
|
|
|
|
"while evaluating the attribute '%1%' of the derivation '%2%'",
|
|
|
|
|
key, drvName);
|
2006-03-08 14:11:19 +00:00
|
|
|
|
throw;
|
2004-04-02 10:49:37 +00:00
|
|
|
|
}
|
2003-10-31 17:09:31 +00:00
|
|
|
|
}
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
Add support for passing structured data to builders
Previously, all derivation attributes had to be coerced into strings
so that they could be passed via the environment. This is lossy
(e.g. lists get flattened, necessitating configureFlags
vs. configureFlagsArray, of which the latter cannot be specified as an
attribute), doesn't support attribute sets at all, and has size
limitations (necessitating hacks like passAsFile).
This patch adds a new mode for passing attributes to builders, namely
encoded as a JSON file ".attrs.json" in the current directory of the
builder. This mode is activated via the special attribute
__structuredAttrs = true;
(The idea is that one day we can set this in stdenv.mkDerivation.)
For example,
stdenv.mkDerivation {
__structuredAttrs = true;
name = "foo";
buildInputs = [ pkgs.hello pkgs.cowsay ];
doCheck = true;
hardening.format = false;
}
results in a ".attrs.json" file containing (sans the indentation):
{
"buildInputs": [],
"builder": "/nix/store/ygl61ycpr2vjqrx775l1r2mw1g2rb754-bash-4.3-p48/bin/bash",
"configureFlags": [
"--with-foo",
"--with-bar=1 2"
],
"doCheck": true,
"hardening": {
"format": false
},
"name": "foo",
"nativeBuildInputs": [
"/nix/store/10h6li26i7g6z3mdpvra09yyf10mmzdr-hello-2.10",
"/nix/store/4jnvjin0r6wp6cv1hdm5jbkx3vinlcvk-cowsay-3.03"
],
"propagatedBuildInputs": [],
"propagatedNativeBuildInputs": [],
"stdenv": "/nix/store/f3hw3p8armnzy6xhd4h8s7anfjrs15n2-stdenv",
"system": "x86_64-linux"
}
"passAsFile" is ignored in this mode because it's not needed - large
strings are included directly in the JSON representation.
It is up to the builder to do something with the JSON
representation. For example, in bash-based builders, lists/attrsets of
string values could be mapped to bash (associative) arrays.
2017-01-25 15:42:07 +00:00
|
|
|
|
if (jsonObject) {
|
|
|
|
|
jsonObject.reset();
|
|
|
|
|
drv.env.emplace("__json", jsonBuf.str());
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-16 15:55:34 +00:00
|
|
|
|
/* Everything in the context of the strings in the derivation
|
|
|
|
|
attributes should be added as dependencies of the resulting
|
|
|
|
|
derivation. */
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & path : context) {
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
2009-03-18 17:36:42 +00:00
|
|
|
|
/* Paths marked with `=' denote that the path of a derivation
|
|
|
|
|
is explicitly passed to the builder. Since that allows the
|
|
|
|
|
builder to gain access to every path in the dependency
|
|
|
|
|
graph of the derivation (including all outputs), all paths
|
|
|
|
|
in the graph must be added to this derivation's list of
|
|
|
|
|
inputs to ensure that they are available when the builder
|
|
|
|
|
runs. */
|
2008-12-04 10:40:41 +00:00
|
|
|
|
if (path.at(0) == '=') {
|
2011-12-21 18:19:05 +00:00
|
|
|
|
/* !!! This doesn't work if readOnlyMode is set. */
|
2019-12-05 18:11:09 +00:00
|
|
|
|
StorePathSet refs;
|
|
|
|
|
state.store->computeFSClosure(state.store->parseStorePath(std::string_view(path).substr(1)), refs);
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & j : refs) {
|
2020-06-16 20:20:18 +00:00
|
|
|
|
drv.inputSrcs.insert(j);
|
2019-12-05 18:11:09 +00:00
|
|
|
|
if (j.isDerivation())
|
2020-06-16 20:20:18 +00:00
|
|
|
|
drv.inputDrvs[j] = state.store->readDerivation(j).outputNames();
|
2009-03-18 17:36:42 +00:00
|
|
|
|
}
|
2008-12-04 10:40:41 +00:00
|
|
|
|
}
|
2009-10-21 15:05:30 +00:00
|
|
|
|
|
2016-11-25 23:37:43 +00:00
|
|
|
|
/* Handle derivation outputs of the form ‘!<name>!<path>’. */
|
2011-12-21 15:33:30 +00:00
|
|
|
|
else if (path.at(0) == '!') {
|
2022-03-12 00:28:00 +00:00
|
|
|
|
auto ctx = decodeContext(*state.store, path);
|
|
|
|
|
drv.inputDrvs[ctx.first].insert(ctx.second);
|
2009-10-21 15:05:30 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-12-21 15:33:30 +00:00
|
|
|
|
/* Otherwise it's a source file. */
|
2006-10-16 15:55:34 +00:00
|
|
|
|
else
|
2019-12-05 18:11:09 +00:00
|
|
|
|
drv.inputSrcs.insert(state.store->parseStorePath(path));
|
2006-10-16 15:55:34 +00:00
|
|
|
|
}
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
2003-10-31 17:09:31 +00:00
|
|
|
|
/* Do we have all required attributes? */
|
2005-01-19 11:16:11 +00:00
|
|
|
|
if (drv.builder == "")
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("required attribute 'builder' missing"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-05-09 00:18:28 +00:00
|
|
|
|
|
2005-01-19 11:16:11 +00:00
|
|
|
|
if (drv.platform == "")
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("required attribute 'system' missing"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2004-08-24 11:46:05 +00:00
|
|
|
|
|
2006-09-21 18:52:05 +00:00
|
|
|
|
/* Check whether the derivation name is valid. */
|
2005-01-20 15:25:01 +00:00
|
|
|
|
if (isDerivation(drvName))
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("derivation names are not allowed to end in '%s'", drvExtension),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2005-01-20 15:25:01 +00:00
|
|
|
|
|
2017-05-15 16:44:58 +00:00
|
|
|
|
if (outputHash) {
|
2020-07-22 23:59:25 +00:00
|
|
|
|
/* Handle fixed-output derivations.
|
|
|
|
|
|
|
|
|
|
Ignore `__contentAddressed` because fixed output derivations are
|
|
|
|
|
already content addressed. */
|
2011-07-20 18:26:00 +00:00
|
|
|
|
if (outputs.size() != 1 || *(outputs.begin()) != "out")
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Error({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("multiple outputs are not supported in fixed-output derivations"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = posDrvName
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
2022-04-01 10:40:49 +00:00
|
|
|
|
auto h = newHashAllowEmpty(*outputHash, parseHashTypeOpt(outputHashAlgo));
|
2012-11-27 14:01:32 +00:00
|
|
|
|
|
2022-03-31 14:56:44 +00:00
|
|
|
|
auto method = ingestionMethod.value_or(FileIngestionMethod::Flat);
|
|
|
|
|
auto outPath = state.store->makeFixedOutputPath(method, h, drvName);
|
2020-08-11 01:13:26 +00:00
|
|
|
|
drv.env["out"] = state.store->printStorePath(outPath);
|
2022-03-17 22:29:15 +00:00
|
|
|
|
drv.outputs.insert_or_assign("out",
|
|
|
|
|
DerivationOutput::CAFixed {
|
|
|
|
|
.hash = FixedOutputHash {
|
2022-03-31 14:56:44 +00:00
|
|
|
|
.method = method,
|
2022-03-17 22:29:15 +00:00
|
|
|
|
.hash = std::move(h),
|
2020-07-08 23:11:39 +00:00
|
|
|
|
},
|
2022-03-17 22:29:15 +00:00
|
|
|
|
});
|
2011-07-20 18:26:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-03-30 14:31:01 +00:00
|
|
|
|
else if (contentAddressed || isImpure) {
|
|
|
|
|
if (contentAddressed && isImpure)
|
|
|
|
|
throw EvalError({
|
|
|
|
|
.msg = hintfmt("derivation cannot be both content-addressed and impure"),
|
|
|
|
|
.errPos = posDrvName
|
|
|
|
|
});
|
|
|
|
|
|
2022-04-01 10:40:49 +00:00
|
|
|
|
auto ht = parseHashTypeOpt(outputHashAlgo).value_or(htSHA256);
|
2022-03-31 14:56:44 +00:00
|
|
|
|
auto method = ingestionMethod.value_or(FileIngestionMethod::Recursive);
|
|
|
|
|
|
2020-07-22 23:59:25 +00:00
|
|
|
|
for (auto & i : outputs) {
|
2020-08-11 01:13:26 +00:00
|
|
|
|
drv.env[i] = hashPlaceholder(i);
|
2022-03-30 14:31:01 +00:00
|
|
|
|
if (isImpure)
|
|
|
|
|
drv.outputs.insert_or_assign(i,
|
|
|
|
|
DerivationOutput::Impure {
|
2022-03-31 14:56:44 +00:00
|
|
|
|
.method = method,
|
2022-03-30 14:31:01 +00:00
|
|
|
|
.hashType = ht,
|
|
|
|
|
});
|
|
|
|
|
else
|
|
|
|
|
drv.outputs.insert_or_assign(i,
|
|
|
|
|
DerivationOutput::CAFloating {
|
2022-03-31 14:56:44 +00:00
|
|
|
|
.method = method,
|
2022-03-30 14:31:01 +00:00
|
|
|
|
.hashType = ht,
|
|
|
|
|
});
|
2020-07-22 23:59:25 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-20 18:26:00 +00:00
|
|
|
|
else {
|
2019-12-05 18:11:09 +00:00
|
|
|
|
/* 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. */
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : outputs) {
|
2020-08-11 01:13:26 +00:00
|
|
|
|
drv.env[i] = "";
|
2020-01-21 20:14:13 +00:00
|
|
|
|
drv.outputs.insert_or_assign(i,
|
2022-03-18 02:07:31 +00:00
|
|
|
|
DerivationOutput::Deferred { });
|
* Support multiple outputs. A derivation can declare multiple outputs
by setting the ‘outputs’ attribute. For example:
stdenv.mkDerivation {
name = "aterm-2.5";
src = ...;
outputs = [ "out" "tools" "dev" ];
configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include";
}
This derivation creates three outputs, named like this:
/nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5
/nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools
/nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev
That is, the symbolic name of the output is suffixed to the store
path (except for the ‘out’ output). Each path is passed to the
builder through the corresponding environment variable, e.g.,
${tools}.
The main reason for multiple outputs is to allow parts of a package
to be distributed and garbage-collected separately. For instance,
most packages depend on Glibc for its libraries, but don't need its
header files. If these are separated into different store paths,
then a package that depends on the Glibc libraries only causes the
libraries and not the headers to be downloaded.
The main problem with multiple outputs is that if one output exists
while the others have been garbage-collected (or never downloaded in
the first place), and we want to rebuild the other outputs, then
this isn't possible because we can't clobber a valid output (it
might be in active use). This currently gives an error message
like:
error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths
There are two solutions: 1) Do the build in a chroot. Then we don't
need to overwrite the existing path. 2) Use hash rewriting (see the
ASE-2005 paper). Scary but it should work.
This is not finished yet. There is not yet an easy way to refer to
non-default outputs in Nix expressions. Also, mutually recursive
outputs aren't detected yet and cause the garbage collector to
crash.
2011-07-18 23:31:03 +00:00
|
|
|
|
}
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
2020-09-23 14:30:42 +00:00
|
|
|
|
auto hashModulo = hashDerivationModulo(*state.store, Derivation(drv), true);
|
2022-03-16 13:21:09 +00:00
|
|
|
|
switch (hashModulo.kind) {
|
|
|
|
|
case DrvHash::Kind::Regular:
|
|
|
|
|
for (auto & i : outputs) {
|
|
|
|
|
auto h = hashModulo.hashes.at(i);
|
|
|
|
|
auto outPath = state.store->makeOutputPath(i, h, drvName);
|
|
|
|
|
drv.env[i] = state.store->printStorePath(outPath);
|
|
|
|
|
drv.outputs.insert_or_assign(
|
|
|
|
|
i,
|
|
|
|
|
DerivationOutputInputAddressed {
|
|
|
|
|
.path = std::move(outPath),
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
;
|
|
|
|
|
case DrvHash::Kind::Deferred:
|
|
|
|
|
for (auto & i : outputs) {
|
|
|
|
|
drv.outputs.insert_or_assign(i, DerivationOutputDeferred {});
|
|
|
|
|
}
|
|
|
|
|
}
|
* Support multiple outputs. A derivation can declare multiple outputs
by setting the ‘outputs’ attribute. For example:
stdenv.mkDerivation {
name = "aterm-2.5";
src = ...;
outputs = [ "out" "tools" "dev" ];
configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include";
}
This derivation creates three outputs, named like this:
/nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5
/nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools
/nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev
That is, the symbolic name of the output is suffixed to the store
path (except for the ‘out’ output). Each path is passed to the
builder through the corresponding environment variable, e.g.,
${tools}.
The main reason for multiple outputs is to allow parts of a package
to be distributed and garbage-collected separately. For instance,
most packages depend on Glibc for its libraries, but don't need its
header files. If these are separated into different store paths,
then a package that depends on the Glibc libraries only causes the
libraries and not the headers to be downloaded.
The main problem with multiple outputs is that if one output exists
while the others have been garbage-collected (or never downloaded in
the first place), and we want to rebuild the other outputs, then
this isn't possible because we can't clobber a valid output (it
might be in active use). This currently gives an error message
like:
error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths
There are two solutions: 1) Do the build in a chroot. Then we don't
need to overwrite the existing path. 2) Use hash rewriting (see the
ASE-2005 paper). Scary but it should work.
This is not finished yet. There is not yet an easy way to refer to
non-default outputs in Nix expressions. Also, mutually recursive
outputs aren't detected yet and cause the garbage collector to
crash.
2011-07-18 23:31:03 +00:00
|
|
|
|
}
|
2011-07-20 18:26:00 +00:00
|
|
|
|
|
2003-10-31 17:09:31 +00:00
|
|
|
|
/* Write the resulting term into the Nix store directory. */
|
2020-08-23 15:00:25 +00:00
|
|
|
|
auto drvPath = writeDerivation(*state.store, drv, state.repair);
|
2019-12-05 18:11:09 +00:00
|
|
|
|
auto drvPathS = state.store->printStorePath(drvPath);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
printMsg(lvlChatty, "instantiated '%1%' -> '%2%'", drvName, drvPathS);
|
2003-10-31 17:09:31 +00:00
|
|
|
|
|
2005-01-18 11:15:50 +00:00
|
|
|
|
/* Optimisation, but required in read-only mode! because in that
|
* Support multiple outputs. A derivation can declare multiple outputs
by setting the ‘outputs’ attribute. For example:
stdenv.mkDerivation {
name = "aterm-2.5";
src = ...;
outputs = [ "out" "tools" "dev" ];
configureFlags = "--bindir=$(tools)/bin --includedir=$(dev)/include";
}
This derivation creates three outputs, named like this:
/nix/store/gcnqgllbh01p3d448q8q6pzn2nc2gpyl-aterm-2.5
/nix/store/gjf1sgirwfnrlr0bdxyrwzpw2r304j02-aterm-2.5-tools
/nix/store/hp6108bqfgxvza25nnxfs7kj88xi2vdx-aterm-2.5-dev
That is, the symbolic name of the output is suffixed to the store
path (except for the ‘out’ output). Each path is passed to the
builder through the corresponding environment variable, e.g.,
${tools}.
The main reason for multiple outputs is to allow parts of a package
to be distributed and garbage-collected separately. For instance,
most packages depend on Glibc for its libraries, but don't need its
header files. If these are separated into different store paths,
then a package that depends on the Glibc libraries only causes the
libraries and not the headers to be downloaded.
The main problem with multiple outputs is that if one output exists
while the others have been garbage-collected (or never downloaded in
the first place), and we want to rebuild the other outputs, then
this isn't possible because we can't clobber a valid output (it
might be in active use). This currently gives an error message
like:
error: derivation `/nix/store/1s9zw4c8qydpjyrayxamx2z7zzp5pcgh-aterm-2.5.drv' is blocked by its output paths
There are two solutions: 1) Do the build in a chroot. Then we don't
need to overwrite the existing path. 2) Use hash rewriting (see the
ASE-2005 paper). Scary but it should work.
This is not finished yet. There is not yet an easy way to refer to
non-default outputs in Nix expressions. Also, mutually recursive
outputs aren't detected yet and cause the garbage collector to
crash.
2011-07-18 23:31:03 +00:00
|
|
|
|
case we don't actually write store derivations, so we can't
|
2022-03-18 00:36:52 +00:00
|
|
|
|
read them later. */
|
|
|
|
|
{
|
2022-03-18 02:15:32 +00:00
|
|
|
|
auto h = hashDerivationModulo(*state.store, drv, false);
|
2020-11-19 16:50:06 +00:00
|
|
|
|
drvHashes.lock()->insert_or_assign(drvPath, h);
|
|
|
|
|
}
|
2005-01-18 11:15:50 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = state.buildBindings(1 + drv.outputs.size());
|
|
|
|
|
attrs.alloc(state.sDrvPath).mkString(drvPathS, {"=" + drvPathS});
|
2020-08-07 19:09:26 +00:00
|
|
|
|
for (auto & i : drv.outputs)
|
2022-01-04 16:39:16 +00:00
|
|
|
|
mkOutputString(state, attrs, drvPath, drv, i);
|
|
|
|
|
v.mkAttrs(attrs);
|
2010-03-31 15:38:03 +00:00
|
|
|
|
}
|
2003-11-02 16:31:35 +00:00
|
|
|
|
|
2020-08-25 09:25:01 +00:00
|
|
|
|
static RegisterPrimOp primop_derivationStrict(RegisterPrimOp::Info {
|
|
|
|
|
.name = "derivationStrict",
|
|
|
|
|
.arity = 1,
|
|
|
|
|
.fun = prim_derivationStrict,
|
|
|
|
|
});
|
2003-11-02 16:31:35 +00:00
|
|
|
|
|
2016-08-17 13:12:54 +00:00
|
|
|
|
/* Return a placeholder string for the specified output that will be
|
|
|
|
|
substituted by the corresponding output path at build time. For
|
2017-07-30 11:27:57 +00:00
|
|
|
|
example, 'placeholder "out"' returns the string
|
2016-08-17 13:12:54 +00:00
|
|
|
|
/1rz4g4znpzjwh1xymhjpm42vipw92pr73vdgl6xs1hycac8kf2n9. At build
|
2022-01-30 08:51:39 +00:00
|
|
|
|
time, any occurrence of this string in an derivation attribute will
|
2016-08-17 13:12:54 +00:00
|
|
|
|
be replaced with the concrete path in the Nix store of the output
|
2016-11-25 23:37:43 +00:00
|
|
|
|
‘out’. */
|
2016-08-17 13:12:54 +00:00
|
|
|
|
static void prim_placeholder(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(hashPlaceholder(state.forceStringNoCtx(*args[0], pos)));
|
2016-08-17 13:12:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_placeholder({
|
|
|
|
|
.name = "placeholder",
|
|
|
|
|
.args = {"output"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a placeholder string for the specified *output* that will be
|
|
|
|
|
substituted by the corresponding output path at build time. Typical
|
|
|
|
|
outputs would be `"out"`, `"bin"` or `"dev"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_placeholder,
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-17 13:12:54 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Paths
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Convert the argument to a path. !!! obsolete? */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_toPath(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2003-11-02 16:31:35 +00:00
|
|
|
|
{
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
2014-04-04 20:19:33 +00:00
|
|
|
|
Path path = state.coerceToPath(pos, *args[0], context);
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(canonPath(path), context);
|
2003-11-02 16:31:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_toPath({
|
|
|
|
|
.name = "__toPath",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
2020-08-25 09:16:45 +00:00
|
|
|
|
**DEPRECATED.** Use `/. + "/path"` to convert a string into an absolute
|
2020-08-24 12:31:10 +00:00
|
|
|
|
path. For relative paths, use `./. + "/path"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_toPath,
|
|
|
|
|
});
|
2003-11-02 16:31:35 +00:00
|
|
|
|
|
2008-11-19 23:26:19 +00:00
|
|
|
|
/* Allow a valid store path to be used in an expression. This is
|
|
|
|
|
useful in some generated expressions such as in nix-push, which
|
|
|
|
|
generates a call to a function with an already existing store path
|
|
|
|
|
as argument. You don't want to use `toPath' here because it copies
|
|
|
|
|
the path to the Nix store, which yields a copy like
|
|
|
|
|
/nix/store/newhash-oldhash-oldname. In the past, `toPath' had
|
|
|
|
|
special case behaviour for store paths, but that created weird
|
|
|
|
|
corner cases. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_storePath(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2008-11-19 23:26:19 +00:00
|
|
|
|
{
|
2020-08-24 12:31:10 +00:00
|
|
|
|
if (evalSettings.pureEval)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-04-27 15:24:38 +00:00
|
|
|
|
.msg = hintfmt("'%s' is not allowed in pure evaluation mode", "builtins.storePath"),
|
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-08-24 12:31:10 +00:00
|
|
|
|
|
2008-11-19 23:26:19 +00:00
|
|
|
|
PathSet context;
|
2015-02-23 13:41:53 +00:00
|
|
|
|
Path path = state.checkSourcePath(state.coerceToPath(pos, *args[0], context));
|
2016-11-25 23:37:43 +00:00
|
|
|
|
/* Resolve symlinks in ‘path’, unless ‘path’ itself is a symlink
|
2012-07-12 22:25:01 +00:00
|
|
|
|
directly in the store. The latter condition is necessary so
|
|
|
|
|
e.g. nix-push does the right thing. */
|
2016-06-01 12:49:12 +00:00
|
|
|
|
if (!state.store->isStorePath(path)) path = canonPath(path, true);
|
|
|
|
|
if (!state.store->isInStore(path))
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("path '%1%' is not in the Nix store", path),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-07-13 14:19:37 +00:00
|
|
|
|
auto path2 = state.store->toStorePath(path).first;
|
2013-12-05 16:51:54 +00:00
|
|
|
|
if (!settings.readOnlyMode)
|
2020-07-13 14:19:37 +00:00
|
|
|
|
state.store->ensurePath(path2);
|
|
|
|
|
context.insert(state.store->printStorePath(path2));
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(path, context);
|
2008-11-19 23:26:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
static RegisterPrimOp primop_storePath({
|
|
|
|
|
.name = "__storePath",
|
|
|
|
|
.args = {"path"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
This function allows you to define a dependency on an already
|
|
|
|
|
existing store path. For example, the derivation attribute `src
|
|
|
|
|
= builtins.storePath /nix/store/f1d18v1y…-source` causes the
|
|
|
|
|
derivation to depend on the specified path, which must exist or
|
|
|
|
|
be substitutable. Note that this differs from a plain path
|
|
|
|
|
(e.g. `src = /nix/store/f1d18v1y…-source`) in that the latter
|
|
|
|
|
causes the path to be *copied* again to the Nix store, resulting
|
|
|
|
|
in a new path (e.g. `/nix/store/ld01dnzc…-source-source`).
|
|
|
|
|
|
|
|
|
|
This function is not available in pure evaluation mode.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_storePath,
|
|
|
|
|
});
|
2008-11-19 23:26:19 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_pathExists(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2005-08-14 14:00:39 +00:00
|
|
|
|
{
|
2022-01-21 12:51:05 +00:00
|
|
|
|
/* 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 `*args[0]` tries to
|
|
|
|
|
access an unauthorized path). */
|
|
|
|
|
auto path = realisePath(state, pos, *args[0], { .checkForPureEval = false });
|
2019-07-30 09:22:55 +00:00
|
|
|
|
|
2015-02-23 13:41:53 +00:00
|
|
|
|
try {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(pathExists(state.checkSourcePath(path)));
|
2015-02-23 13:41:53 +00:00
|
|
|
|
} catch (SysError & e) {
|
|
|
|
|
/* Don't give away info from errors while canonicalising
|
2016-11-25 23:37:43 +00:00
|
|
|
|
‘path’ in restricted mode. */
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(false);
|
2015-02-23 13:41:53 +00:00
|
|
|
|
} catch (RestrictedPathError & e) {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(false);
|
2015-02-23 13:41:53 +00:00
|
|
|
|
}
|
2006-03-10 16:20:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_pathExists({
|
|
|
|
|
.name = "__pathExists",
|
|
|
|
|
.args = {"path"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if the path *path* exists at evaluation time, and
|
|
|
|
|
`false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_pathExists,
|
|
|
|
|
});
|
2006-03-10 16:20:42 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/* Return the base name of the given string, i.e., everything
|
|
|
|
|
following the last slash. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_baseNameOf(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2003-11-02 16:31:35 +00:00
|
|
|
|
{
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
v.mkString(baseNameOf(*state.coerceToString(pos, *args[0], context, false, false)), context);
|
2003-11-02 16:31:35 +00:00
|
|
|
|
}
|
2003-11-05 16:27:40 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_baseNameOf({
|
|
|
|
|
.name = "baseNameOf",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the *base name* of the string *s*, that is, everything
|
|
|
|
|
following the final slash in the string. This is similar to the GNU
|
|
|
|
|
`basename` command.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_baseNameOf,
|
|
|
|
|
});
|
2003-11-05 16:27:40 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/* Return the directory of the given path, i.e., everything before the
|
|
|
|
|
last slash. Return either a path or a string depending on the type
|
|
|
|
|
of the argument. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_dirOf(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-09-24 18:23:32 +00:00
|
|
|
|
{
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
auto path = state.coerceToString(pos, *args[0], context, false, false);
|
|
|
|
|
auto dir = dirOf(*path);
|
2022-01-04 17:45:16 +00:00
|
|
|
|
if (args[0]->type() == nPath) v.mkPath(dir); else v.mkString(dir, context);
|
2006-09-24 18:23:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_dirOf({
|
|
|
|
|
.name = "dirOf",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the directory part of the string *s*, that is, everything
|
|
|
|
|
before the final slash in the string. This is similar to the GNU
|
|
|
|
|
`dirname` command.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_dirOf,
|
|
|
|
|
});
|
2006-09-24 18:23:32 +00:00
|
|
|
|
|
2007-11-21 13:49:59 +00:00
|
|
|
|
/* Return the contents of a file as a string. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_readFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-11-21 13:49:59 +00:00
|
|
|
|
{
|
2022-01-21 12:51:05 +00:00
|
|
|
|
auto path = realisePath(state, pos, *args[0]);
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto s = readFile(path);
|
|
|
|
|
if (s.find((char) 0) != std::string::npos)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Error("the contents of the file '%1%' cannot be represented as a Nix string", path));
|
2022-01-24 22:02:28 +00:00
|
|
|
|
StorePathSet refs;
|
|
|
|
|
if (state.store->isInStore(path)) {
|
|
|
|
|
try {
|
|
|
|
|
refs = state.store->queryPathInfo(state.store->toStorePath(path).first)->references;
|
|
|
|
|
} catch (Error &) { // FIXME: should be InvalidPathError
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-03-04 10:47:19 +00:00
|
|
|
|
auto context = state.store->printStorePathSet(refs);
|
|
|
|
|
v.mkString(s, context);
|
2007-11-21 13:49:59 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_readFile({
|
|
|
|
|
.name = "__readFile",
|
|
|
|
|
.args = {"path"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the contents of the file *path* as a string.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_readFile,
|
|
|
|
|
});
|
2007-11-21 13:49:59 +00:00
|
|
|
|
|
2014-05-26 15:02:22 +00:00
|
|
|
|
/* Find a file in the Nix search path. Used to implement <x> paths,
|
2017-07-30 11:27:57 +00:00
|
|
|
|
which are desugared to 'findFile __nixPath "x"'. */
|
2014-05-26 15:02:22 +00:00
|
|
|
|
static void prim_findFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceList(*args[0], pos);
|
|
|
|
|
|
|
|
|
|
SearchPath searchPath;
|
|
|
|
|
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto v2 : args[0]->listItems()) {
|
|
|
|
|
state.forceAttrs(*v2, pos);
|
2014-05-26 15:02:22 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string prefix;
|
2022-01-12 17:08:48 +00:00
|
|
|
|
Bindings::iterator i = v2->attrs->find(state.sPrefix);
|
2021-11-24 19:21:34 +00:00
|
|
|
|
if (i != v2->attrs->end())
|
2014-05-26 15:02:22 +00:00
|
|
|
|
prefix = state.forceStringNoCtx(*i->value, pos);
|
|
|
|
|
|
2021-04-13 21:08:59 +00:00
|
|
|
|
i = getAttr(
|
2021-04-11 11:55:07 +00:00
|
|
|
|
state,
|
|
|
|
|
"findFile",
|
2022-01-12 17:08:48 +00:00
|
|
|
|
state.sPath,
|
2021-11-24 19:21:34 +00:00
|
|
|
|
v2->attrs,
|
2021-04-11 11:55:07 +00:00
|
|
|
|
pos
|
|
|
|
|
);
|
2014-05-26 15:02:22 +00:00
|
|
|
|
|
2022-01-27 14:32:14 +00:00
|
|
|
|
PathSet context;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto path = state.coerceToString(pos, *i->value, context, false, false).toOwned();
|
2014-05-26 15:02:22 +00:00
|
|
|
|
|
2016-04-14 13:32:24 +00:00
|
|
|
|
try {
|
2022-01-27 14:32:14 +00:00
|
|
|
|
auto rewrites = state.realiseContext(context);
|
|
|
|
|
path = rewriteStrings(path, rewrites);
|
2016-04-14 13:32:24 +00:00
|
|
|
|
} catch (InvalidPathError & e) {
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("cannot find '%1%', since path '%2%' is not valid", path, e.path),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2016-04-14 13:32:24 +00:00
|
|
|
|
}
|
2014-05-30 19:43:31 +00:00
|
|
|
|
|
|
|
|
|
|
2016-04-14 13:32:24 +00:00
|
|
|
|
searchPath.emplace_back(prefix, path);
|
2014-05-30 19:43:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto path = state.forceStringNoCtx(*args[1], pos);
|
2016-04-14 13:32:24 +00:00
|
|
|
|
|
2022-01-04 17:45:16 +00:00
|
|
|
|
v.mkPath(state.checkSourcePath(state.findFile(searchPath, path, pos)));
|
2014-05-26 15:02:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:25:01 +00:00
|
|
|
|
static RegisterPrimOp primop_findFile(RegisterPrimOp::Info {
|
|
|
|
|
.name = "__findFile",
|
|
|
|
|
.arity = 2,
|
|
|
|
|
.fun = prim_findFile,
|
|
|
|
|
});
|
|
|
|
|
|
2019-05-03 12:30:29 +00:00
|
|
|
|
/* Return the cryptographic hash of a file in base-16. */
|
|
|
|
|
static void prim_hashFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto type = state.forceStringNoCtx(*args[0], pos);
|
2020-06-02 15:52:13 +00:00
|
|
|
|
std::optional<HashType> ht = parseHashType(type);
|
|
|
|
|
if (!ht)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Error({
|
2021-09-05 14:42:06 +00:00
|
|
|
|
.msg = hintfmt("unknown hash type '%1%'", type),
|
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2019-05-03 12:30:29 +00:00
|
|
|
|
|
2022-01-21 12:51:05 +00:00
|
|
|
|
auto path = realisePath(state, pos, *args[1]);
|
2019-05-03 12:30:29 +00:00
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(hashFile(*ht, path).to_string(Base16, false));
|
2019-05-03 12:30:29 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_hashFile({
|
|
|
|
|
.name = "__hashFile",
|
|
|
|
|
.args = {"type", "p"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a base-16 representation of the cryptographic hash of the
|
|
|
|
|
file at path *p*. The hash algorithm specified by *type* must be one
|
|
|
|
|
of `"md5"`, `"sha1"`, `"sha256"` or `"sha512"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_hashFile,
|
|
|
|
|
});
|
|
|
|
|
|
2014-10-01 14:17:50 +00:00
|
|
|
|
/* Read a directory (without . or ..) */
|
|
|
|
|
static void prim_readDir(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2022-01-21 12:51:05 +00:00
|
|
|
|
auto path = realisePath(state, pos, *args[0]);
|
2014-10-01 14:17:50 +00:00
|
|
|
|
|
2021-12-21 07:42:19 +00:00
|
|
|
|
DirEntries entries = readDirectory(path);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
|
|
|
|
|
auto attrs = state.buildBindings(entries.size());
|
2014-10-01 14:17:50 +00:00
|
|
|
|
|
2014-10-03 20:37:51 +00:00
|
|
|
|
for (auto & ent : entries) {
|
|
|
|
|
if (ent.type == DT_UNKNOWN)
|
2015-01-09 13:56:25 +00:00
|
|
|
|
ent.type = getFileType(path + "/" + ent.name);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
attrs.alloc(ent.name).mkString(
|
2014-10-03 20:37:51 +00:00
|
|
|
|
ent.type == DT_REG ? "regular" :
|
|
|
|
|
ent.type == DT_DIR ? "directory" :
|
|
|
|
|
ent.type == DT_LNK ? "symlink" :
|
|
|
|
|
"unknown");
|
2014-10-01 14:17:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
v.mkAttrs(attrs);
|
2014-10-01 14:17:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_readDir({
|
|
|
|
|
.name = "__readDir",
|
|
|
|
|
.args = {"path"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the contents of the directory *path* as a set mapping
|
|
|
|
|
directory entries to the corresponding file type. For instance, if
|
|
|
|
|
directory `A` contains a regular file `B` and another directory
|
|
|
|
|
`C`, then `builtins.readDir ./A` will return the set
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
{ B = "regular"; C = "directory"; }
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
The possible values for the file type are `"regular"`,
|
|
|
|
|
`"directory"`, `"symlink"` and `"unknown"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_readDir,
|
|
|
|
|
});
|
|
|
|
|
|
2014-05-26 15:02:22 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Creating files
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
|
2006-09-01 12:07:31 +00:00
|
|
|
|
/* 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). */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_toXML(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-08-24 14:34:29 +00:00
|
|
|
|
{
|
2006-09-04 21:06:23 +00:00
|
|
|
|
std::ostringstream out;
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
2021-11-14 01:29:31 +00:00
|
|
|
|
printValueAsXML(state, true, false, *args[0], out, context, pos);
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(out.str(), context);
|
2006-08-24 14:34:29 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_toXML({
|
|
|
|
|
.name = "__toXML",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a string containing an XML representation of *e*. The main
|
|
|
|
|
application for `toXML` is to communicate information with the
|
|
|
|
|
builder in a more structured format than plain environment
|
|
|
|
|
variables.
|
|
|
|
|
|
|
|
|
|
Here is an example where this is the case:
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
{ stdenv, fetchurl, libxslt, jira, uberwiki }:
|
|
|
|
|
|
|
|
|
|
stdenv.mkDerivation (rec {
|
|
|
|
|
name = "web-server";
|
|
|
|
|
|
|
|
|
|
buildInputs = [ libxslt ];
|
|
|
|
|
|
|
|
|
|
builder = builtins.toFile "builder.sh" "
|
|
|
|
|
source $stdenv/setup
|
|
|
|
|
mkdir $out
|
|
|
|
|
echo "$servlets" | xsltproc ${stylesheet} - > $out/server-conf.xml ①
|
|
|
|
|
";
|
|
|
|
|
|
|
|
|
|
stylesheet = builtins.toFile "stylesheet.xsl" ②
|
|
|
|
|
"<?xml version='1.0' encoding='UTF-8'?>
|
|
|
|
|
<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
|
|
|
|
|
<xsl:template match='/'>
|
|
|
|
|
<Configure>
|
|
|
|
|
<xsl:for-each select='/expr/list/attrs'>
|
|
|
|
|
<Call name='addWebApplication'>
|
|
|
|
|
<Arg><xsl:value-of select=\"attr[@name = 'path']/string/@value\" /></Arg>
|
|
|
|
|
<Arg><xsl:value-of select=\"attr[@name = 'war']/path/@value\" /></Arg>
|
|
|
|
|
</Call>
|
|
|
|
|
</xsl:for-each>
|
|
|
|
|
</Configure>
|
|
|
|
|
</xsl:template>
|
|
|
|
|
</xsl:stylesheet>
|
|
|
|
|
";
|
|
|
|
|
|
|
|
|
|
servlets = builtins.toXML [ ③
|
|
|
|
|
{ path = "/bugtracker"; war = jira + "/lib/atlassian-jira.war"; }
|
|
|
|
|
{ path = "/wiki"; war = uberwiki + "/uberwiki.war"; }
|
|
|
|
|
];
|
|
|
|
|
})
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
The builder is supposed to generate the configuration file for a
|
|
|
|
|
[Jetty servlet container](http://jetty.mortbay.org/). A servlet
|
|
|
|
|
container contains a number of servlets (`*.war` files) each
|
|
|
|
|
exported under a specific URI prefix. So the servlet configuration
|
|
|
|
|
is a list of sets containing the `path` and `war` of the servlet
|
|
|
|
|
(①). This kind of information is difficult to communicate with the
|
|
|
|
|
normal method of passing information through an environment
|
|
|
|
|
variable, which just concatenates everything together into a
|
|
|
|
|
string (which might just work in this case, but wouldn’t work if
|
|
|
|
|
fields are optional or contain lists themselves). Instead the Nix
|
|
|
|
|
expression is converted to an XML representation with `toXML`,
|
|
|
|
|
which is unambiguous and can easily be processed with the
|
|
|
|
|
appropriate tools. For instance, in the example an XSLT stylesheet
|
|
|
|
|
(at point ②) is applied to it (at point ①) to generate the XML
|
|
|
|
|
configuration file for the Jetty server. The XML representation
|
|
|
|
|
produced at point ③ by `toXML` is as follows:
|
|
|
|
|
|
|
|
|
|
```xml
|
|
|
|
|
<?xml version='1.0' encoding='utf-8'?>
|
|
|
|
|
<expr>
|
|
|
|
|
<list>
|
|
|
|
|
<attrs>
|
|
|
|
|
<attr name="path">
|
|
|
|
|
<string value="/bugtracker" />
|
|
|
|
|
</attr>
|
|
|
|
|
<attr name="war">
|
|
|
|
|
<path value="/nix/store/d1jh9pasa7k2...-jira/lib/atlassian-jira.war" />
|
|
|
|
|
</attr>
|
|
|
|
|
</attrs>
|
|
|
|
|
<attrs>
|
|
|
|
|
<attr name="path">
|
|
|
|
|
<string value="/wiki" />
|
|
|
|
|
</attr>
|
|
|
|
|
<attr name="war">
|
|
|
|
|
<path value="/nix/store/y6423b1yi4sx...-uberwiki/uberwiki.war" />
|
|
|
|
|
</attr>
|
|
|
|
|
</attrs>
|
|
|
|
|
</list>
|
|
|
|
|
</expr>
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Note that we used the `toFile` built-in to write the builder and
|
|
|
|
|
the stylesheet “inline” in the Nix expression. The path of the
|
|
|
|
|
stylesheet is spliced into the builder using the syntax `xsltproc
|
|
|
|
|
${stylesheet}`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_toXML,
|
|
|
|
|
});
|
2006-08-24 14:34:29 +00:00
|
|
|
|
|
2013-11-18 23:03:11 +00:00
|
|
|
|
/* 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). */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_toJSON(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2013-11-18 23:03:11 +00:00
|
|
|
|
{
|
|
|
|
|
std::ostringstream out;
|
|
|
|
|
PathSet context;
|
2021-10-25 21:13:35 +00:00
|
|
|
|
printValueAsJSON(state, true, *args[0], pos, out, context);
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(out.str(), context);
|
2013-11-18 23:03:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_toJSON({
|
|
|
|
|
.name = "__toJSON",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a string containing a JSON representation of *e*. Strings,
|
|
|
|
|
integers, floats, booleans, nulls and lists are mapped to their JSON
|
|
|
|
|
equivalents. Sets (except derivations) are represented as objects.
|
|
|
|
|
Derivations are translated to a JSON string containing the
|
|
|
|
|
derivation’s output path. Paths are copied to the store and
|
|
|
|
|
represented as a JSON string of the resulting store path.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_toJSON,
|
|
|
|
|
});
|
2013-11-18 23:03:11 +00:00
|
|
|
|
|
2014-07-04 11:34:15 +00:00
|
|
|
|
/* Parse a JSON string to a value. */
|
|
|
|
|
static void prim_fromJSON(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto s = state.forceStringNoCtx(*args[0], pos);
|
2020-12-11 15:31:14 +00:00
|
|
|
|
try {
|
|
|
|
|
parseJSON(state, s, v);
|
|
|
|
|
} catch (JSONParseError &e) {
|
|
|
|
|
e.addTrace(pos, "while decoding a JSON string");
|
2021-09-27 12:35:55 +00:00
|
|
|
|
throw;
|
2020-12-11 15:31:14 +00:00
|
|
|
|
}
|
2014-07-04 11:34:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_fromJSON({
|
|
|
|
|
.name = "__fromJSON",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Convert a JSON string to a Nix value. For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.fromJSON ''{"x": [1, 2, 3], "y": null}''
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
returns the value `{ x = [ 1 2 3 ]; y = null; }`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_fromJSON,
|
|
|
|
|
});
|
2014-07-04 11:34:15 +00:00
|
|
|
|
|
2006-09-01 12:07:31 +00:00
|
|
|
|
/* Store a string in the Nix store as a source file that can be used
|
|
|
|
|
as an input by derivations. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_toFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-09-01 12:07:31 +00:00
|
|
|
|
{
|
2006-10-16 15:55:34 +00:00
|
|
|
|
PathSet context;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string name(state.forceStringNoCtx(*args[0], pos));
|
|
|
|
|
std::string contents(state.forceString(*args[1], context, pos));
|
2006-10-03 14:55:54 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
StorePathSet refs;
|
2006-10-03 14:55:54 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto path : context) {
|
2019-01-13 15:33:15 +00:00
|
|
|
|
if (path.at(0) != '/')
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError( {
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(
|
2020-06-15 12:06:58 +00:00
|
|
|
|
"in 'toFile': the file named '%1%' must not contain a reference "
|
|
|
|
|
"to a derivation but contains (%2%)",
|
|
|
|
|
name, path),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2019-12-05 18:11:09 +00:00
|
|
|
|
refs.insert(state.store->parseStorePath(path));
|
2006-10-03 14:55:54 +00:00
|
|
|
|
}
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2019-12-05 18:11:09 +00:00
|
|
|
|
auto storePath = state.store->printStorePath(settings.readOnlyMode
|
2016-06-01 12:49:12 +00:00
|
|
|
|
? state.store->computeStorePathForText(name, contents, refs)
|
2019-12-05 18:11:09 +00:00
|
|
|
|
: state.store->addTextToStore(name, contents, refs, state.repair));
|
2006-10-03 14:55:54 +00:00
|
|
|
|
|
2006-10-16 15:55:34 +00:00
|
|
|
|
/* Note: we don't need to add `context' to the context of the
|
|
|
|
|
result, since `storePath' itself has references to the paths
|
|
|
|
|
used in args[1]. */
|
2010-03-31 15:38:03 +00:00
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(storePath, {storePath});
|
2006-09-01 12:07:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_toFile({
|
|
|
|
|
.name = "__toFile",
|
|
|
|
|
.args = {"name", "s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Store the string *s* in a file in the Nix store and return its
|
|
|
|
|
path. The file has suffix *name*. This file can be used as an
|
|
|
|
|
input to derivations. One application is to write builders
|
|
|
|
|
“inline”. For instance, the following Nix expression combines the
|
|
|
|
|
[Nix expression for GNU Hello](expression-syntax.md) and its
|
|
|
|
|
[build script](build-script.md) into one file:
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
{ stdenv, fetchurl, perl }:
|
|
|
|
|
|
|
|
|
|
stdenv.mkDerivation {
|
|
|
|
|
name = "hello-2.1.1";
|
|
|
|
|
|
|
|
|
|
builder = builtins.toFile "builder.sh" "
|
|
|
|
|
source $stdenv/setup
|
|
|
|
|
|
|
|
|
|
PATH=$perl/bin:$PATH
|
|
|
|
|
|
|
|
|
|
tar xvfz $src
|
|
|
|
|
cd hello-*
|
|
|
|
|
./configure --prefix=$out
|
|
|
|
|
make
|
|
|
|
|
make install
|
|
|
|
|
";
|
|
|
|
|
|
|
|
|
|
src = fetchurl {
|
|
|
|
|
url = "http://ftp.nluug.nl/pub/gnu/hello/hello-2.1.1.tar.gz";
|
|
|
|
|
sha256 = "1md7jsfd8pa45z73bz1kszpp01yw6x5ljkjk2hx7wl800any6465";
|
|
|
|
|
};
|
|
|
|
|
inherit perl;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
It is even possible for one file to refer to another, e.g.,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builder = let
|
|
|
|
|
configFile = builtins.toFile "foo.conf" "
|
|
|
|
|
# This is some dummy configuration file.
|
|
|
|
|
...
|
|
|
|
|
";
|
|
|
|
|
in builtins.toFile "builder.sh" "
|
|
|
|
|
source $stdenv/setup
|
|
|
|
|
...
|
|
|
|
|
cp ${configFile} $out/etc/foo.conf
|
|
|
|
|
";
|
2020-09-16 12:18:46 +00:00
|
|
|
|
```
|
2020-08-24 12:31:10 +00:00
|
|
|
|
|
|
|
|
|
Note that `${configFile}` is an
|
|
|
|
|
[antiquotation](language-values.md), so the result of the
|
|
|
|
|
expression `configFile`
|
|
|
|
|
(i.e., a path like `/nix/store/m7p7jfny445k...-foo.conf`) will be
|
|
|
|
|
spliced into the resulting string.
|
|
|
|
|
|
|
|
|
|
It is however *not* allowed to have files mutually referring to each
|
|
|
|
|
other, like so:
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
let
|
|
|
|
|
foo = builtins.toFile "foo" "...${bar}...";
|
|
|
|
|
bar = builtins.toFile "bar" "...${foo}...";
|
|
|
|
|
in foo
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
This is not allowed because it would cause a cyclic dependency in
|
|
|
|
|
the computation of the cryptographic hashes for `foo` and `bar`.
|
|
|
|
|
|
|
|
|
|
It is also not possible to reference the result of a derivation. If
|
|
|
|
|
you are using Nixpkgs, the `writeTextFile` function is able to do
|
|
|
|
|
that.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_toFile,
|
|
|
|
|
});
|
2006-09-01 12:07:31 +00:00
|
|
|
|
|
2021-10-07 11:43:17 +00:00
|
|
|
|
static void addPath(
|
|
|
|
|
EvalState & state,
|
|
|
|
|
const Pos & pos,
|
2022-02-25 15:00:00 +00:00
|
|
|
|
const std::string & name,
|
2021-10-07 11:47:15 +00:00
|
|
|
|
Path path,
|
2021-10-07 11:43:17 +00:00
|
|
|
|
Value * filterFun,
|
|
|
|
|
FileIngestionMethod method,
|
|
|
|
|
const std::optional<Hash> expectedHash,
|
|
|
|
|
Value & v,
|
|
|
|
|
const PathSet & context)
|
2004-02-04 16:03:29 +00:00
|
|
|
|
{
|
2021-10-07 11:43:17 +00:00
|
|
|
|
try {
|
2021-10-07 11:47:15 +00:00
|
|
|
|
// FIXME: handle CA derivation outputs (where path needs to
|
2021-10-07 11:43:17 +00:00
|
|
|
|
// be rewritten to the actual output).
|
2021-12-20 18:46:55 +00:00
|
|
|
|
auto rewrites = state.realiseContext(context);
|
|
|
|
|
path = state.toRealPath(rewriteStrings(path, rewrites), context);
|
2004-02-04 16:03:29 +00:00
|
|
|
|
|
2021-11-09 09:24:49 +00:00
|
|
|
|
StorePathSet refs;
|
2010-04-07 13:55:46 +00:00
|
|
|
|
|
2021-10-07 11:47:15 +00:00
|
|
|
|
if (state.store->isInStore(path)) {
|
2022-01-24 22:02:28 +00:00
|
|
|
|
try {
|
|
|
|
|
auto [storePath, subPath] = state.store->toStorePath(path);
|
|
|
|
|
// FIXME: we should scanForReferences on the path before adding it
|
|
|
|
|
refs = state.store->queryPathInfo(storePath)->references;
|
|
|
|
|
path = state.store->toRealPath(storePath) + subPath;
|
|
|
|
|
} catch (Error &) { // FIXME: should be InvalidPathError
|
|
|
|
|
}
|
2021-10-07 11:47:15 +00:00
|
|
|
|
}
|
2010-04-07 13:55:46 +00:00
|
|
|
|
|
2021-10-07 12:07:51 +00:00
|
|
|
|
path = evalSettings.pureEval && expectedHash
|
|
|
|
|
? path
|
|
|
|
|
: state.checkSourcePath(path);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2021-10-07 11:47:15 +00:00
|
|
|
|
PathFilter filter = filterFun ? ([&](const Path & path) {
|
|
|
|
|
auto st = lstat(path);
|
2021-10-07 11:43:17 +00:00
|
|
|
|
|
2021-10-07 11:47:15 +00:00
|
|
|
|
/* Call the filter function. The first argument is the path,
|
|
|
|
|
the second is a string indicating the type of the file. */
|
|
|
|
|
Value arg1;
|
2022-01-04 17:24:42 +00:00
|
|
|
|
arg1.mkString(path);
|
2004-02-04 16:03:29 +00:00
|
|
|
|
|
2021-10-07 11:47:15 +00:00
|
|
|
|
Value arg2;
|
2022-01-04 17:24:42 +00:00
|
|
|
|
arg2.mkString(
|
2021-10-07 11:47:15 +00:00
|
|
|
|
S_ISREG(st.st_mode) ? "regular" :
|
|
|
|
|
S_ISDIR(st.st_mode) ? "directory" :
|
|
|
|
|
S_ISLNK(st.st_mode) ? "symlink" :
|
|
|
|
|
"unknown" /* not supported, will fail! */);
|
2010-04-07 13:55:46 +00:00
|
|
|
|
|
2020-03-02 16:22:31 +00:00
|
|
|
|
Value * args []{&arg1, &arg2};
|
2021-10-07 11:47:15 +00:00
|
|
|
|
Value res;
|
2020-03-02 16:22:31 +00:00
|
|
|
|
state.callFunction(*filterFun, 2, args, res, pos);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2021-10-07 11:47:15 +00:00
|
|
|
|
return state.forceBool(res, pos);
|
|
|
|
|
}) : defaultPathFilter;
|
2010-04-07 13:55:46 +00:00
|
|
|
|
|
2021-10-07 11:47:15 +00:00
|
|
|
|
std::optional<StorePath> expectedStorePath;
|
|
|
|
|
if (expectedHash)
|
|
|
|
|
expectedStorePath = state.store->makeFixedOutputPath(method, *expectedHash, name);
|
2010-04-07 13:55:46 +00:00
|
|
|
|
|
2021-10-07 11:47:15 +00:00
|
|
|
|
if (!expectedHash || !state.store->isValidPath(*expectedStorePath)) {
|
2022-02-27 14:59:34 +00:00
|
|
|
|
StorePath dstPath = settings.readOnlyMode
|
2021-10-07 11:47:15 +00:00
|
|
|
|
? state.store->computeStorePathForPath(name, path, method, htSHA256, filter).first
|
2022-02-27 14:59:34 +00:00
|
|
|
|
: state.store->addToStore(name, path, method, htSHA256, filter, state.repair, refs);
|
|
|
|
|
if (expectedHash && expectedStorePath != dstPath)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Error("store path mismatch in (possibly filtered) path added from '%s'", path));
|
2022-02-27 14:59:34 +00:00
|
|
|
|
state.allowAndSetStorePathString(dstPath, v);
|
2021-10-07 11:47:15 +00:00
|
|
|
|
} else
|
2022-02-27 14:59:34 +00:00
|
|
|
|
state.allowAndSetStorePathString(*expectedStorePath, v);
|
2021-10-07 11:47:15 +00:00
|
|
|
|
} catch (Error & e) {
|
|
|
|
|
e.addTrace(pos, "while adding path '%s'", path);
|
|
|
|
|
throw;
|
|
|
|
|
}
|
2006-09-22 14:55:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-01-25 15:05:57 +00:00
|
|
|
|
static void prim_filterSource(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
|
|
|
|
Path path = state.coerceToPath(pos, *args[1], context);
|
|
|
|
|
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (args[0]->type() != nFunction)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(TypeError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt(
|
2020-06-15 12:06:58 +00:00
|
|
|
|
"first argument in call to 'filterSource' is not a function but %1%",
|
|
|
|
|
showType(*args[0])),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2018-01-25 15:05:57 +00:00
|
|
|
|
|
2021-10-07 11:43:17 +00:00
|
|
|
|
addPath(state, pos, std::string(baseNameOf(path)), path, args[0], FileIngestionMethod::Recursive, std::nullopt, v, context);
|
2018-01-25 15:05:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_filterSource({
|
|
|
|
|
.name = "__filterSource",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
2021-09-22 18:58:21 +00:00
|
|
|
|
> **Warning**
|
|
|
|
|
>
|
|
|
|
|
> `filterSource` should not be used to filter store paths. Since
|
|
|
|
|
> `filterSource` uses the name of the input directory while naming
|
|
|
|
|
> the output directory, doing so will produce a directory name in
|
|
|
|
|
> the form of `<hash2>-<hash>-<name>`, where `<hash>-<name>` is
|
|
|
|
|
> the name of the input directory. Since `<hash>` depends on the
|
|
|
|
|
> unfiltered directory, the name of the output directory will
|
|
|
|
|
> indirectly depend on files that are filtered out by the
|
|
|
|
|
> function. This will trigger a rebuild even when a filtered out
|
|
|
|
|
> file is changed. Use `builtins.path` instead, which allows
|
|
|
|
|
> specifying the name of the output directory.
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
This function allows you to copy sources into the Nix store while
|
|
|
|
|
filtering certain files. For instance, suppose that you want to use
|
|
|
|
|
the directory `source-dir` as an input to a Nix expression, e.g.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
stdenv.mkDerivation {
|
|
|
|
|
...
|
|
|
|
|
src = ./source-dir;
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
However, if `source-dir` is a Subversion working copy, then all
|
|
|
|
|
those annoying `.svn` subdirectories will also be copied to the
|
|
|
|
|
store. Worse, the contents of those directories may change a lot,
|
|
|
|
|
causing lots of spurious rebuilds. With `filterSource` you can
|
|
|
|
|
filter out the `.svn` directories:
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
src = builtins.filterSource
|
|
|
|
|
(path: type: type != "directory" || baseNameOf path != ".svn")
|
|
|
|
|
./source-dir;
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Thus, the first argument *e1* must be a predicate function that is
|
|
|
|
|
called for each regular file, directory or symlink in the source
|
|
|
|
|
tree *e2*. If the function returns `true`, the file is copied to the
|
|
|
|
|
Nix store, otherwise it is omitted. The function is called with two
|
|
|
|
|
arguments. The first is the full path of the file. The second is a
|
|
|
|
|
string that identifies the type of the file, which is either
|
|
|
|
|
`"regular"`, `"directory"`, `"symlink"` or `"unknown"` (for other
|
|
|
|
|
kinds of files such as device nodes or fifos — but note that those
|
|
|
|
|
cannot be copied to the Nix store, so if the predicate returns
|
|
|
|
|
`true` for them, the copy will fail). If you exclude a directory,
|
|
|
|
|
the entire corresponding subtree of *e2* will be excluded.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_filterSource,
|
|
|
|
|
});
|
|
|
|
|
|
2018-01-25 15:05:57 +00:00
|
|
|
|
static void prim_path(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceAttrs(*args[0], pos);
|
|
|
|
|
Path path;
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string name;
|
2018-01-25 15:05:57 +00:00
|
|
|
|
Value * filterFun = nullptr;
|
2020-05-27 18:04:20 +00:00
|
|
|
|
auto method = FileIngestionMethod::Recursive;
|
2020-07-30 21:40:21 +00:00
|
|
|
|
std::optional<Hash> expectedHash;
|
2021-10-07 11:43:17 +00:00
|
|
|
|
PathSet context;
|
2018-01-25 15:05:57 +00:00
|
|
|
|
|
|
|
|
|
for (auto & attr : *args[0]->attrs) {
|
2022-02-25 15:00:00 +00:00
|
|
|
|
auto & n(attr.name);
|
2021-10-07 11:43:17 +00:00
|
|
|
|
if (n == "path")
|
2018-01-25 15:05:57 +00:00
|
|
|
|
path = state.coerceToPath(*attr.pos, *attr.value, context);
|
2021-10-07 11:43:17 +00:00
|
|
|
|
else if (attr.name == state.sName)
|
2018-01-25 15:05:57 +00:00
|
|
|
|
name = state.forceStringNoCtx(*attr.value, *attr.pos);
|
|
|
|
|
else if (n == "filter") {
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*attr.value, pos);
|
2018-01-25 15:05:57 +00:00
|
|
|
|
filterFun = attr.value;
|
|
|
|
|
} else if (n == "recursive")
|
2020-05-27 18:04:20 +00:00
|
|
|
|
method = FileIngestionMethod { state.forceBool(*attr.value, *attr.pos) };
|
2018-01-25 15:05:57 +00:00
|
|
|
|
else if (n == "sha256")
|
2020-06-12 15:09:42 +00:00
|
|
|
|
expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA256);
|
2018-01-25 15:05:57 +00:00
|
|
|
|
else
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("unsupported argument '%1%' to 'addPath'", attr.name),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = *attr.pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2018-01-25 15:05:57 +00:00
|
|
|
|
}
|
|
|
|
|
if (path.empty())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("'path' required"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2018-01-25 15:05:57 +00:00
|
|
|
|
if (name.empty())
|
|
|
|
|
name = baseNameOf(path);
|
|
|
|
|
|
2021-10-07 11:43:17 +00:00
|
|
|
|
addPath(state, pos, name, path, filterFun, method, expectedHash, v, context);
|
2018-01-25 15:05:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_path({
|
|
|
|
|
.name = "__path",
|
|
|
|
|
.args = {"args"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
An enrichment of the built-in path type, based on the attributes
|
|
|
|
|
present in *args*. All are optional except `path`:
|
|
|
|
|
|
2021-04-23 12:30:42 +00:00
|
|
|
|
- path\
|
2020-08-24 12:31:10 +00:00
|
|
|
|
The underlying path.
|
|
|
|
|
|
2021-04-23 12:30:42 +00:00
|
|
|
|
- name\
|
2020-08-24 12:31:10 +00:00
|
|
|
|
The name of the path when added to the store. This can used to
|
|
|
|
|
reference paths that have nix-illegal characters in their names,
|
|
|
|
|
like `@`.
|
|
|
|
|
|
2021-04-23 12:30:42 +00:00
|
|
|
|
- filter\
|
2020-08-24 12:31:10 +00:00
|
|
|
|
A function of the type expected by `builtins.filterSource`,
|
|
|
|
|
with the same semantics.
|
|
|
|
|
|
2021-04-23 12:30:42 +00:00
|
|
|
|
- recursive\
|
2020-08-24 12:31:10 +00:00
|
|
|
|
When `false`, when `path` is added to the store it is with a
|
|
|
|
|
flat hash, rather than a hash of the NAR serialization of the
|
|
|
|
|
file. Thus, `path` must refer to a regular file, not a
|
|
|
|
|
directory. This allows similar behavior to `fetchurl`. Defaults
|
|
|
|
|
to `true`.
|
|
|
|
|
|
2021-04-23 12:30:42 +00:00
|
|
|
|
- sha256\
|
2020-08-24 12:31:10 +00:00
|
|
|
|
When provided, this is the expected hash of the file at the
|
|
|
|
|
path. Evaluation will fail if the hash is incorrect, and
|
|
|
|
|
providing a hash allows `builtins.path` to be used even when the
|
|
|
|
|
`pure-eval` nix config option is on.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_path,
|
|
|
|
|
});
|
|
|
|
|
|
2018-01-25 15:05:57 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/*************************************************************
|
2013-10-24 14:41:04 +00:00
|
|
|
|
* Sets
|
2007-01-29 15:11:32 +00:00
|
|
|
|
*************************************************************/
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
|
|
|
|
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* Return the names of the attributes in a set as a sorted list of
|
|
|
|
|
strings. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_attrNames(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
{
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[0], pos);
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
2010-03-30 22:39:48 +00:00
|
|
|
|
state.mkList(v, args[0]->attrs->size());
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
2017-01-25 15:06:50 +00:00
|
|
|
|
size_t n = 0;
|
2018-02-16 03:14:35 +00:00
|
|
|
|
for (auto & i : *args[0]->attrs)
|
2022-01-04 18:09:40 +00:00
|
|
|
|
(v.listElems()[n++] = state.allocValue())->mkString(i.name);
|
2018-02-16 03:14:35 +00:00
|
|
|
|
|
|
|
|
|
std::sort(v.listElems(), v.listElems() + n,
|
|
|
|
|
[](Value * v1, Value * v2) { return strcmp(v1->string.s, v2->string.s) < 0; });
|
2014-10-04 14:41:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_attrNames({
|
|
|
|
|
.name = "__attrNames",
|
|
|
|
|
.args = {"set"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the names of the attributes in the set *set* in an
|
|
|
|
|
alphabetically sorted list. For instance, `builtins.attrNames { y
|
|
|
|
|
= 1; x = "foo"; }` evaluates to `[ "x" "y" ]`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_attrNames,
|
|
|
|
|
});
|
2014-10-04 14:41:24 +00:00
|
|
|
|
|
|
|
|
|
/* Return the values of the attributes in a set as a list, in the same
|
|
|
|
|
order as attrNames. */
|
|
|
|
|
static void prim_attrValues(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceAttrs(*args[0], pos);
|
|
|
|
|
|
|
|
|
|
state.mkList(v, args[0]->attrs->size());
|
|
|
|
|
|
|
|
|
|
unsigned int n = 0;
|
|
|
|
|
for (auto & i : *args[0]->attrs)
|
2015-07-23 20:05:09 +00:00
|
|
|
|
v.listElems()[n++] = (Value *) &i;
|
2014-10-04 14:41:24 +00:00
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
std::sort(v.listElems(), v.listElems() + n,
|
2022-01-12 17:17:59 +00:00
|
|
|
|
[](Value * v1, Value * v2) {
|
|
|
|
|
std::string_view s1 = ((Attr *) v1)->name, s2 = ((Attr *) v2)->name;
|
|
|
|
|
return s1 < s2;
|
|
|
|
|
});
|
2014-10-04 14:41:24 +00:00
|
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < n; ++i)
|
2015-07-23 20:05:09 +00:00
|
|
|
|
v.listElems()[i] = ((Attr *) v.listElems()[i])->value;
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_attrValues({
|
|
|
|
|
.name = "__attrValues",
|
|
|
|
|
.args = {"set"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the values of the attributes in the set *set* in the order
|
|
|
|
|
corresponding to the sorted attribute names.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_attrValues,
|
|
|
|
|
});
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/* Dynamic version of the `.' operator. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto attr = state.forceStringNoCtx(*args[0], pos);
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[1], pos);
|
2021-04-13 21:08:59 +00:00
|
|
|
|
Bindings::iterator i = getAttr(
|
2021-04-11 11:55:07 +00:00
|
|
|
|
state,
|
|
|
|
|
"getAttr",
|
2022-01-12 17:08:48 +00:00
|
|
|
|
state.symbols.create(attr),
|
2021-04-11 11:55:07 +00:00
|
|
|
|
args[1]->attrs,
|
|
|
|
|
pos
|
|
|
|
|
);
|
2010-05-07 12:11:05 +00:00
|
|
|
|
// !!! add to stack trace?
|
2021-08-29 16:09:13 +00:00
|
|
|
|
if (state.countCalls && *i->pos != noPos) state.attrSelects[*i->pos]++;
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*i->value, pos);
|
2010-10-24 00:41:29 +00:00
|
|
|
|
v = *i->value;
|
2007-01-29 15:11:32 +00:00
|
|
|
|
}
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_getAttr({
|
|
|
|
|
.name = "__getAttr",
|
|
|
|
|
.args = {"s", "set"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
`getAttr` returns the attribute named *s* from *set*. Evaluation
|
|
|
|
|
aborts if the attribute doesn’t exist. This is a dynamic version of
|
|
|
|
|
the `.` operator, since *s* is an expression rather than an
|
|
|
|
|
identifier.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_getAttr,
|
|
|
|
|
});
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
2013-11-18 21:22:35 +00:00
|
|
|
|
/* Return position information of the specified attribute. */
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static void prim_unsafeGetAttrPos(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2013-11-18 21:22:35 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto attr = state.forceStringNoCtx(*args[0], pos);
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[1], pos);
|
2013-11-18 21:22:35 +00:00
|
|
|
|
Bindings::iterator i = args[1]->attrs->find(state.symbols.create(attr));
|
|
|
|
|
if (i == args[1]->attrs->end())
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkNull();
|
2013-11-18 21:22:35 +00:00
|
|
|
|
else
|
|
|
|
|
state.mkPos(v, i->pos);
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:25:01 +00:00
|
|
|
|
static RegisterPrimOp primop_unsafeGetAttrPos(RegisterPrimOp::Info {
|
|
|
|
|
.name = "__unsafeGetAttrPos",
|
|
|
|
|
.arity = 2,
|
|
|
|
|
.fun = prim_unsafeGetAttrPos,
|
|
|
|
|
});
|
2013-11-18 21:22:35 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/* Dynamic version of the `?' operator. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_hasAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 15:11:32 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto attr = state.forceStringNoCtx(*args[0], pos);
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[1], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[1]->attrs->find(state.symbols.create(attr)) != args[1]->attrs->end());
|
2007-01-29 15:11:32 +00:00
|
|
|
|
}
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_hasAttr({
|
|
|
|
|
.name = "__hasAttr",
|
|
|
|
|
.args = {"s", "set"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
`hasAttr` returns `true` if *set* has an attribute named *s*, and
|
|
|
|
|
`false` otherwise. This is a dynamic version of the `?` operator,
|
|
|
|
|
since *s* is an expression rather than an identifier.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_hasAttr,
|
|
|
|
|
});
|
2005-08-14 14:00:39 +00:00
|
|
|
|
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* Determine whether the argument is a set. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_isAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2010-03-30 22:39:48 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nAttrs);
|
2010-03-30 22:39:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isAttrs({
|
|
|
|
|
.name = "__isAttrs",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to a set, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isAttrs,
|
|
|
|
|
});
|
2010-03-30 22:39:48 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_removeAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2010-03-30 22:39:48 +00:00
|
|
|
|
{
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[0], pos);
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*args[1], pos);
|
2010-03-30 22:39:48 +00:00
|
|
|
|
|
2022-01-01 23:41:21 +00:00
|
|
|
|
/* 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]. */
|
|
|
|
|
boost::container::small_vector<Attr, 64> names;
|
|
|
|
|
names.reserve(args[1]->listSize());
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : args[1]->listItems()) {
|
|
|
|
|
state.forceStringNoCtx(*elem, pos);
|
2022-01-01 23:41:21 +00:00
|
|
|
|
names.emplace_back(state.symbols.create(elem->string.s), nullptr);
|
2010-10-24 00:41:29 +00:00
|
|
|
|
}
|
2022-01-01 23:41:21 +00:00
|
|
|
|
std::sort(names.begin(), names.end());
|
2010-10-24 00:41:29 +00:00
|
|
|
|
|
2010-10-24 19:52:33 +00:00
|
|
|
|
/* 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. */
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto attrs = state.buildBindings(args[0]->attrs->size());
|
2022-01-01 23:41:21 +00:00
|
|
|
|
std::set_difference(
|
|
|
|
|
args[0]->attrs->begin(), args[0]->attrs->end(),
|
|
|
|
|
names.begin(), names.end(),
|
|
|
|
|
std::back_inserter(attrs));
|
2022-01-04 19:29:17 +00:00
|
|
|
|
v.mkAttrs(attrs.alreadySorted());
|
2010-03-30 22:39:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_removeAttrs({
|
|
|
|
|
.name = "removeAttrs",
|
|
|
|
|
.args = {"set", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Remove the attributes listed in *list* from *set*. The attributes
|
|
|
|
|
don’t have to exist in *set*. For instance,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
removeAttrs { x = 1; y = 2; z = 3; } [ "a" "x" "z" ]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to `{ y = 2; }`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_removeAttrs,
|
|
|
|
|
});
|
2010-03-30 22:39:48 +00:00
|
|
|
|
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* 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;
|
2022-01-30 08:51:39 +00:00
|
|
|
|
... nameN = valueN;}. In case of duplicate occurrences of the same
|
2013-10-28 06:34:44 +00:00
|
|
|
|
name, the first takes precedence. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_listToAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-08-18 22:12:00 +00:00
|
|
|
|
{
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*args[0], pos);
|
2010-03-31 15:38:03 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = state.buildBindings(args[0]->listSize());
|
2010-03-31 15:38:03 +00:00
|
|
|
|
|
2010-10-24 19:52:33 +00:00
|
|
|
|
std::set<Symbol> seen;
|
|
|
|
|
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto v2 : args[0]->listItems()) {
|
|
|
|
|
state.forceAttrs(*v2, pos);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2021-04-13 21:08:59 +00:00
|
|
|
|
Bindings::iterator j = getAttr(
|
2021-04-11 10:14:05 +00:00
|
|
|
|
state,
|
|
|
|
|
"listToAttrs",
|
|
|
|
|
state.sName,
|
2021-11-24 19:21:34 +00:00
|
|
|
|
v2->attrs,
|
2021-04-11 10:14:05 +00:00
|
|
|
|
pos
|
|
|
|
|
);
|
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto name = state.forceStringNoCtx(*j->value, *j->pos);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2010-10-24 19:52:33 +00:00
|
|
|
|
Symbol sym = state.symbols.create(name);
|
2019-10-09 13:51:52 +00:00
|
|
|
|
if (seen.insert(sym).second) {
|
2021-04-13 21:08:59 +00:00
|
|
|
|
Bindings::iterator j2 = getAttr(
|
2021-04-11 10:14:05 +00:00
|
|
|
|
state,
|
|
|
|
|
"listToAttrs",
|
|
|
|
|
state.sValue,
|
2021-11-24 19:21:34 +00:00
|
|
|
|
v2->attrs,
|
2021-04-11 10:14:05 +00:00
|
|
|
|
pos
|
|
|
|
|
);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
attrs.insert(sym, j2->value, j2->pos);
|
2010-10-24 19:52:33 +00:00
|
|
|
|
}
|
2007-10-09 12:51:25 +00:00
|
|
|
|
}
|
2010-10-24 19:52:33 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
v.mkAttrs(attrs);
|
2007-08-18 22:12:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_listToAttrs({
|
|
|
|
|
.name = "__listToAttrs",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Construct a set from a list specifying the names and values of each
|
|
|
|
|
attribute. Each element of the list should be a set consisting of a
|
|
|
|
|
string-valued attribute `name` specifying the name of the attribute,
|
|
|
|
|
and an attribute `value` specifying its value. Example:
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.listToAttrs
|
|
|
|
|
[ { name = "foo"; value = 123; }
|
|
|
|
|
{ name = "bar"; value = 456; }
|
|
|
|
|
]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
{ foo = 123; bar = 456; }
|
|
|
|
|
```
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_listToAttrs,
|
|
|
|
|
});
|
2007-10-31 18:01:56 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_intersectAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
{
|
2014-04-04 17:11:40 +00:00
|
|
|
|
state.forceAttrs(*args[0], pos);
|
|
|
|
|
state.forceAttrs(*args[1], pos);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto attrs = state.buildBindings(std::min(args[0]->attrs->size(), args[1]->attrs->size()));
|
2010-08-02 11:54:44 +00:00
|
|
|
|
|
2015-07-17 17:24:28 +00:00
|
|
|
|
for (auto & i : *args[0]->attrs) {
|
|
|
|
|
Bindings::iterator j = args[1]->attrs->find(i.name);
|
2010-10-22 14:47:42 +00:00
|
|
|
|
if (j != args[1]->attrs->end())
|
2022-01-04 19:29:17 +00:00
|
|
|
|
attrs.insert(*j);
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
}
|
2022-01-04 19:29:17 +00:00
|
|
|
|
|
|
|
|
|
v.mkAttrs(attrs.alreadySorted());
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_intersectAttrs({
|
|
|
|
|
.name = "__intersectAttrs",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a set consisting of the attributes in the set *e2* that also
|
|
|
|
|
exist in the set *e1*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_intersectAttrs,
|
|
|
|
|
});
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
|
2014-10-04 16:15:03 +00:00
|
|
|
|
static void prim_catAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
Symbol attrName = state.symbols.create(state.forceStringNoCtx(*args[0], pos));
|
|
|
|
|
state.forceList(*args[1], pos);
|
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
Value * res[args[1]->listSize()];
|
2014-10-04 16:15:03 +00:00
|
|
|
|
unsigned int found = 0;
|
|
|
|
|
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto v2 : args[1]->listItems()) {
|
|
|
|
|
state.forceAttrs(*v2, pos);
|
|
|
|
|
Bindings::iterator i = v2->attrs->find(attrName);
|
|
|
|
|
if (i != v2->attrs->end())
|
2014-10-04 16:15:03 +00:00
|
|
|
|
res[found++] = i->value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
state.mkList(v, found);
|
|
|
|
|
for (unsigned int n = 0; n < found; ++n)
|
2015-07-23 20:05:09 +00:00
|
|
|
|
v.listElems()[n] = res[n];
|
2014-10-04 16:15:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
static RegisterPrimOp primop_catAttrs({
|
|
|
|
|
.name = "__catAttrs",
|
|
|
|
|
.args = {"attr", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Collect each attribute named *attr* from a list of attribute
|
|
|
|
|
sets. Attrsets that don't contain the named attribute are
|
|
|
|
|
ignored. For example,
|
2014-10-04 16:15:03 +00:00
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
```nix
|
|
|
|
|
builtins.catAttrs "a" [{a = 1;} {b = 0;} {a = 2;}]
|
|
|
|
|
```
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
evaluates to `[1 2]`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_catAttrs,
|
|
|
|
|
});
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_functionArgs(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2020-12-12 01:15:11 +00:00
|
|
|
|
if (args[0]->isPrimOpApp() || args[0]->isPrimOp()) {
|
2022-01-04 19:29:17 +00:00
|
|
|
|
v.mkAttrs(&state.emptyBindings);
|
2020-05-25 17:07:38 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
2020-12-12 01:15:11 +00:00
|
|
|
|
if (!args[0]->isLambda())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(TypeError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("'functionArgs' requires a function"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
|
2021-10-06 15:08:08 +00:00
|
|
|
|
if (!args[0]->lambda.fun->hasFormals()) {
|
2022-01-04 19:29:17 +00:00
|
|
|
|
v.mkAttrs(&state.emptyBindings);
|
2010-10-24 20:09:37 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
2010-04-16 15:13:47 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = state.buildBindings(args[0]->lambda.fun->formals->formals.size());
|
|
|
|
|
for (auto & i : args[0]->lambda.fun->formals->formals)
|
2010-10-22 14:47:42 +00:00
|
|
|
|
// !!! should optimise booleans (allocate only once)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
attrs.alloc(i.name, ptr(&i.pos)).mkBool(i.def);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
v.mkAttrs(attrs);
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_functionArgs({
|
|
|
|
|
.name = "__functionArgs",
|
|
|
|
|
.args = {"f"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a set containing the names of the formal arguments expected
|
|
|
|
|
by the function *f*. The value of each attribute is a Boolean
|
|
|
|
|
denoting whether the corresponding argument has a default value. For
|
|
|
|
|
instance, `functionArgs ({ x, y ? 123}: ...) = { x = false; y =
|
|
|
|
|
true; }`.
|
|
|
|
|
|
|
|
|
|
"Formal argument" here refers to the attributes pattern-matched by
|
|
|
|
|
the function. Plain lambdas are not included, e.g. `functionArgs (x:
|
|
|
|
|
...) = { }`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_functionArgs,
|
|
|
|
|
});
|
* Two primops: builtins.intersectAttrs and builtins.functionArgs.
intersectAttrs returns the (right-biased) intersection between two
attribute sets, e.g. every attribute from the second set that also
exists in the first. functionArgs returns the set of attributes
expected by a function.
The main goal of these is to allow the elimination of most of
all-packages.nix. Most package instantiations in all-packages.nix
have this form:
foo = import ./foo.nix {
inherit a b c;
};
With intersectAttrs and functionArgs, this can be written as:
foo = callPackage (import ./foo.nix) { };
where
callPackage = f: args:
f ((builtins.intersectAttrs (builtins.functionArgs f) pkgs) // args);
I.e., foo.nix is called with all attributes from "pkgs" that it
actually needs (e.g., pkgs.a, pkgs.b and pkgs.c). (callPackage can
do any other generic package-level stuff we might want, such as
applying makeOverridable.) Of course, the automatically supplied
arguments can be overriden if needed, e.g.
foo = callPackage (import ./foo.nix) {
c = c_version_2;
};
but for the vast majority of packages, this won't be needed.
The advantages are to reduce the amount of typing needed to add a
dependency (from three sites to two), and to reduce the number of
trivial commits to all-packages.nix. For the former, there have
been two previous attempts:
- Use "args: with args;" in the package's function definition.
This however obscures the actual expected arguments of a
function, which is very bad.
- Use "{ arg1, arg2, ... }:" in the package's function definition
(i.e. use the ellipis "..." to allow arbitrary additional
arguments), and then call the function with all of "pkgs" as an
argument. But this inhibits error detection if you call it with
an misspelled (or obsolete) argument.
2009-09-15 13:01:46 +00:00
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
/* */
|
2018-07-05 02:52:02 +00:00
|
|
|
|
static void prim_mapAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceAttrs(*args[1], pos);
|
|
|
|
|
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto attrs = state.buildBindings(args[1]->attrs->size());
|
2018-07-05 02:52:02 +00:00
|
|
|
|
|
|
|
|
|
for (auto & i : *args[1]->attrs) {
|
2018-07-05 15:33:12 +00:00
|
|
|
|
Value * vName = state.allocValue();
|
|
|
|
|
Value * vFun2 = state.allocValue();
|
2022-01-04 18:09:40 +00:00
|
|
|
|
vName->mkString(i.name);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
vFun2->mkApp(args[0], vName);
|
2022-01-04 19:29:17 +00:00
|
|
|
|
attrs.alloc(i.name).mkApp(vFun2, i.value);
|
2018-07-05 02:52:02 +00:00
|
|
|
|
}
|
2022-01-04 19:29:17 +00:00
|
|
|
|
|
|
|
|
|
v.mkAttrs(attrs.alreadySorted());
|
2018-07-05 02:52:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
static RegisterPrimOp primop_mapAttrs({
|
|
|
|
|
.name = "__mapAttrs",
|
|
|
|
|
.args = {"f", "attrset"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Apply function *f* to every element of *attrset*. For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.mapAttrs (name: value: value * 10) { a = 1; b = 2; }
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to `{ a = 10; b = 20; }`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_mapAttrs,
|
|
|
|
|
});
|
2018-07-05 02:52:02 +00:00
|
|
|
|
|
2021-12-25 14:29:49 +00:00
|
|
|
|
static void prim_zipAttrsWith(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
// 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], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
|
|
|
|
const auto listSize = args[1]->listSize();
|
|
|
|
|
const auto listElems = args[1]->listElems();
|
|
|
|
|
|
|
|
|
|
for (unsigned int n = 0; n < listSize; ++n) {
|
|
|
|
|
Value * vElem = listElems[n];
|
|
|
|
|
try {
|
2022-01-21 15:43:16 +00:00
|
|
|
|
state.forceAttrs(*vElem, noPos);
|
2021-12-25 14:29:49 +00:00
|
|
|
|
for (auto & attr : *vElem->attrs)
|
|
|
|
|
attrsSeen[attr.name].first++;
|
|
|
|
|
} catch (TypeError & e) {
|
|
|
|
|
e.addTrace(pos, hintfmt("while invoking '%s'", "zipAttrsWith"));
|
2022-03-14 17:39:53 +00:00
|
|
|
|
state.debug_throw(e);
|
2021-12-25 14:29:49 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto attrs = state.buildBindings(attrsSeen.size());
|
2021-12-25 14:29:49 +00:00
|
|
|
|
for (auto & [sym, elem] : attrsSeen) {
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto & list = attrs.alloc(sym);
|
|
|
|
|
state.mkList(list, elem.first);
|
|
|
|
|
elem.second = list.listElems();
|
2021-12-25 14:29:49 +00:00
|
|
|
|
}
|
2022-01-04 19:29:17 +00:00
|
|
|
|
v.mkAttrs(attrs.alreadySorted());
|
2021-12-25 14:29:49 +00:00
|
|
|
|
|
|
|
|
|
for (unsigned int n = 0; n < listSize; ++n) {
|
|
|
|
|
Value * vElem = listElems[n];
|
|
|
|
|
for (auto & attr : *vElem->attrs)
|
|
|
|
|
*attrsSeen[attr.name].second++ = attr.value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (auto & attr : *v.attrs) {
|
2022-01-04 18:09:40 +00:00
|
|
|
|
auto name = state.allocValue();
|
|
|
|
|
name->mkString(attr.name);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
auto call1 = state.allocValue();
|
|
|
|
|
call1->mkApp(args[0], name);
|
|
|
|
|
auto call2 = state.allocValue();
|
|
|
|
|
call2->mkApp(call1, attr.value);
|
2021-12-25 14:29:49 +00:00
|
|
|
|
attr.value = call2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static RegisterPrimOp primop_zipAttrsWith({
|
|
|
|
|
.name = "__zipAttrsWith",
|
|
|
|
|
.args = {"f", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Transpose a list of attribute sets into an attribute set of lists,
|
|
|
|
|
then apply `mapAttrs`.
|
|
|
|
|
|
|
|
|
|
`f` receives two arguments: the attribute name and a non-empty
|
|
|
|
|
list of all values encountered for that attribute name.
|
|
|
|
|
|
|
|
|
|
The result is an attribute set where the attribute names are the
|
|
|
|
|
union of the attribute names in each element of `list`. The attribute
|
|
|
|
|
values are the return values of `f`.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.zipAttrsWith
|
|
|
|
|
(name: values: { inherit name values; })
|
|
|
|
|
[ { a = "x"; } { a = "y"; b = "z"; } ]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to
|
|
|
|
|
|
|
|
|
|
```
|
|
|
|
|
{
|
|
|
|
|
a = { name = "a"; values = [ "x" "y" ]; };
|
|
|
|
|
b = { name = "b"; values = [ "z" ]; };
|
|
|
|
|
}
|
|
|
|
|
```
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_zipAttrsWith,
|
|
|
|
|
});
|
|
|
|
|
|
2018-07-05 02:52:02 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Lists
|
|
|
|
|
*************************************************************/
|
* A primitive operation `dependencyClosure' to do automatic dependency
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
2005-08-14 12:38:47 +00:00
|
|
|
|
|
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/* Determine whether the argument is a list. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_isList(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-08-23 15:46:00 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(args[0]->type() == nList);
|
2006-08-23 15:46:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_isList({
|
|
|
|
|
.name = "__isList",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if *e* evaluates to a list, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_isList,
|
|
|
|
|
});
|
2006-08-23 15:46:00 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void elemAt(EvalState & state, const Pos & pos, Value & list, int n, Value & v)
|
2012-08-13 17:46:42 +00:00
|
|
|
|
{
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(list, pos);
|
2015-07-23 20:05:09 +00:00
|
|
|
|
if (n < 0 || (unsigned int) n >= list.listSize())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Error({
|
|
|
|
|
.msg = hintfmt("list index %1% is out of boundz", n),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*list.listElems()[n], pos);
|
2015-07-23 20:05:09 +00:00
|
|
|
|
v = *list.listElems()[n];
|
2012-08-13 17:46:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the n-1'th element of a list. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_elemAt(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2012-08-13 17:46:42 +00:00
|
|
|
|
{
|
2014-04-04 16:58:15 +00:00
|
|
|
|
elemAt(state, pos, *args[0], state.forceInt(*args[1], pos), v);
|
2012-08-13 17:46:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_elemAt({
|
|
|
|
|
.name = "__elemAt",
|
|
|
|
|
.args = {"xs", "n"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return element *n* from the list *xs*. Elements are counted starting
|
|
|
|
|
from 0. A fatal error occurs if the index is out of bounds.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_elemAt,
|
|
|
|
|
});
|
2012-08-13 17:46:42 +00:00
|
|
|
|
|
2006-09-22 14:46:36 +00:00
|
|
|
|
/* Return the first element of a list. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_head(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-09-22 14:46:36 +00:00
|
|
|
|
{
|
2014-04-04 16:51:01 +00:00
|
|
|
|
elemAt(state, pos, *args[0], 0, v);
|
2006-09-22 14:46:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_head({
|
|
|
|
|
.name = "__head",
|
|
|
|
|
.args = {"list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the first element of a list; abort evaluation if the argument
|
|
|
|
|
isn’t a list or is an empty list. You can test whether a list is
|
|
|
|
|
empty by comparing it with `[]`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_head,
|
|
|
|
|
});
|
2006-09-22 14:46:36 +00:00
|
|
|
|
|
2015-03-06 15:39:48 +00:00
|
|
|
|
/* Return a list consisting of everything but the first element of
|
2012-08-13 05:05:35 +00:00
|
|
|
|
a list. Warning: this function takes O(n) time, so you probably
|
|
|
|
|
don't want to use it! */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_tail(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-09-22 14:46:36 +00:00
|
|
|
|
{
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*args[0], pos);
|
2015-07-23 20:05:09 +00:00
|
|
|
|
if (args[0]->listSize() == 0)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Error({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("'tail' called on an empty list"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-05-09 00:18:28 +00:00
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
state.mkList(v, args[0]->listSize() - 1);
|
|
|
|
|
for (unsigned int n = 0; n < v.listSize(); ++n)
|
|
|
|
|
v.listElems()[n] = args[0]->listElems()[n + 1];
|
2006-09-22 14:46:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_tail({
|
|
|
|
|
.name = "__tail",
|
|
|
|
|
.args = {"list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the second to last elements of a list; abort evaluation if
|
|
|
|
|
the argument isn’t a list or is an empty list.
|
|
|
|
|
|
|
|
|
|
> **Warning**
|
2021-09-22 18:58:21 +00:00
|
|
|
|
>
|
2020-08-24 12:31:10 +00:00
|
|
|
|
> This function should generally be avoided since it's inefficient:
|
|
|
|
|
> unlike Haskell's `tail`, it takes O(n) time, so recursing over a
|
|
|
|
|
> list by repeatedly calling `tail` takes O(n^2) time.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_tail,
|
|
|
|
|
});
|
2006-09-22 14:46:36 +00:00
|
|
|
|
|
2004-08-04 10:59:20 +00:00
|
|
|
|
/* Apply a function to every element of a list. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_map(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2004-08-04 10:59:20 +00:00
|
|
|
|
{
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*args[1], pos);
|
2004-08-04 11:27:53 +00:00
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
state.mkList(v, args[1]->listSize());
|
2004-08-04 11:27:53 +00:00
|
|
|
|
|
2015-07-23 20:05:09 +00:00
|
|
|
|
for (unsigned int n = 0; n < v.listSize(); ++n)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
(v.listElems()[n] = state.allocValue())->mkApp(
|
|
|
|
|
args[0], args[1]->listElems()[n]);
|
2004-08-04 10:59:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_map({
|
|
|
|
|
.name = "map",
|
|
|
|
|
.args = {"f", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Apply the function *f* to each element in the list *list*. For
|
|
|
|
|
example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
map (x: "foo" + x) [ "bar" "bla" "abc" ]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to `[ "foobar" "foobla" "fooabc" ]`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_map,
|
|
|
|
|
});
|
2004-08-04 10:59:20 +00:00
|
|
|
|
|
2012-08-13 04:28:08 +00:00
|
|
|
|
/* Filter a list using a predicate; that is, return a list containing
|
|
|
|
|
every element from the list for which the predicate function
|
|
|
|
|
returns true. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_filter(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2012-08-13 04:28:08 +00:00
|
|
|
|
{
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceFunction(*args[0], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
2012-08-13 04:28:08 +00:00
|
|
|
|
|
|
|
|
|
// FIXME: putting this on the stack is risky.
|
2015-07-23 20:05:09 +00:00
|
|
|
|
Value * vs[args[1]->listSize()];
|
2012-08-13 04:28:08 +00:00
|
|
|
|
unsigned int k = 0;
|
|
|
|
|
|
2012-12-04 16:22:20 +00:00
|
|
|
|
bool same = true;
|
2015-07-23 20:05:09 +00:00
|
|
|
|
for (unsigned int n = 0; n < args[1]->listSize(); ++n) {
|
2012-08-13 04:28:08 +00:00
|
|
|
|
Value res;
|
2015-07-23 20:05:09 +00:00
|
|
|
|
state.callFunction(*args[0], *args[1]->listElems()[n], res, noPos);
|
2016-08-29 15:56:35 +00:00
|
|
|
|
if (state.forceBool(res, pos))
|
2015-07-23 20:05:09 +00:00
|
|
|
|
vs[k++] = args[1]->listElems()[n];
|
2012-12-04 16:22:20 +00:00
|
|
|
|
else
|
|
|
|
|
same = false;
|
2012-08-13 04:28:08 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-04 16:22:20 +00:00
|
|
|
|
if (same)
|
|
|
|
|
v = *args[1];
|
|
|
|
|
else {
|
|
|
|
|
state.mkList(v, k);
|
2015-07-23 20:05:09 +00:00
|
|
|
|
for (unsigned int n = 0; n < k; ++n) v.listElems()[n] = vs[n];
|
2012-12-04 16:22:20 +00:00
|
|
|
|
}
|
2012-08-13 04:28:08 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_filter({
|
|
|
|
|
.name = "__filter",
|
|
|
|
|
.args = {"f", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a list consisting of the elements of *list* for which the
|
|
|
|
|
function *f* returns `true`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_filter,
|
|
|
|
|
});
|
2012-08-13 04:28:08 +00:00
|
|
|
|
|
2012-08-13 05:53:10 +00:00
|
|
|
|
/* Return true if a list contains a given element. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_elem(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2012-08-13 05:05:35 +00:00
|
|
|
|
{
|
|
|
|
|
bool res = false;
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*args[1], pos);
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : args[1]->listItems())
|
|
|
|
|
if (state.eqValues(*args[0], *elem)) {
|
2012-08-13 05:05:35 +00:00
|
|
|
|
res = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(res);
|
2012-08-13 05:05:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_elem({
|
|
|
|
|
.name = "__elem",
|
|
|
|
|
.args = {"x", "xs"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if a value equal to *x* occurs in the list *xs*, and
|
|
|
|
|
`false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_elem,
|
|
|
|
|
});
|
2012-08-13 05:05:35 +00:00
|
|
|
|
|
2012-08-13 05:53:10 +00:00
|
|
|
|
/* Concatenate a list of lists. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_concatLists(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2012-08-13 05:53:10 +00:00
|
|
|
|
{
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*args[0], pos);
|
2015-07-23 20:05:09 +00:00
|
|
|
|
state.concatLists(v, args[0]->listSize(), args[0]->listElems(), pos);
|
2012-08-13 05:53:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_concatLists({
|
|
|
|
|
.name = "__concatLists",
|
|
|
|
|
.args = {"lists"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Concatenate a list of lists into a single list.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_concatLists,
|
|
|
|
|
});
|
2012-08-13 05:53:10 +00:00
|
|
|
|
|
2008-07-11 13:29:04 +00:00
|
|
|
|
/* Return the length of a list. This is an O(1) time operation. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_length(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2008-07-11 13:29:04 +00:00
|
|
|
|
{
|
2014-04-04 17:05:36 +00:00
|
|
|
|
state.forceList(*args[0], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(args[0]->listSize());
|
2008-07-11 13:29:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_length({
|
|
|
|
|
.name = "__length",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the length of the list *e*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_length,
|
|
|
|
|
});
|
2008-07-11 13:29:04 +00:00
|
|
|
|
|
2015-07-23 15:03:02 +00:00
|
|
|
|
/* Reduce a list by applying a binary operator, from left to
|
|
|
|
|
right. The operator is applied strictly. */
|
|
|
|
|
static void prim_foldlStrict(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceFunction(*args[0], pos);
|
|
|
|
|
state.forceList(*args[2], pos);
|
|
|
|
|
|
2018-07-21 06:44:42 +00:00
|
|
|
|
if (args[2]->listSize()) {
|
|
|
|
|
Value * vCur = args[1];
|
2015-07-23 15:03:02 +00:00
|
|
|
|
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto [n, elem] : enumerate(args[2]->listItems())) {
|
|
|
|
|
Value * vs []{vCur, elem};
|
2015-07-23 20:05:09 +00:00
|
|
|
|
vCur = n == args[2]->listSize() - 1 ? &v : state.allocValue();
|
2020-03-02 16:22:31 +00:00
|
|
|
|
state.callFunction(*args[0], 2, vs, *vCur, pos);
|
2015-07-23 15:03:02 +00:00
|
|
|
|
}
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(v, pos);
|
2018-07-21 06:44:42 +00:00
|
|
|
|
} else {
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[1], pos);
|
2018-07-21 06:44:42 +00:00
|
|
|
|
v = *args[1];
|
|
|
|
|
}
|
2015-07-23 15:03:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_foldlStrict({
|
|
|
|
|
.name = "__foldl'",
|
|
|
|
|
.args = {"op", "nul", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Reduce a list by applying a binary operator, from left to right,
|
2021-11-22 12:35:35 +00:00
|
|
|
|
e.g. `foldl' op nul [x0 x1 x2 ...] = op (op (op nul x0) x1) x2)
|
2020-08-24 12:31:10 +00:00
|
|
|
|
...`. The operator is applied strictly, i.e., its arguments are
|
2021-11-22 12:35:35 +00:00
|
|
|
|
evaluated first. For example, `foldl' (x: y: x + y) 0 [1 2 3]`
|
2020-08-24 12:31:10 +00:00
|
|
|
|
evaluates to 6.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_foldlStrict,
|
|
|
|
|
});
|
2015-07-23 15:03:02 +00:00
|
|
|
|
|
2015-07-23 17:23:11 +00:00
|
|
|
|
static void anyOrAll(bool any, EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceFunction(*args[0], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
|
|
|
|
|
|
|
|
|
Value vTmp;
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : args[1]->listItems()) {
|
|
|
|
|
state.callFunction(*args[0], *elem, vTmp, pos);
|
2016-08-29 15:56:35 +00:00
|
|
|
|
bool res = state.forceBool(vTmp, pos);
|
2015-07-23 17:23:11 +00:00
|
|
|
|
if (res == any) {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(any);
|
2015-07-23 17:23:11 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(!any);
|
2015-07-23 17:23:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void prim_any(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
anyOrAll(true, state, pos, args, v);
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_any({
|
|
|
|
|
.name = "__any",
|
|
|
|
|
.args = {"pred", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if the function *pred* returns `true` for at least one
|
|
|
|
|
element of *list*, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_any,
|
|
|
|
|
});
|
2015-07-23 17:23:11 +00:00
|
|
|
|
|
|
|
|
|
static void prim_all(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
anyOrAll(false, state, pos, args, v);
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_all({
|
|
|
|
|
.name = "__all",
|
|
|
|
|
.args = {"pred", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if the function *pred* returns `true` for all elements
|
|
|
|
|
of *list*, and `false` otherwise.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_all,
|
|
|
|
|
});
|
2015-07-23 17:23:11 +00:00
|
|
|
|
|
2015-07-28 15:27:32 +00:00
|
|
|
|
static void prim_genList(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
auto len = state.forceInt(*args[1], pos);
|
|
|
|
|
|
|
|
|
|
if (len < 0)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("cannot create list of size %1%", len),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2015-07-28 15:27:32 +00:00
|
|
|
|
|
|
|
|
|
state.mkList(v, len);
|
|
|
|
|
|
2016-01-07 13:37:39 +00:00
|
|
|
|
for (unsigned int n = 0; n < (unsigned int) len; ++n) {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
auto arg = state.allocValue();
|
|
|
|
|
arg->mkInt(n);
|
|
|
|
|
(v.listElems()[n] = state.allocValue())->mkApp(args[0], arg);
|
2015-07-28 15:27:32 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_genList({
|
|
|
|
|
.name = "__genList",
|
|
|
|
|
.args = {"generator", "length"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Generate list of size *length*, with each element *i* equal to the
|
|
|
|
|
value returned by *generator* `i`. For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.genList (x: x * x) 5
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
returns the list `[ 0 1 4 9 16 ]`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_genList,
|
|
|
|
|
});
|
2015-07-28 15:27:32 +00:00
|
|
|
|
|
2015-07-28 16:39:00 +00:00
|
|
|
|
static void prim_lessThan(EvalState & state, const Pos & pos, Value * * args, Value & v);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void prim_sort(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceFunction(*args[0], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
|
|
|
|
|
|
|
|
|
auto len = args[1]->listSize();
|
|
|
|
|
state.mkList(v, len);
|
|
|
|
|
for (unsigned int n = 0; n < len; ++n) {
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[1]->listElems()[n], pos);
|
2015-07-28 16:39:00 +00:00
|
|
|
|
v.listElems()[n] = args[1]->listElems()[n];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
auto comparator = [&](Value * a, Value * b) {
|
|
|
|
|
/* Optimization: if the comparator is lessThan, bypass
|
|
|
|
|
callFunction. */
|
2020-12-12 01:15:11 +00:00
|
|
|
|
if (args[0]->isPrimOp() && args[0]->primOp->fun == prim_lessThan)
|
2021-11-22 22:56:40 +00:00
|
|
|
|
return CompareValues(state)(a, b);
|
2015-07-28 16:39:00 +00:00
|
|
|
|
|
2020-03-02 16:22:31 +00:00
|
|
|
|
Value * vs[] = {a, b};
|
|
|
|
|
Value vBool;
|
|
|
|
|
state.callFunction(*args[0], 2, vs, vBool, pos);
|
|
|
|
|
return state.forceBool(vBool, pos);
|
2015-07-28 16:39:00 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* 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(v.listElems(), v.listElems() + len, comparator);
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_sort({
|
|
|
|
|
.name = "__sort",
|
|
|
|
|
.args = {"comparator", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return *list* in sorted order. It repeatedly calls the function
|
|
|
|
|
*comparator* with two elements. The comparator should return `true`
|
|
|
|
|
if the first element is less than the second, and `false` otherwise.
|
|
|
|
|
For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.sort builtins.lessThan [ 483 249 526 147 42 77 ]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
produces the list `[ 42 77 147 249 483 526 ]`.
|
|
|
|
|
|
|
|
|
|
This is a stable sort: it preserves the relative order of elements
|
|
|
|
|
deemed equal by the comparator.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_sort,
|
|
|
|
|
});
|
2015-07-28 16:39:00 +00:00
|
|
|
|
|
2016-08-29 15:28:20 +00:00
|
|
|
|
static void prim_partition(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceFunction(*args[0], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
|
|
|
|
|
|
|
|
|
auto len = args[1]->listSize();
|
|
|
|
|
|
|
|
|
|
ValueVector right, wrong;
|
|
|
|
|
|
|
|
|
|
for (unsigned int n = 0; n < len; ++n) {
|
|
|
|
|
auto vElem = args[1]->listElems()[n];
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*vElem, pos);
|
2016-08-29 15:28:20 +00:00
|
|
|
|
Value res;
|
|
|
|
|
state.callFunction(*args[0], *vElem, res, pos);
|
2016-08-29 15:56:35 +00:00
|
|
|
|
if (state.forceBool(res, pos))
|
2016-08-29 15:28:20 +00:00
|
|
|
|
right.push_back(vElem);
|
|
|
|
|
else
|
|
|
|
|
wrong.push_back(vElem);
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = state.buildBindings(2);
|
2016-08-29 15:28:20 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto & vRight = attrs.alloc(state.sRight);
|
2018-03-15 03:53:43 +00:00
|
|
|
|
auto rsize = right.size();
|
2022-01-04 16:39:16 +00:00
|
|
|
|
state.mkList(vRight, rsize);
|
2018-03-15 03:53:43 +00:00
|
|
|
|
if (rsize)
|
2022-01-04 16:39:16 +00:00
|
|
|
|
memcpy(vRight.listElems(), right.data(), sizeof(Value *) * rsize);
|
2016-08-29 15:28:20 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto & vWrong = attrs.alloc(state.sWrong);
|
2018-03-15 03:53:43 +00:00
|
|
|
|
auto wsize = wrong.size();
|
2022-01-04 16:39:16 +00:00
|
|
|
|
state.mkList(vWrong, wsize);
|
2018-03-15 03:53:43 +00:00
|
|
|
|
if (wsize)
|
2022-01-04 16:39:16 +00:00
|
|
|
|
memcpy(vWrong.listElems(), wrong.data(), sizeof(Value *) * wsize);
|
2016-08-29 15:28:20 +00:00
|
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
|
v.mkAttrs(attrs);
|
2016-08-29 15:28:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
static RegisterPrimOp primop_partition({
|
|
|
|
|
.name = "__partition",
|
|
|
|
|
.args = {"pred", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Given a predicate function *pred*, this function returns an
|
|
|
|
|
attrset containing a list named `right`, containing the elements
|
|
|
|
|
in *list* for which *pred* returned `true`, and a list named
|
|
|
|
|
`wrong`, containing the elements for which it returned
|
|
|
|
|
`false`. For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.partition (x: x > 10) [1 23 9 3 42]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
{ right = [ 23 42 ]; wrong = [ 1 9 3 ]; }
|
|
|
|
|
```
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_partition,
|
|
|
|
|
});
|
2016-08-29 15:28:20 +00:00
|
|
|
|
|
2021-12-02 16:46:44 +00:00
|
|
|
|
static void prim_groupBy(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceFunction(*args[0], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
|
|
|
|
|
|
|
|
|
ValueVectorMap attrs;
|
|
|
|
|
|
|
|
|
|
for (auto vElem : args[1]->listItems()) {
|
|
|
|
|
Value res;
|
|
|
|
|
state.callFunction(*args[0], *vElem, res, pos);
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto name = state.forceStringNoCtx(res, pos);
|
2021-12-02 16:46:44 +00:00
|
|
|
|
Symbol sym = state.symbols.create(name);
|
|
|
|
|
auto vector = attrs.try_emplace(sym, ValueVector()).first;
|
|
|
|
|
vector->second.push_back(vElem);
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto attrs2 = state.buildBindings(attrs.size());
|
2021-12-02 16:46:44 +00:00
|
|
|
|
|
|
|
|
|
for (auto & i : attrs) {
|
2022-01-04 19:29:17 +00:00
|
|
|
|
auto & list = attrs2.alloc(i.first);
|
2021-12-02 16:46:44 +00:00
|
|
|
|
auto size = i.second.size();
|
2022-01-04 19:29:17 +00:00
|
|
|
|
state.mkList(list, size);
|
|
|
|
|
memcpy(list.listElems(), i.second.data(), sizeof(Value *) * size);
|
2021-12-02 16:46:44 +00:00
|
|
|
|
}
|
2022-01-04 19:29:17 +00:00
|
|
|
|
|
|
|
|
|
v.mkAttrs(attrs2.alreadySorted());
|
2021-12-02 16:46:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static RegisterPrimOp primop_groupBy({
|
|
|
|
|
.name = "__groupBy",
|
|
|
|
|
.args = {"f", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Groups elements of *list* together by the string returned from the
|
|
|
|
|
function *f* called on each element. It returns an attribute set
|
|
|
|
|
where each attribute value contains the elements of *list* that are
|
|
|
|
|
mapped to the same corresponding attribute name returned by *f*.
|
|
|
|
|
|
|
|
|
|
For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.groupBy (builtins.substring 0 1) ["foo" "bar" "baz"]
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
{ b = [ "bar" "baz" ]; f = [ "foo" ]; }
|
|
|
|
|
```
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_groupBy,
|
|
|
|
|
});
|
|
|
|
|
|
2018-07-05 02:52:02 +00:00
|
|
|
|
static void prim_concatMap(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceFunction(*args[0], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
2018-07-05 12:37:37 +00:00
|
|
|
|
auto nrLists = args[1]->listSize();
|
2018-07-05 02:52:02 +00:00
|
|
|
|
|
2018-07-05 12:37:37 +00:00
|
|
|
|
Value lists[nrLists];
|
|
|
|
|
size_t len = 0;
|
2018-07-05 02:52:02 +00:00
|
|
|
|
|
2018-07-05 12:37:37 +00:00
|
|
|
|
for (unsigned int n = 0; n < nrLists; ++n) {
|
2018-07-05 02:52:02 +00:00
|
|
|
|
Value * vElem = args[1]->listElems()[n];
|
2018-07-05 12:37:37 +00:00
|
|
|
|
state.callFunction(*args[0], *vElem, lists[n], pos);
|
2021-01-08 21:27:00 +00:00
|
|
|
|
try {
|
|
|
|
|
state.forceList(lists[n], lists[n].determinePos(args[0]->determinePos(pos)));
|
|
|
|
|
} catch (TypeError &e) {
|
|
|
|
|
e.addTrace(pos, hintfmt("while invoking '%s'", "concatMap"));
|
2022-03-14 17:39:53 +00:00
|
|
|
|
state.debug_throw(e);
|
2021-01-08 21:27:00 +00:00
|
|
|
|
}
|
2018-07-05 12:37:37 +00:00
|
|
|
|
len += lists[n].listSize();
|
2018-07-05 02:52:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-07-05 12:37:37 +00:00
|
|
|
|
state.mkList(v, len);
|
|
|
|
|
auto out = v.listElems();
|
|
|
|
|
for (unsigned int n = 0, pos = 0; n < nrLists; ++n) {
|
|
|
|
|
auto l = lists[n].listSize();
|
|
|
|
|
if (l)
|
|
|
|
|
memcpy(out + pos, lists[n].listElems(), l * sizeof(Value *));
|
|
|
|
|
pos += l;
|
|
|
|
|
}
|
2018-07-05 02:52:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-25 09:16:45 +00:00
|
|
|
|
static RegisterPrimOp primop_concatMap({
|
|
|
|
|
.name = "__concatMap",
|
|
|
|
|
.args = {"f", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
This function is equivalent to `builtins.concatLists (map f list)`
|
|
|
|
|
but is more efficient.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_concatMap,
|
|
|
|
|
});
|
|
|
|
|
|
2018-07-05 02:52:02 +00:00
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Integer arithmetic
|
|
|
|
|
*************************************************************/
|
2005-08-14 14:00:39 +00:00
|
|
|
|
|
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_add(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-09-22 15:29:21 +00:00
|
|
|
|
{
|
2018-08-19 09:59:49 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
|
|
|
|
state.forceValue(*args[1], pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (args[0]->type() == nFloat || args[1]->type() == nFloat)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkFloat(state.forceFloat(*args[0], pos) + state.forceFloat(*args[1], pos));
|
2016-01-04 23:40:40 +00:00
|
|
|
|
else
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(state.forceInt(*args[0], pos) + state.forceInt(*args[1], pos));
|
2006-09-22 15:29:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_add({
|
|
|
|
|
.name = "__add",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the sum of the numbers *e1* and *e2*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_add,
|
|
|
|
|
});
|
2006-09-22 15:29:21 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_sub(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 14:23:09 +00:00
|
|
|
|
{
|
2018-08-19 09:59:49 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
|
|
|
|
state.forceValue(*args[1], pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (args[0]->type() == nFloat || args[1]->type() == nFloat)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkFloat(state.forceFloat(*args[0], pos) - state.forceFloat(*args[1], pos));
|
2016-01-04 23:40:40 +00:00
|
|
|
|
else
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(state.forceInt(*args[0], pos) - state.forceInt(*args[1], pos));
|
2007-01-29 14:23:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_sub({
|
|
|
|
|
.name = "__sub",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the difference between the numbers *e1* and *e2*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_sub,
|
|
|
|
|
});
|
2007-01-29 14:23:09 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_mul(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2008-07-11 13:29:04 +00:00
|
|
|
|
{
|
2018-08-19 09:59:49 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
|
|
|
|
state.forceValue(*args[1], pos);
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (args[0]->type() == nFloat || args[1]->type() == nFloat)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkFloat(state.forceFloat(*args[0], pos) * state.forceFloat(*args[1], pos));
|
2016-01-04 23:40:40 +00:00
|
|
|
|
else
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(state.forceInt(*args[0], pos) * state.forceInt(*args[1], pos));
|
2008-07-11 13:29:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_mul({
|
|
|
|
|
.name = "__mul",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the product of the numbers *e1* and *e2*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_mul,
|
|
|
|
|
});
|
2008-07-11 13:29:04 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_div(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2008-07-11 13:29:04 +00:00
|
|
|
|
{
|
2018-08-19 09:59:49 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
|
|
|
|
state.forceValue(*args[1], pos);
|
|
|
|
|
|
2016-01-04 23:40:40 +00:00
|
|
|
|
NixFloat f2 = state.forceFloat(*args[1], pos);
|
2020-06-15 12:06:58 +00:00
|
|
|
|
if (f2 == 0)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("division by zero"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2016-01-04 23:40:40 +00:00
|
|
|
|
|
2020-12-17 13:45:45 +00:00
|
|
|
|
if (args[0]->type() == nFloat || args[1]->type() == nFloat) {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkFloat(state.forceFloat(*args[0], pos) / state.forceFloat(*args[1], pos));
|
2016-10-26 15:09:01 +00:00
|
|
|
|
} else {
|
|
|
|
|
NixInt i1 = state.forceInt(*args[0], pos);
|
|
|
|
|
NixInt i2 = state.forceInt(*args[1], pos);
|
|
|
|
|
/* Avoid division overflow as it might raise SIGFPE. */
|
|
|
|
|
if (i1 == std::numeric_limits<NixInt>::min() && i2 == -1)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("overflow in integer division"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2020-05-09 00:18:28 +00:00
|
|
|
|
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(i1 / i2);
|
2016-10-26 15:09:01 +00:00
|
|
|
|
}
|
2008-07-11 13:29:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_div({
|
|
|
|
|
.name = "__div",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the quotient of the numbers *e1* and *e2*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_div,
|
|
|
|
|
});
|
|
|
|
|
|
2018-05-16 10:52:19 +00:00
|
|
|
|
static void prim_bitAnd(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2018-05-12 16:50:39 +00:00
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(state.forceInt(*args[0], pos) & state.forceInt(*args[1], pos));
|
2018-05-12 16:50:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_bitAnd({
|
|
|
|
|
.name = "__bitAnd",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the bitwise AND of the integers *e1* and *e2*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_bitAnd,
|
|
|
|
|
});
|
|
|
|
|
|
2018-05-16 10:52:19 +00:00
|
|
|
|
static void prim_bitOr(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2018-05-12 16:50:39 +00:00
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(state.forceInt(*args[0], pos) | state.forceInt(*args[1], pos));
|
2018-05-12 16:50:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_bitOr({
|
|
|
|
|
.name = "__bitOr",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the bitwise OR of the integers *e1* and *e2*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_bitOr,
|
|
|
|
|
});
|
|
|
|
|
|
2018-05-16 10:52:19 +00:00
|
|
|
|
static void prim_bitXor(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2018-05-12 16:50:39 +00:00
|
|
|
|
{
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(state.forceInt(*args[0], pos) ^ state.forceInt(*args[1], pos));
|
2018-05-12 16:50:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_bitXor({
|
|
|
|
|
.name = "__bitXor",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the bitwise XOR of the integers *e1* and *e2*.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_bitXor,
|
|
|
|
|
});
|
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_lessThan(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2006-09-24 15:21:48 +00:00
|
|
|
|
{
|
2020-04-16 10:32:07 +00:00
|
|
|
|
state.forceValue(*args[0], pos);
|
|
|
|
|
state.forceValue(*args[1], pos);
|
2021-11-22 22:56:40 +00:00
|
|
|
|
CompareValues comp{state};
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(comp(args[0], args[1]));
|
2006-09-24 15:21:48 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_lessThan({
|
|
|
|
|
.name = "__lessThan",
|
|
|
|
|
.args = {"e1", "e2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return `true` if the number *e1* is less than the number *e2*, and
|
|
|
|
|
`false` otherwise. Evaluation aborts if either *e1* or *e2* does not
|
|
|
|
|
evaluate to a number.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_lessThan,
|
|
|
|
|
});
|
|
|
|
|
|
2006-09-24 15:21:48 +00:00
|
|
|
|
|
2007-01-29 14:23:09 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* String manipulation
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
|
2007-01-29 15:15:37 +00:00
|
|
|
|
/* Convert the argument to a string. Paths are *not* copied to the
|
|
|
|
|
store, so `toString /foo/bar' yields `"/foo/bar"', not
|
|
|
|
|
`"/nix/store/whatever..."'. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_toString(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 15:15:37 +00:00
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
auto s = state.coerceToString(pos, *args[0], context, true, false);
|
|
|
|
|
v.mkString(*s, context);
|
2007-01-29 15:15:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_toString({
|
|
|
|
|
.name = "toString",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Convert the expression *e* to a string. *e* can be:
|
|
|
|
|
|
|
|
|
|
- A string (in which case the string is returned unmodified).
|
|
|
|
|
|
|
|
|
|
- A path (e.g., `toString /foo/bar` yields `"/foo/bar"`.
|
|
|
|
|
|
2021-07-09 20:50:10 +00:00
|
|
|
|
- A set containing `{ __toString = self: ...; }` or `{ outPath = ...; }`.
|
2020-08-24 12:31:10 +00:00
|
|
|
|
|
|
|
|
|
- An integer.
|
|
|
|
|
|
|
|
|
|
- A list, in which case the string representations of its elements
|
|
|
|
|
are joined with spaces.
|
|
|
|
|
|
|
|
|
|
- A Boolean (`false` yields `""`, `true` yields `"1"`).
|
|
|
|
|
|
|
|
|
|
- `null`, which yields the empty string.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_toString,
|
|
|
|
|
});
|
2007-01-29 15:15:37 +00:00
|
|
|
|
|
2007-12-31 00:08:09 +00:00
|
|
|
|
/* `substring start len str' returns the substring of `str' starting
|
|
|
|
|
at character position `min(start, stringLength str)' inclusive and
|
2007-01-29 14:23:09 +00:00
|
|
|
|
ending at `min(start + len, stringLength str)'. `start' must be
|
|
|
|
|
non-negative. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_substring(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 14:23:09 +00:00
|
|
|
|
{
|
2014-04-04 16:58:15 +00:00
|
|
|
|
int start = state.forceInt(*args[0], pos);
|
|
|
|
|
int len = state.forceInt(*args[1], pos);
|
2007-01-29 14:23:09 +00:00
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
auto s = state.coerceToString(pos, *args[2], context);
|
2007-01-29 14:23:09 +00:00
|
|
|
|
|
2020-06-15 12:06:58 +00:00
|
|
|
|
if (start < 0)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("negative start position in 'substring'"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2007-01-29 14:23:09 +00:00
|
|
|
|
|
2022-01-21 15:20:54 +00:00
|
|
|
|
v.mkString((unsigned int) start >= s->size() ? "" : s->substr(start, len), context);
|
2007-01-29 14:23:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_substring({
|
|
|
|
|
.name = "__substring",
|
|
|
|
|
.args = {"start", "len", "s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the substring of *s* from character position *start*
|
|
|
|
|
(zero-based) up to but not including *start + len*. If *start* is
|
|
|
|
|
greater than the length of the string, an empty string is returned,
|
|
|
|
|
and if *start + len* lies beyond the end of the string, only the
|
|
|
|
|
substring up to the end of the string is returned. *start* must be
|
|
|
|
|
non-negative. For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.substring 0 3 "nixos"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to `"nix"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_substring,
|
|
|
|
|
});
|
2007-01-29 14:23:09 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_stringLength(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2007-01-29 14:23:09 +00:00
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
auto s = state.coerceToString(pos, *args[0], context);
|
|
|
|
|
v.mkInt(s->size());
|
2007-01-29 14:23:09 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_stringLength({
|
|
|
|
|
.name = "__stringLength",
|
|
|
|
|
.args = {"e"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return the length of the string *e*. If *e* is not a string,
|
|
|
|
|
evaluation is aborted.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_stringLength,
|
|
|
|
|
});
|
2007-01-29 14:23:09 +00:00
|
|
|
|
|
2013-03-08 00:24:59 +00:00
|
|
|
|
/* Return the cryptographic hash of a string in base-16. */
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_hashString(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2013-03-08 00:24:59 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto type = state.forceStringNoCtx(*args[0], pos);
|
2020-06-02 15:52:13 +00:00
|
|
|
|
std::optional<HashType> ht = parseHashType(type);
|
|
|
|
|
if (!ht)
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(Error({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("unknown hash type '%1%'", type),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2013-03-08 00:24:59 +00:00
|
|
|
|
|
|
|
|
|
PathSet context; // discarded
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto s = state.forceString(*args[1], context, pos);
|
2013-03-08 00:24:59 +00:00
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(hashString(*ht, s).to_string(Base16, false));
|
2014-11-25 10:47:06 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_hashString({
|
|
|
|
|
.name = "__hashString",
|
|
|
|
|
.args = {"type", "s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Return a base-16 representation of the cryptographic hash of string
|
|
|
|
|
*s*. The hash algorithm specified by *type* must be one of `"md5"`,
|
|
|
|
|
`"sha1"`, `"sha256"` or `"sha512"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_hashString,
|
|
|
|
|
});
|
2014-11-25 10:47:06 +00:00
|
|
|
|
|
2020-09-21 16:22:45 +00:00
|
|
|
|
struct RegexCache
|
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
// 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(), std::regex(keys.back(), std::regex::extended)).first->second;
|
|
|
|
|
}
|
2020-09-21 16:22:45 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
std::shared_ptr<RegexCache> makeRegexCache()
|
|
|
|
|
{
|
|
|
|
|
return std::make_shared<RegexCache>();
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-21 18:25:49 +00:00
|
|
|
|
void prim_match(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2014-11-25 10:47:06 +00:00
|
|
|
|
{
|
2017-05-17 09:58:01 +00:00
|
|
|
|
auto re = state.forceStringNoCtx(*args[0], pos);
|
2014-11-25 10:47:06 +00:00
|
|
|
|
|
2017-05-17 09:58:01 +00:00
|
|
|
|
try {
|
2016-10-18 18:21:21 +00:00
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto regex = state.regexCache->get(re);
|
2014-11-25 10:47:06 +00:00
|
|
|
|
|
2017-05-17 09:58:01 +00:00
|
|
|
|
PathSet context;
|
2022-01-21 13:44:00 +00:00
|
|
|
|
const auto str = state.forceString(*args[1], context, pos);
|
2014-11-25 10:47:06 +00:00
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
std::cmatch match;
|
|
|
|
|
if (!std::regex_match(str.begin(), str.end(), match, regex)) {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkNull();
|
2017-05-17 09:58:01 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// the first match is the whole string
|
|
|
|
|
const size_t len = match.size() - 1;
|
|
|
|
|
state.mkList(v, len);
|
|
|
|
|
for (size_t i = 0; i < len; ++i) {
|
|
|
|
|
if (!match[i+1].matched)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
(v.listElems()[i] = state.allocValue())->mkNull();
|
2017-05-17 09:58:01 +00:00
|
|
|
|
else
|
2022-01-04 17:24:42 +00:00
|
|
|
|
(v.listElems()[i] = state.allocValue())->mkString(match[i + 1].str());
|
2017-05-17 09:58:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
2017-06-30 04:14:50 +00:00
|
|
|
|
} catch (std::regex_error &e) {
|
|
|
|
|
if (e.code() == std::regex_constants::error_space) {
|
2020-05-09 00:18:28 +00:00
|
|
|
|
// limit is _GLIBCXX_REGEX_STATE_LIMIT for libstdc++
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("memory limit exceeded by regular expression '%s'", re),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2017-06-30 04:14:50 +00:00
|
|
|
|
} else {
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("invalid regular expression '%s'", re),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2017-06-30 04:14:50 +00:00
|
|
|
|
}
|
2014-11-25 10:47:06 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2013-03-08 00:24:59 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_match({
|
|
|
|
|
.name = "__match",
|
|
|
|
|
.args = {"regex", "str"},
|
|
|
|
|
.doc = R"s(
|
|
|
|
|
Returns a list if the [extended POSIX regular
|
|
|
|
|
expression](http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_04)
|
|
|
|
|
*regex* matches *str* precisely, otherwise returns `null`. Each item
|
|
|
|
|
in the list is a regex group.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.match "ab" "abc"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Evaluates to `null`.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.match "abc" "abc"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Evaluates to `[ ]`.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.match "a(b)(c)" "abc"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Evaluates to `[ "b" "c" ]`.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.match "[[:space:]]+([[:upper:]]+)[[:space:]]+" " FOO "
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Evaluates to `[ "foo" ]`.
|
|
|
|
|
)s",
|
|
|
|
|
.fun = prim_match,
|
|
|
|
|
});
|
2013-03-08 00:24:59 +00:00
|
|
|
|
|
2017-08-15 18:08:41 +00:00
|
|
|
|
/* Split a string with a regular expression, and return a list of the
|
|
|
|
|
non-matching parts interleaved by the lists of the matching groups. */
|
2022-01-01 23:46:43 +00:00
|
|
|
|
void prim_split(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2017-08-15 18:08:41 +00:00
|
|
|
|
{
|
|
|
|
|
auto re = state.forceStringNoCtx(*args[0], pos);
|
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto regex = state.regexCache->get(re);
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
|
|
|
|
PathSet context;
|
2022-01-21 13:44:00 +00:00
|
|
|
|
const auto str = state.forceString(*args[1], context, pos);
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto begin = std::cregex_iterator(str.begin(), str.end(), regex);
|
|
|
|
|
auto end = std::cregex_iterator();
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
|
|
|
|
// Any matches results are surrounded by non-matching results.
|
|
|
|
|
const size_t len = std::distance(begin, end);
|
|
|
|
|
state.mkList(v, 2 * len + 1);
|
|
|
|
|
size_t idx = 0;
|
|
|
|
|
|
|
|
|
|
if (len == 0) {
|
|
|
|
|
v.listElems()[idx++] = args[1];
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-21 13:44:00 +00:00
|
|
|
|
for (auto i = begin; i != end; ++i) {
|
2017-08-15 18:08:41 +00:00
|
|
|
|
assert(idx <= 2 * len + 1 - 3);
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto match = *i;
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
|
|
|
|
// Add a string for non-matched characters.
|
2022-01-04 17:24:42 +00:00
|
|
|
|
(v.listElems()[idx++] = state.allocValue())->mkString(match.prefix().str());
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
|
|
|
|
// Add a list for matched substrings.
|
|
|
|
|
const size_t slen = match.size() - 1;
|
2022-01-04 17:24:42 +00:00
|
|
|
|
auto elem = v.listElems()[idx++] = state.allocValue();
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
|
|
|
|
// Start at 1, beacause the first match is the whole string.
|
|
|
|
|
state.mkList(*elem, slen);
|
|
|
|
|
for (size_t si = 0; si < slen; ++si) {
|
|
|
|
|
if (!match[si + 1].matched)
|
2022-01-04 17:40:39 +00:00
|
|
|
|
(elem->listElems()[si] = state.allocValue())->mkNull();
|
2017-08-15 18:08:41 +00:00
|
|
|
|
else
|
2022-01-04 17:24:42 +00:00
|
|
|
|
(elem->listElems()[si] = state.allocValue())->mkString(match[si + 1].str());
|
2017-08-15 18:08:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Add a string for non-matched suffix characters.
|
2022-01-04 17:24:42 +00:00
|
|
|
|
if (idx == 2 * len)
|
|
|
|
|
(v.listElems()[idx++] = state.allocValue())->mkString(match.suffix().str());
|
2017-08-15 18:08:41 +00:00
|
|
|
|
}
|
2022-01-04 17:24:42 +00:00
|
|
|
|
|
2017-08-15 18:08:41 +00:00
|
|
|
|
assert(idx == 2 * len + 1);
|
|
|
|
|
|
|
|
|
|
} catch (std::regex_error &e) {
|
|
|
|
|
if (e.code() == std::regex_constants::error_space) {
|
2020-05-13 21:56:39 +00:00
|
|
|
|
// limit is _GLIBCXX_REGEX_STATE_LIMIT for libstdc++
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("memory limit exceeded by regular expression '%s'", re),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2017-08-15 18:08:41 +00:00
|
|
|
|
} else {
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("invalid regular expression '%s'", re),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2017-08-15 18:08:41 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_split({
|
|
|
|
|
.name = "__split",
|
|
|
|
|
.args = {"regex", "str"},
|
|
|
|
|
.doc = R"s(
|
|
|
|
|
Returns a list composed of non matched strings interleaved with the
|
|
|
|
|
lists of the [extended POSIX regular
|
|
|
|
|
expression](http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_04)
|
|
|
|
|
*regex* matches of *str*. Each item in the lists of matched
|
|
|
|
|
sequences is a regex group.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.split "(a)b" "abc"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Evaluates to `[ "" [ "a" ] "c" ]`.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.split "([ac])" "abc"
|
|
|
|
|
```
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
Evaluates to `[ "" [ "a" ] "b" [ "c" ] "" ]`.
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.split "(a)|(c)" "abc"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Evaluates to `[ "" [ "a" null ] "b" [ null "c" ] "" ]`.
|
2017-08-15 18:08:41 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
```nix
|
|
|
|
|
builtins.split "([[:upper:]]+)" " FOO "
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Evaluates to `[ " " [ "FOO" ] " " ]`.
|
|
|
|
|
)s",
|
|
|
|
|
.fun = prim_split,
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
static void prim_concatStringsSep(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2015-07-24 00:31:58 +00:00
|
|
|
|
{
|
|
|
|
|
PathSet context;
|
|
|
|
|
|
|
|
|
|
auto sep = state.forceString(*args[0], context, pos);
|
2015-07-24 13:32:24 +00:00
|
|
|
|
state.forceList(*args[1], pos);
|
2015-07-24 00:31:58 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string res;
|
2015-07-24 00:31:58 +00:00
|
|
|
|
res.reserve((args[1]->listSize() + 32) * sep.size());
|
|
|
|
|
bool first = true;
|
|
|
|
|
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : args[1]->listItems()) {
|
2015-07-24 00:31:58 +00:00
|
|
|
|
if (first) first = false; else res += sep;
|
2022-01-21 15:20:54 +00:00
|
|
|
|
res += *state.coerceToString(pos, *elem, context);
|
2015-07-24 00:31:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(res, context);
|
2015-07-24 00:31:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_concatStringsSep({
|
|
|
|
|
.name = "__concatStringsSep",
|
|
|
|
|
.args = {"separator", "list"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Concatenate a list of strings with a separator between each
|
|
|
|
|
element, e.g. `concatStringsSep "/" ["usr" "local" "bin"] ==
|
|
|
|
|
"usr/local/bin"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_concatStringsSep,
|
|
|
|
|
});
|
2015-07-24 00:31:58 +00:00
|
|
|
|
|
2015-07-24 13:32:24 +00:00
|
|
|
|
static void prim_replaceStrings(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
|
|
|
|
state.forceList(*args[0], pos);
|
|
|
|
|
state.forceList(*args[1], pos);
|
|
|
|
|
if (args[0]->listSize() != args[1]->listSize())
|
2022-02-11 21:14:25 +00:00
|
|
|
|
state.debug_throw(EvalError({
|
2021-01-20 23:27:36 +00:00
|
|
|
|
.msg = hintfmt("'from' and 'to' arguments to 'replaceStrings' have different lengths"),
|
2020-06-23 21:30:13 +00:00
|
|
|
|
.errPos = pos
|
2022-02-11 21:14:25 +00:00
|
|
|
|
}));
|
2015-07-24 13:32:24 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::vector<std::string> from;
|
2016-08-14 01:54:48 +00:00
|
|
|
|
from.reserve(args[0]->listSize());
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : args[0]->listItems())
|
2022-01-21 13:44:00 +00:00
|
|
|
|
from.emplace_back(state.forceString(*elem, pos));
|
2015-07-24 13:32:24 +00:00
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::vector<std::pair<std::string, PathSet>> to;
|
2016-08-14 01:54:48 +00:00
|
|
|
|
to.reserve(args[1]->listSize());
|
2021-11-24 19:21:34 +00:00
|
|
|
|
for (auto elem : args[1]->listItems()) {
|
2016-08-14 01:54:48 +00:00
|
|
|
|
PathSet ctx;
|
2021-11-24 19:21:34 +00:00
|
|
|
|
auto s = state.forceString(*elem, ctx, pos);
|
2022-01-21 13:44:00 +00:00
|
|
|
|
to.emplace_back(s, std::move(ctx));
|
2016-08-14 01:54:48 +00:00
|
|
|
|
}
|
2015-07-24 13:32:24 +00:00
|
|
|
|
|
|
|
|
|
PathSet context;
|
|
|
|
|
auto s = state.forceString(*args[2], context, pos);
|
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
|
std::string res;
|
2018-02-19 15:52:33 +00:00
|
|
|
|
// Loops one past last character to handle the case where 'from' contains an empty string.
|
|
|
|
|
for (size_t p = 0; p <= s.size(); ) {
|
2015-07-24 13:32:24 +00:00
|
|
|
|
bool found = false;
|
2016-08-14 01:54:48 +00:00
|
|
|
|
auto i = from.begin();
|
|
|
|
|
auto j = to.begin();
|
|
|
|
|
for (; i != from.end(); ++i, ++j)
|
2015-07-24 13:32:24 +00:00
|
|
|
|
if (s.compare(p, i->size(), *i) == 0) {
|
|
|
|
|
found = true;
|
2016-08-14 01:54:48 +00:00
|
|
|
|
res += j->first;
|
2018-02-19 15:52:33 +00:00
|
|
|
|
if (i->empty()) {
|
|
|
|
|
if (p < s.size())
|
|
|
|
|
res += s[p];
|
|
|
|
|
p++;
|
|
|
|
|
} else {
|
|
|
|
|
p += i->size();
|
|
|
|
|
}
|
2016-08-14 01:54:48 +00:00
|
|
|
|
for (auto& path : j->second)
|
|
|
|
|
context.insert(path);
|
|
|
|
|
j->second.clear();
|
2015-07-24 13:32:24 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2018-02-19 15:52:33 +00:00
|
|
|
|
if (!found) {
|
|
|
|
|
if (p < s.size())
|
|
|
|
|
res += s[p];
|
|
|
|
|
p++;
|
|
|
|
|
}
|
2015-07-24 13:32:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(res, context);
|
2015-07-24 13:32:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_replaceStrings({
|
|
|
|
|
.name = "__replaceStrings",
|
|
|
|
|
.args = {"from", "to", "s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Given string *s*, replace every occurrence of the strings in *from*
|
|
|
|
|
with the corresponding string in *to*. For example,
|
|
|
|
|
|
|
|
|
|
```nix
|
|
|
|
|
builtins.replaceStrings ["oo" "a"] ["a" "i"] "foobar"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
evaluates to `"fabir"`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_replaceStrings,
|
|
|
|
|
});
|
|
|
|
|
|
2015-07-24 13:32:24 +00:00
|
|
|
|
|
2008-07-01 10:10:32 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Versions
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_parseDrvName(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2008-07-01 10:10:32 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto name = state.forceStringNoCtx(*args[0], pos);
|
2008-07-01 10:10:32 +00:00
|
|
|
|
DrvName parsed(name);
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = state.buildBindings(2);
|
|
|
|
|
attrs.alloc(state.sName).mkString(parsed.name);
|
|
|
|
|
attrs.alloc("version").mkString(parsed.version);
|
|
|
|
|
v.mkAttrs(attrs);
|
2008-07-01 10:10:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_parseDrvName({
|
|
|
|
|
.name = "__parseDrvName",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Split the string *s* into a package name and version. The package
|
|
|
|
|
name is everything up to but not including the first dash followed
|
|
|
|
|
by a digit, and the version is everything following that dash. The
|
|
|
|
|
result is returned in a set `{ name, version }`. Thus,
|
|
|
|
|
`builtins.parseDrvName "nix-0.12pre12876"` returns `{ name =
|
|
|
|
|
"nix"; version = "0.12pre12876"; }`.
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_parseDrvName,
|
|
|
|
|
});
|
2008-07-01 10:10:32 +00:00
|
|
|
|
|
2014-04-04 16:51:01 +00:00
|
|
|
|
static void prim_compareVersions(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
2008-07-01 10:10:32 +00:00
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto version1 = state.forceStringNoCtx(*args[0], pos);
|
|
|
|
|
auto version2 = state.forceStringNoCtx(*args[1], pos);
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(compareVersions(version1, version2));
|
2008-07-01 10:10:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_compareVersions({
|
|
|
|
|
.name = "__compareVersions",
|
|
|
|
|
.args = {"s1", "s2"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Compare two strings representing versions and return `-1` if
|
|
|
|
|
version *s1* is older than version *s2*, `0` if they are the same,
|
|
|
|
|
and `1` if *s1* is newer than *s2*. The version comparison
|
|
|
|
|
algorithm is the same as the one used by [`nix-env
|
|
|
|
|
-u`](../command-ref/nix-env.md#operation---upgrade).
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_compareVersions,
|
|
|
|
|
});
|
2008-07-01 10:10:32 +00:00
|
|
|
|
|
2018-02-13 23:28:27 +00:00
|
|
|
|
static void prim_splitVersion(EvalState & state, const Pos & pos, Value * * args, Value & v)
|
|
|
|
|
{
|
2022-01-21 13:44:00 +00:00
|
|
|
|
auto version = state.forceStringNoCtx(*args[0], pos);
|
2018-02-13 23:28:27 +00:00
|
|
|
|
auto iter = version.cbegin();
|
|
|
|
|
Strings components;
|
|
|
|
|
while (iter != version.cend()) {
|
|
|
|
|
auto component = nextComponent(iter, version.cend());
|
|
|
|
|
if (component.empty())
|
|
|
|
|
break;
|
2022-01-21 13:44:00 +00:00
|
|
|
|
components.emplace_back(component);
|
2018-02-13 23:28:27 +00:00
|
|
|
|
}
|
|
|
|
|
state.mkList(v, components.size());
|
2022-01-04 17:24:42 +00:00
|
|
|
|
for (const auto & [n, component] : enumerate(components))
|
|
|
|
|
(v.listElems()[n] = state.allocValue())->mkString(std::move(component));
|
2018-02-13 23:28:27 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
static RegisterPrimOp primop_splitVersion({
|
|
|
|
|
.name = "__splitVersion",
|
|
|
|
|
.args = {"s"},
|
|
|
|
|
.doc = R"(
|
|
|
|
|
Split a string representing a version into its components, by the
|
|
|
|
|
same version splitting logic underlying the version comparison in
|
|
|
|
|
[`nix-env -u`](../command-ref/nix-env.md#operation---upgrade).
|
|
|
|
|
)",
|
|
|
|
|
.fun = prim_splitVersion,
|
|
|
|
|
});
|
|
|
|
|
|
2018-02-13 23:28:27 +00:00
|
|
|
|
|
2007-01-29 15:15:37 +00:00
|
|
|
|
/*************************************************************
|
|
|
|
|
* Primop registration
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
|
|
|
|
|
2016-04-13 09:15:45 +00:00
|
|
|
|
RegisterPrimOp::PrimOps * RegisterPrimOp::primOps;
|
|
|
|
|
|
|
|
|
|
|
2021-09-28 20:12:41 +00:00
|
|
|
|
RegisterPrimOp::RegisterPrimOp(std::string name, size_t arity, PrimOpFun fun)
|
2016-04-13 09:15:45 +00:00
|
|
|
|
{
|
|
|
|
|
if (!primOps) primOps = new PrimOps;
|
2020-08-24 11:11:56 +00:00
|
|
|
|
primOps->push_back({
|
|
|
|
|
.name = name,
|
|
|
|
|
.args = {},
|
|
|
|
|
.arity = arity,
|
2022-03-25 13:04:18 +00:00
|
|
|
|
.fun = fun,
|
2020-08-24 11:11:56 +00:00
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
RegisterPrimOp::RegisterPrimOp(Info && info)
|
|
|
|
|
{
|
|
|
|
|
if (!primOps) primOps = new PrimOps;
|
|
|
|
|
primOps->push_back(std::move(info));
|
2016-04-13 09:15:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-03-29 14:37:56 +00:00
|
|
|
|
void EvalState::createBaseEnv()
|
2004-08-04 10:59:20 +00:00
|
|
|
|
{
|
2010-03-29 14:37:56 +00:00
|
|
|
|
baseEnv.up = 0;
|
|
|
|
|
|
|
|
|
|
/* Add global constants such as `true' to the base environment. */
|
2010-03-30 14:39:27 +00:00
|
|
|
|
Value v;
|
|
|
|
|
|
2010-04-14 22:59:39 +00:00
|
|
|
|
/* `builtins' must be first! */
|
2022-01-04 19:29:17 +00:00
|
|
|
|
v.mkAttrs(buildBindings(128).finish());
|
2010-04-14 22:59:39 +00:00
|
|
|
|
addConstant("builtins", v);
|
|
|
|
|
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(true);
|
2010-03-30 14:39:27 +00:00
|
|
|
|
addConstant("true", v);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkBool(false);
|
2010-03-30 14:39:27 +00:00
|
|
|
|
addConstant("false", v);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkNull();
|
2010-03-30 14:39:27 +00:00
|
|
|
|
addConstant("null", v);
|
|
|
|
|
|
2018-03-27 17:02:22 +00:00
|
|
|
|
if (!evalSettings.pureEval) {
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(time(0));
|
2018-01-16 17:50:38 +00:00
|
|
|
|
addConstant("__currentTime", v);
|
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(settings.thisSystem.get());
|
2018-01-16 17:50:38 +00:00
|
|
|
|
addConstant("__currentSystem", v);
|
|
|
|
|
}
|
2004-08-04 10:59:20 +00:00
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(nixVersion);
|
2012-11-27 12:29:55 +00:00
|
|
|
|
addConstant("__nixVersion", v);
|
|
|
|
|
|
2022-01-04 17:24:42 +00:00
|
|
|
|
v.mkString(store->storeDir);
|
2015-03-24 10:15:45 +00:00
|
|
|
|
addConstant("__storeDir", v);
|
|
|
|
|
|
2012-11-27 12:29:55 +00:00
|
|
|
|
/* Language version. This should be increased every time a new
|
|
|
|
|
language feature gets added. It's not necessary to increase it
|
|
|
|
|
when primops get added, because you can just use `builtins ?
|
|
|
|
|
primOp' to check. */
|
2022-01-04 17:40:39 +00:00
|
|
|
|
v.mkInt(6);
|
2012-11-27 12:29:55 +00:00
|
|
|
|
addConstant("__langVersion", v);
|
|
|
|
|
|
2007-01-29 15:11:32 +00:00
|
|
|
|
// Miscellaneous
|
2018-03-27 17:02:22 +00:00
|
|
|
|
if (evalSettings.enableNativeCode) {
|
2014-06-24 14:50:03 +00:00
|
|
|
|
addPrimOp("__importNative", 2, prim_importNative);
|
2017-03-30 12:04:21 +00:00
|
|
|
|
addPrimOp("__exec", 1, prim_exec);
|
|
|
|
|
}
|
2011-09-14 05:59:17 +00:00
|
|
|
|
|
2014-05-26 12:55:47 +00:00
|
|
|
|
/* Add a value containing the current Nix expression search path. */
|
|
|
|
|
mkList(v, searchPath.size());
|
|
|
|
|
int n = 0;
|
|
|
|
|
for (auto & i : searchPath) {
|
2022-01-04 16:39:16 +00:00
|
|
|
|
auto attrs = buildBindings(2);
|
|
|
|
|
attrs.alloc("path").mkString(i.second);
|
|
|
|
|
attrs.alloc("prefix").mkString(i.first);
|
|
|
|
|
(v.listElems()[n++] = allocValue())->mkAttrs(attrs);
|
2014-05-26 12:55:47 +00:00
|
|
|
|
}
|
2014-07-30 09:27:34 +00:00
|
|
|
|
addConstant("__nixPath", v);
|
2014-05-26 12:55:47 +00:00
|
|
|
|
|
2016-04-13 09:15:45 +00:00
|
|
|
|
if (RegisterPrimOp::primOps)
|
|
|
|
|
for (auto & primOp : *RegisterPrimOp::primOps)
|
2022-03-25 13:04:18 +00:00
|
|
|
|
if (!primOp.experimentalFeature
|
|
|
|
|
|| settings.isExperimentalFeatureEnabled(*primOp.experimentalFeature))
|
|
|
|
|
{
|
|
|
|
|
addPrimOp({
|
|
|
|
|
.fun = primOp.fun,
|
|
|
|
|
.arity = std::max(primOp.args.size(), primOp.arity),
|
|
|
|
|
.name = symbols.create(primOp.name),
|
|
|
|
|
.args = primOp.args,
|
|
|
|
|
.doc = primOp.doc,
|
|
|
|
|
});
|
|
|
|
|
}
|
2016-04-13 09:15:45 +00:00
|
|
|
|
|
2020-08-24 12:31:10 +00:00
|
|
|
|
/* Add a wrapper around the derivation primop that computes the
|
|
|
|
|
`drvPath' and `outPath' attributes lazily. */
|
2020-09-17 07:12:39 +00:00
|
|
|
|
sDerivationNix = symbols.create("//builtin/derivation.nix");
|
2020-03-02 17:15:06 +00:00
|
|
|
|
auto vDerivation = allocValue();
|
|
|
|
|
addConstant("derivation", vDerivation);
|
2016-04-13 09:15:45 +00:00
|
|
|
|
|
2013-10-24 14:41:04 +00:00
|
|
|
|
/* Now that we've added all primops, sort the `builtins' set,
|
|
|
|
|
because attribute lookups expect it to be sorted. */
|
2010-10-24 19:52:33 +00:00
|
|
|
|
baseEnv.values[0]->attrs->sort();
|
2020-02-21 17:31:16 +00:00
|
|
|
|
|
2021-11-30 21:15:02 +00:00
|
|
|
|
staticBaseEnv->sort();
|
2020-03-02 17:15:06 +00:00
|
|
|
|
|
|
|
|
|
/* Note: we have to initialize the 'derivation' constant *after*
|
|
|
|
|
building baseEnv/staticBaseEnv because it uses 'builtins'. */
|
2021-12-21 12:56:57 +00:00
|
|
|
|
char code[] =
|
2020-03-02 17:15:06 +00:00
|
|
|
|
#include "primops/derivation.nix.gen.hh"
|
2021-12-21 12:56:57 +00:00
|
|
|
|
// the parser needs two NUL bytes as terminators; one of them
|
|
|
|
|
// is implied by being a C string.
|
|
|
|
|
"\0";
|
|
|
|
|
eval(parse(code, sizeof(code), foFile, sDerivationNix, "/", staticBaseEnv), *vDerivation);
|
2004-08-04 10:59:20 +00:00
|
|
|
|
}
|
2006-09-04 21:06:23 +00:00
|
|
|
|
|
2007-01-29 14:23:09 +00:00
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
|
}
|