2012-07-18 18:59:03 +00:00
|
|
|
#pragma once
|
2023-04-01 03:18:41 +00:00
|
|
|
///@file
|
2003-10-30 16:48:26 +00:00
|
|
|
|
2015-07-14 17:18:56 +00:00
|
|
|
#include "attr-set.hh"
|
2022-01-21 15:20:54 +00:00
|
|
|
#include "types.hh"
|
2012-01-07 17:26:33 +00:00
|
|
|
#include "value.hh"
|
2003-11-18 12:06:07 +00:00
|
|
|
#include "nixexpr.hh"
|
2010-04-13 12:25:42 +00:00
|
|
|
#include "symbol-table.hh"
|
2018-03-27 17:02:22 +00:00
|
|
|
#include "config.hh"
|
2021-10-25 13:53:01 +00:00
|
|
|
#include "experimental-features.hh"
|
2023-04-06 11:15:50 +00:00
|
|
|
#include "input-accessor.hh"
|
2003-10-30 16:48:26 +00:00
|
|
|
|
2010-10-04 17:55:38 +00:00
|
|
|
#include <map>
|
2019-10-27 09:15:51 +00:00
|
|
|
#include <optional>
|
2018-05-22 11:02:14 +00:00
|
|
|
#include <unordered_map>
|
2019-11-14 17:32:11 +00:00
|
|
|
#include <mutex>
|
2010-10-04 17:55:38 +00:00
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
namespace nix {
|
|
|
|
|
|
|
|
|
2016-02-04 13:48:42 +00:00
|
|
|
class Store;
|
2010-03-29 14:37:56 +00:00
|
|
|
class EvalState;
|
2020-06-17 17:26:37 +00:00
|
|
|
class StorePath;
|
2023-05-10 23:25:52 +00:00
|
|
|
struct DerivedPath;
|
2017-06-28 16:11:01 +00:00
|
|
|
enum RepairFlag : bool;
|
2019-05-29 13:31:07 +00:00
|
|
|
|
2010-10-24 00:41:29 +00:00
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
typedef void (* PrimOpFun) (EvalState & state, const PosIdx pos, Value * * args, Value & v);
|
2010-10-23 20:07:47 +00:00
|
|
|
|
|
|
|
struct PrimOp
|
|
|
|
{
|
|
|
|
PrimOpFun fun;
|
2016-04-13 09:15:45 +00:00
|
|
|
size_t arity;
|
2022-03-05 18:26:36 +00:00
|
|
|
std::string name;
|
2020-08-24 11:11:56 +00:00
|
|
|
std::vector<std::string> args;
|
|
|
|
const char * doc = nullptr;
|
2010-10-23 20:07:47 +00:00
|
|
|
};
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2022-05-06 02:26:10 +00:00
|
|
|
#if HAVE_BOEHMGC
|
|
|
|
typedef std::map<std::string, Value *, std::less<std::string>, traceable_allocator<std::pair<const std::string, Value *> > > ValMap;
|
|
|
|
#else
|
|
|
|
typedef std::map<std::string, Value *> ValMap;
|
|
|
|
#endif
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2010-04-14 14:42:32 +00:00
|
|
|
struct Env
|
|
|
|
{
|
|
|
|
Env * up;
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Number of of levels up to next `with` environment
|
|
|
|
*/
|
|
|
|
unsigned short prevWith:14;
|
2018-05-22 14:02:32 +00:00
|
|
|
enum { Plain = 0, HasWithExpr, HasWithAttrs } type:2;
|
2010-10-22 15:51:52 +00:00
|
|
|
Value * values[0];
|
2010-04-14 14:42:32 +00:00
|
|
|
};
|
|
|
|
|
2022-05-19 23:01:23 +00:00
|
|
|
void printEnvBindings(const EvalState &es, const Expr & expr, const Env & env);
|
|
|
|
void printEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env, int lvl = 0);
|
|
|
|
|
2022-05-05 21:43:23 +00:00
|
|
|
std::unique_ptr<ValMap> mapStaticEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env);
|
2010-04-14 14:42:32 +00:00
|
|
|
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
void copyContext(const Value & v, NixStringContext & context);
|
2010-06-10 10:29:50 +00:00
|
|
|
|
2010-03-30 09:22:33 +00:00
|
|
|
|
2022-03-05 13:40:24 +00:00
|
|
|
std::string printValue(const EvalState & state, const Value & v);
|
2022-05-06 16:05:27 +00:00
|
|
|
std::ostream & operator << (std::ostream & os, const ValueType t);
|
2004-02-04 16:03:29 +00:00
|
|
|
|
|
|
|
|
2023-04-06 11:15:50 +00:00
|
|
|
// FIXME: maybe change this to an std::variant<SourcePath, URL>.
|
2016-04-14 13:32:24 +00:00
|
|
|
typedef std::pair<std::string, std::string> SearchPathElem;
|
|
|
|
typedef std::list<SearchPathElem> SearchPath;
|
2014-05-26 15:02:22 +00:00
|
|
|
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Initialise the Boehm GC, if applicable.
|
|
|
|
*/
|
2015-03-19 19:02:37 +00:00
|
|
|
void initGC();
|
|
|
|
|
|
|
|
|
2020-09-21 16:22:45 +00:00
|
|
|
struct RegexCache;
|
|
|
|
|
|
|
|
std::shared_ptr<RegexCache> makeRegexCache();
|
|
|
|
|
2021-12-23 20:36:39 +00:00
|
|
|
struct DebugTrace {
|
2022-12-12 23:48:04 +00:00
|
|
|
std::shared_ptr<AbstractPos> pos;
|
2022-05-05 10:29:14 +00:00
|
|
|
const Expr & expr;
|
|
|
|
const Env & env;
|
2021-12-23 20:36:39 +00:00
|
|
|
hintformat hint;
|
2022-05-05 10:29:14 +00:00
|
|
|
bool isError;
|
2021-12-23 20:36:39 +00:00
|
|
|
};
|
|
|
|
|
2022-05-06 15:09:49 +00:00
|
|
|
void debugError(Error * e, Env & env, Expr & expr);
|
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
class ErrorBuilder
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
EvalState & state;
|
|
|
|
ErrorInfo info;
|
|
|
|
|
|
|
|
ErrorBuilder(EvalState & s, ErrorInfo && i): state(s), info(i) { }
|
|
|
|
|
|
|
|
public:
|
|
|
|
template<typename... Args>
|
|
|
|
[[nodiscard, gnu::noinline]]
|
|
|
|
static ErrorBuilder * create(EvalState & s, const Args & ... args)
|
|
|
|
{
|
|
|
|
return new ErrorBuilder(s, ErrorInfo { .msg = hintfmt(args...) });
|
|
|
|
}
|
|
|
|
|
|
|
|
[[nodiscard, gnu::noinline]]
|
|
|
|
ErrorBuilder & atPos(PosIdx pos);
|
|
|
|
|
|
|
|
[[nodiscard, gnu::noinline]]
|
|
|
|
ErrorBuilder & withTrace(PosIdx pos, const std::string_view text);
|
|
|
|
|
|
|
|
[[nodiscard, gnu::noinline]]
|
|
|
|
ErrorBuilder & withFrameTrace(PosIdx pos, const std::string_view text);
|
|
|
|
|
|
|
|
[[nodiscard, gnu::noinline]]
|
|
|
|
ErrorBuilder & withSuggestions(Suggestions & s);
|
|
|
|
|
|
|
|
[[nodiscard, gnu::noinline]]
|
|
|
|
ErrorBuilder & withFrame(const Env & e, const Expr & ex);
|
|
|
|
|
|
|
|
template<class ErrorType>
|
|
|
|
[[gnu::noinline, gnu::noreturn]]
|
|
|
|
void debugThrow();
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2022-05-25 16:21:20 +00:00
|
|
|
class EvalState : public std::enable_shared_from_this<EvalState>
|
2003-10-30 16:48:26 +00:00
|
|
|
{
|
2010-03-31 15:38:03 +00:00
|
|
|
public:
|
2010-04-13 12:25:42 +00:00
|
|
|
SymbolTable symbols;
|
2022-03-04 18:31:59 +00:00
|
|
|
PosTable positions;
|
2010-04-13 12:25:42 +00:00
|
|
|
|
2013-10-28 06:34:44 +00:00
|
|
|
const Symbol sWith, sOutPath, sDrvPath, sType, sMeta, sName, sValue,
|
2013-11-18 19:14:54 +00:00
|
|
|
sSystem, sOverrides, sOutputs, sOutputName, sIgnoreNulls,
|
2016-08-29 15:28:20 +00:00
|
|
|
sFile, sLine, sColumn, sFunctor, sToString,
|
2017-03-04 13:24:06 +00:00
|
|
|
sRight, sWrong, sStructuredAttrs, sBuilder, sArgs,
|
2022-03-30 14:31:01 +00:00
|
|
|
sContentAddressed, sImpure,
|
2018-11-29 18:18:36 +00:00
|
|
|
sOutputHash, sOutputHashAlgo, sOutputHashMode,
|
2020-06-26 06:46:46 +00:00
|
|
|
sRecurseForDerivations,
|
2022-01-12 17:08:48 +00:00
|
|
|
sDescription, sSelf, sEpsilon, sStartSet, sOperator, sKey, sPath,
|
2022-05-30 09:32:37 +00:00
|
|
|
sPrefix,
|
|
|
|
sOutputSpecified;
|
2010-04-13 12:25:42 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* If set, force copying files to the Nix store even if they
|
|
|
|
* already exist there.
|
|
|
|
*/
|
2017-06-28 16:11:01 +00:00
|
|
|
RepairFlag repair;
|
2012-10-03 19:09:18 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* The allowed filesystem paths in restricted or pure evaluation
|
|
|
|
* mode.
|
|
|
|
*/
|
2019-02-12 12:43:32 +00:00
|
|
|
std::optional<PathSet> allowedPaths;
|
2015-02-23 13:41:53 +00:00
|
|
|
|
2022-01-04 18:23:11 +00:00
|
|
|
Bindings emptyBindings;
|
2015-07-23 21:11:08 +00:00
|
|
|
|
2023-04-06 13:25:06 +00:00
|
|
|
const SourcePath derivationInternal;
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Store used to materialise .drv files.
|
|
|
|
*/
|
2016-02-04 13:48:42 +00:00
|
|
|
const ref<Store> store;
|
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
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Store used to build stuff.
|
|
|
|
*/
|
2021-06-29 19:09:48 +00:00
|
|
|
const ref<Store> buildStore;
|
|
|
|
|
2021-08-29 16:55:38 +00:00
|
|
|
RootValue vCallFlake = nullptr;
|
2021-08-29 17:31:52 +00:00
|
|
|
RootValue vImportedDrvToDerivation = nullptr;
|
2019-03-21 08:30:16 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Debugger
|
|
|
|
*/
|
2022-05-25 16:21:20 +00:00
|
|
|
void (* debugRepl)(ref<EvalState> es, const ValMap & extraEnv);
|
2022-02-03 20:15:21 +00:00
|
|
|
bool debugStop;
|
2022-02-15 16:49:25 +00:00
|
|
|
bool debugQuit;
|
2022-06-02 18:17:28 +00:00
|
|
|
int trylevel;
|
2021-12-23 20:36:39 +00:00
|
|
|
std::list<DebugTrace> debugTraces;
|
2022-05-25 10:32:22 +00:00
|
|
|
std::map<const Expr*, const std::shared_ptr<const StaticEnv>> exprEnvs;
|
|
|
|
const std::shared_ptr<const StaticEnv> getStaticEnv(const Expr & expr) const
|
2022-05-19 16:48:10 +00:00
|
|
|
{
|
|
|
|
auto i = exprEnvs.find(&expr);
|
2022-05-25 10:32:22 +00:00
|
|
|
if (i != exprEnvs.end())
|
2022-05-19 16:48:10 +00:00
|
|
|
return i->second;
|
|
|
|
else
|
|
|
|
return std::shared_ptr<const StaticEnv>();;
|
|
|
|
}
|
|
|
|
|
2022-05-20 16:33:50 +00:00
|
|
|
void runDebugRepl(const Error * error, const Env & env, const Expr & expr);
|
2022-05-06 14:47:21 +00:00
|
|
|
|
2022-05-12 19:59:58 +00:00
|
|
|
template<class E>
|
2022-05-06 14:47:21 +00:00
|
|
|
[[gnu::noinline, gnu::noreturn]]
|
2023-01-19 12:23:04 +00:00
|
|
|
void debugThrowLastTrace(E && error)
|
2022-05-12 19:59:58 +00:00
|
|
|
{
|
2023-01-19 12:23:04 +00:00
|
|
|
debugThrow(error, nullptr, nullptr);
|
2022-05-12 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template<class E>
|
2022-05-06 14:47:21 +00:00
|
|
|
[[gnu::noinline, gnu::noreturn]]
|
2023-01-19 12:23:04 +00:00
|
|
|
void debugThrow(E && error, const Env * env, const Expr * expr)
|
2022-05-12 19:59:58 +00:00
|
|
|
{
|
2023-01-19 12:23:04 +00:00
|
|
|
if (debugRepl && ((env && expr) || !debugTraces.empty())) {
|
|
|
|
if (!env || !expr) {
|
|
|
|
const DebugTrace & last = debugTraces.front();
|
|
|
|
env = &last.env;
|
|
|
|
expr = &last.expr;
|
|
|
|
}
|
|
|
|
runDebugRepl(&error, *env, *expr);
|
2022-05-12 19:59:58 +00:00
|
|
|
}
|
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
throw std::move(error);
|
2022-05-12 19:59:58 +00:00
|
|
|
}
|
2022-02-11 21:14:25 +00:00
|
|
|
|
2022-12-20 11:06:27 +00:00
|
|
|
// This is dangerous, but gets in line with the idea that error creation and
|
|
|
|
// throwing should not allocate on the stack of hot functions.
|
|
|
|
// as long as errors are immediately thrown, it works.
|
2023-01-19 12:23:04 +00:00
|
|
|
ErrorBuilder * errorBuilder;
|
|
|
|
|
|
|
|
template<typename... Args>
|
|
|
|
[[nodiscard, gnu::noinline]]
|
|
|
|
ErrorBuilder & error(const Args & ... args) {
|
|
|
|
errorBuilder = ErrorBuilder::create(*this, args...);
|
|
|
|
return *errorBuilder;
|
|
|
|
}
|
2022-05-19 23:01:23 +00:00
|
|
|
|
2010-03-31 15:38:03 +00:00
|
|
|
private:
|
2023-04-06 11:15:50 +00:00
|
|
|
|
|
|
|
/* Cache for calls to addToStore(); maps source paths to the store
|
|
|
|
paths. */
|
|
|
|
std::map<SourcePath, StorePath> srcToStore;
|
2003-10-30 16:48:26 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* A cache from path names to parse trees.
|
|
|
|
*/
|
2018-06-11 14:06:01 +00:00
|
|
|
#if HAVE_BOEHMGC
|
2023-04-06 11:15:50 +00:00
|
|
|
typedef std::map<SourcePath, Expr *, std::less<SourcePath>, traceable_allocator<std::pair<const SourcePath, Expr *>>> FileParseCache;
|
2018-06-11 14:06:01 +00:00
|
|
|
#else
|
2023-04-06 11:15:50 +00:00
|
|
|
typedef std::map<SourcePath, Expr *> FileParseCache;
|
2018-06-11 14:06:01 +00:00
|
|
|
#endif
|
|
|
|
FileParseCache fileParseCache;
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* A cache from path names to values.
|
|
|
|
*/
|
2011-08-06 19:45:43 +00:00
|
|
|
#if HAVE_BOEHMGC
|
2023-04-06 11:15:50 +00:00
|
|
|
typedef std::map<SourcePath, Value, std::less<SourcePath>, traceable_allocator<std::pair<const SourcePath, Value>>> FileEvalCache;
|
2011-08-06 19:45:43 +00:00
|
|
|
#else
|
2023-04-06 11:15:50 +00:00
|
|
|
typedef std::map<SourcePath, Value> FileEvalCache;
|
2011-08-06 19:45:43 +00:00
|
|
|
#endif
|
|
|
|
FileEvalCache fileEvalCache;
|
|
|
|
|
2011-08-06 17:48:57 +00:00
|
|
|
SearchPath searchPath;
|
2011-08-06 16:05:24 +00:00
|
|
|
|
2016-04-14 13:32:24 +00:00
|
|
|
std::map<std::string, std::pair<bool, std::string>> searchPathResolved;
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Cache used by checkSourcePath().
|
|
|
|
*/
|
2023-04-06 11:15:50 +00:00
|
|
|
std::unordered_map<Path, SourcePath> resolvedPaths;
|
2018-05-22 11:02:14 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Cache used by prim_match().
|
|
|
|
*/
|
2020-09-21 16:22:45 +00:00
|
|
|
std::shared_ptr<RegexCache> regexCache;
|
2020-02-21 18:25:49 +00:00
|
|
|
|
2022-01-05 00:48:26 +00:00
|
|
|
#if HAVE_BOEHMGC
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Allocation cache for GC'd Value objects.
|
|
|
|
*/
|
2022-01-22 20:17:35 +00:00
|
|
|
std::shared_ptr<void *> valueAllocCache;
|
2021-12-20 12:28:54 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Allocation cache for size-1 Env objects.
|
|
|
|
*/
|
2021-12-26 18:32:08 +00:00
|
|
|
std::shared_ptr<void *> env1AllocCache;
|
2022-01-05 00:48:26 +00:00
|
|
|
#endif
|
2021-12-26 18:32:08 +00:00
|
|
|
|
2010-03-30 15:18:20 +00:00
|
|
|
public:
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2021-06-29 19:09:48 +00:00
|
|
|
EvalState(
|
|
|
|
const Strings & _searchPath,
|
|
|
|
ref<Store> store,
|
|
|
|
std::shared_ptr<Store> buildStore = nullptr);
|
2010-04-09 12:00:49 +00:00
|
|
|
~EvalState();
|
2004-02-04 16:03:29 +00:00
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
void addToSearchPath(const std::string & s);
|
2011-08-06 16:05:24 +00:00
|
|
|
|
2016-08-23 15:11:19 +00:00
|
|
|
SearchPath getSearchPath() { return searchPath; }
|
|
|
|
|
2023-04-06 11:15:50 +00:00
|
|
|
/**
|
|
|
|
* Return a `SourcePath` that refers to `path` in the root
|
|
|
|
* filesystem.
|
|
|
|
*/
|
|
|
|
SourcePath rootPath(CanonPath path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Allow access to a path.
|
|
|
|
*/
|
2021-10-07 10:11:00 +00:00
|
|
|
void allowPath(const Path & path);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Allow access to a store path. Note that this gets remapped to
|
|
|
|
* the real store path if `store` is a chroot store.
|
|
|
|
*/
|
2021-10-07 12:07:51 +00:00
|
|
|
void allowPath(const StorePath & storePath);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Allow access to a store path and return it as a string.
|
|
|
|
*/
|
2022-03-01 10:29:19 +00:00
|
|
|
void allowAndSetStorePathString(const StorePath & storePath, Value & v);
|
2022-02-27 14:59:34 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Check whether access to a path is allowed and throw an error if
|
|
|
|
* not. Otherwise return the canonicalised path.
|
|
|
|
*/
|
2023-04-06 11:15:50 +00:00
|
|
|
SourcePath checkSourcePath(const SourcePath & path);
|
2015-02-23 13:41:53 +00:00
|
|
|
|
2017-10-30 11:39:59 +00:00
|
|
|
void checkURI(const std::string & uri);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* When using a diverted store and 'path' is in the Nix store, map
|
|
|
|
* 'path' to the diverted location (e.g. /nix/store/foo is mapped
|
|
|
|
* to /home/alice/my-nix/nix/store/foo). However, this is only
|
|
|
|
* done if the context is not empty, since otherwise we're
|
|
|
|
* probably trying to read from the actual /nix/store. This is
|
|
|
|
* intended to distinguish between import-from-derivation and
|
|
|
|
* sources stored in the actual /nix/store.
|
|
|
|
*/
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
Path toRealPath(const Path & path, const NixStringContext & context);
|
2018-01-12 16:31:08 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Parse a Nix expression from the specified file.
|
|
|
|
*/
|
2023-04-06 11:15:50 +00:00
|
|
|
Expr * parseExprFromFile(const SourcePath & path);
|
|
|
|
Expr * parseExprFromFile(const SourcePath & path, std::shared_ptr<StaticEnv> & staticEnv);
|
2011-08-06 13:02:55 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Parse a Nix expression from the specified string.
|
|
|
|
*/
|
2023-04-06 11:15:50 +00:00
|
|
|
Expr * parseExprFromString(std::string s, const SourcePath & basePath, std::shared_ptr<StaticEnv> & staticEnv);
|
|
|
|
Expr * parseExprFromString(std::string s, const SourcePath & basePath);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2017-07-25 13:09:06 +00:00
|
|
|
Expr * parseStdin();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Evaluate an expression read from the given file to normal
|
|
|
|
* form. Optionally enforce that the top-level expression is
|
|
|
|
* trivial (i.e. doesn't require arbitrary computation).
|
|
|
|
*/
|
2023-04-06 11:15:50 +00:00
|
|
|
void evalFile(const SourcePath & path, Value & v, bool mustBeTrivial = false);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Like `evalFile`, but with an already parsed expression.
|
|
|
|
*/
|
2021-09-13 12:41:28 +00:00
|
|
|
void cacheFile(
|
2023-04-06 11:15:50 +00:00
|
|
|
const SourcePath & path,
|
|
|
|
const SourcePath & resolvedPath,
|
2021-09-13 12:41:28 +00:00
|
|
|
Expr * e,
|
|
|
|
Value & v,
|
|
|
|
bool mustBeTrivial = false);
|
|
|
|
|
2013-09-02 16:34:04 +00:00
|
|
|
void resetFileCache();
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Look up a file in the search path.
|
|
|
|
*/
|
2023-04-06 11:15:50 +00:00
|
|
|
SourcePath findFile(const std::string_view path);
|
|
|
|
SourcePath findFile(SearchPath & searchPath, const std::string_view path, const PosIdx pos = noPos);
|
2011-08-06 16:05:24 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* If the specified search path element is a URI, download it.
|
|
|
|
*/
|
2016-04-14 13:32:24 +00:00
|
|
|
std::pair<bool, std::string> resolveSearchPathElem(const SearchPathElem & elem);
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Evaluate an expression to normal form
|
|
|
|
*
|
|
|
|
* @param [out] v The resulting is stored here.
|
|
|
|
*/
|
2010-04-12 18:30:11 +00:00
|
|
|
void eval(Expr * e, Value & v);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Evaluation the expression, then verify that it has the expected
|
|
|
|
* type.
|
|
|
|
*/
|
2012-02-04 13:50:25 +00:00
|
|
|
inline bool evalBool(Env & env, Expr * e);
|
2023-01-19 12:23:04 +00:00
|
|
|
inline bool evalBool(Env & env, Expr * e, const PosIdx pos, std::string_view errorCtx);
|
|
|
|
inline void evalAttrs(Env & env, Expr * e, Value & v, const PosIdx pos, std::string_view errorCtx);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* If `v` is a thunk, enter it and overwrite `v` with the result
|
|
|
|
* of the evaluation of the thunk. If `v` is a delayed function
|
|
|
|
* application, call the function and overwrite `v` with the
|
|
|
|
* result. Otherwise, this is a no-op.
|
|
|
|
*/
|
2022-03-04 18:31:59 +00:00
|
|
|
inline void forceValue(Value & v, const PosIdx pos);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2022-02-03 23:31:33 +00:00
|
|
|
template <typename Callable>
|
|
|
|
inline void forceValue(Value & v, Callable getPos);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Force a value, then recursively force list elements and
|
|
|
|
* attributes.
|
|
|
|
*/
|
2014-09-22 13:03:59 +00:00
|
|
|
void forceValueDeep(Value & v);
|
2010-04-07 13:55:46 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Force `v`, and then verify that it has the expected type.
|
|
|
|
*/
|
2023-01-19 12:23:04 +00:00
|
|
|
NixInt forceInt(Value & v, const PosIdx pos, std::string_view errorCtx);
|
|
|
|
NixFloat forceFloat(Value & v, const PosIdx pos, std::string_view errorCtx);
|
|
|
|
bool forceBool(Value & v, const PosIdx pos, std::string_view errorCtx);
|
2022-02-03 23:31:33 +00:00
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
void forceAttrs(Value & v, const PosIdx pos, std::string_view errorCtx);
|
2022-02-03 23:31:33 +00:00
|
|
|
|
|
|
|
template <typename Callable>
|
2023-01-19 12:23:04 +00:00
|
|
|
inline void forceAttrs(Value & v, Callable getPos, std::string_view errorCtx);
|
2022-04-29 16:02:17 +00:00
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
inline void forceList(Value & v, const PosIdx pos, std::string_view errorCtx);
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @param v either lambda or primop
|
|
|
|
*/
|
|
|
|
void forceFunction(Value & v, const PosIdx pos, std::string_view errorCtx);
|
2023-01-19 12:23:04 +00:00
|
|
|
std::string_view forceString(Value & v, const PosIdx pos, std::string_view errorCtx);
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
std::string_view forceString(Value & v, NixStringContext & context, const PosIdx pos, std::string_view errorCtx);
|
2023-01-19 12:23:04 +00:00
|
|
|
std::string_view forceStringNoCtx(Value & v, const PosIdx pos, std::string_view errorCtx);
|
2022-03-07 20:02:17 +00:00
|
|
|
|
|
|
|
[[gnu::noinline]]
|
|
|
|
void addErrorTrace(Error & e, const char * s, const std::string & s2) const;
|
|
|
|
[[gnu::noinline]]
|
2023-01-19 12:23:04 +00:00
|
|
|
void addErrorTrace(Error & e, const PosIdx pos, const char * s, const std::string & s2, bool frame = false) const;
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2022-03-07 20:02:17 +00:00
|
|
|
public:
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return true iff the value `v` denotes a derivation (i.e. a
|
|
|
|
* set with attribute `type = "derivation"`).
|
|
|
|
*/
|
2010-04-07 13:55:46 +00:00
|
|
|
bool isDerivation(Value & v);
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
std::optional<std::string> tryAttrsToString(const PosIdx pos, Value & v,
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
NixStringContext & context, bool coerceMore = false, bool copyToStore = true);
|
2019-10-27 09:15:51 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* String coercion.
|
|
|
|
*
|
|
|
|
* Converts strings, paths and derivations to a
|
|
|
|
* string. If `coerceMore` is set, also converts nulls, integers,
|
|
|
|
* booleans and lists to a string. If `copyToStore` is set,
|
|
|
|
* referenced paths are copied to the Nix store as a side effect.
|
|
|
|
*/
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
BackedStringView coerceToString(const PosIdx pos, Value & v, NixStringContext & context,
|
2022-11-28 23:25:36 +00:00
|
|
|
std::string_view errorCtx,
|
2021-07-29 16:03:07 +00:00
|
|
|
bool coerceMore = false, bool copyToStore = true,
|
2022-11-28 23:25:36 +00:00
|
|
|
bool canonicalizePath = true);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
2023-04-24 11:20:36 +00:00
|
|
|
StorePath copyPathToStore(NixStringContext & context, const SourcePath & path);
|
2013-11-18 23:03:11 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Path coercion.
|
|
|
|
*
|
|
|
|
* Converts strings, paths and derivations to a
|
|
|
|
* path. The result is guaranteed to be a canonicalised, absolute
|
|
|
|
* path. Nothing is copied to the store.
|
|
|
|
*/
|
2023-04-24 11:20:36 +00:00
|
|
|
SourcePath coerceToPath(const PosIdx pos, Value & v, NixStringContext & context, std::string_view errorCtx);
|
2010-03-30 09:22:33 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Like coerceToPath, but the result must be a store path.
|
|
|
|
*/
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
StorePath coerceToStorePath(const PosIdx pos, Value & v, NixStringContext & context, std::string_view errorCtx);
|
2022-03-02 09:57:19 +00:00
|
|
|
|
2023-05-10 23:25:52 +00:00
|
|
|
/**
|
|
|
|
* Part of `coerceToDerivedPath()` without any store IO which is exposed for unit testing only.
|
|
|
|
*/
|
|
|
|
std::pair<DerivedPath, std::string_view> coerceToDerivedPathUnchecked(const PosIdx pos, Value & v, std::string_view errorCtx);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Coerce to `DerivedPath`.
|
|
|
|
*
|
|
|
|
* Must be a string which is either a literal store path or a
|
2023-05-11 22:01:41 +00:00
|
|
|
* "placeholder (see `DownstreamPlaceholder`).
|
2023-05-10 23:25:52 +00:00
|
|
|
*
|
|
|
|
* Even more importantly, the string context must be exactly one
|
|
|
|
* element, which is either a `NixStringContextElem::Opaque` or
|
|
|
|
* `NixStringContextElem::Built`. (`NixStringContextEleme::DrvDeep`
|
|
|
|
* is not permitted).
|
|
|
|
*
|
|
|
|
* The string is parsed based on the context --- the context is the
|
|
|
|
* source of truth, and ultimately tells us what we want, and then
|
|
|
|
* we ensure the string corresponds to it.
|
|
|
|
*/
|
|
|
|
DerivedPath coerceToDerivedPath(const PosIdx pos, Value & v, std::string_view errorCtx);
|
|
|
|
|
2013-09-02 16:34:04 +00:00
|
|
|
public:
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* The base environment, containing the builtin functions and
|
|
|
|
* values.
|
|
|
|
*/
|
2010-03-29 14:37:56 +00:00
|
|
|
Env & baseEnv;
|
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* The same, but used during parsing to resolve variables.
|
|
|
|
*/
|
2021-09-14 16:49:22 +00:00
|
|
|
std::shared_ptr<StaticEnv> staticBaseEnv; // !!! should be private
|
2010-04-14 22:59:39 +00:00
|
|
|
|
|
|
|
private:
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2015-07-23 21:14:07 +00:00
|
|
|
unsigned int baseEnvDispl = 0;
|
2013-09-02 16:34:04 +00:00
|
|
|
|
2010-03-29 14:37:56 +00:00
|
|
|
void createBaseEnv();
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
Value * addConstant(const std::string & name, Value & v);
|
2010-03-30 14:39:27 +00:00
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
void addConstant(const std::string & name, Value * v);
|
2020-03-02 17:15:06 +00:00
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
Value * addPrimOp(const std::string & name,
|
2018-05-02 11:56:34 +00:00
|
|
|
size_t arity, PrimOpFun primOp);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2020-08-24 11:11:56 +00:00
|
|
|
Value * addPrimOp(PrimOp && primOp);
|
|
|
|
|
2013-09-03 13:45:32 +00:00
|
|
|
public:
|
|
|
|
|
2022-02-25 15:00:00 +00:00
|
|
|
Value & getBuiltin(const std::string & name);
|
2013-09-03 13:45:32 +00:00
|
|
|
|
2020-08-25 11:31:11 +00:00
|
|
|
struct Doc
|
|
|
|
{
|
|
|
|
Pos pos;
|
2022-03-05 18:26:36 +00:00
|
|
|
std::optional<std::string> name;
|
2020-08-25 11:31:11 +00:00
|
|
|
size_t arity;
|
|
|
|
std::vector<std::string> args;
|
|
|
|
const char * doc;
|
|
|
|
};
|
|
|
|
|
|
|
|
std::optional<Doc> getDoc(Value & v);
|
|
|
|
|
2013-09-03 13:45:32 +00:00
|
|
|
private:
|
|
|
|
|
2013-10-08 12:24:53 +00:00
|
|
|
inline Value * lookupVar(Env * env, const ExprVar & var, bool noEval);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2014-01-21 17:29:55 +00:00
|
|
|
friend struct ExprVar;
|
|
|
|
friend struct ExprAttrs;
|
|
|
|
friend struct ExprLet;
|
2010-04-13 12:25:42 +00:00
|
|
|
|
2022-12-12 23:48:04 +00:00
|
|
|
Expr * parse(
|
|
|
|
char * text,
|
|
|
|
size_t length,
|
|
|
|
Pos::Origin origin,
|
2023-04-06 11:15:50 +00:00
|
|
|
const SourcePath & basePath,
|
2022-12-12 23:48:04 +00:00
|
|
|
std::shared_ptr<StaticEnv> & staticEnv);
|
2011-08-06 13:02:55 +00:00
|
|
|
|
2010-04-12 18:30:11 +00:00
|
|
|
public:
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Do a deep equality test between two values. That is, list
|
|
|
|
* elements and attributes are compared recursively.
|
|
|
|
*/
|
2023-01-19 12:23:04 +00:00
|
|
|
bool eqValues(Value & v1, Value & v2, const PosIdx pos, std::string_view errorCtx);
|
2010-03-29 14:37:56 +00:00
|
|
|
|
2015-09-06 23:03:23 +00:00
|
|
|
bool isFunctor(Value & fun);
|
|
|
|
|
2020-02-24 00:32:01 +00:00
|
|
|
// FIXME: use std::span
|
2022-03-04 18:31:59 +00:00
|
|
|
void callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const PosIdx pos);
|
2020-02-24 00:32:01 +00:00
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
void callFunction(Value & fun, Value & arg, Value & vRes, const PosIdx pos)
|
2020-02-24 00:32:01 +00:00
|
|
|
{
|
|
|
|
Value * args[] = {&arg};
|
|
|
|
callFunction(fun, 1, args, vRes, pos);
|
|
|
|
}
|
2010-04-07 13:55:46 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Automatically call a function for which each argument has a
|
|
|
|
* default value or has a binding in the `args` map.
|
|
|
|
*/
|
2010-10-22 14:47:42 +00:00
|
|
|
void autoCallFunction(Bindings & args, Value & fun, Value & res);
|
2013-09-02 14:29:15 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Allocation primitives.
|
|
|
|
*/
|
2021-12-28 18:18:17 +00:00
|
|
|
inline Value * allocValue();
|
|
|
|
inline Env & allocEnv(size_t size);
|
2010-03-30 14:39:27 +00:00
|
|
|
|
2022-04-26 11:23:32 +00:00
|
|
|
Value * allocAttr(Value & vAttrs, Symbol name);
|
2022-01-04 16:39:16 +00:00
|
|
|
Value * allocAttr(Value & vAttrs, std::string_view name);
|
2010-10-22 14:47:42 +00:00
|
|
|
|
2018-05-02 11:56:34 +00:00
|
|
|
Bindings * allocBindings(size_t capacity);
|
2014-09-19 14:49:41 +00:00
|
|
|
|
2022-01-04 16:39:16 +00:00
|
|
|
BindingsBuilder buildBindings(size_t capacity)
|
|
|
|
{
|
|
|
|
return BindingsBuilder(*this, allocBindings(capacity));
|
|
|
|
}
|
|
|
|
|
2018-05-02 11:56:34 +00:00
|
|
|
void mkList(Value & v, size_t length);
|
2010-04-12 18:30:11 +00:00
|
|
|
void mkThunk_(Value & v, Expr * expr);
|
2022-03-04 18:31:59 +00:00
|
|
|
void mkPos(Value & v, PosIdx pos);
|
2010-10-24 14:20:02 +00:00
|
|
|
|
2023-05-11 00:47:25 +00:00
|
|
|
/**
|
|
|
|
* Create a string representing a store path.
|
|
|
|
*
|
|
|
|
* The string is the printed store path with a context containing a single
|
|
|
|
* `NixStringContextElem::Opaque` element of that store path.
|
|
|
|
*/
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
void mkStorePathString(const StorePath & storePath, Value & v);
|
|
|
|
|
2023-05-11 00:47:25 +00:00
|
|
|
/**
|
|
|
|
* Create a string representing a `DerivedPath::Built`.
|
|
|
|
*
|
|
|
|
* The string is the printed store path with a context containing a single
|
|
|
|
* `NixStringContextElem::Built` element of the drv path and output name.
|
|
|
|
*
|
|
|
|
* @param value Value we are settings
|
|
|
|
*
|
|
|
|
* @param drvPath Path the drv whose output we are making a string for
|
|
|
|
*
|
|
|
|
* @param outputName Name of the output
|
|
|
|
*
|
|
|
|
* @param optOutputPath Optional output path for that string. Must
|
|
|
|
* be passed if and only if output store object is input-addressed.
|
|
|
|
* Will be printed to form string if passed, otherwise a placeholder
|
2023-05-11 22:01:41 +00:00
|
|
|
* will be used (see `DownstreamPlaceholder`).
|
2023-05-11 00:47:25 +00:00
|
|
|
*/
|
|
|
|
void mkOutputString(
|
|
|
|
Value & value,
|
|
|
|
const StorePath & drvPath,
|
|
|
|
const std::string outputName,
|
|
|
|
std::optional<StorePath> optOutputPath);
|
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
void concatLists(Value & v, size_t nrLists, Value * * lists, const PosIdx pos, std::string_view errorCtx);
|
2012-08-13 05:53:10 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Print statistics.
|
|
|
|
*/
|
2010-03-30 15:18:20 +00:00
|
|
|
void printStats();
|
2010-04-09 12:00:49 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* Realise the given context, and return a mapping from the placeholders
|
2021-12-20 18:46:55 +00:00
|
|
|
* used to construct the associated value to their final store path
|
|
|
|
*/
|
Use `std::set<StringContextElem>` not `PathSet` for string contexts
Motivation
`PathSet` is not correct because string contexts have other forms
(`Built` and `DrvDeep`) that are not rendered as plain store paths.
Instead of wrongly using `PathSet`, or "stringly typed" using
`StringSet`, use `std::std<StringContextElem>`.
-----
In support of this change, `NixStringContext` is now defined as
`std::std<StringContextElem>` not `std:vector<StringContextElem>`. The
old definition was just used by a `getContext` method which was only
used by the eval cache. It can be deleted altogether since the types are
now unified and the preexisting `copyContext` function already suffices.
Summarizing the previous paragraph:
Old:
- `value/context.hh`: `NixStringContext = std::vector<StringContextElem>`
- `value.hh`: `NixStringContext Value::getContext(...)`
- `value.hh`: `copyContext(...)`
New:
- `value/context.hh`: `NixStringContext = std::set<StringContextElem>`
- `value.hh`: `copyContext(...)`
----
The string representation of string context elements no longer contains
the store dir. The diff of `src/libexpr/tests/value/context.cc` should
make clear what the new representation is, so we recommend reviewing
that file first. This was done for two reasons:
Less API churn:
`Value::mkString` and friends did not take a `Store` before. But if
`NixStringContextElem::{parse, to_string}` *do* take a store (as they
did before), then we cannot have the `Value` functions use them (in
order to work with the fully-structured `NixStringContext`) without
adding that argument.
That would have been a lot of churn of threading the store, and this
diff is already large enough, so the easier and less invasive thing to
do was simply make the element `parse` and `to_string` functions not
take the `Store` reference, and the easiest way to do that was to simply
drop the store dir.
Space usage:
Dropping the `/nix/store/` (or similar) from the internal representation
will safe space in the heap of the Nix programming being interpreted. If
the heap contains many strings with non-trivial contexts, the saving
could add up to something significant.
----
The eval cache version is bumped.
The eval cache serialization uses `NixStringContextElem::{parse,
to_string}`, and since those functions are changed per the above, that
means the on-disk representation is also changed.
This is simply done by changing the name of the used for the eval cache
from `eval-cache-v4` to eval-cache-v5`.
----
To avoid some duplication `EvalCache::mkPathString` is added to abstract
over the simple case of turning a store path to a string with just that
string in the context.
Context
This PR picks up where #7543 left off. That one introduced the fully
structured `NixStringContextElem` data type, but kept `PathSet context`
as an awkward middle ground between internal `char[][]` interpreter heap
string contexts and `NixStringContext` fully parsed string contexts.
The infelicity of `PathSet context` was specifically called out during
Nix team group review, but it was agreeing that fixing it could be left
as future work. This is that future work.
A possible follow-up step would be to get rid of the `char[][]`
evaluator heap representation, too, but it is not yet clear how to do
that. To use `NixStringContextElem` there we would need to get the STL
containers to GC pointers in the GC build, and I am not sure how to do
that.
----
PR #7543 effectively is writing the inverse of a `mkPathString`,
`mkOutputString`, and one more such function for the `DrvDeep` case. I
would like that PR to have property tests ensuring it is actually the
inverse as expected.
This PR sets things up nicely so that reworking that PR to be in that
more elegant and better tested way is possible.
Co-authored-by: Théophane Hufschmitt <7226587+thufschmitt@users.noreply.github.com>
2023-01-29 01:31:10 +00:00
|
|
|
[[nodiscard]] StringMap realiseContext(const NixStringContext & context);
|
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
|
|
|
|
2010-04-09 12:00:49 +00:00
|
|
|
private:
|
2012-08-13 03:41:48 +00:00
|
|
|
|
2015-07-23 21:14:07 +00:00
|
|
|
unsigned long nrEnvs = 0;
|
|
|
|
unsigned long nrValuesInEnvs = 0;
|
|
|
|
unsigned long nrValues = 0;
|
|
|
|
unsigned long nrListElems = 0;
|
2021-07-21 22:31:08 +00:00
|
|
|
unsigned long nrLookups = 0;
|
2015-07-23 21:14:07 +00:00
|
|
|
unsigned long nrAttrsets = 0;
|
|
|
|
unsigned long nrAttrsInAttrsets = 0;
|
2021-07-21 22:31:08 +00:00
|
|
|
unsigned long nrAvoided = 0;
|
2015-07-23 21:14:07 +00:00
|
|
|
unsigned long nrOpUpdates = 0;
|
|
|
|
unsigned long nrOpUpdateValuesCopied = 0;
|
|
|
|
unsigned long nrListConcats = 0;
|
|
|
|
unsigned long nrPrimOpCalls = 0;
|
|
|
|
unsigned long nrFunctionCalls = 0;
|
2012-08-13 03:29:28 +00:00
|
|
|
|
|
|
|
bool countCalls;
|
|
|
|
|
2022-03-05 18:26:36 +00:00
|
|
|
typedef std::map<std::string, size_t> PrimOpCalls;
|
2012-08-13 03:29:28 +00:00
|
|
|
PrimOpCalls primOpCalls;
|
|
|
|
|
2018-05-02 11:56:34 +00:00
|
|
|
typedef std::map<ExprLambda *, size_t> FunctionCalls;
|
2012-08-13 03:29:28 +00:00
|
|
|
FunctionCalls functionCalls;
|
|
|
|
|
2013-11-07 17:04:36 +00:00
|
|
|
void incrFunctionCall(ExprLambda * fun);
|
|
|
|
|
2022-03-04 18:31:59 +00:00
|
|
|
typedef std::map<PosIdx, size_t> AttrSelects;
|
2012-08-13 03:29:28 +00:00
|
|
|
AttrSelects attrSelects;
|
|
|
|
|
2014-01-21 17:29:55 +00:00
|
|
|
friend struct ExprOpUpdate;
|
|
|
|
friend struct ExprOpConcatLists;
|
2021-07-21 22:31:08 +00:00
|
|
|
friend struct ExprVar;
|
|
|
|
friend struct ExprString;
|
|
|
|
friend struct ExprInt;
|
|
|
|
friend struct ExprFloat;
|
|
|
|
friend struct ExprPath;
|
2014-01-21 17:29:55 +00:00
|
|
|
friend struct ExprSelect;
|
2022-03-04 18:31:59 +00:00
|
|
|
friend void prim_getAttr(EvalState & state, const PosIdx pos, Value * * args, Value & v);
|
|
|
|
friend void prim_match(EvalState & state, const PosIdx pos, Value * * args, Value & v);
|
|
|
|
friend void prim_split(EvalState & state, const PosIdx pos, Value * * args, Value & v);
|
2022-01-04 19:29:17 +00:00
|
|
|
|
|
|
|
friend struct Value;
|
2003-10-30 16:48:26 +00:00
|
|
|
};
|
2010-04-07 13:55:46 +00:00
|
|
|
|
2022-05-05 10:29:14 +00:00
|
|
|
struct DebugTraceStacker {
|
|
|
|
DebugTraceStacker(EvalState & evalState, DebugTrace t);
|
|
|
|
~DebugTraceStacker()
|
|
|
|
{
|
|
|
|
// assert(evalState.debugTraces.front() == trace);
|
|
|
|
evalState.debugTraces.pop_front();
|
|
|
|
}
|
|
|
|
EvalState & evalState;
|
|
|
|
DebugTrace trace;
|
2021-12-28 00:35:27 +00:00
|
|
|
};
|
2010-04-07 13:55:46 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* @return A string representing the type of the value `v`.
|
|
|
|
*/
|
2022-02-25 15:00:00 +00:00
|
|
|
std::string_view showType(ValueType type);
|
|
|
|
std::string showType(const Value & v);
|
2003-10-30 16:48:26 +00:00
|
|
|
|
2023-04-07 13:55:28 +00:00
|
|
|
/**
|
|
|
|
* If `path` refers to a directory, then append "/default.nix".
|
|
|
|
*/
|
2023-04-06 11:15:50 +00:00
|
|
|
SourcePath resolveExprPath(const SourcePath & path);
|
2013-09-03 10:56:33 +00:00
|
|
|
|
2014-10-18 02:15:09 +00:00
|
|
|
struct InvalidPathError : EvalError
|
|
|
|
{
|
|
|
|
Path path;
|
|
|
|
InvalidPathError(const Path & path);
|
2014-10-20 16:15:50 +00:00
|
|
|
#ifdef EXCEPTION_NEEDS_THROW_SPEC
|
|
|
|
~InvalidPathError() throw () { };
|
|
|
|
#endif
|
2014-10-18 02:15:09 +00:00
|
|
|
};
|
|
|
|
|
2018-03-27 17:02:22 +00:00
|
|
|
struct EvalSettings : Config
|
|
|
|
{
|
2019-11-22 22:07:35 +00:00
|
|
|
EvalSettings();
|
|
|
|
|
2023-02-27 14:11:36 +00:00
|
|
|
static Strings getDefaultNixPath();
|
2019-11-22 22:07:35 +00:00
|
|
|
|
2022-09-12 13:37:09 +00:00
|
|
|
static bool isPseudoUrl(std::string_view s);
|
|
|
|
|
|
|
|
static std::string resolvePseudoUrl(std::string_view url);
|
|
|
|
|
2018-03-27 17:02:22 +00:00
|
|
|
Setting<bool> enableNativeCode{this, false, "allow-unsafe-native-code-during-evaluation",
|
|
|
|
"Whether builtin functions that allow executing native code should be enabled."};
|
|
|
|
|
2020-08-19 16:28:04 +00:00
|
|
|
Setting<Strings> nixPath{
|
2023-02-27 14:11:36 +00:00
|
|
|
this, getDefaultNixPath(), "nix-path",
|
2023-02-27 13:16:49 +00:00
|
|
|
"List of directories to be searched for `<...>` file references."};
|
2020-08-19 16:28:04 +00:00
|
|
|
|
|
|
|
Setting<bool> restrictEval{
|
|
|
|
this, false, "restrict-eval",
|
|
|
|
R"(
|
|
|
|
If set to `true`, the Nix evaluator will not allow access to any
|
|
|
|
files outside of the Nix search path (as set via the `NIX_PATH`
|
|
|
|
environment variable or the `-I` option), or to URIs outside of
|
2023-06-15 04:47:58 +00:00
|
|
|
`allowed-uris`. The default is `false`.
|
2020-08-19 16:28:04 +00:00
|
|
|
)"};
|
2018-03-27 17:02:22 +00:00
|
|
|
|
|
|
|
Setting<bool> pureEval{this, false, "pure-eval",
|
2023-05-17 12:59:47 +00:00
|
|
|
R"(
|
|
|
|
Pure evaluation mode ensures that the result of Nix expressions is fully determined by explicitly declared inputs, and not influenced by external state:
|
|
|
|
|
|
|
|
- Restrict file system and network access to files specified by cryptographic hash
|
|
|
|
- Disable [`bultins.currentSystem`](@docroot@/language/builtin-constants.md#builtins-currentSystem) and [`builtins.currentTime`](@docroot@/language/builtin-constants.md#builtins-currentTime)
|
|
|
|
)"
|
|
|
|
};
|
2018-03-27 17:02:22 +00:00
|
|
|
|
2020-08-19 16:28:04 +00:00
|
|
|
Setting<bool> enableImportFromDerivation{
|
|
|
|
this, true, "allow-import-from-derivation",
|
|
|
|
R"(
|
|
|
|
By default, Nix allows you to `import` from a derivation, allowing
|
|
|
|
building at evaluation time. With this option set to false, Nix will
|
|
|
|
throw an error when evaluating an expression that uses this feature,
|
|
|
|
allowing users to ensure their evaluation will not require any
|
|
|
|
builds to take place.
|
|
|
|
)"};
|
2018-03-27 17:02:22 +00:00
|
|
|
|
|
|
|
Setting<Strings> allowedUris{this, {}, "allowed-uris",
|
2020-08-19 16:28:04 +00:00
|
|
|
R"(
|
|
|
|
A list of URI prefixes to which access is allowed in restricted
|
|
|
|
evaluation mode. For example, when set to
|
|
|
|
`https://github.com/NixOS`, builtin functions such as `fetchGit` are
|
|
|
|
allowed to access `https://github.com/NixOS/patchelf.git`.
|
|
|
|
)"};
|
2019-05-07 20:29:16 +00:00
|
|
|
|
2019-04-12 16:31:33 +00:00
|
|
|
Setting<bool> traceFunctionCalls{this, false, "trace-function-calls",
|
2020-08-19 16:28:04 +00:00
|
|
|
R"(
|
|
|
|
If set to `true`, the Nix evaluator will trace every function call.
|
|
|
|
Nix will print a log message at the "vomit" level for every function
|
|
|
|
entrance and function exit.
|
|
|
|
|
|
|
|
function-trace entered undefined position at 1565795816999559622
|
|
|
|
function-trace exited undefined position at 1565795816999581277
|
|
|
|
function-trace entered /nix/store/.../example.nix:226:41 at 1565795253249935150
|
|
|
|
function-trace exited /nix/store/.../example.nix:226:41 at 1565795253249941684
|
|
|
|
|
|
|
|
The `undefined position` means the function call is a builtin.
|
|
|
|
|
|
|
|
Use the `contrib/stack-collapse.py` script distributed with the Nix
|
|
|
|
source code to convert the trace logs in to a format suitable for
|
|
|
|
`flamegraph.pl`.
|
|
|
|
)"};
|
2020-08-07 12:13:24 +00:00
|
|
|
|
|
|
|
Setting<bool> useEvalCache{this, true, "eval-cache",
|
|
|
|
"Whether to use the flake evaluation cache."};
|
2022-07-11 16:47:09 +00:00
|
|
|
|
|
|
|
Setting<bool> ignoreExceptionsDuringTry{this, false, "ignore-try",
|
|
|
|
R"(
|
|
|
|
If set to true, ignore exceptions inside 'tryEval' calls when evaluating nix expressions in
|
|
|
|
debug mode (using the --debugger flag). By default the debugger will pause on all exceptions.
|
|
|
|
)"};
|
|
|
|
|
2021-12-13 07:24:24 +00:00
|
|
|
Setting<bool> traceVerbose{this, false, "trace-verbose",
|
|
|
|
"Whether `builtins.traceVerbose` should trace its first argument when evaluated."};
|
2018-03-27 17:02:22 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
extern EvalSettings evalSettings;
|
|
|
|
|
2020-12-22 13:43:20 +00:00
|
|
|
static const std::string corepkgsPrefix{"/__corepkgs__/"};
|
|
|
|
|
2023-01-19 12:23:04 +00:00
|
|
|
template<class ErrorType>
|
|
|
|
void ErrorBuilder::debugThrow()
|
|
|
|
{
|
|
|
|
// NOTE: We always use the -LastTrace version as we push the new trace in withFrame()
|
|
|
|
state.debugThrowLastTrace(ErrorType(info));
|
|
|
|
}
|
|
|
|
|
2006-09-04 21:06:23 +00:00
|
|
|
}
|
2021-12-28 18:18:17 +00:00
|
|
|
|
|
|
|
#include "eval-inline.hh"
|